test implementation of collection objects

src/Models/AbstractCollection.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace CTApi\Models;
+
+
+use ArrayAccess;
+use ArrayObject;
+use Countable;
+use IteratorAggregate;
+use Traversable;
+
+abstract class AbstractCollection implements IteratorAggregate, ArrayAccess, Countable
+{
+    private ArrayObject $arrayObject;
+
+    public function __construct(array $array = [])
+    {
+        foreach($array as $value){
+            $this->validateValue($value);
+        }
+        $this->arrayObject = new ArrayObject($array);
+    }
+
+    protected abstract function getClassType(): string;
+
+    protected abstract function createInstance(array $data): AbstractCollection;
+
+    private function validateValue(mixed $value): void
+    {
+        $classType = $this->getClassType();
+        if(!is_a($value, $classType)){
+            $valueType = is_object($value) ? get_class($value) : gettype($value);
+            throw new \InvalidArgumentException("Value from type " . $valueType . " is not assignable to Collection from type " . get_class($this));
+        }
+    }
+
+    /**
+     * Alias for append.
+     * @param object $value
+     * @return void
+     */
+    public function push(object $value): void
+    {
+        $this->append($value);
+    }
+    public function append(object $value): void
+    {
+        $this->validateValue($value);
+        $this->arrayObject[] = $value;
+    }
+
+    public function first(): ?object
+    {
+        $iterator = $this->arrayObject->getIterator();
+        return $iterator->current();
+    }
+
+    public function filter(callable $callback, int $mode = 0): self
+    {
+        $filtered = array_filter((array) $this->arrayObject, $callback, $mode);
+        return $this->createInstance($filtered);
+    }
+
+    public function map(callable $callback): self
+    {
+        $filtered = array_map($callback, (array) $this->arrayObject);
+        return $this->createInstance($filtered);
+    }
+
+    public function count(): int
+    {
+        return $this->arrayObject->count();
+    }
+
+    /**
+     * Sort the entries by value
+     * @param int $flags
+     * @return bool
+     */
+    public function asort(int $flags = SORT_REGULAR): bool
+    {
+        return $this->arrayObject->asort($flags);
+    }
+
+    /**
+     * Sort the entries by key
+     * @param int $flags
+     * @return bool
+     */
+    public function ksort(int $flags = SORT_REGULAR): bool
+    {
+        return $this->arrayObject->ksort($flags);
+    }
+
+    /**
+     * Sort the entries with a user-defined comparison function and maintain key association
+     * @param callable $callback
+     * @return bool
+     */
+    public function uasort(callable $callback): bool
+    {
+        return $this->arrayObject->uasort($callback);
+    }
+
+    public function getIterator(): Traversable
+    {
+        return $this->arrayObject->getIterator();
+    }
+
+    public function offsetExists(mixed $offset): bool
+    {
+        return $this->arrayObject->offsetExists($offset);
+    }
+
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $this->arrayObject->offsetGet($offset);
+    }
+
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        $this->validateValue($value);
+        $this->arrayObject->offsetSet($offset, $value);
+    }
+
+    public function offsetUnset(mixed $offset): void
+    {
+        $this->arrayObject->offsetUnset($offset);
+        $this->filterNullableEntries();
+    }
+
+    private function filterNullableEntries(): void
+    {
+        $withoutNullable = array_filter($this->arrayObject->getArrayCopy(), function($element){
+           return isset($element);
+        });
+        $this->arrayObject->exchangeArray(array_values($withoutNullable));
+    }
+}

src/Models/Groups/Group/GroupTypeCollection.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace CTApi\Models\Groups\Group;
+
+use CTApi\Models\AbstractCollection;
+
+class GroupTypeCollection extends AbstractCollection
+{
+    protected function getClassType(): string
+    {
+        return GroupType::class;
+    }
+}

src/Models/Groups/Group/GroupTypeRequest.php

@@ -5,9 +5,9 @@
 
 class GroupTypeRequest
 {
-    public static function all(): array
+    public static function all(): GroupTypeCollection
     {
-        return (new GroupTypeRequestBuilder())->all();
+        return new GroupTypeCollection((new GroupTypeRequestBuilder())->all());
     }
 
     public static function where(string $key, $value): GroupTypeRequestBuilder

src/Models/Groups/GroupMember/GroupMemberCollection.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace CTApi\Models\Groups\GroupMember;
+
+use CTApi\Models\AbstractCollection;
+use CTApi\Models\Groups\Person\PersonCollection;
+use CTApi\Models\Groups\Person\PersonRequest;
+
+class GroupMemberCollection extends AbstractCollection
+{
+
+    protected function getClassType(): string
+    {
+        return GroupMember::class;
+    }
+
+    public function requestPersons(): PersonCollection
+    {
+        $ids = array_map(function(GroupMember $groupMember){
+            return $groupMember->getPersonId();
+        }, $this);
+
+        return PersonRequest::where('ids', $ids)->get();
+    }
+
+}

src/Models/Groups/Person/PersonCollection.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace CTApi\Models\Groups\Person;
+
+use CTApi\Models\AbstractCollection;
+
+class PersonCollection extends AbstractCollection
+{
+    protected function getClassType(): string
+    {
+        return Person::class;
+    }
+}

tests/Unit/Models/Collection/Car.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace CTApi\Test\Unit\Models\Collection;
+
+class Car
+{
+    public function __construct(
+        public string $brand
+    )
+    {
+    }
+
+    public static function fromBrand(string $brand): Car
+    {
+        return new Car($brand);
+    }
+}

tests/Unit/Models/Collection/CarCollection.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace CTApi\Test\Unit\Models\Collection;
+
+use CTApi\Models\AbstractCollection;
+
+class CarCollection extends AbstractCollection
+{
+    protected function getClassType(): string
+    {
+        return Car::class;
+    }
+
+    protected function createInstance(array $data): CarCollection
+    {
+        return new CarCollection($data);
+    }
+}

tests/Unit/Models/Collection/CollectionTest.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace CTApi\Test\Unit\Models\Collection;
+
+use CTApi\Models\Groups\Group\Group;
+use CTApi\Models\Groups\Person\Person;
+use CTApi\Models\PersonCustomCollection;
+use PHPUnit\Framework\TestCase;
+
+class CollectionTest extends TestCase
+{
+
+    public function testAddCollection()
+    {
+        $carCollection = new CarCollection();
+        $carCollection[] = new Car("mercedes");
+        $carCollection->append(new Car("bmw"));
+        $carCollection[] = new Car("daimler");
+
+        $this->assertEquals(3, sizeof($carCollection));
+    }
+
+    public function testAddCollection_TypeCheck()
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $carCollection = new CarCollection();
+        $carCollection[] = new Car("mercedes");
+        $carCollection[] = "awidon";
+    }
+
+    public function testCreateCollection()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $carCollection = new CarCollection([$car1, $car2]);
+        $this->assertEquals(2, sizeof($carCollection));
+    }
+
+    public function testCreateCollection_TypeCheck()
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $carCollection = new CarCollection(["test"]);
+    }
+
+    public function testGetSpecificElement()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $carCollection = new CarCollection([$car1, $car2]);
+
+        $car = $carCollection->offsetGet(1);
+        $this->assertEquals($car->brand, "bmw");
+
+        $car = $carCollection[0];
+        $this->assertEquals($car->brand, "mercedes");
+    }
+
+    public function testRemoveElement()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $car3 = new Car("daimler");
+        $carCollection = new CarCollection([$car1, $car2, $car3]);
+
+        $carCollection->offsetUnset(1);
+        $this->assertEquals(2, sizeof($carCollection));
+    }
+
+    public function testRemoveElementInLoop()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $car3 = new Car("daimler");
+
+        $carCollection = new CarCollection([$car1, $car2, $car3]);
+
+        $numberOfIterations = 0;
+        foreach($carCollection as $car)
+        {
+            echo "\n". $car->brand;
+            if($car->brand === "bmw"){
+                $carCollection->offsetUnset(1);
+            }
+            $numberOfIterations++;
+        }
+        $this->assertEquals(3, $numberOfIterations);
+    }
+
+    public function testGetFirstElement()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $car3 = new Car("daimler");
+
+        $carCollection = new CarCollection([$car1, $car2, $car3]);
+
+        foreach($carCollection as $carIterator){
+            $car = $carCollection->first();
+            $this->assertEquals("mercedes", $car->brand);
+        }
+    }
+
+    public function testGetFirstElement_Empty()
+    {
+        $carCollection = new CarCollection();
+        $this->assertNull($carCollection->first());
+    }
+
+    public function testGetFirstElement_FirstUnset()
+    {
+        $carCollection = new CarCollection([Car::fromBrand("mercedes"), Car::fromBrand("audi")]);
+        $this->assertNotNull($carCollection->first());
+        $this->assertEquals("mercedes", $carCollection->first()->brand);
+
+        $carCollection->offsetUnset(0);
+        $this->assertNotNull($carCollection->first());
+        $this->assertEquals("audi", $carCollection->first()->brand);
+    }
+
+    public function testFilter()
+    {
+        $car1 = new Car("mercedes");
+        $car2 = new Car("bmw");
+        $car3 = new Car("daimler");
+
+        $carCollection = new CarCollection([$car1, $car2, $car3]);
+
+
+        $carCollectionFiltered = $carCollection->filter(function($test){
+            return $test->brand === "bmw";
+        });
+
+        $this->assertEquals(sizeof($carCollectionFiltered), 1);
+    }
+
+}