bug fixes and fix tests

Author: akira-dev

flask_rest_jsonapi/data_layers/alchemy.py

@@ -12,9 +12,9 @@
 from flask import current_app
 from flask_rest_jsonapi.data_layers.base import BaseDataLayer
 from flask_rest_jsonapi.exceptions import RelationNotFound, RelatedObjectNotFound, JsonApiException,\
-    InvalidSort, ObjectNotFound
+    InvalidSort, ObjectNotFound, InvalidInclude
 from flask_rest_jsonapi.data_layers.filtering.alchemy import create_filters
-from flask_rest_jsonapi.schema import get_model_field, get_related_schema, get_relationships
+from flask_rest_jsonapi.schema import get_model_field, get_related_schema, get_relationships, get_schema_field
 
 
 class SqlalchemyDataLayer(BaseDataLayer):
@@ -43,8 +43,8 @@ def create_object(self, data, view_kwargs):
         """
         self.before_create_object(data, view_kwargs)
 
-        relationship_fields = get_relationships(self.resource.schema)
-        obj = self.model(**{get_model_field(self.resource.schema, key): value
+        relationship_fields = get_relationships(self.resource.schema, model_field=True)
+        obj = self.model(**{key: value
                             for (key, value) in data.items() if key not in relationship_fields})
         self.apply_relationships(data, obj)
 
@@ -131,10 +131,10 @@ def update_object(self, obj, data, view_kwargs):
 
         self.before_update_object(obj, data, view_kwargs)
 
-        relationship_fields = get_relationships(self.resource.schema)
+        relationship_fields = get_relationships(self.resource.schema, model_field=True)
         for key, value in data.items():
-            if hasattr(obj, get_model_field(self.resource.schema, key)) and key not in relationship_fields:
-                setattr(obj, get_model_field(self.resource.schema, key), value)
+            if hasattr(obj, key) and key not in relationship_fields:
+                setattr(obj, key, value)
 
         self.apply_relationships(data, obj)
 
@@ -395,12 +395,12 @@ def apply_relationships(self, data, obj):
         :return boolean: True if relationship have changed else False
         """
         relationships_to_apply = []
-        relationship_fields = get_relationships(self.resource.schema)
+        relationship_fields = get_relationships(self.resource.schema, model_field=True)
         for key, value in data.items():
             if key in relationship_fields:
-                related_model = getattr(obj.__class__,
-                                        get_model_field(self.resource.schema, key)).property.mapper.class_
-                related_id_field = self.resource.schema._declared_fields[key].id_field
+                related_model = getattr(obj.__class__, key).property.mapper.class_
+                schema_field = get_schema_field(self.resource.schema, key)
+                related_id_field = self.resource.schema._declared_fields[schema_field].id_field
 
                 if isinstance(value, list):
                     related_objects = []
@@ -419,7 +419,7 @@ def apply_relationships(self, data, obj):
                     relationships_to_apply.append({'field': key, 'value': related_object})
 
         for relationship in relationships_to_apply:
-            setattr(obj, get_model_field(self.resource.schema, relationship['field']), relationship['value'])
+            setattr(obj, relationship['field'], relationship['value'])
 
     def filter_query(self, query, filter_info, model):
         """Filter query according to jsonapi 1.0
@@ -480,7 +480,10 @@ def eagerload_includes(self, query, qs):
             if '.' in include:
                 current_schema = self.resource.schema
                 for obj in include.split('.'):
-                    field = get_model_field(current_schema, obj)
+                    try:
+                        field = get_model_field(current_schema, obj)
+                    except Exception as e:
+                        raise InvalidInclude(str(e))
 
                     if joinload_object is None:
                         joinload_object = joinedload(field, innerjoin=True)
@@ -496,7 +499,11 @@ def eagerload_includes(self, query, qs):
 
                     current_schema = related_schema_cls
             else:
-                field = get_model_field(self.resource.schema, include)
+                try:
+                    field = get_model_field(self.resource.schema, include)
+                except Exception as e:
+                    raise InvalidInclude(str(e))
+
                 joinload_object = joinedload(field, innerjoin=True)
 
             query = query.options(joinload_object)

flask_rest_jsonapi/schema.py

@@ -95,13 +95,18 @@ def get_model_field(schema, field):
     return field
 
 
-def get_relationships(schema):
+def get_relationships(schema, model_field=False):
     """Return relationship fields of a schema
 
     :param Schema schema: a marshmallow schema
     :param list: list of relationship fields of a schema
     """
-    return [key for (key, value) in schema._declared_fields.items() if isinstance(value, Relationship)]
+    relationships = [key for (key, value) in schema._declared_fields.items() if isinstance(value, Relationship)]
+
+    if model_field is True:
+        relationships = [get_model_field(schema, key) for key in relationships]
+
+    return relationships
 
 
 def get_related_schema(schema, field):
@@ -128,3 +133,18 @@ def get_schema_from_type(resource_type):
             pass
 
     raise Exception("Couldn't find schema for type: {}".format(resource_type))
+
+
+def get_schema_field(schema, field):
+    """Get the schema field of a model field
+
+    :param Schema schema: a marshmallow schema
+    :param str field: the name of the model field
+    :return str: the name of the field in the schema
+    """
+    schema_fields_to_model = {key: get_model_field(schema, key) for (key, value) in schema._declared_fields.items()}
+    for key, value in schema_fields_to_model.items():
+        if value == field:
+            return key
+
+    raise Exception("Couldn't find schema field from {}".format(field))

tests/test_sqlalchemy_data_layer.py

@@ -328,10 +328,11 @@ def __init__(self, kwargs):
     return get_object
 
 
-def test_add_pagination_links():
-    qs = {'page[number]': '15', 'page[size]': '10'}
-    qsm = QSManager(qs, None)
-    add_pagination_links(dict(), 1000, qsm, str())
+def test_add_pagination_links(app):
+    with app.app_context():
+        qs = {'page[number]': '15', 'page[size]': '10'}
+        qsm = QSManager(qs, None)
+        add_pagination_links(dict(), 1000, qsm, str())
 
 
 def test_Node(person_model, person_schema, monkeypatch):
@@ -390,33 +391,35 @@ def test_query_string_manager(person_schema):
         qsm.sorting
 
 
-def test_resource(person_model, person_schema, session, monkeypatch):
+def test_resource(app, person_model, person_schema, session, monkeypatch):
     def schema_load_mock(*args):
         raise ValidationError(dict(errors=[dict(status=None, title=None)]))
-    query_string = {'page[slumber]': '3'}
-    app = type('app', (object,), dict(config=dict(DEBUG=True)))
-    headers = {'Content-Type': 'application/vnd.api+json'}
-    request = type('request', (object,), dict(method='POST',
-                                              headers=headers,
-                                              get_json=dict,
-                                              args=query_string))
-    dl = SqlalchemyDataLayer(dict(session=session, model=person_model))
-    rl = ResourceList()
-    rd = ResourceDetail()
-    rl._data_layer = dl
-    rl.schema = person_schema
-    rd._data_layer = dl
-    rd.schema = person_schema
-    monkeypatch.setattr(flask_rest_jsonapi.resource, 'request', request)
-    monkeypatch.setattr(flask_rest_jsonapi.resource, 'current_app', app)
-    monkeypatch.setattr(flask_rest_jsonapi.decorators, 'request', request)
-    monkeypatch.setattr(rl.schema, 'load', schema_load_mock)
-    r = super(flask_rest_jsonapi.resource.Resource, ResourceList)\
-        .__new__(ResourceList)
-    with pytest.raises(Exception):
-        r.dispatch_request()
-    rl.post()
-    rd.patch()
+
+    with app.app_context():
+        query_string = {'page[slumber]': '3'}
+        app = type('app', (object,), dict(config=dict(DEBUG=True)))
+        headers = {'Content-Type': 'application/vnd.api+json'}
+        request = type('request', (object,), dict(method='POST',
+                                                  headers=headers,
+                                                  get_json=dict,
+                                                  args=query_string))
+        dl = SqlalchemyDataLayer(dict(session=session, model=person_model))
+        rl = ResourceList()
+        rd = ResourceDetail()
+        rl._data_layer = dl
+        rl.schema = person_schema
+        rd._data_layer = dl
+        rd.schema = person_schema
+        monkeypatch.setattr(flask_rest_jsonapi.resource, 'request', request)
+        monkeypatch.setattr(flask_rest_jsonapi.resource, 'current_app', app)
+        monkeypatch.setattr(flask_rest_jsonapi.decorators, 'request', request)
+        monkeypatch.setattr(rl.schema, 'load', schema_load_mock)
+        r = super(flask_rest_jsonapi.resource.Resource, ResourceList)\
+            .__new__(ResourceList)
+        with pytest.raises(Exception):
+            r.dispatch_request()
+        rl.post()
+        rd.patch()
 
 
 def test_compute_schema(person_schema):