Validate properties have keys

src/Exception/InvalidOpenAPI.php

@@ -409,4 +409,16 @@ public static function mustSpecifyItemsForArrayType(
 
         return new self($message);
     }
+
+    public static function mustHaveStringKeys(
+        Identifier $identifier,
+        string $keyword,
+    ): self {
+        $message = <<<TEXT
+            $identifier
+            $keyword MUST be specified an array with string keys
+            TEXT;
+
+        return new self($message);
+    }
 }

src/ValueObject/Valid/V30/Schema.php

@@ -296,17 +296,24 @@ private function validateSubSchemas(string $keyword, ?array $subSchemas): ?array
     }
 
     /**
-     * @param null|array<Partial\Schema> $subSchemas
-     * @return array<Schema>
+     * @param array<string, Partial\Schema> $properties
+     * @return array<string, Schema>
      */
-    private function validateProperties(?array $subSchemas): array
+    private function validateProperties(?array $properties): array
     {
-        $subSchemas ??= [];
+        $properties ??= [];
 
         $result = [];
-        foreach ($subSchemas as $index => $subSchema) {
-            $result[] = new Schema(
-                $this->getIdentifier()->append("properties($index)"),
+        foreach ($properties as $key => $subSchema) {
+            if (!is_string($key)) {
+                throw InvalidOpenAPI::mustHaveStringKeys(
+                    $this->getIdentifier(),
+                    'properties',
+                );
+            }
+
+            $result[$key] = new Schema(
+                $this->getIdentifier()->append("properties($key)"),
                 $subSchema
             );
         }

tests/ValueObject/Valid/V30/SchemaTest.php

@@ -33,8 +33,9 @@
 #[UsesClass(Warnings::class)]
 class SchemaTest extends TestCase
 {
-    #[Test, DataProvider('provideInvalidComplexSchemas')]
-    public function itInvalidatesEmptyComplexSchemas(
+    #[Test]
+    #[DataProvider('provideInvalidSchemas')]
+    public function itThrowsOnInvalidSchemas(
         InvalidOpenAPI $expected,
         Identifier $identifier,
         Partial\Schema $partialSchema,
@@ -44,19 +45,6 @@ public function itInvalidatesEmptyComplexSchemas(
         new Schema($identifier, $partialSchema);
     }
 
-    #[Test]
-    public function itInvalidatesInvalidTypes(): void
-    {
-        $identifier = new Identifier('');
-        $schema = PartialHelper::createSchema(type: 'invalid');
-
-
-
-        self::expectExceptionObject(InvalidOpenAPI::invalidType($identifier, 'invalid'));
-
-        new Schema($identifier, $schema);
-    }
-
     /** @param Type[] $typesItCanBe */
     #[Test, DataProvider('provideSchemasToCheckTypes')]
     public function itKnowsIfItCanBeACertainType(
@@ -152,7 +140,29 @@ public function itGetsTypes(array $expected, Partial\Schema $schema): void
         self::assertEqualsCanonicalizing($expected, $sut->getTypes());
     }
 
-    public static function provideInvalidComplexSchemas(): Generator
+    public static function provideInvalidSchemas(): Generator
+    {
+        foreach (self::provideInvalidComplexSchemas() as $case => $dataset) {
+            yield $case => $dataset;
+        }
+
+        yield 'invalid type' => [
+            InvalidOpenAPI::invalidType(new Identifier('invalid type'), 'invalid'),
+            new Identifier('invalid type'),
+            new Partial\Schema(type: 'invalid'),
+        ];
+
+        yield 'properties list' => [
+            InvalidOpenAPI::mustHaveStringKeys(
+                new Identifier('properties list'),
+                'properties',
+            ),
+            new Identifier('properties list'),
+            new Partial\Schema(properties: [new Partial\Schema()]),
+        ];
+    }
+
+    private static function provideInvalidComplexSchemas(): Generator
     {
         $xOfs = [
             'allOf' => fn(Partial\Schema ...$subSchemas) => PartialHelper::createSchema(