Tests for UniteTheTypes + verify param is variadic

Author: AydinHassan

src/Exercise/UniteTheTypes.php

@@ -52,13 +52,13 @@ public function getArgs(): array
         $numbers = array_map(
             function (): string {
                 if ($this->faker->boolean) {
-                    return $this->faker->numberBetween(0, 50);
+                    return (string) $this->faker->numberBetween(0, 50);
                 }
-                return $this->faker->randomFloat(3, 0, 50);
+                return (string) $this->faker->randomFloat(3, 0, 50);
             },
             range(0, random_int(5, 15))
         );
-        
+
         return [$numbers];
     }
 
@@ -135,6 +135,13 @@ public function check(Input $input): ResultInterface
             );
         }
 
+        if (!$firstParam->variadic) {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Function adder\'s first parameter should be variadic in order to accept multiple arguments'
+            );
+        }
+
         return new Success('Union type for adder is correct');
     }
-}
+}

test/Exercise/UniteTheTypesTest.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace PhpSchool\PHP8AppreciateTest\Exercise;
+
+use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
+use PhpSchool\PhpWorkshop\Application;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\TestUtils\WorkshopExerciseTest;
+
+class UniteTheTypesTest extends WorkshopExerciseTest
+{
+    public function getExerciseClass(): string
+    {
+        return UniteTheTypes::class;
+    }
+
+    public function getApplication(): Application
+    {
+        return require __DIR__ . '/../../app/bootstrap.php';
+    }
+
+    public function testFailureWhenNoFunctionNamedAdder(): void
+    {
+        $this->runExercise('no-adder-function.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No function named adder was found');
+    }
+
+    public function testFailureWhenAdderFunctionHasNoParams(): void
+    {
+        $this->runExercise('no-function-params.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'Function adder has no parameters');
+    }
+
+    public function testFailureWhenAdderFunctionHasNoUnionTypeParam(): void
+    {
+        $this->runExercise('no-union-type-param.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(
+            Failure::class,
+            'Function adder does not use a union type for it\'s first param'
+        );
+    }
+
+    public function testFailureWhenAdderFunctionHasClassTypeInUnion(): void
+    {
+        $this->runExercise('incorrect-union-class-type.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(
+            Failure::class,
+            'Union type is incorrect, it should only accept the required types'
+        );
+    }
+
+    public function testFailureWhenAdderFunctionHasIncorrectUnion(): void
+    {
+        $this->runExercise('incorrect-union-scalar-type.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(
+            Failure::class,
+            'Union type is incorrect, it should only accept the required types'
+        );
+    }
+
+    public function testFailureWhenAdderFunctionParamIsNotVariadic(): void
+    {
+        $this->runExercise('union-type-param-not-variadic.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(
+            Failure::class,
+            'Function adder\'s first parameter should be variadic in order to accept multiple arguments'
+        );
+    }
+
+    public function testSuccessfulSolution(): void
+    {
+        $this->runExercise('correct-union-type-same-order.php');
+
+        $this->assertVerifyWasSuccessful();
+    }
+
+    public function testSuccessfulSolutionWithDifferentOrderUnion(): void
+    {
+        $this->runExercise('correct-union-type-diff-order.php');
+
+        $this->assertVerifyWasSuccessful();
+    }
+}

test/solutions/unite-the-types/correct-union-type-diff-order.php

@@ -0,0 +1,10 @@
+<?php
+
+function adder(float|string|int ...$numbers) {
+    return array_sum($numbers);
+}
+
+$nums = $argv;
+array_shift($nums);
+
+echo adder(...$nums) . "\n";

test/solutions/unite-the-types/correct-union-type-same-order.php

@@ -0,0 +1,10 @@
+<?php
+
+function adder(string|float|int ...$numbers) {
+    return array_sum($numbers);
+}
+
+$nums = $argv;
+array_shift($nums);
+
+echo adder(...$nums) . "\n";

test/solutions/unite-the-types/incorrect-union-class-type.php

@@ -0,0 +1,4 @@
+<?php
+
+function adder(int|float|Stringable $numbers) {
+}

test/solutions/unite-the-types/incorrect-union-scalar-type.php

@@ -0,0 +1,4 @@
+<?php
+
+function adder(int|float|bool $numbers) {
+}

test/solutions/unite-the-types/no-adder-function.php

@@ -0,0 +1,4 @@
+<?php
+
+function lol()
+{}

test/solutions/unite-the-types/no-function-params.php

@@ -0,0 +1,4 @@
+<?php
+
+function adder()
+{}

test/solutions/unite-the-types/no-union-type-param.php

@@ -0,0 +1,4 @@
+<?php
+
+function adder(int $numbers) {
+}

test/solutions/unite-the-types/union-type-param-not-variadic.php

@@ -0,0 +1,10 @@
+<?php
+
+function adder(string|float|int $numbers) {
+    return array_sum($numbers);
+}
+
+$nums = $argv;
+array_shift($nums);
+
+echo adder(...$nums) . "\n";