parser / properties / tests cleanup + behaviour fixes

Author: Nementon

openapi_python_client/parser/properties/__init__.py

@@ -571,11 +571,17 @@ def _property_from_data(
         else:
 
             def lookup_is_reference_to_itself(
-                ref_name: str, owner_class_name: str, lazy_references: Dict[str, oai.Reference]
+                ref_name: str,
+                owner_class_name: str,
+                lazy_references: Dict[str, oai.Reference],
             ) -> bool:
                 if ref_name in lazy_references:
                     next_ref_name = _reference_pointer_name(lazy_references[ref_name])
-                    return lookup_is_reference_to_itself(next_ref_name, owner_class_name, lazy_references)
+                    return lookup_is_reference_to_itself(
+                        next_ref_name,
+                        owner_class_name,
+                        lazy_references,
+                    )
 
                 return ref_name.casefold() == owner_class_name.casefold()
 
@@ -783,14 +789,14 @@ def build_schemas(*, components: Dict[str, Union[oai.Reference, oai.Schema]]) ->
     to_process: Iterable[Tuple[str, Union[oai.Reference, oai.Schema]]] = components.items()
     processing = True
     errors: List[PropertyError] = []
-    LazyReferencePropertyProxy.flush_internal_references()  # Cleanup side effects
     lazy_self_references: Dict[str, oai.Reference] = dict()
     visited: List[str] = []
+    references_by_name: Dict[str, oai.Reference] = dict()
+    references_to_process: List[Tuple[str, oai.Reference]] = list()
+    LazyReferencePropertyProxy.flush_internal_references()  # Cleanup side effects
 
     # References could have forward References so keep going as long as we are making progress
     while processing:
-        references_by_name: Dict[str, oai.Reference] = dict()
-        references_to_process: List[Tuple[str, oai.Reference]] = list()
         processing = False
         errors = []
         next_round = []
@@ -822,24 +828,29 @@ def build_schemas(*, components: Dict[str, Union[oai.Reference, oai.Schema]]) ->
             schemas_or_err = resolve_reference_and_update_schemas(name, reference, schemas, references_by_name)
 
             if isinstance(schemas_or_err, PropertyError):
-                if _reference_pointer_name(reference) in visited:
+                if _reference_pointer_name(reference) in visited and name not in lazy_self_references:
                     # It's a reference to an already visited Enum|Model; not yet resolved
                     # It's an indirect reference toward this Enum|Model;
                     # It will be lazy proxified and resolved later on
                     lazy_self_references[name] = reference
+                    processing = True
                 else:
                     errors.append(schemas_or_err)
 
+    schemas.errors.extend(errors)
+
     for name in lazy_self_references.keys():
         schemas_or_err = resolve_reference_and_update_schemas(
             name, lazy_self_references[name], schemas, references_by_name
         )
+        if isinstance(schemas_or_err, PropertyError):
+            schemas.errors.extend(errors)
 
-    schemas.errors.extend(errors)
     LazyReferencePropertyProxy.update_schemas(schemas)
     for reference_proxy, data in LazyReferencePropertyProxy.created_proxies():
         if not reference_proxy.resolve():
             schemas.errors.append(
                 PropertyError(data=data, detail="Could not find reference in parsed models or enums.")
             )
+
     return schemas

tests/test_parser/test_properties/test_init.py

@@ -1492,7 +1492,7 @@ def _base_api_data():
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/fooBarModel'
+                $ref: '#/components/schemas/fooBar'
 """
 
 
@@ -1607,93 +1607,7 @@ def test_build_schemas_resolve_inner_property_remote_reference():
     )
 
 
-def test_build_schemas_lazy_resolve_known_inner_property_local_reference():
-    import yaml
-
-    import openapi_python_client.schema as oai
-    from openapi_python_client.parser.properties import Schemas, build_schemas
-
-    data = yaml.safe_load(
-        f"""
-{_base_api_data()}
-components:
-  schemas:
-    fooBar:
-      type: object
-      properties:
-        childSettings:
-          type: array
-          items:
-            $ref: '#/components/schemas/bar'
-    bar:
-      type: object
-      properties:
-        a_prop:
-          type: number
-"""
-    )
-    openapi = oai.OpenAPI.parse_obj(data)
-
-    schemas = build_schemas(components=openapi.components.schemas)
-
-    foo_bar = schemas.models.get("FooBar")
-    bar = schemas.models.get("Bar")
-    assert len(schemas.errors) == 0
-    assert foo_bar and bar
-    child_settings = foo_bar.optional_properties[0]
-    assert child_settings.inner_property.reference == bar.reference
-
-
-def test_build_schemas_lazy_resolve_known_inner_property_local_reference_with_loop():
-    import yaml
-
-    import openapi_python_client.schema as oai
-    from openapi_python_client.parser.properties import Schemas, build_schemas
-
-    data = yaml.safe_load(
-        f"""
-{_base_api_data()}
-components:
-  schemas:
-    fooBar:
-      type: object
-      properties:
-        childSettings:
-          type: array
-          items:
-            $ref: '#/components/schemas/barDeeperLoop'
-
-    barDeeperLoop:
-      $ref: '#/components/schemas/barLoop'
-    barLoop:
-      $ref: '#/components/schemas/bar'
-    bar:
-      type: object
-      properties:
-        a_prop:
-          type: number
-
-"""
-    )
-    openapi = oai.OpenAPI.parse_obj(data)
-
-    schemas = build_schemas(components=openapi.components.schemas)
-
-    foo_bar = schemas.models.get("FooBar")
-    bar_deeper_loop = schemas.models.get("BarDeeperLoop")
-    bar_loop = schemas.models.get("BarLoop")
-    bar = schemas.models.get("Bar")
-    assert len(schemas.errors) == 0
-    assert foo_bar and bar_deeper_loop and bar_loop and bar
-    assert bar == bar_deeper_loop == bar_loop
-
-    child_settings = foo_bar.optional_properties[0]
-    assert child_settings.inner_property.reference == bar.reference
-    assert child_settings.inner_property.reference == bar_loop.reference
-    assert child_settings.inner_property.reference == bar_deeper_loop.reference
-
-
-def test_build_schemas_lazy_resolve_inner_property_self_local_reference():
+def test_build_schemas_lazy_resolve_inner_property_self_direct_reference():
     import yaml
 
     import openapi_python_client.schema as oai
@@ -1724,7 +1638,7 @@ def test_build_schemas_lazy_resolve_inner_property_self_local_reference():
     assert child_settings.inner_property.reference == foo_bar.reference
 
 
-def test_build_schemas_lazy_resolve_unknown_inner_property_local_reference():
+def test_build_schemas_lazy_resolve_known_inner_property_self_indirect_reference():
     import yaml
 
     import openapi_python_client.schema as oai
@@ -1740,16 +1654,25 @@ def test_build_schemas_lazy_resolve_unknown_inner_property_local_reference():
       properties:
         childSettings:
           type: array
+          description: test
           items:
-            $ref: '#/components/schemas/noexist'
+            $ref: '#/components/schemas/FoobarSelfIndirectReference'
+    FoobarSelfIndirectReference:
+      $ref: '#/components/schemas/foobarSelfDeeperIndirectReference'
+    foobarSelfDeeperIndirectReference:
+      $ref: '#/components/schemas/fooBar'
 """
     )
     openapi = oai.OpenAPI.parse_obj(data)
 
     schemas = build_schemas(components=openapi.components.schemas)
 
-    assert len(schemas.errors) == 1
-    assert schemas.errors[0] == PropertyError(
-        detail="invalid data in items of array childSettings",
-        data=oai.Reference(ref="#/components/schemas/noexist"),
-    )
+    assert len(schemas.errors) == 0
+    foobar = schemas.models.get("FooBar")
+    foobar_indirect_ref = schemas.models.get("FoobarSelfIndirectReference")
+    foobar_deep_indirect_ref = schemas.models.get("FoobarSelfDeeperIndirectReference")
+    assert foobar is not None and foobar_indirect_ref is not None and foobar_deep_indirect_ref is not None
+    assert foobar == foobar_indirect_ref == foobar_deep_indirect_ref
+
+    child_settings = foobar.optional_properties[0]
+    assert child_settings.inner_property.reference == foobar.reference