refactor(tests): Refactor CodeStyleCommandTest and DevToolsTest for improved dependency handling and add new tests for ProcessQueue

Signed-off-by: Felipe Sayão Lobato Abreu <github@mentordosnerds.com>

Author: coisa

tests/Console/Command/CodeStyleCommandTest.php

@@ -19,43 +19,71 @@
 namespace FastForward\DevTools\Tests\Console\Command;
 
 use FastForward\DevTools\Console\Command\CodeStyleCommand;
-use FastForward\DevTools\Process\ProcessBuilder;
-use FastForward\DevTools\Process\ProcessQueue;
+use FastForward\DevTools\Process\ProcessBuilderInterface;
+use FastForward\DevTools\Process\ProcessQueueInterface;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
+use Prophecy\Prophecy\ObjectProphecy;
+use ReflectionMethod;
 use Symfony\Component\Config\FileLocatorInterface;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\Process;
 
 #[CoversClass(CodeStyleCommand::class)]
-#[CoversClass(ProcessBuilder::class)]
-#[CoversClass(ProcessQueue::class)]
 final class CodeStyleCommandTest extends TestCase
 {
     use ProphecyTrait;
 
+    private ObjectProphecy $fileLocator;
+
+    private ObjectProphecy $processQueue;
+
+    private ObjectProphecy $process;
+
+    private ObjectProphecy $input;
+
+    private ObjectProphecy $output;
+
+    private ObjectProphecy $processBuilder;
+
     private CodeStyleCommand $command;
 
     /**
      * @return void
      */
     protected function setUp(): void
     {
-        $fileLocator = $this->createMock(FileLocatorInterface::class);
-        $fileLocator->method('locate')
-            ->willReturn('/path/to/ecs.php');
+        $this->fileLocator = $this->prophesize(FileLocatorInterface::class);
+        $this->processBuilder = $this->prophesize(ProcessBuilderInterface::class);
+        $this->processQueue = $this->prophesize(ProcessQueueInterface::class);
+        $this->process = $this->prophesize(Process::class);
+        $this->input = $this->prophesize(InputInterface::class);
+        $this->output = $this->prophesize(OutputInterface::class);
 
-        $processBuilder = new ProcessBuilder();
-        $processQueue = new ProcessQueue();
+        $this->processBuilder->withArgument(Argument::any())
+            ->willReturn($this->processBuilder->reveal());
+        $this->processBuilder->withArgument(Argument::any(), Argument::any())
+            ->willReturn($this->processBuilder->reveal());
 
-        $this->command = new CodeStyleCommand($fileLocator, $processBuilder, $processQueue);
+        $this->processBuilder->build(Argument::any())
+            ->willReturn($this->process->reveal());
+
+        $this->command = new CodeStyleCommand(
+            $this->fileLocator->reveal(),
+            $this->processBuilder->reveal(),
+            $this->processQueue->reveal(),
+        );
     }
 
     /**
      * @return void
      */
     #[Test]
-    public function configureWillSetExpectedNameDescriptionAndHelp(): void
+    public function commandWillSetExpectedNameDescriptionAndHelp(): void
     {
         self::assertSame('code-style', $this->command->getName());
         self::assertSame(
@@ -76,4 +104,80 @@ public function commandCanBeConstructedWithDependencies(): void
     {
         self::assertInstanceOf(CodeStyleCommand::class, $this->command);
     }
+
+    /**
+     * @return void
+     */
+    #[Test]
+    public function executeWillReturnSuccessWhenProcessQueueSucceeds(): void
+    {
+        $this->input->getOption('fix')
+            ->willReturn(false);
+
+        $this->fileLocator->locate(CodeStyleCommand::CONFIG)
+            ->willReturn('/path/to/ecs.php');
+
+        $this->processQueue->run($this->output->reveal())
+            ->willReturn(CodeStyleCommand::SUCCESS)
+            ->shouldBeCalled();
+
+        $result = $this->executeCommand();
+
+        self::assertSame(CodeStyleCommand::SUCCESS, $result);
+    }
+
+    /**
+     * @return void
+     */
+    #[Test]
+    public function executeWillReturnFailureWhenProcessQueueFails(): void
+    {
+        $this->input->getOption('fix')
+            ->willReturn(false);
+
+        $this->fileLocator->locate(CodeStyleCommand::CONFIG)
+            ->willReturn('/path/to/ecs.php');
+
+        $this->processQueue->run($this->output->reveal())
+            ->willReturn(CodeStyleCommand::FAILURE)
+            ->shouldBeCalled();
+
+        $result = $this->executeCommand();
+
+        self::assertSame(CodeStyleCommand::FAILURE, $result);
+    }
+
+    /**
+     * @return void
+     */
+    #[Test]
+    public function executeWillRunWithFixOptionWhenFixIsEnabled(): void
+    {
+        $this->input->getOption('fix')
+            ->willReturn(true);
+
+        $this->fileLocator->locate(CodeStyleCommand::CONFIG)
+            ->willReturn('/path/to/ecs.php');
+
+        $this->processQueue->run($this->output->reveal())
+            ->willReturn(CodeStyleCommand::SUCCESS)
+            ->shouldBeCalled();
+
+        $result = $this->executeCommand();
+
+        self::assertSame(CodeStyleCommand::SUCCESS, $result);
+    }
+
+    /**
+     * @return int
+     */
+    private function executeCommand(): int
+    {
+        $this->processQueue->add($this->process->reveal())
+            ->shouldBeCalledTimes(3);
+
+        $reflectionMethod = new ReflectionMethod($this->command, 'execute');
+
+        return $reflectionMethod->invoke($this->command, $this->input->reveal(), $this->output->reveal());
+    }
 }

tests/Console/DevToolsTest.php

@@ -18,14 +18,18 @@
 
 namespace FastForward\DevTools\Tests\Console;
 
+use FastForward\DevTools\Console\CommandLoader\DevToolsCommandLoader;
 use FastForward\DevTools\Console\DevTools;
+use FastForward\DevTools\ServiceProvider\DevToolsServiceProvider;
 use Override;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\UsesClass;
 use PHPUnit\Framework\TestCase;
 use Prophecy\PhpUnit\ProphecyTrait;
 use Prophecy\Prophecy\ObjectProphecy;
 use ReflectionMethod;
+use ReflectionProperty;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Command\CompleteCommand;
 use Symfony\Component\Console\Command\DumpCompletionCommand;
@@ -34,6 +38,8 @@
 use Symfony\Component\Console\CommandLoader\CommandLoaderInterface;
 
 #[CoversClass(DevTools::class)]
+#[UsesClass(DevToolsCommandLoader::class)]
+#[UsesClass(DevToolsServiceProvider::class)]
 final class DevToolsTest extends TestCase
 {
     use ProphecyTrait;
@@ -97,6 +103,21 @@ public function __construct()
         self::assertSame($customCommand, $this->devTools->get('custom'));
     }
 
+    /**
+     * @return void
+     */
+    #[Test]
+    public function createWillReturnInstanceOfDevTools(): void
+    {
+        $reflectionProperty = new ReflectionProperty(DevTools::class, 'container');
+        $reflectionProperty->setValue(null, null);
+
+        $devTools = DevTools::create();
+
+        self::assertInstanceOf(DevTools::class, $devTools);
+        self::assertSame($devTools, DevTools::create());
+    }
+
     /**
      * @param DevTools $devTools
      *