Merge pull request #28 from AdCombo/develop

for release 1.0.1

Author: roman-adcombo

.github/workflows/publish_to_pypi.yml

@@ -0,0 +1,27 @@
+name: Publish Python distributions to PyPI
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build-n-publish:
+    name: Build and publish Python distributions to PyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v1
+      with:
+        python-version: '3.8'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*

flask_combo_jsonapi/errors.py

@@ -30,7 +30,7 @@ def format_http_exception(ex):
     code = getattr(ex, 'code', None)
     try:
         status = int(code)
-    except TypeError:
+    except (TypeError, ValueError):
         return
 
     api_ex = STATUS_MAP.get(status)

flask_combo_jsonapi/resource.py

@@ -17,7 +17,7 @@
 from flask_combo_jsonapi.schema import compute_schema, get_relationships, get_model_field
 from flask_combo_jsonapi.data_layers.base import BaseDataLayer
 from flask_combo_jsonapi.data_layers.alchemy import SqlalchemyDataLayer
-from flask_combo_jsonapi.utils import JSONEncoder
+from flask_combo_jsonapi.utils import JSONEncoder, validate_model_init_params
 
 
 class ResourceMeta(MethodViewType):
@@ -39,6 +39,14 @@ def __new__(cls, name, bases, d):
             data_layer_kwargs = d["data_layer"]
             rv._data_layer = data_layer_cls(data_layer_kwargs)
 
+            if "schema" in d and "model" in data_layer_kwargs:
+                model = data_layer_kwargs["model"]
+                schema_fields = [get_model_field(d["schema"], key) for key in d["schema"]._declared_fields.keys()]
+                invalid_params = validate_model_init_params(model=model, params_names=schema_fields)
+                if invalid_params:
+                    raise Exception(f"Construction of {name} failed. Schema '{d['schema'].__name__}' has "
+                                    f"fields={invalid_params} are not declare in {model.__name__} init parameters")
+
         rv.decorators = (check_headers,)
         if "decorators" in d:
             rv.decorators += d["decorators"]

flask_combo_jsonapi/schema.py

@@ -108,8 +108,8 @@ def get_nested_fields(schema, model_field=False):
 
     nested_fields = []
     for (key, value) in schema._declared_fields.items():
-        if isinstance(value, List) and isinstance(value.container, Nested) \
-                and not isinstance(value.container, Relationship):
+        if isinstance(value, List) and isinstance(value.inner, Nested) \
+                and not isinstance(value.inner, Relationship):
             nested_fields.append(key)
         elif isinstance(value, Nested) and not isinstance(value, Relationship):
             nested_fields.append(key)

flask_combo_jsonapi/utils.py

@@ -1,3 +1,5 @@
+import inspect
+
 import simplejson as json
 from uuid import UUID
 from datetime import datetime
@@ -17,3 +19,30 @@ def default(self, obj):
         elif isinstance(obj, UUID):
             return str(obj)
         return json.JSONEncoder.default(self, obj)
+
+
+def get_model_init_params_names(model):
+    """Retrieve all params of model init method
+
+    :param DeclarativeMeta model: an object from sqlalchemy
+    :return tuple: list of init method fields names and boolean flag that init method has kwargs
+    """
+    argnames, _, varkw = inspect.getfullargspec(model.__init__)[:3]
+    if argnames:
+        argnames.remove('self')
+    return argnames, bool(varkw)
+
+
+def validate_model_init_params(model, params_names):
+    """Retrieve invalid params of model init method if it exists
+    :param DeclarativeMeta model: an object from sqlalchemy
+    :param list params_names: parameters names to check
+    :return list: list of invalid fields or None
+    """
+    init_args, has_kwargs = get_model_init_params_names(model)
+    if has_kwargs:
+        return
+
+    invalid_params = [name for name in params_names if name not in init_args]
+    if invalid_params:
+        return invalid_params

tests/test_errors.py

@@ -0,0 +1,28 @@
+from unittest.mock import Mock
+
+from flask_combo_jsonapi import JsonApiException
+from flask_combo_jsonapi.errors import format_http_exception
+
+
+def test_format_http_exception__value_error():
+    ex = Mock()
+    ex.code = 'f405'
+
+    assert format_http_exception(ex) is None
+
+
+def test_format_http_exception__type_error():
+    ex = Mock()
+    ex.code = 'not_int'
+
+    assert format_http_exception(ex) is None
+
+
+def test_format_http_exception__success():
+    ex = Mock()
+    ex.code = 400
+
+    res = format_http_exception(ex)
+
+    assert isinstance(res, JsonApiException)
+    assert res.status == '400'

tests/test_resource.py

@@ -0,0 +1,61 @@
+from unittest.mock import Mock
+
+import pytest
+from marshmallow_jsonapi import fields, Schema
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+
+from flask_combo_jsonapi import ResourceList
+
+
+@pytest.fixture(scope='module')
+def base():
+    yield declarative_base()
+
+
+@pytest.fixture(scope='module')
+def model(base):
+    class SampleModel(base):
+        __tablename__ = 'model_sample'
+
+        id = Column(Integer, primary_key=True, index=True)
+        key1 = Column(String)
+        key2 = Column(String)
+
+        def __init__(self, key1):
+            pass
+
+    yield SampleModel
+
+
+@pytest.fixture(scope='module')
+def schema_for_model(model):
+    class SampleSchema(Schema):
+        class Meta:
+            model = model
+
+        id = fields.Integer()
+        key1 = fields.String()
+        key2 = fields.String()
+
+    yield SampleSchema
+
+
+def test_resource_meta_init(model, schema_for_model):
+    expected_fields = ['id', 'key2']
+    raised_ex = None
+    try:
+        class SampleResourceList(ResourceList):
+            schema = schema_for_model
+            methods = ['GET', 'POST']
+            data_layer = {
+                'session': Mock(),
+                'model': model,
+            }
+    except Exception as ex:
+        raised_ex = ex
+
+    assert raised_ex
+    message = f"Construction of SampleResourceList failed. Schema '{schema_for_model.__name__}' " \
+              f"has fields={expected_fields}"
+    assert message in str(raised_ex)

tests/test_sqlalchemy_data_layer.py

@@ -98,6 +98,7 @@ class StringJsonAttributePerson(base):
         # This model uses a String type for "json_tags" to avoid dependency on a nonstandard SQL type in testing, \
         # while still demonstrating support
         address = Column(MagicJSON)
+        tags = Column(MagicJSON)
 
     yield StringJsonAttributePerson
 
@@ -136,7 +137,10 @@ class Computer(base):
 
 
 @pytest.fixture(scope="module")
-def engine(person_tag_model, person_single_tag_model, person_model, computer_model, string_json_attribute_person_model):
+def engine(
+        person_tag_model, person_single_tag_model, person_model,
+        computer_model, string_json_attribute_person_model
+    ):
     engine = create_engine("sqlite:///:memory:")
     person_tag_model.metadata.create_all(engine)
     person_single_tag_model.metadata.create_all(engine)
@@ -245,6 +249,7 @@ class Meta:
         name = fields.Str(required=True)
         birth_date = fields.DateTime()
         address = fields.Nested(address_schema, many=False)
+        tags = fields.List(fields.Dict())
 
     yield StringJsonAttributePersonSchema
 
@@ -774,6 +779,35 @@ def test_post_list_nested(client, register_routes, computer):
         assert response.status_code == 201
         assert json.loads(response.get_data())["data"]["attributes"]["tags"][0]["key"] == "k1"
 
+def test_post_list_nested_field(client, register_routes):
+    """
+    Test a schema contains a nested field is correctly serialized and deserialized
+    """
+    payload = {
+        'data': {
+            'type': 'string_json_attribute_person',
+            'attributes': {
+                'name': 'test',
+                'tags': [
+                    {'key': 'new_key', 'value': 'new_value'}
+                ],
+            },
+        }
+    }
+    with client:
+        response = client.post(
+            '/string_json_attribute_persons',
+            data=json.dumps(payload),
+            content_type='application/vnd.api+json'
+        )
+        assert response.status_code == 201, response.json['errors']
+        assert json.loads(
+            response.get_data()
+        )['data']['attributes']['tags'][0]['key'] == 'new_key'
+        assert json.loads(
+            response.get_data()
+        )['data']['attributes']['tags'][0]['value'] == 'new_value'
+
 
 def test_post_list_single(client, register_routes, person):
     payload = {

tests/test_utils.py

@@ -0,0 +1,73 @@
+import pytest
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+
+from flask_combo_jsonapi.utils import get_model_init_params_names, validate_model_init_params
+
+
+@pytest.fixture(scope='module')
+def base():
+    yield declarative_base()
+
+
+@pytest.fixture(scope='module')
+def model_without_init(base):
+    class ModelWithoutInit(base):
+        __tablename__ = 'model_without_init'
+
+        id = Column(Integer, primary_key=True, index=True)
+        key1 = Column(String)
+        key2 = Column(String)
+
+    yield ModelWithoutInit
+
+
+@pytest.fixture(scope='module')
+def model_with_kwargs_in_init(base):
+    class ModelWithKwargsInit(base):
+        __tablename__ = 'model_with_kwargs_init'
+
+        id = Column(Integer, primary_key=True, index=True)
+        key1 = Column(String)
+        key2 = Column(String)
+
+        def __init__(self, key1=0, **kwargs):
+            pass
+
+    yield ModelWithKwargsInit
+
+
+@pytest.fixture(scope='module')
+def model_with_positional_args_init(base):
+    class ModelWithPositionalArgsInit(base):
+        __tablename__ = 'model_with_positional_args_init'
+
+        id = Column(Integer, primary_key=True, index=True)
+        key1 = Column(String)
+        key2 = Column(String)
+
+        def __init__(self, key1, key2=0):
+            pass
+
+    yield ModelWithPositionalArgsInit
+
+
+def test_get_model_init_params_names(model_without_init, model_with_kwargs_in_init,
+                                     model_with_positional_args_init):
+    args, has_kwargs = get_model_init_params_names(model_without_init)
+    assert ([], True) == (args, has_kwargs)
+
+    args, has_kwargs = get_model_init_params_names(model_with_kwargs_in_init)
+    assert (['key1'], True) == (args, has_kwargs)
+
+    args, has_kwargs = get_model_init_params_names(model_with_positional_args_init)
+    assert (['key1', 'key2'], False) == (args, has_kwargs)
+
+
+def test_validate_model_init_params(model_with_kwargs_in_init, model_with_positional_args_init):
+    schema_attrs = ['id', 'key1', 'key2']
+    invalid_params = validate_model_init_params(model_with_kwargs_in_init, schema_attrs)
+    assert invalid_params is None
+
+    invalid_params = validate_model_init_params(model_with_positional_args_init, schema_attrs)
+    assert invalid_params == ['id']