fix: Update for rebase on main

Author: dbanty

end_to_end_tests/golden-record/my_test_api_client/api/parameters/delete_common_parameters_overriding_param.py

@@ -7,9 +7,9 @@
 
 
 def _get_kwargs(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: Union[Unset, None, str] = UNSET,
 ) -> Dict[str, Any]:
     url = "{}/common_parameters_overriding/{param}".format(client.base_url, param=param_path)
@@ -41,14 +41,14 @@ def _build_response(*, response: httpx.Response) -> Response[Any]:
 
 
 def sync_detailed(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: Union[Unset, None, str] = UNSET,
 ) -> Response[Any]:
     kwargs = _get_kwargs(
-        client=client,
         param_path=param_path,
+        client=client,
         param_query=param_query,
     )
 
@@ -60,14 +60,14 @@ def sync_detailed(
 
 
 async def asyncio_detailed(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: Union[Unset, None, str] = UNSET,
 ) -> Response[Any]:
     kwargs = _get_kwargs(
-        client=client,
         param_path=param_path,
+        client=client,
         param_query=param_query,
     )
 

end_to_end_tests/golden-record/my_test_api_client/api/parameters/get_common_parameters_overriding_param.py

@@ -7,9 +7,9 @@
 
 
 def _get_kwargs(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: str = "overriden_in_GET",
 ) -> Dict[str, Any]:
     url = "{}/common_parameters_overriding/{param}".format(client.base_url, param=param_path)
@@ -41,14 +41,14 @@ def _build_response(*, response: httpx.Response) -> Response[Any]:
 
 
 def sync_detailed(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: str = "overriden_in_GET",
 ) -> Response[Any]:
     kwargs = _get_kwargs(
-        client=client,
         param_path=param_path,
+        client=client,
         param_query=param_query,
     )
 
@@ -60,14 +60,14 @@ def sync_detailed(
 
 
 async def asyncio_detailed(
+    param_path: str,
     *,
     client: Client,
-    param_path: str,
     param_query: str = "overriden_in_GET",
 ) -> Response[Any]:
     kwargs = _get_kwargs(
-        client=client,
         param_path=param_path,
+        client=client,
         param_query=param_query,
     )
 

openapi_python_client/parser/openapi.py

@@ -1,5 +1,5 @@
-import itertools
 import re
+from collections import OrderedDict
 from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union
@@ -55,6 +55,8 @@ def from_data(
                     endpoint, schemas = Endpoint.add_parameters(
                         endpoint=endpoint, data=path_data, schemas=schemas, config=config
                     )
+                if not isinstance(endpoint, ParseError):
+                    endpoint = Endpoint.sort_parameters(endpoint=endpoint)
                 if isinstance(endpoint, ParseError):
                     endpoint.header = (
                         f"ERROR parsing {method.upper()} {path} within {tag}. Endpoint will not be generated."
@@ -64,7 +66,6 @@ def from_data(
                 for error in endpoint.errors:
                     error.header = f"WARNING parsing {method.upper()} {path} within {tag}."
                     collection.parse_errors.append(error)
-                endpoint = Endpoint.sort_parameters(endpoint=endpoint, path=path)
                 collection.endpoints.append(endpoint)
 
         return endpoints_by_tag, schemas
@@ -95,7 +96,7 @@ class Endpoint:
     summary: Optional[str] = ""
     relative_imports: Set[str] = field(default_factory=set)
     query_parameters: Dict[str, Property] = field(default_factory=dict)
-    path_parameters: Dict[str, Property] = field(default_factory=dict)
+    path_parameters: OrderedDict[str, Property] = field(default_factory=OrderedDict)
     header_parameters: Dict[str, Property] = field(default_factory=dict)
     cookie_parameters: Dict[str, Property] = field(default_factory=dict)
     responses: List[Response] = field(default_factory=list)
@@ -331,10 +332,13 @@ def sort_parameters(*, endpoint: "Endpoint") -> Union["Endpoint", ParseError]:
         endpoint = deepcopy(endpoint)
         parameters_from_path = re.findall(_PATH_PARAM_REGEX, endpoint.path)
         try:
-            endpoint.path_parameters.sort(key=lambda p: parameters_from_path.index(p.name))
+            sorted_params = sorted(
+                endpoint.path_parameters.values(), key=lambda param: parameters_from_path.index(param.name)
+            )
+            endpoint.path_parameters = OrderedDict((param.name, param) for param in sorted_params)
         except ValueError:
             pass  # We're going to catch the difference down below
-        path_parameter_names = [p.name for p in endpoint.path_parameters]
+        path_parameter_names = [name for name in endpoint.path_parameters]
         if parameters_from_path != path_parameter_names:
             return ParseError(
                 detail=f"Incorrect path templating for {endpoint.path} (Path parameters do not match with path)",

tests/test_parser/test_openapi.py

@@ -530,22 +530,20 @@ def test_add_parameters_parse_error(self, mocker):
             property_schemas,
         )
 
-    def test_add_parameters_parse_error_on_non_required_path_param(self, mocker):
-        from openapi_python_client.parser.openapi import Endpoint, Schemas
-
+    def test__add_parameters_parse_error_on_non_required_path_param(self):
         endpoint = self.make_endpoint()
-        parsed_schemas = mocker.MagicMock()
-        mocker.patch(f"{MODULE_NAME}.property_from_data", return_value=(mocker.MagicMock(), parsed_schemas))
         param = oai.Parameter.construct(
-            name="test", required=False, param_schema=mocker.MagicMock(), param_in=oai.ParameterLocation.PATH
+            name="test",
+            required=False,
+            param_schema=oai.Schema.construct(type="string"),
+            param_in=oai.ParameterLocation.PATH,
         )
         schemas = Schemas()
-        config = MagicMock()
 
         result = Endpoint.add_parameters(
-            endpoint=endpoint, data=oai.Operation.construct(parameters=[param]), schemas=schemas, config=config
+            endpoint=endpoint, data=oai.Operation.construct(parameters=[param]), schemas=schemas, config=Config()
         )
-        assert result == (ParseError(data=param, detail="Path parameter must be required"), parsed_schemas)
+        assert result == (ParseError(data=param, detail="Path parameter must be required"), schemas)
 
     def test_validation_error_when_location_not_supported(self, mocker):
         parsed_schemas = mocker.MagicMock()
@@ -656,7 +654,7 @@ def test__add_parameters_skips_references(self):
             ]
         )
 
-        (endpoint, _) = endpoint._add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
+        (endpoint, _) = endpoint.add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
 
         assert isinstance(endpoint, Endpoint)
         assert (
@@ -679,7 +677,7 @@ def test__add_parameters_skips_params_without_schemas(self):
             ]
         )
 
-        (endpoint, _) = endpoint._add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
+        (endpoint, _) = endpoint.add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
 
         assert isinstance(endpoint, Endpoint)
         assert len(endpoint.path_parameters) == 0
@@ -692,11 +690,13 @@ def test__add_parameters_same_identifier_conflict(self):
                     name="param",
                     param_in="path",
                     param_schema=oai.Schema.construct(nullable=False, type="string"),
+                    required=True,
                 ),
                 oai.Parameter.construct(
                     name="param_path",
                     param_in="path",
                     param_schema=oai.Schema.construct(nullable=False, type="string"),
+                    required=True,
                 ),
                 oai.Parameter.construct(
                     name="param",
@@ -706,7 +706,7 @@ def test__add_parameters_same_identifier_conflict(self):
             ]
         )
 
-        (err, _) = endpoint._add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
+        (err, _) = endpoint.add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
 
         assert isinstance(err, ParseError)
         assert "param_path" in err.detail
@@ -742,7 +742,7 @@ def test__add_parameters_query_optionality(self):
             ]
         )
 
-        (endpoint, _) = endpoint._add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
+        (endpoint, _) = endpoint.add_parameters(endpoint=endpoint, data=data, schemas=Schemas(), config=Config())
 
         assert len(endpoint.query_parameters) == 4, "Not all query params were added"
         for param in endpoint.query_parameters.values():
@@ -798,33 +798,29 @@ def test_add_parameters_duplicate_properties_different_location(self):
         assert result.path_parameters["test"].name == "test"
         assert result.query_parameters["test"].name == "test"
 
-    def test_sort_parameters(self, mocker):
+    def test_sort_parameters(self, string_property_factory):
         from openapi_python_client.parser.openapi import Endpoint
 
         endpoint = self.make_endpoint()
         endpoint.path = "/multiple-path-parameters/{param4}/{param2}/{param1}/{param3}"
 
         for i in range(1, 5):
-            param = oai.Parameter.construct(
-                name=f"param{i}", required=True, param_schema=mocker.MagicMock(), param_in=oai.ParameterLocation.PATH
-            )
-            endpoint.path_parameters.append(param)
+            prop = string_property_factory(name=f"param{i}")
+            endpoint.path_parameters[prop.name] = prop
 
         result = Endpoint.sort_parameters(endpoint=endpoint)
-        result_names = [p.name for p in result.path_parameters]
+        result_names = [name for name in result.path_parameters]
         expected_names = [f"param{i}" for i in (4, 2, 1, 3)]
 
         assert result_names == expected_names
 
-    def test_sort_parameters_invalid_path_templating(self, mocker):
+    def test_sort_parameters_invalid_path_templating(self, string_property_factory):
         from openapi_python_client.parser.openapi import Endpoint
 
         endpoint = self.make_endpoint()
         endpoint.path = "/multiple-path-parameters/{param1}/{param2}"
-        param = oai.Parameter.construct(
-            name="param1", required=True, param_schema=mocker.MagicMock(), param_in=oai.ParameterLocation.PATH
-        )
-        endpoint.path_parameters.append(param)
+        param = string_property_factory(name="param1")
+        endpoint.path_parameters[param.name] = param
 
         result = Endpoint.sort_parameters(endpoint=endpoint)