Merge pull request #140 from fschmtt/improve-map-type

fschmtt · web-flow · commit cca201a555ce · 2024-12-30T10:53:49.000+01:00
feat: improve map type
diff --git a/src/Serializer/MapNormalizer.php b/src/Serializer/MapNormalizer.php
@@ -6,16 +6,21 @@
 
 use ArrayObject;
 use Fschmtt\Keycloak\Type\Map;
+use InvalidArgumentException;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 
 class MapNormalizer implements NormalizerInterface
 {
     /**
      * @param array<string, mixed> $context
      */
-    public function normalize(mixed $object, ?string $format = null, array $context = []): ArrayObject
+    public function normalize(mixed $data, ?string $format = null, array $context = []): ArrayObject
     {
-        return new ArrayObject($object);
+        if (!$data instanceof Map) {
+            throw new InvalidArgumentException(sprintf('Data must be an instance of "%s"', Map::class));
+        }
+
+        return new ArrayObject($data->jsonSerialize());
     }
 
     /**
diff --git a/src/Serializer/Serializer.php b/src/Serializer/Serializer.php
@@ -44,6 +44,7 @@ public function __construct(
             new ArrayDenormalizer(),
             new CollectionDenormalizer($propertyNormalizer),
             new MapNormalizer(),
+            new MapDenormalizer(),
             new AttributeNormalizer($propertyNormalizer, $keycloakVersion),
             $propertyNormalizer,
         ], [
diff --git a/src/Type/Map.php b/src/Type/Map.php
@@ -7,22 +7,21 @@
 use ArrayIterator;
 use Countable;
 use IteratorAggregate;
+use OutOfBoundsException;
 use Traversable;
 
-use function count;
-
 /**
- * @internal
+ * @template T
  *
- * @implements IteratorAggregate<string, mixed>
+ * @implements IteratorAggregate<string, T>
  */
 class Map extends Type implements Countable, IteratorAggregate
 {
     /**
-     * @param array<mixed> $map
+     * @param array<string, T> $map
      */
     public function __construct(
-        private readonly array $map = [],
+        private array $map = [],
     ) {}
 
     public function jsonSerialize(): object
@@ -39,4 +38,44 @@ public function count(): int
     {
         return count($this->map);
     }
+
+    public function contains(string $key): bool
+    {
+        return array_key_exists($key, $this->map);
+    }
+
+    public function get(string $key): mixed
+    {
+        if (!$this->contains($key)) {
+            throw new OutOfBoundsException(sprintf('Key "%s" does not exist in map', $key));
+        }
+
+        return $this->map[$key];
+    }
+
+    public function with(string $key, mixed $value): self
+    {
+        $clone = clone $this;
+
+        $clone->map[$key] = $value;
+
+        return $clone;
+    }
+
+    public function without(string $key): self
+    {
+        $clone = clone $this;
+
+        unset($clone->map[$key]);
+
+        return $clone;
+    }
+
+    /**
+     * @return array<string, T>
+     */
+    public function getMap(): array
+    {
+        return $this->map;
+    }
 }
diff --git a/tests/Integration/Resource/RealmsTest.php b/tests/Integration/Resource/RealmsTest.php
@@ -7,6 +7,7 @@
 use Fschmtt\Keycloak\Collection\RealmCollection;
 use Fschmtt\Keycloak\Representation\Realm;
 use Fschmtt\Keycloak\Test\Integration\IntegrationTestBehaviour;
+use Fschmtt\Keycloak\Type\Map;
 use PHPUnit\Framework\TestCase;
 
 class RealmsTest extends TestCase
@@ -103,4 +104,21 @@ public function testCanDeleteAdminEvents(): void
 
         $this->getKeycloak()->realms()->deleteAdminEvents('master');
     }
+
+    public function testCanUpdateRealmAttributes(): void
+    {
+        $realm = $this->getKeycloak()->realms()->get(realm: 'master');
+
+        static::assertFalse($realm->getAttributes()->contains('termsUrl'));
+
+        $realm = $realm->withAttributes(new Map([
+            'termsUrl' => 'https://example.com/terms',
+        ]));
+
+        $this->getKeycloak()->realms()->update($realm->getRealm(), $realm);
+
+        $updatedRealm = $this->getKeycloak()->realms()->get(realm: $realm->getRealm());
+
+        static::assertEquals('https://example.com/terms', $updatedRealm->getAttributes()->get('termsUrl'));
+    }
 }
diff --git a/tests/Unit/Representation/GroupTest.php b/tests/Unit/Representation/GroupTest.php
@@ -19,9 +19,9 @@ class GroupTest extends TestCase
     protected function setUp(): void
     {
         $subGroup = new Group(
-            access: new Map(['acl-a', 'acl-b']),
-            attributes: new Map(['attr-1', 'attr-2']),
-            clientRoles: new Map(['client-role-x', 'client-role-y', 'client-role-z']),
+            access: new Map(['acl-a' => true, 'acl-b' => false]),
+            attributes: new Map(['attr-1' => 'val-1', 'attr-2' => 'val-2']),
+            clientRoles: new Map(['client-role-x' => ['foo', 'bar'], 'client-role-y' => ['foo', 'bar'], 'client-role-z' => ['foo', 'bar']]),
             id: 'unique-id',
             name: 'unique-name',
             path: '/where/am/i',
@@ -30,9 +30,9 @@ protected function setUp(): void
         $subGroup->withId('unique-id');
 
         $this->group = new Group(
-            access: new Map(['acl-a', 'acl-b']),
-            attributes: new Map(['attr-1', 'attr-2']),
-            clientRoles: new Map(['client-role-x', 'client-role-y', 'client-role-z']),
+            access: new Map(['acl-a' => true, 'acl-b' => false]),
+            attributes: new Map(['attr-1' => 'val-1', 'attr-2' => 'val-2']),
+            clientRoles: new Map(['client-role-x' => ['foo', 'bar'], 'client-role-y' => ['foo', 'bar'], 'client-role-z' => ['foo', 'bar']]),
             id: 'unique-id',
             name: 'unique-name',
             path: '/where/am/i',
@@ -75,17 +75,17 @@ public static function provideProperties(): array
     {
         $group = [
             'access' => new Map([
-                'acl-a',
-                'acl-b',
+                'acl-a' => true,
+                'acl-b' => false,
             ]),
             'attributes' => new Map([
-                'attr-1',
-                'attr-2',
+                'attr-1' => 'val-1',
+                'attr-2' => 'val-2',
             ]),
             'clientRoles' => new Map([
-                'client-role-x',
-                'client-role-y',
-                'client-role-z',
+                'client-role-x' => ['foo', 'bar'],
+                'client-role-y' => ['foo', 'bar'],
+                'client-role-z' => ['foo', 'bar'],
             ]),
             'id' => 'unique-id',
             'name' => 'unique-name',
diff --git a/tests/Unit/Serializer/MapNormalizerTest.php b/tests/Unit/Serializer/MapNormalizerTest.php
@@ -8,6 +8,7 @@
 use Fschmtt\Keycloak\Serializer\MapNormalizer;
 use Fschmtt\Keycloak\Type\Map;
 use Generator;
+use InvalidArgumentException;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -17,59 +18,61 @@ class MapNormalizerTest extends TestCase
 {
     public function testSupportedTypes(): void
     {
-        $denormalizer = new MapNormalizer();
+        $normalizer = new MapNormalizer();
 
         static::assertSame(
             [Map::class => true],
-            $denormalizer->getSupportedTypes('json'),
+            $normalizer->getSupportedTypes('json'),
         );
     }
 
     public function testSupportsNormalization(): void
     {
-        $denormalizer = new MapNormalizer();
+        $normalizer = new MapNormalizer();
 
-        static::assertTrue($denormalizer->supportsNormalization(new Map()));
-        static::assertFalse($denormalizer->supportsNormalization([]));
+        static::assertTrue($normalizer->supportsNormalization(new Map()));
+        static::assertFalse($normalizer->supportsNormalization([]));
     }
+
     #[DataProvider('maps')]
     public function testNormalize(mixed $value, ArrayObject $expected): void
     {
-        $denormalizer = new MapNormalizer();
+        $normalizer = new MapNormalizer();
 
-        self::assertEquals(
+        static::assertEquals(
             $expected,
-            $denormalizer->normalize($value, Map::class),
+            $normalizer->normalize($value, Map::class),
         );
     }
 
+    public function testThrowsIfDataIsNotAMap(): void
+    {
+        $normalizer = new MapNormalizer();
+
+        static::expectException(InvalidArgumentException::class);
+        static::expectExceptionMessage(sprintf('Data must be an instance of "%s"', Map::class));
+
+        $normalizer->normalize([]);
+    }
+
     public static function maps(): Generator
     {
-        yield 'filled array' => [
-            [
+        yield 'filled map' => [
+            new Map([
                 'a' => 1,
                 'b' => 2,
                 'c' => 3,
-            ],
+            ]),
             new ArrayObject([
                 'a' => 1,
                 'b' => 2,
                 'c' => 3,
             ]),
         ];
 
-        yield 'empty array' => [
-            [],
+        yield 'empty map' => [
+            new Map(),
             new ArrayObject(),
         ];
-
-        yield Map::class => [
-            new ArrayObject([
-                'a' => 1,
-            ]),
-            new ArrayObject([
-                'a' => 1,
-            ]),
-        ];
     }
 }
diff --git a/tests/Unit/Type/MapTest.php b/tests/Unit/Type/MapTest.php
@@ -5,6 +5,7 @@
 namespace Fschmtt\Keycloak\Test\Unit\Type;
 
 use Fschmtt\Keycloak\Type\Map;
+use OutOfBoundsException;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\TestCase;
 
@@ -61,4 +62,61 @@ public function testCanBeCounted(): void
 
         static::assertCount(3, $map);
     }
+
+    public function testContains(): void
+    {
+        $map = new Map(['key-1' => 'value-1', 'key-2' => 'value-2']);
+
+        static::assertTrue($map->contains('key-1'));
+        static::assertTrue($map->contains('key-2'));
+        static::assertFalse($map->contains('key-3'));
+    }
+
+    public function testGet(): void
+    {
+        $map = new Map(['key-1' => 'value-1', 'key-2' => 'value-2']);
+
+        static::assertSame('value-1', $map->get('key-1'));
+        static::assertSame('value-2', $map->get('key-2'));
+    }
+
+    public function testGetThrows(): void
+    {
+        $map = new Map(['key-1' => 'value-1', 'key-2' => 'value-2']);
+
+        static::expectException(OutOfBoundsException::class);
+        static::expectExceptionMessage('Key "key-3" does not exist in map');
+
+        $map->get('key-3');
+    }
+
+    public function testWith(): void
+    {
+        $map = new Map(['key-1' => 'value-1', 'key-2' => 'value-2']);
+
+        $updatedMap = $map->with('key-3', 'value-3');
+
+        static::assertNotSame($map, $updatedMap);
+        static::assertCount(2, $map);
+        static::assertCount(3, $updatedMap);
+    }
+
+    public function testWithout(): void
+    {
+        $map = new Map(['key-1' => 'value-1', 'key-2' => 'value-2']);
+
+        $updatedMap = $map->without('key-2');
+
+        static::assertNotSame($map, $updatedMap);
+        static::assertCount(2, $map);
+        static::assertCount(1, $updatedMap);
+    }
+
+    public function testGetMap(): void
+    {
+        $inner = ['key-1' => 'value-1', 'key-2' => 'value-2'];
+        $map = new Map($inner);
+
+        static::assertSame($inner, $map->getMap());
+    }
 }
