e2e / add {api_init.py.jina, endpoint_init.py.jinja} custom templates tests

Author: p1-ra

end_to_end_tests/custom-templates-golden-record/README.md

@@ -0,0 +1 @@
+my-test-api-client

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/__init__.py

@@ -0,0 +1,17 @@
+""" Contains methods for accessing the API """
+
+
+from typing import Type
+
+from my_test_api_client.api.default import DefaultEndpoints
+from my_test_api_client.api.tests import TestsEndpoints
+
+
+class MyTestApiClientApi:
+    @classmethod
+    def tests(cls) -> Type[TestsEndpoints]:
+        return TestsEndpoints
+
+    @classmethod
+    def default(cls) -> Type[DefaultEndpoints]:
+        return DefaultEndpoints

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/default/__init__.py

@@ -0,0 +1,16 @@
+""" Contains methods for accessing the API Endpoints """
+
+
+import types
+
+from my_test_api_client.api.default import get_common_parameters, post_common_parameters
+
+
+class DefaultEndpoints:
+    @classmethod
+    def get_common_parameters(cls) -> types.ModuleType:
+        return get_common_parameters
+
+    @classmethod
+    def post_common_parameters(cls) -> types.ModuleType:
+        return post_common_parameters

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/tests/__init__.py

@@ -0,0 +1,129 @@
+""" Contains methods for accessing the API Endpoints """
+
+
+import types
+
+from my_test_api_client.api.tests import (
+    defaults_tests_defaults_post,
+    get_basic_list_of_booleans,
+    get_basic_list_of_floats,
+    get_basic_list_of_integers,
+    get_basic_list_of_strings,
+    get_user_list,
+    int_enum_tests_int_enum_post,
+    json_body_tests_json_body_post,
+    no_response_tests_no_response_get,
+    octet_stream_tests_octet_stream_get,
+    optional_value_tests_optional_query_param,
+    test_inline_objects,
+    token_with_cookie_auth_token_with_cookie_get,
+    unsupported_content_tests_unsupported_content_get,
+    upload_file_tests_upload_post,
+)
+
+
+class TestsEndpoints:
+    @classmethod
+    def get_user_list(cls) -> types.ModuleType:
+        """
+        Get a list of things
+        """
+        return get_user_list
+
+    @classmethod
+    def get_basic_list_of_strings(cls) -> types.ModuleType:
+        """
+        Get a list of strings
+        """
+        return get_basic_list_of_strings
+
+    @classmethod
+    def get_basic_list_of_integers(cls) -> types.ModuleType:
+        """
+        Get a list of integers
+        """
+        return get_basic_list_of_integers
+
+    @classmethod
+    def get_basic_list_of_floats(cls) -> types.ModuleType:
+        """
+        Get a list of floats
+        """
+        return get_basic_list_of_floats
+
+    @classmethod
+    def get_basic_list_of_booleans(cls) -> types.ModuleType:
+        """
+        Get a list of booleans
+        """
+        return get_basic_list_of_booleans
+
+    @classmethod
+    def upload_file_tests_upload_post(cls) -> types.ModuleType:
+        """
+        Upload a file
+        """
+        return upload_file_tests_upload_post
+
+    @classmethod
+    def json_body_tests_json_body_post(cls) -> types.ModuleType:
+        """
+        Try sending a JSON body
+        """
+        return json_body_tests_json_body_post
+
+    @classmethod
+    def defaults_tests_defaults_post(cls) -> types.ModuleType:
+        """
+        Defaults
+        """
+        return defaults_tests_defaults_post
+
+    @classmethod
+    def octet_stream_tests_octet_stream_get(cls) -> types.ModuleType:
+        """
+        Octet Stream
+        """
+        return octet_stream_tests_octet_stream_get
+
+    @classmethod
+    def no_response_tests_no_response_get(cls) -> types.ModuleType:
+        """
+        No Response
+        """
+        return no_response_tests_no_response_get
+
+    @classmethod
+    def unsupported_content_tests_unsupported_content_get(cls) -> types.ModuleType:
+        """
+        Unsupported Content
+        """
+        return unsupported_content_tests_unsupported_content_get
+
+    @classmethod
+    def int_enum_tests_int_enum_post(cls) -> types.ModuleType:
+        """
+        Int Enum
+        """
+        return int_enum_tests_int_enum_post
+
+    @classmethod
+    def test_inline_objects(cls) -> types.ModuleType:
+        """
+        Test Inline Objects
+        """
+        return test_inline_objects
+
+    @classmethod
+    def optional_value_tests_optional_query_param(cls) -> types.ModuleType:
+        """
+        Test optional query parameters
+        """
+        return optional_value_tests_optional_query_param
+
+    @classmethod
+    def token_with_cookie_auth_token_with_cookie_get(cls) -> types.ModuleType:
+        """
+        Test optional cookie parameters
+        """
+        return token_with_cookie_auth_token_with_cookie_get

end_to_end_tests/test_custom_templates/api_init.py.jinja

@@ -0,0 +1,19 @@
+""" Contains methods for accessing the API """
+
+{% macro snake_to_pascal_case(name) %}
+{%- for part in name.split('_') -%}
+{{ part | capitalize }}
+{%- endfor -%}
+{% endmacro %}
+
+from typing import Type
+{% for tag, collection in endpoint_collections_by_tag %}
+from {{ package_name }}.api.{{ tag }} import {{ snake_to_pascal_case(tag) }}Endpoints
+{% endfor %}
+
+class {{ snake_to_pascal_case(package_name) }}Api:
+{% for tag, collection in endpoint_collections_by_tag %}
+    @classmethod
+    def {{ tag }}(cls) -> Type[{{ snake_to_pascal_case(tag) }}Endpoints]:
+        return {{ snake_to_pascal_case(tag) }}Endpoints
+{% endfor %}

end_to_end_tests/test_custom_templates/endpoint_init.py.jinja

@@ -0,0 +1,37 @@
+""" Contains methods for accessing the API Endpoints """
+
+{% macro snake_to_pascal_case(name) %}
+{%- for part in name.split('_') -%}
+{{ part | capitalize }}
+{%- endfor -%}
+{% endmacro %}
+
+{% macro to_snake_name(name) %}
+{% set last_snakize = {'at': 0} %}
+{%- for part in name -%}
+{{ '_' if not loop.first and part in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' and (loop.index - last_snakize.at) > 1 and not last_snakize.update({'at': loop.index}) }}{{ part | lower }}
+{%- endfor -%}
+{% endmacro %}
+
+import types
+{% for endpoint in endpoints %}
+from {{ package_name }}.api.{{ tag }} import {{ to_snake_name(endpoint.name) }}
+{% endfor %}
+
+class {{ snake_to_pascal_case(tag) }}Endpoints:
+
+{% for endpoint in endpoints %}
+
+    @classmethod
+    def {{ to_snake_name(endpoint.name) }}(cls) -> types.ModuleType:
+        {% if endpoint.description %}
+        """
+            {{ endpoint.description }}
+        """
+        {% elif endpoint.summary %}
+        """
+            {{ endpoint.summary  }}
+        """
+        {% endif %}
+        return {{ to_snake_name(endpoint.name) }}
+{% endfor %}

end_to_end_tests/test_end_to_end.py

@@ -12,7 +12,8 @@
 def _compare_directories(
     record: Path,
     test_subject: Path,
-    expected_differences: Optional[Dict[str, str]] = None,
+    expected_differences: Optional[Dict[str, str]] = None, #key: path relative to generated directory, value: expected generated content
+    depth=0
 ):
     first_printable = record.relative_to(Path.cwd())
     second_printable = test_subject.relative_to(Path.cwd())
@@ -22,28 +23,42 @@ def _compare_directories(
         pytest.fail(f"{first_printable} or {second_printable} was missing: {missing_files}", pytrace=False)
 
     expected_differences = expected_differences or {}
-    _, mismatch, errors = cmpfiles(record, test_subject, dc.common_files, shallow=False)
-    mismatch = set(mismatch)
-
-    for file_name in mismatch | set(expected_differences.keys()):
-        if file_name not in expected_differences:
-            continue
-        if file_name not in mismatch:
-            pytest.fail(f"Expected {file_name} to be different but it was not", pytrace=False)
-        generated = (test_subject / file_name).read_text()
-        assert generated == expected_differences[file_name], f"Unexpected output in {file_name}"
-        del expected_differences[file_name]
-        mismatch.remove(file_name)
-
-    if mismatch:
+    _, mismatches, errors = cmpfiles(record, test_subject, dc.common_files, shallow=False)
+    mismatches = set(mismatches)
+
+    expected_path_mismatches = []
+    for file_name in mismatches:
+
+        mismatch_file_path = test_subject.joinpath(file_name)
+        for expected_differences_path in expected_differences.keys():
+
+            if mismatch_file_path.match(str(expected_differences_path)):
+            
+                generated_content = (test_subject / file_name).read_text()
+                expected_content = expected_differences[expected_differences_path]
+                assert generated_content == expected_content, f"Unexpected output in {mismatch_file_path}"
+                expected_path_mismatches.append(expected_differences_path)
+
+    for path_mismatch in expected_path_mismatches:
+        matched_file_name = path_mismatch.name
+        mismatches.remove(matched_file_name)
+        del expected_differences[path_mismatch]
+
+    if mismatches:
         pytest.fail(
-            f"{first_printable} and {second_printable} had differing files: {mismatch}, and errors {errors}",
+            f"{first_printable} and {second_printable} had differing files: {mismatches}, and errors {errors}",
             pytrace=False,
         )
 
     for sub_path in dc.common_dirs:
-        _compare_directories(record / sub_path, test_subject / sub_path, expected_differences=expected_differences)
+        _compare_directories(record / sub_path, test_subject / sub_path, expected_differences=expected_differences, depth=depth+1)
 
+    if depth == 0 and len(expected_differences.keys()) > 0:
+        failure = "\n".join([f"Expected {path} to be different but it was not" for path in expected_differences.keys()])
+        pytest.fail(
+            failure,
+            pytrace=False
+        )
 
 def run_e2e_test(extra_args=None, expected_differences=None):
     runner = CliRunner()
@@ -60,6 +75,7 @@ def run_e2e_test(extra_args=None, expected_differences=None):
 
     if result.exit_code != 0:
         raise result.exception
+
     _compare_directories(gr_path, output_path, expected_differences=expected_differences)
 
     import mypy.api
@@ -75,7 +91,20 @@ def test_end_to_end():
 
 
 def test_custom_templates():
+    expected_differences = {} #key: path relative to generated directory, value: expected generated content
+    expected_difference_paths = [
+        Path('README.md'),
+        Path('my_test_api_client').joinpath('api', '__init__.py'),
+        Path('my_test_api_client').joinpath('api', 'tests', '__init__.py'),
+        Path('my_test_api_client').joinpath('api', 'default', '__init__.py'),
+    ]
+
+    golden_tpls_root_dir = Path(__file__).parent.joinpath('custom-templates-golden-record')
+    for expected_difference_path in expected_difference_paths:
+        path = Path('my-test-api-client').joinpath(expected_difference_path)
+        expected_differences[path] = (golden_tpls_root_dir / expected_difference_path).read_text()
+
     run_e2e_test(
-        extra_args=["--custom-template-path=end_to_end_tests/test_custom_templates"],
-        expected_differences={"README.md": "my-test-api-client"},
+        extra_args=["--custom-template-path=end_to_end_tests/test_custom_templates/"],
+        expected_differences=expected_differences,
     )