Merge pull request #6 from php-strictus/feature/test-suite

further work on the test suite

Author: WendellAdriel

src/Traits/StrictusTyping.php

@@ -12,31 +12,31 @@
  */
 trait StrictusTyping
 {
-    public mixed $value;
+    private mixed $value;
 
     /**
      * @param  mixed  $value
      * @return mixed
      */
     public function __invoke(mixed $value = new StrictusUndefined()): mixed
     {
-        if (($value === null || $value instanceof StrictusUndefined) && ! $this->nullable) {
+        if ($value instanceof StrictusUndefined) {
+            return $this->value;
+        }
+
+        if ($value === null && !$this->nullable) {
             throw new StrictusTypeException($this->errorMessage);
         }
 
-        if (! ($value instanceof StrictusUndefined)) {
-            if (gettype($value) !== $this->instanceType) {
-                if ($this->nullable && $value !== null) {
-                    throw new StrictusTypeException($this->errorMessage);
-                }
+        if (gettype($value) !== $this->instanceType) {
+            if ($this->nullable && $value !== null) {
+                throw new StrictusTypeException($this->errorMessage);
             }
-
-            $this->value = $value;
-
-            return $this;
         }
 
-        return $this->value;
+        $this->value = $value;
+
+        return $this;
     }
 
     /**
@@ -68,4 +68,15 @@ public function __set(string $name, mixed $value): void
 
         $this->value = $value;
     }
+
+    public function handleInstantiation(mixed $value)
+    {
+        if (gettype($value) !== $this->instanceType) {
+            if (!$this->nullable) {
+                throw new StrictusTypeException($this->errorMessage);
+            } else if ($value !== null) {
+                throw new StrictusTypeException($this->errorMessage);
+            }
+        }
+    }
 }

src/Types/StrictusArray.php

@@ -22,10 +22,12 @@ final class StrictusArray implements StrictusTypeInterface
      * @param  mixed  $value
      * @param  bool  $nullable
      */
-    public function __construct(mixed $value, private bool $nullable)
+    public function __construct(private mixed $value, private bool $nullable)
     {
         if ($this->nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

src/Types/StrictusBoolean.php

@@ -22,10 +22,12 @@ final class StrictusBoolean implements StrictusTypeInterface
      * @param  mixed  $value
      * @param  bool  $nullable
      */
-    public function __construct(mixed $value, private bool $nullable)
+    public function __construct(private mixed $value, private bool $nullable)
     {
         if ($this->nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

src/Types/StrictusFloat.php

@@ -14,18 +14,21 @@ final class StrictusFloat implements StrictusTypeInterface
 {
     use StrictusTyping;
 
-    private string $instanceType = 'float';
+    //this is the internal type name given to what we call float
+    private string $instanceType = 'double';
 
     private string $errorMessage = 'Expected Float';
 
     /**
      * @param  mixed  $value
      * @param  bool  $nullable
      */
-    public function __construct(mixed $value, private bool $nullable)
+    public function __construct(private mixed $value, private bool $nullable)
     {
         if ($nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

src/Types/StrictusInteger.php

@@ -22,10 +22,12 @@ final class StrictusInteger implements StrictusTypeInterface
      * @param  mixed  $value
      * @param  bool  $nullable
      */
-    public function __construct(mixed $value, private bool $nullable)
+    public function __construct(private mixed $value, private bool $nullable)
     {
         if ($this->nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

src/Types/StrictusObject.php

@@ -27,5 +27,7 @@ public function __construct(mixed $value, private bool $nullable)
         if ($this->nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

src/Types/StrictusString.php

@@ -22,10 +22,12 @@ final class StrictusString implements StrictusTypeInterface
      * @param  mixed  $value
      * @param  bool  $nullable
      */
-    public function __construct(mixed $value, private bool $nullable)
+    public function __construct(private mixed $value, private bool $nullable)
     {
         if ($this->nullable) {
             $this->errorMessage .= ' Or Null';
         }
+
+        $this->handleInstantiation($value);
     }
 }

tests/Unit/ArrayTest.php

@@ -14,24 +14,24 @@
     $myArray = Strictus::array([1, 2, 3]);
 
     expect($myArray->value)
-        ->toBe([1, 2, 3])
+        ->toEqualCanonicalizing([1, 2, 3])
         ->and($myArray())
-        ->toBe([1, 2, 3]);
+        ->toEqualCanonicalizing([1, 2, 3]);
 });
 
 it('sets the correct array value', function () {
     $myArray = Strictus::array([1, 2, 3]);
 
     expect($myArray->value)
-        ->toBe([1, 2, 3])
+        ->toEqualCanonicalizing([1, 2, 3])
         ->and($myArray())
-        ->toBe([1, 2, 3]);
+        ->toEqualCanonicalizing([1, 2, 3]);
 
     $myArray->value = [4, 5, 6];
-    expect($myArray)->toBe([4, 5, 6]);
+    expect($myArray->value)->toEqualCanonicalizing([4, 5, 6]);
 
     $myArray([7, 8, 9]);
-    expect($myArray)->toBe([7, 8, 9]);
+    expect($myArray())->toEqualCanonicalizing([7, 8, 9]);
 });
 
 it('instantiates a nullable array variable with array method', function () {
@@ -47,9 +47,9 @@
 });
 
 it('throws exception when trying to instantiate an array as nullable with array method', function () {
-    expect(Strictus::array(null))->toThrow(StrictusTypeException::class);
+    expect(fn() => Strictus::array(null))->toThrow(StrictusTypeException::class);
 });
 
 it('throws exception when trying to instantiate an array with wrong type', function () {
-    expect(Strictus::array('foo'))->toThrow(StrictusTypeException::class);
+    expect(fn() => Strictus::array('foo'))->toThrow(StrictusTypeException::class);
 });

tests/Unit/BooleanTest.php

@@ -11,21 +11,41 @@
 });
 
 it('instantiates a nullable boolean variable with boolean method', function () {
-    $myArray = Strictus::boolean(null, true);
-    expect($myArray)
+    $myBoolean = Strictus::boolean(null, true);
+    expect($myBoolean)
         ->toBeInstanceOf(StrictusBoolean::class);
 });
 
 it('instantiates a nullable boolean variable with nullableBoolean method', function () {
-    $myArray = Strictus::nullableBoolean(null);
-    expect($myArray)
+    $myBoolean = Strictus::nullableBoolean(null);
+    expect($myBoolean)
         ->toBeInstanceOf(StrictusBoolean::class);
 });
 
 it('throws exception when trying to instantiate a boolean as nullable with boolean method', function () {
-    expect(Strictus::boolean(null))->toThrow(StrictusTypeException::class);
+    expect(fn () => Strictus::boolean(null))->toThrow(StrictusTypeException::class);
 });
 
 it('throws exception when trying to instantiate a boolean with wrong type', function () {
-    expect(Strictus::boolean('foo'))->toThrow(StrictusTypeException::class);
+    expect(fn () => Strictus::boolean('foo'))->toThrow(StrictusTypeException::class);
+});
+
+it('returns value correctly', function () {
+    $myBoolean = Strictus::boolean(true);
+
+    expect($myBoolean())->toBeTrue();
+    expect($myBoolean->value)->toBeTrue();
 });
+
+it('changes value correctly', function () {
+    $myBoolean = Strictus::boolean(true);
+
+    $myBoolean->value = false;
+
+    expect($myBoolean())->toBeFalse()->and($myBoolean->value)->toBeFalse();
+
+    $myBoolean2 = Strictus::boolean(true);
+    $myBoolean2(false);
+
+    expect($myBoolean2())->toBeFalse()->and($myBoolean2->value)->toBeFalse();
+});

tests/Unit/FloatTest.php

@@ -1 +1,50 @@
-<?php
+<?php
+
+use Strictus\Exceptions\StrictusTypeException;
+use Strictus\Strictus;
+use Strictus\Types\StrictusFloat;
+
+it('instantiates a float variable', function () {
+    $myFloat = Strictus::float(3.14);
+    expect($myFloat)
+        ->toBeInstanceOf(StrictusFloat::class);
+});
+
+it('instantiates a nullable float variable with float method', function () {
+    $myFloat = Strictus::float(null, true);
+    expect($myFloat)
+        ->toBeInstanceOf(StrictusFloat::class);
+});
+
+it('instantiates a nullable boolean variable with nullableBoolean method', function () {
+    $myFloat = Strictus::nullableFloat(null);
+    expect($myFloat)
+        ->toBeInstanceOf(StrictusFloat::class);
+});
+
+it('throws exception when trying to instantiate a boolean as nullable with boolean method', function () {
+    expect(fn () => Strictus::float(null))->toThrow(StrictusTypeException::class);
+});
+
+it('throws exception when trying to instantiate a boolean with wrong type', function () {
+    expect(fn () => Strictus::float('foo'))->toThrow(StrictusTypeException::class);
+});
+
+it('returns value correctly', function () {
+    $myFloat = Strictus::float(3.14);
+
+    expect($myFloat())->toEqual(3.14)->and($myFloat->value)->toEqual(3.14);
+});
+
+it('changes value correctly', function () {
+    $myFloat = Strictus::float(3.14);
+
+    $myFloat->value = 1.12;
+
+    expect($myFloat())->toEqual(1.12)->and($myFloat->value)->toEqual(1.12);
+
+    $myFloat2 = Strictus::float(3.14);
+    $myFloat2(1.12);
+
+    expect($myFloat2())->toEqual(1.12)->and($myFloat2->value)->toEqual(1.12);
+});

tests/Unit/IntegerTest.php

@@ -1 +1,50 @@
-<?php
+<?php
+
+use Strictus\Exceptions\StrictusTypeException;
+use Strictus\Strictus;
+use Strictus\Types\StrictusInteger;
+
+it('instantiates a integer variable', function () {
+    $myInt = Strictus::int(3);
+    expect($myInt)
+        ->toBeInstanceOf(StrictusInteger::class);
+});
+
+it('instantiates a nullable integer variable with integer method', function () {
+    $myInt = Strictus::int(null, true);
+    expect($myInt)
+        ->toBeInstanceOf(StrictusInteger::class);
+});
+
+it('instantiates a nullable integer variable with nullableinteger method', function () {
+    $myInt = Strictus::nullableInt(null);
+    expect($myInt)
+        ->toBeInstanceOf(StrictusInteger::class);
+});
+
+it('throws exception when trying to instantiate a integer as nullable with integer method', function () {
+    expect(fn () => Strictus::int(null))->toThrow(StrictusTypeException::class);
+});
+
+it('throws exception when trying to instantiate a integer with wrong type', function () {
+    expect(fn () => Strictus::int('foo'))->toThrow(StrictusTypeException::class);
+});
+
+it('returns value correctly', function () {
+    $myInt = Strictus::int(3);
+
+    expect($myInt())->toEqual(3)->and($myInt->value)->toEqual(3);
+});
+
+it('changes value correctly', function () {
+    $myInt = Strictus::int(3);
+
+    $myInt->value = 1;
+
+    expect($myInt())->toEqual(1)->and($myInt->value)->toEqual(1);
+
+    $myInt2 = Strictus::int(3);
+    $myInt2(1);
+
+    expect($myInt2())->toEqual(1)->and($myInt2->value)->toEqual(1);
+});