Initial exercise

Author: AydinHassan

app/bootstrap.php

@@ -28,6 +28,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
 use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
+use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use PhpSchool\PhpWorkshop\Application;
 
@@ -43,6 +44,7 @@
 $app->addExercise(ASafeSpaceForNulls::class);
 $app->addExercise(AllMixedUp::class);
 $app->addExercise(TheReturnOfStatic::class);
+$app->addExercise(ThrowAnExpression::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -9,6 +9,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
 use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
+use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use Psr\Container\ContainerInterface;
 
@@ -48,5 +49,8 @@
     },
     TheReturnOfStatic::class => function (ContainerInterface $c) {
         return new TheReturnOfStatic($c->get(PhpParser\Parser::class));
+    },
+    ThrowAnExpression::class => function (ContainerInterface $c) {
+        return new ThrowAnExpression($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
     }
 ];

exercises/throw-an-expression/initial/throw-an-expression.php

@@ -0,0 +1,7 @@
+<?php
+
+if (str_starts_with($_SERVER['REQUEST_URI'], '/forbidden')) {
+    echo 'Welcome!';
+} else {
+    throw new InvalidArgumentException('Access denied!');
+}

exercises/throw-an-expression/problem/problem.md

@@ -0,0 +1,5 @@
+<?php
+
+echo str_starts_with($_SERVER['REQUEST_URI'], '/forbidden')
+    ? 'Welcome!'
+    : throw new InvalidArgumentException('Access denied!');

exercises/throw-an-expression/solution/solution.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use Faker\Generator as FakerGenerator;
+use GuzzleHttp\Psr7\Request;
+use PhpParser\Node\Expr\Ternary;
+use PhpParser\Node\Expr\Throw_;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\If_;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CgiExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\ProvidesInitialCode;
+use PhpSchool\PhpWorkshop\Exercise\SubmissionPatchable;
+use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Patch;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+use PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
+use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
+
+class ThrowAnExpression extends AbstractExercise implements
+    ExerciseInterface,
+    CgiExercise,
+    SelfCheck,
+    ProvidesInitialCode,
+    SubmissionPatchable
+{
+    public function __construct(private Parser $parser, private FakerGenerator $faker)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'Throw an Expression';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s throw expression';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CGI();
+    }
+
+    public function getRequests(): array
+    {
+        return [
+            (new Request('GET', 'https://top-secret.com/forbidden')),
+            (new Request('GET', 'https://top-secret.com/blog'))
+        ];
+    }
+
+    public function check(Input $input): ResultInterface
+    {
+        /** @var array<Stmt> $statements */
+        $statements = $this->parser->parse((string) file_get_contents($input->getRequiredArgument('program')));
+
+        /** @var If_|null $if */
+        $if = (new NodeFinder())->findFirstInstanceOf($statements, If_::class);
+
+        if ($if) {
+            return Failure::fromNameAndReason($this->getName(), 'If statement found');
+        }
+
+        /** @var Ternary|null $ternary */
+        $ternary = (new NodeFinder())->findFirstInstanceOf($statements, Ternary::class);
+
+        if ($ternary === null) {
+            return Failure::fromNameAndReason($this->getName(), 'No ternary statement found');
+        }
+
+        if (!$ternary->else instanceof Throw_) {
+            return Failure::fromNameAndReason($this->getName(), 'Ternary does not make use of throw expression');
+        }
+
+        return new Success($this->getName());
+    }
+
+    public function getInitialCode(): SolutionInterface
+    {
+        return SingleFileSolution::fromFile(
+            __DIR__ . '/../../exercises/throw-an-expression/initial/throw-an-expression.php'
+        );
+    }
+
+    public function getPatch(): Patch
+    {
+        return (new Patch())
+            ->withTransformer(new Patch\WrapInTryCatch(\InvalidArgumentException::class));
+    }
+}

src/Exercise/ThrowAnExpression.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace PhpSchool\PHP8AppreciateTest\Exercise;
+
+use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
+use PhpSchool\PhpWorkshop\Application;
+use PhpSchool\PhpWorkshop\Result\Cgi\RequestFailure;
+use PhpSchool\PhpWorkshop\Result\Cgi\Success;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\TestUtils\WorkshopExerciseTest;
+
+class ThrowAnExpressionTest extends WorkshopExerciseTest
+{
+    public function getExerciseClass(): string
+    {
+        return ThrowAnExpression::class;
+    }
+
+    public function getApplication(): Application
+    {
+        return require __DIR__ . '/../../app/bootstrap.php';
+    }
+
+    public function testThrowingWrongException(): void
+    {
+        $this->runExercise('wrong-exception.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $output = $this->getOutputResult();
+
+        self::assertInstanceOf(Success::class, $output->getResults()[0]);
+        self::assertInstanceOf(RequestFailure::class, $output->getResults()[1]);
+
+        self::assertMatchesRegularExpression(
+            '/Fatal error: Uncaught Exception: Access denied!/',
+            $output->getResults()[1]->getActualOutput()
+        );
+
+        $this->assertOutputWasIncorrect();
+    }
+
+    public function testUsingIfStatement(): void
+    {
+        $this->runExercise('if-statement.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'If statement found');
+
+        $this->assertOutputWasCorrect();
+    }
+
+    public function testUsingNoTernary(): void
+    {
+        $this->runExercise('no-ternary.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No ternary statement found');
+
+        $this->assertOutputWasIncorrect();
+    }
+
+    public function testNoThrowExpression(): void
+    {
+        $this->runExercise('no-throw-expression.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'Ternary does not make use of throw expression');
+
+        $this->assertOutputWasCorrect();
+    }
+
+    public function testSuccessfulSolution(): void
+    {
+        $this->runExercise('solution-correct.php');
+
+        $this->assertVerifyWasSuccessful();
+        $this->assertOutputWasCorrect();
+    }
+}

test/Exercise/ThrowAnExpressionTest.php

@@ -1,9 +1,12 @@
 <?php
 
+date_default_timezone_set("Europe/London");
+error_reporting(E_ALL);
+ini_set("display_errors", "1");
 echo match ($argv[1]) {
     'enter' => 13 + 10,
     'up' => 119 + 10,
     'down' => 73 + 10,
     'esc' => 27 + 10,
-    default => 0 + 10
-};
+    default => 0 + 10,
+};

test/solutions/a-match-made-in-heaven/solution-wrong-output.php

@@ -0,0 +1,7 @@
+<?php
+
+if (str_starts_with($_SERVER['REQUEST_URI'], '/forbidden')) {
+    echo 'Welcome!';
+} else {
+    throw new InvalidArgumentException('Access denied!');
+}

test/solutions/throw-an-expression/if-statement.php

@@ -0,0 +1,4 @@
+<?php
+
+echo 'Welcome!';
+