Reset captured. Test "run" as array. Implement "toString"

* Reset captured commands.
* Test that a command passed as an array is executed.
* Implemented the "toString" method that returns the current (or given) command as a string.

src/Builder.php

@@ -382,6 +382,25 @@ protected function getSeconds($timeout)
         return $timeout;
     }
 
+    /**
+     * Get the current command as string.
+     *
+     * @param  string|array|null  $command
+     * @return string
+     */
+    public function toString($command = null)
+    {
+        if (! is_null($command)) {
+            $this->command($command);
+        }
+
+        if (is_string($this->command)) {
+            return $this->command;
+        }
+
+        return $this->process()->getCommandLine();
+    }
+
     /**
      * Dynamically forward calls to the process instance.
      *

src/Fakes/BuilderFake.php

@@ -35,6 +35,17 @@ public static function capture(Builder $builder)
         static::$captured[] = $builder;
     }
 
+    /**
+     * Set captured commands.
+     *
+     * @param  array  $captured
+     * @return void
+     */
+    public static function setCaptured(array $captured)
+    {
+        static::$captured = $captured;
+    }
+
     /**
      * Set fake commands.
      *
@@ -91,11 +102,7 @@ protected function runProcess(Process $process)
     {
         Terminal::capture($this);
 
-        // if (static::shouldRun($process->getCommandLine())) {
-        //     return parent::runProcess($process);
-        // }
-
-        return static::$commands[$this->command] ?? Terminal::response();
+        return static::$commands[$this->toString()] ?? Terminal::response();
     }
 
     /**
@@ -106,13 +113,14 @@ protected function runProcess(Process $process)
      */
     public static function assertExecuted($command, int $times = 1)
     {
-        $count = count(array_filter(static::$captured, is_callable($command) ?: function ($captured) use ($command) {
-            return $captured->getCommand() == $command;
-        }));
+        $filter = is_callable($command) ? $command : function ($captured) use ($command) {
+            return $captured->toString() == Terminal::toString($command);
+        };
+
+        $count = count(array_filter(static::$captured, $filter));
 
         Assert::assertTrue($count === $times, sprintf(
-            'The expected command [%s] was executed %s times instead of %s times.',
-            $command, $count, $times
+            'The command was executed %s times instead of expected %s times.', $count, $times
         ));
     }
 }

src/Terminal.php

@@ -36,6 +36,7 @@ public static function reset()
         static::$fake = false;
 
         Fakes\BuilderFake::setCommands([]);
+        Fakes\BuilderFake::setCaptured([]);
     }
 
     /**
@@ -129,4 +130,4 @@ public static function __callStatic(string $method, array $parameters)
     {
         return call_user_func([static::builder(), $method], ...$parameters);
     }
-}
+}

tests/BuilderTest.php

@@ -130,6 +130,18 @@ public function testExecute()
         $this->assertEquals($builder->process(), $response->process());
     }
 
+    /**
+     * Test that the terminal can execute array commands.
+     *
+     * @return void
+     */
+    public function testExecuteArrayCommands()
+    {
+        $response = (new Builder)->run(['echo', 'Hello, World']);
+
+        $this->assertEquals("Hello, World\n", (string) $response);
+    }
+
     /**
      * Test that "execute" method starts the process.
      *
@@ -259,6 +271,29 @@ public function testRetry()
             ->execute('echo Hello, World');
     }
 
+    /**
+     * Test that terminal can convert commands to string.
+     *
+     * @return void
+     */
+    public function testToString()
+    {
+        $this->assertEquals(
+            '\'echo\' \'Hello, World\'',
+            (new Builder)->toString(['echo', 'Hello, World'])
+        );
+
+        $this->assertEquals(
+            '\'echo\' \'Hello, World\'',
+            (new Builder)->command(['echo', 'Hello, World'])->toString()
+        );
+
+        $this->assertEquals(
+            'echo "Hello, World"',
+            (new Builder)->toString('echo "Hello, World"')
+        );
+    }
+
     /**
      * Create a new builder instance with a mocked process instance.
      *
@@ -285,4 +320,4 @@ protected function builderWithMockedProccess($mocker = null)
 
         return $builder;
     }
-}
+}

tests/FakeTerminalTest.php

@@ -40,6 +40,22 @@ public function testCaptureAndAssertExecuted()
         Terminal::assertExecuted($expected);
     }
 
+    /**
+     * Test that Terminal can capture and assert executions using a custom filter.
+     *
+     * @return void
+     */
+    public function testCaptureAndAssertExecutedUsingCustomFilter()
+    {
+        Terminal::fake();
+
+        Terminal::execute($expected = 'echo "Hello, World"');
+
+        Terminal::assertExecuted(function ($captured) use ($expected) {
+            return $captured->toString() == $expected;
+        });
+    }
+
     public function testResponseLinesAsStrings()
     {
         Terminal::fake([
@@ -113,4 +129,19 @@ public function testEmptyResponse()
             ->assertEmpty()
             ->assertOk();
     }
-}
+
+    public function testCaptureArrayCommands()
+    {
+        $expected = ['rm', '-rf', 'vendor'];
+
+        Terminal::fake([
+            Terminal::toString($expected) => 'success',
+        ]);
+
+        $response = Terminal::run($expected);
+
+        Terminal::assertExecuted($expected);
+
+        $this->assertEquals('success', $response->output());
+    }
+}

tests/TerminalTest.php

@@ -53,4 +53,4 @@ public function testBuilder()
     {
         $this->assertEquals(new Builder, Terminal::builder());
     }
-}
+}

tests/TestCase.php

@@ -22,4 +22,4 @@ protected function tearDown(): void
         Mockery::close();
         Terminal::reset();
     }
-}
+}