Merge pull request #195 from WinterFramework/custom_crud_methods

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [9.0.0] - 2021-03-31
+
+### New features
+- CRUDRepository now supports custom implementation extensions
+### Changed
+- set_factory changed to set_injector
+- DomainEventDispatcher.set_handler_factory is deleted
+
 ## [8.2.0] - 2021-01-27
 
 ### New features

tests/conftest.py

@@ -1,7 +1,14 @@
 from pathlib import Path
 
 import django
+from injector import CallableProvider
+from injector import Injector
+from injector import Module
+from injector import singleton
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
 
+from winter.core import set_injector
 from .entities import Guest
 
 
@@ -28,4 +35,15 @@ def pytest_configure():
             'tests',
         ),
     )
+    injector = Injector([Configuration])
+    set_injector(injector)
     django.setup()
+
+
+class Configuration(Module):
+    def configure(self, binder):
+        binder.bind(Engine, to=CallableProvider(make_engine), scope=singleton)
+
+
+def make_engine():
+    return create_engine('sqlite://')

tests/controllers/__init__.py

@@ -1,10 +1,10 @@
 from .controller_with_exceptions import ControllerWithExceptions
-from .controller_with_request_data import ControllerWithRequestData
 from .controller_with_limits import ControllerWithLimits
 from .controller_with_media_types_routing import ControllerWithMediaTypesRouting
 from .controller_with_path_parameters import ControllerWithPathParameters
 from .controller_with_problem_exceptions import ControllerWithProblemExceptions
 from .controller_with_query_parameters import ControllerWithQueryParameters
+from .controller_with_request_data import ControllerWithRequestData
 from .controller_with_response_headers import ControllerWithResponseHeaders
 from .controller_with_throttling import ControllerWithThrottling
 from .no_authentication_controller import NoAuthenticationController

tests/controllers/controller_with_exceptions.py

@@ -36,7 +36,7 @@ def handle(self, exception: CustomException) -> int:
 
 class WithUnknownArgumentExceptionHandler(winter.web.ExceptionHandler):
     @winter.response_status(400)
-    def handle(self, exception: CustomException, unknown_argument: int) -> str:  # pragma: no cover
+    def handle(self, exception: WithUnknownArgumentException, unknown_argument: int) -> str:  # pragma: no cover
         pass
 
 

tests/core/test_annotations.py

@@ -81,11 +81,13 @@ def test_get_one():
     assert annotation == SimpleAnnotation('first')
 
 
-@pytest.mark.parametrize(('decorator_factory', 'error_message_template'), (
-    (annotate, 'Need function or class. Got: {instance}'),
-    (annotate_class, 'Need class. Got: {instance}'),
-    (annotate_method, 'Need function. Got: {instance}'),
-))
+@pytest.mark.parametrize(
+    ('decorator_factory', 'error_message_template'), (
+        (annotate, 'Need function or class. Got: {instance}'),
+        (annotate_class, 'Need class. Got: {instance}'),
+        (annotate_method, 'Need function. Got: {instance}'),
+    ),
+)
 def test_annotate_with_instance(decorator_factory, error_message_template):
     instance = object()
 

tests/core/test_component_method_argument.py

@@ -6,7 +6,7 @@
 
 def test_parameter():
     def test(number: int) -> int:  # pragma: no cover
-        return number
+        pass
 
     method = ComponentMethod(test)
     argument = method.get_argument('number')
@@ -18,7 +18,7 @@ def test(number: int) -> int:  # pragma: no cover
 
 def test_default():
     def test(number: int) -> int:  # pragma: no cover
-        return number
+        pass
 
     method = ComponentMethod(test)
     argument = method.get_argument('number')

tests/core/test_injection.py

@@ -0,0 +1,6 @@
+from winter.core import get_injector
+
+
+def test_get_injector():
+    injector = get_injector()
+    assert injector is not None

tests/routing/test_path_parameters.py

@@ -7,21 +7,23 @@
 from tests.controllers.controller_with_path_parameters import ControllerWithPathParameters
 from tests.controllers.controller_with_path_parameters import OneTwoEnum
 from tests.controllers.controller_with_path_parameters import OneTwoEnumWithInt
+from winter.core import Component
 from winter.web.argument_resolver import ArgumentNotSupported
 from winter.web.controller import get_component
-from winter.core import Component
 from winter.web.path_parameters_argument_resolver import PathParametersArgumentResolver
 
 uuid_ = uuid.uuid4()
 
 
-@pytest.mark.parametrize('path, arg_name, expected_value', [
-    (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param1', '123'),
-    (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param2', 456),
-    (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param3', OneTwoEnum.ONE),
-    (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param4', uuid_),
-    (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param5', OneTwoEnumWithInt.TWO),
-])
+@pytest.mark.parametrize(
+    'path, arg_name, expected_value', [
+        (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param1', '123'),
+        (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param2', 456),
+        (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param3', OneTwoEnum.ONE),
+        (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param4', uuid_),
+        (f'/controller_with_path_parameters/123/456/one/{uuid_}/2/', 'param5', OneTwoEnumWithInt.TWO),
+    ],
+)
 def test_resolve_path_parameter(path, arg_name, expected_value):
     component = Component.get_by_cls(ControllerWithPathParameters)
     argument = component.get_method('test').get_argument(arg_name)
@@ -36,11 +38,13 @@ def test_resolve_path_parameter(path, arg_name, expected_value):
     assert result == expected_value
 
 
-@pytest.mark.parametrize('controller_class, method_name, arg_name, expected_value', [
-    (ControllerWithPathParameters, 'test', 'param1', True),
-    (ControllerWithPathParameters, 'test', 'param2', True),
-    (ControllerWithPathParameters, 'test', 'param6', False),
-])
+@pytest.mark.parametrize(
+    'controller_class, method_name, arg_name, expected_value', [
+        (ControllerWithPathParameters, 'test', 'param1', True),
+        (ControllerWithPathParameters, 'test', 'param2', True),
+        (ControllerWithPathParameters, 'test', 'param6', False),
+    ],
+)
 def test_is_supported_path_parameter(controller_class, method_name, arg_name, expected_value):
     component = get_component(controller_class)
     argument = component.get_method(method_name).get_argument(arg_name)

tests/winter_sqlalchemy/test_injector.py

@@ -1,61 +0,0 @@
-from typing import Optional
-
-from injector import ClassProvider
-from injector import Injector
-from injector import Module
-from injector import singleton
-from sqlalchemy import Column
-from sqlalchemy import Integer
-from sqlalchemy import MetaData
-from sqlalchemy import String
-from sqlalchemy import Table
-from sqlalchemy import create_engine
-from sqlalchemy.engine import Engine
-from sqlalchemy.orm import mapper
-
-from winter.data import CRUDRepository
-from winter_ddd import AggregateRoot
-from winter_sqlalchemy import sqla_crud
-
-
-class Fixture:
-    def __init__(self):
-        class MyEntity(AggregateRoot):
-            pass
-
-        engine = self._engine = create_engine('sqlite://')
-        metadata = MetaData()
-        my_entity_table = Table(
-            'my_entities',
-            metadata,
-            Column('id', Integer, primary_key=True),
-            Column('name', String),
-        )
-        mapper(MyEntity, my_entity_table)
-
-        class MyRepository(CRUDRepository[MyEntity, int]):
-            pass
-
-        metadata.create_all(bind=self._engine)
-
-        class Configuration(Module):
-            def configure(self, binder):
-                binder.bind(Engine, engine)
-                binder.bind(MyRepository, to=ClassProvider(sqla_crud(MyRepository)), scope=singleton)
-
-        configuration = Configuration()
-        injector = Injector([configuration])
-        self.repository = injector.get(MyRepository)
-
-    def execute(self, sql):
-        return self._engine.execute(sql)
-
-
-def test_count():
-    fixture = Fixture()
-    fixture.execute('INSERT INTO my_entities (id) VALUES (1), (2), (3);')
-
-    # Act
-    count = fixture.repository.count()
-
-    assert count == 3