Get tests running

Author: AydinHassan

src/Exception/InvalidArgumentException.php

@@ -1,6 +1,7 @@
 <?php
 
 namespace PhpSchool\PhpWorkshop\Exception;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 
 /**
  * Represents invalid argument exceptions.
@@ -48,6 +49,22 @@ public static function notValidParameter($parameterName, array $allowedValues, $
         );
     }
 
+    /**
+     * @param object $object
+     * @param string $requiredInterface
+     * @return static
+     */
+    public static function missingImplements($object, $requiredInterface)
+    {
+        return new static(
+            sprintf(
+                '"%s" is required to implement "%s", but it does not',
+                get_class($object),
+                $requiredInterface
+            )
+        );
+    }
+
     /**
      * @param $value
      * @return string

src/Exercise/ExerciseType.php

@@ -3,22 +3,43 @@
 namespace PhpSchool\PhpWorkshop\Exercise;
 
 use MyCLabs\Enum\Enum;
-use PhpSchool\PhpWorkshop\ExerciseRunner\CgiRunner;
-use PhpSchool\PhpWorkshop\ExerciseRunner\CliRunner;
 
 /**
  * This class is a ENUM which represents the types that exercises can be. Instantiation looks like:
  *
  * ```php
  * $typeCli = ExerciseType::CLI();
  * $typeCgi = ExerciseType::CGI();
+ * $typeCustom = ExerciseType::CUSTOM();
  * ```
  *
  * @package PhpSchool\PhpWorkshop\Exercise
  * @author Aydin Hassan <[email protected]>
  */
 class ExerciseType extends Enum
 {
-    const CLI = CliRunner::class;
-    const CGI = CgiRunner::class;
+    const CLI    = 'CLI';
+    const CGI    = 'CGI';
+
+    /**
+     * Map of exercise types to the required interfaces exercises of that particular
+     * type should implement.
+     *
+     * @var array
+     */
+    private static $exerciseTypeToExerciseInterfaceMap = [
+        self::CLI    => CliExercise::class,
+        self::CGI    => CgiExercise::class,
+    ];
+
+    /**
+     * Get the FQCN of the interface this exercise should implement for this
+     * exercise type.
+     *
+     * @return string
+     */
+    public function getExerciseInterface()
+    {
+        return static::$exerciseTypeToExerciseInterfaceMap[$this->getKey()];
+    }
 }

src/ExerciseRepository.php

@@ -4,7 +4,7 @@
 
 use ArrayIterator;
 use Countable;
-use InvalidArgumentException;
+use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 use IteratorAggregate;
 use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 
@@ -28,12 +28,28 @@ class ExerciseRepository implements IteratorAggregate, Countable
      */
     public function __construct(array $exercises)
     {
-        //type safety
-        $this->exercises = array_map(function (ExerciseInterface $e) {
-            return $e;
+        $this->exercises = array_map(function (ExerciseInterface $exercise) {
+            return $this->validateExercise($exercise);
         }, $exercises);
     }
 
+    /**
+     * @param ExerciseInterface $exercise
+     * @return ExerciseInterface
+     */
+    private function validateExercise(ExerciseInterface $exercise)
+    {
+        $type = $exercise->getType();
+
+        $requiredInterface = $type->getExerciseInterface();
+
+        if (!$exercise instanceof $requiredInterface) {
+            throw InvalidArgumentException::missingImplements($exercise, $requiredInterface);
+        }
+
+        return $exercise;
+    }
+
     /**
      * Retrieve all of the exercises as an array.
      *

src/ExerciseRunner/RunnerManager.php

@@ -41,7 +41,7 @@ public function configureInput(ExerciseInterface $exercise, CommandDefinition $c
      */
     public function getRunner(ExerciseInterface $exercise)
     {
-        return $this->getFactory($exercise)->create($exercise, $this->container);
+        return $this->getFactory($exercise)->create($exercise);
     }
 
     /**

test/Asset/CliExerciseImpl.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace PhpSchool\PhpWorkshopTest\Asset;
+
+use PhpSchool\PhpWorkshop\Check\ComposerCheck;
+use PhpSchool\PhpWorkshop\Exercise\CliExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\ExerciseCheck\ComposerExerciseCheck;
+use PhpSchool\PhpWorkshop\ExerciseDispatcher;
+
+/**
+ * @package PhpSchool\PhpWorkshopTest\Asset
+ * @author Aydin Hassan <[email protected]>
+ */
+class CliExerciseImpl implements ExerciseInterface, CliExercise
+{
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'my-exercise';
+    }
+
+    /**
+     * @return string
+     */
+    public function getDescription()
+    {
+        return 'my-exercise';
+    }
+
+    /**
+     * @return string
+     */
+    public function getSolution()
+    {
+        // TODO: Implement getSolution() method.
+    }
+
+    /**
+     * @return string
+     */
+    public function getProblem()
+    {
+        // TODO: Implement getProblem() method.
+    }
+
+    /**
+     * @return void
+     */
+    public function tearDown()
+    {
+        // TODO: Implement tearDown() method.
+    }
+
+    /**
+     * @return array
+     */
+    public function getArgs()
+    {
+        // TODO: Implement getArgs() method.
+    }
+
+    /**
+     * @return ExerciseType
+     */
+    public function getType()
+    {
+        return ExerciseType::CLI();
+    }
+
+    /**
+     * @param ExerciseDispatcher $dispatcher
+     */
+    public function configure(ExerciseDispatcher $dispatcher)
+    {
+        $dispatcher->requireCheck(ComposerCheck::class);
+    }
+}

test/Asset/ComposerExercise.php

@@ -21,7 +21,7 @@ class ComposerExercise implements ExerciseInterface, ComposerExerciseCheck
      */
     public function getName()
     {
-        // TODO: Implement getName() method.
+        return 'composer-exercise';
     }
 
     /**

test/Check/DatabaseCheckTest.php

@@ -14,7 +14,7 @@
 use PhpSchool\PhpWorkshop\ExerciseCheck\DatabaseExerciseCheck;
 use PhpSchool\PhpWorkshop\ExerciseDispatcher;
 use PhpSchool\PhpWorkshop\ExerciseRunner\CliRunner;
-use PhpSchool\PhpWorkshop\Factory\RunnerFactory;
+use PhpSchool\PhpWorkshop\ExerciseRunner\RunnerManager;
 use PhpSchool\PhpWorkshop\Input\Input;
 use PhpSchool\PhpWorkshop\Output\OutputInterface;
 use PhpSchool\PhpWorkshop\ResultAggregator;
@@ -61,6 +61,7 @@ public function setUp()
 
         $this->check = new DatabaseCheck;
         $this->exercise = $this->createMock(DatabaseExerciseInterface::class);
+        $this->exercise->expects($this->any())->method('getType')->willReturn(ExerciseType::CLI());
         $this->dbDir = sprintf(
             '%s/PhpSchool_PhpWorkshop_Check_DatabaseCheck',
             str_replace('\\', '/', realpath(sys_get_temp_dir()))
@@ -75,20 +76,25 @@ public function setUp()
      * @param EventDispatcher $eventDispatcher
      * @return \PHPUnit_Framework_MockObject_MockObject
      */
-    private function getRunnerFactory(ExerciseInterface $exercise, EventDispatcher $eventDispatcher)
+    private function getRunnerManager(ExerciseInterface $exercise, EventDispatcher $eventDispatcher)
     {
         $runner = $this->getMockBuilder(CliRunner::class)
             ->setConstructorArgs([$exercise, $eventDispatcher])
-            ->setMethods(['configure'])
+            ->setMethods(['configure', 'getRequiredChecks'])
             ->getMock();
 
-        $runnerFactory = $this->createMock(RunnerFactory::class);
-        $runnerFactory
+        $runner
+            ->expects($this->any())
+            ->method('getRequiredChecks')
+            ->willReturn([]);
+
+        $runnerManager = $this->createMock(RunnerManager::class);
+        $runnerManager
             ->expects($this->once())
-            ->method('create')
+            ->method('getRunner')
             ->willReturn($runner);
 
-        return $runnerFactory;
+        return $runnerManager;
     }
 
     public function testIfDatabaseFolderExistsExceptionIsThrown()
@@ -153,7 +159,7 @@ public function testIfPDOThrowsExceptionItCleansUp()
         $results            = new ResultAggregator;
         $eventDispatcher    = new EventDispatcher($results);
         $dispatcher         = new ExerciseDispatcher(
-            $this->getRunnerFactory($this->exercise, $eventDispatcher),
+            $this->getRunnerManager($this->exercise, $eventDispatcher),
             $results,
             $eventDispatcher,
             $this->checkRepository
@@ -194,7 +200,7 @@ public function testSuccessIsReturnedIfDatabaseVerificationPassed()
         $results            = new ResultAggregator;
         $eventDispatcher    = new EventDispatcher($results);
         $dispatcher         = new ExerciseDispatcher(
-            $this->getRunnerFactory($this->exercise, $eventDispatcher),
+            $this->getRunnerManager($this->exercise, $eventDispatcher),
             $results,
             $eventDispatcher,
             $this->checkRepository
@@ -225,7 +231,7 @@ public function testRunExercise()
         $results            = new ResultAggregator;
         $eventDispatcher    = new EventDispatcher($results);
         $dispatcher         = new ExerciseDispatcher(
-            $this->getRunnerFactory($this->exercise, $eventDispatcher),
+            $this->getRunnerManager($this->exercise, $eventDispatcher),
             $results,
             $eventDispatcher,
             $this->checkRepository
@@ -241,6 +247,8 @@ public function testRunExercise()
     public function testFailureIsReturnedIfDatabaseVerificationFails()
     {
         $solution = SingleFileSolution::fromFile(realpath(__DIR__ . '/../res/database/solution.php'));
+
+
         $this->exercise
             ->expects($this->once())
             ->method('getSolution')
@@ -269,7 +277,7 @@ public function testFailureIsReturnedIfDatabaseVerificationFails()
         $results            = new ResultAggregator;
         $eventDispatcher    = new EventDispatcher($results);
         $dispatcher         = new ExerciseDispatcher(
-            $this->getRunnerFactory($this->exercise, $eventDispatcher),
+            $this->getRunnerManager($this->exercise, $eventDispatcher),
             $results,
             $eventDispatcher,
             $this->checkRepository
@@ -337,7 +345,7 @@ public function testAlteringDatabaseInSolutionDoesNotEffectDatabaseInUserSolutio
         $results            = new ResultAggregator;
         $eventDispatcher    = new EventDispatcher($results);
         $dispatcher         = new ExerciseDispatcher(
-            $this->getRunnerFactory($this->exercise, $eventDispatcher),
+            $this->getRunnerManager($this->exercise, $eventDispatcher),
             $results,
             $eventDispatcher,
             $this->checkRepository

test/Command/PrintCommandTest.php

@@ -3,6 +3,9 @@
 namespace PhpSchool\PhpWorkshop\Command;
 
 use Colors\Color;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshopTest\Asset\CliExerciseInterface;
+use PhpSchool\PhpWorkshopTest\Asset\ComposerExercise;
 use PHPUnit_Framework_TestCase;
 use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 use PhpSchool\PhpWorkshop\ExerciseRepository;
@@ -22,21 +25,15 @@ public function testExerciseIsPrintedIfAssigned()
         $file = tempnam(sys_get_temp_dir(), 'pws');
         file_put_contents($file, '### Exercise 1');
 
-        $exercise = $this->createMock(ExerciseInterface::class);
-        $exercise
-            ->expects($this->once())
-            ->method('getProblem')
-            ->will($this->returnValue($file));
-
-        $exercise
-            ->expects($this->once())
-            ->method('getName')
-            ->will($this->returnValue('current-exercise'));
+        $exercise = $this->prophesize(CliExerciseInterface::class);
+        $exercise->getProblem()->willReturn($file);
+        $exercise->getType()->willReturn(ExerciseType::CLI());
+        $exercise->getName()->willReturn('some-exercise');
 
-        $repo = new ExerciseRepository([$exercise]);
+        $repo = new ExerciseRepository([$exercise->reveal()]);
 
         $state = new UserState;
-        $state->setCurrentExercise('current-exercise');
+        $state->setCurrentExercise('some-exercise');
 
         $output = $this->createMock(OutputInterface::class);
         $renderer = $this->createMock(MarkdownRenderer::class);