Custom Runner

Author: AydinHassan

app/config.php

@@ -22,6 +22,7 @@
 use PhpSchool\PhpWorkshop\ExerciseDispatcher;
 use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CgiRunnerFactory;
 use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CliRunnerFactory;
+use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CustomRunnerFactory;
 use PhpSchool\PhpWorkshop\ExerciseRunner\RunnerManager;
 use PhpSchool\PhpWorkshop\Factory\EventDispatcherFactory;
 use PhpSchool\PhpWorkshop\Factory\MenuFactory;
@@ -125,6 +126,7 @@
         $manager = new RunnerManager;
         $manager->addFactory(new CliRunnerFactory($c->get(EventDispatcher::class)));
         $manager->addFactory(new CgiRunnerFactory($c->get(EventDispatcher::class)));
+        $manager->addFactory(new CustomRunnerFactory);
         return $manager;
     },
 

src/Exercise/CustomExercise.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\Exercise;
+
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+interface CustomExercise
+{
+    /**
+     * @return ResultInterface
+     */
+    public function verify();
+}

src/Exercise/ExerciseType.php

@@ -20,6 +20,8 @@ class ExerciseType extends Enum
 {
     const CLI    = 'CLI';
     const CGI    = 'CGI';
+    const CUSTOM = 'CUSTOM';
+
 
     /**
      * Map of exercise types to the required interfaces exercises of that particular
@@ -30,6 +32,7 @@ class ExerciseType extends Enum
     private static $exerciseTypeToExerciseInterfaceMap = [
         self::CLI    => CliExercise::class,
         self::CGI    => CgiExercise::class,
+        self::CUSTOM => CustomExercise::class,
     ];
 
     /**

src/ExerciseRunner/CustomRunner.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner;
+
+use PhpSchool\PhpWorkshop\Exercise\CustomExercise;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Output\OutputInterface;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class CustomRunner implements ExerciseRunnerInterface
+{
+    /**
+     * @var CustomExercise
+     */
+    private $exercise;
+
+    /**
+     * @param CustomExercise $exercise
+     */
+    public function __construct(CustomExercise $exercise)
+    {
+        $this->exercise = $exercise;
+    }
+
+    /**
+     * Get the name of the exercise runner.
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return 'External Runner';
+    }
+
+    /**
+     * Get an array of the class names of the required checks this runner needs.
+     *
+     * @return array
+     */
+    public function getRequiredChecks()
+    {
+        return [];
+    }
+
+    /**
+     * Verify a solution to an exercise. Verification involves executing the reference solution
+     * and the student's solution and comparing their output. If the output is the same
+     * an instance of `PhpSchool\PhpWorkshop\Result\SuccessInterface` should be returned, if the output
+     * is not the same, or something else went wrong then an instance of
+     * `\PhpSchool\PhpWorkshop\Result\FailureInterface` should be returned.
+     *
+     * Other things that could go wrong include the student's solution returning a non-zero
+     * exit code, or a notice/warning being exhibited.
+     *
+     * @param Input $input The command line arguments passed to the command.
+     * @return ResultInterface The result of the check.
+     */
+    public function verify(Input $input)
+    {
+        return $this->exercise->verify();
+    }
+
+    /**
+     * Run a solution to an exercise. This simply run's the student's solution with the correct input from the exercise
+     * (such as the CLI arguments) and prints the output directly. This allows the student to have the environment
+     * setup for them including getting a different set of arguments each time (if the exercise supports that).
+     *
+     * @param Input $input The command line arguments passed to the command.
+     * @param OutputInterface $output A wrapper around STDOUT.
+     * @return bool If the solution was successfully executed, eg. exit code was 0.
+     */
+    public function run(Input $input, OutputInterface $output)
+    {
+        $message  = 'Nothing to run here. This exercise does not require a code solution, ';
+        $message .= 'so there is nothing to execute.';
+        $output->writeLine($message);
+        return true;
+    }
+}

src/ExerciseRunner/Factory/CustomRunnerFactory.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner\Factory;
+
+use PhpSchool\PhpWorkshop\CommandArgument;
+use PhpSchool\PhpWorkshop\CommandDefinition;
+use PhpSchool\PhpWorkshop\Event\EventDispatcher;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\ExerciseRunner\CgiRunner;
+use PhpSchool\PhpWorkshop\ExerciseRunner\CustomRunner;
+use PhpSchool\PhpWorkshop\ExerciseRunner\ExerciseRunnerInterface;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class CustomRunnerFactory implements ExerciseRunnerFactoryInterface
+{
+    /**
+     * @var string
+     */
+    private static $type = ExerciseType::CUSTOM;
+
+    /**
+     * Whether the factory supports this exercise type.
+     *
+     * @param ExerciseInterface $exercise
+     * @return bool
+     */
+    public function supports(ExerciseInterface $exercise)
+    {
+        return $exercise->getType()->getValue() === self::$type;
+    }
+
+    /**
+     * Add any extra required arguments to the command.
+     *
+     * @param CommandDefinition $commandDefinition
+     */
+    public function configureInput(CommandDefinition $commandDefinition)
+    {
+    }
+
+    /**
+     * Create and return an instance of the runner.
+     *
+     * @param ExerciseInterface $exercise
+     * @return ExerciseRunnerInterface
+     */
+    public function create(ExerciseInterface $exercise)
+    {
+        return new CustomRunner($exercise);
+    }
+}

test/Asset/ExtExerciseImpl.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpSchool\PhpWorkshopTest\Asset;
+
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\CustomExercise;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class ExtExerciseImpl extends AbstractExercise implements ExerciseInterface, CustomExercise
+{
+
+    /**
+     * Get the name of the exercise, like `Hello World!`.
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return 'EXT exercise';
+    }
+
+    /**
+     * A short description of the exercise.
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return 'EXT exercise';
+    }
+
+    /**
+     * Return the type of exercise. This is an ENUM. See `PhpSchool\PhpWorkshop\Exercise\ExerciseType`.
+     *
+     * @return ExerciseType
+     */
+    public function getType()
+    {
+        return ExerciseType::EXT();
+    }
+
+    /**
+     * @return ResultInterface
+     */
+    public function verify()
+    {
+        return new Success('success');
+    }
+}

test/ExerciseRunner/CustomRunnerTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner;
+
+use Colors\Color;
+use PhpSchool\CliMenu\Terminal\TerminalInterface;
+use PhpSchool\PhpWorkshop\ExerciseDispatcher;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Output\StdOutput;
+use PhpSchool\PhpWorkshopTest\Asset\ExtExerciseImpl;
+use PHPUnit_Framework_TestCase;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class ExtRunnerTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * @var CustomRunner
+     */
+    private $runner;
+
+    /**
+     * @var ExtExerciseImpl
+     */
+    private $exercise;
+
+    public function setUp()
+    {
+        $this->exercise = new ExtExerciseImpl;
+        $this->runner = new CustomRunner($this->exercise);
+
+        $this->assertEquals('External Runner', $this->runner->getName());
+    }
+
+    public function testRunOutputsErrorMessage()
+    {
+        $color = new Color;
+        $color->setForceStyle(true);
+        $output = new StdOutput($color, $this->createMock(TerminalInterface::class));
+
+        $exp  = "Nothing to run here. This exercise does not require a code solution, ";
+        $exp .= "so there is nothing to execute.\n";
+
+        $this->expectOutputString($exp);
+
+        $this->runner->run(new Input('app'), $output);
+    }
+
+    public function testVerifyProxiesToExercise()
+    {
+        self::assertEquals($this->exercise->verify(), $this->runner->verify(new Input('app')));
+    }
+}

test/ExerciseRunner/Factory/CustomRunnerFactoryTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace PhpSchool\PhpWorkshopTest\ExerciseRunner\Factory;
+
+use PhpSchool\PhpWorkshop\CommandDefinition;
+use PhpSchool\PhpWorkshop\Event\EventDispatcher;
+use PhpSchool\PhpWorkshop\Exercise\CustomExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\ExerciseRunner\CustomRunner;
+use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CustomRunnerFactory;
+use PhpSchool\PhpWorkshopTest\Asset\ExtExerciseImpl;
+use PHPUnit_Framework_TestCase;
+
+/**
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class CustomRunnerFactoryTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * @var CustomRunnerFactory
+     */
+    private $factory;
+
+    public function setUp()
+    {
+        $this->factory = new CustomRunnerFactory;
+    }
+
+    public function testSupports()
+    {
+        $exercise1 = $this->prophesize(ExerciseInterface::class);
+        $exercise2 = $this->prophesize(ExerciseInterface::class);
+        $exercise3 = $this->prophesize(ExerciseInterface::class);
+
+        $exercise1->getType()->willReturn(ExerciseType::CLI());
+        $exercise2->getType()->willReturn(ExerciseType::CGI());
+        $exercise3->getType()->willReturn(ExerciseType::CUSTOM());
+
+        $this->assertFalse($this->factory->supports($exercise1->reveal()));
+        $this->assertFalse($this->factory->supports($exercise2->reveal()));
+        $this->assertTrue($this->factory->supports($exercise3->reveal()));
+    }
+
+    public function testConfigureInputAddsNoArgument()
+    {
+        $command = new CommandDefinition('my-command', [], 'var_dump');
+
+        $this->factory->configureInput($command);
+        $this->assertCount(0, $command->getRequiredArgs());
+    }
+
+    public function testCreateReturnsRunner()
+    {
+        $exercise = new ExtExerciseImpl;
+        $this->assertInstanceOf(CustomRunner::class, $this->factory->create($exercise));
+    }
+}