tests for spec plugin

Author: Dmitry Mishanov

combojsonapi/spec/plugin.py

@@ -7,7 +7,7 @@
 from marshmallow import fields, Schema
 from flask_combo_jsonapi import Api
 from flask_combo_jsonapi.plugin import BasePlugin
-from flask_combo_jsonapi.resource import ResourceList, ResourceDetail
+from flask_combo_jsonapi.resource import ResourceList, ResourceDetail, Resource
 from flask_combo_jsonapi.utils import SPLIT_REL
 
 from combojsonapi.spec.apispec import DocBlueprintMixin
@@ -34,7 +34,6 @@ def __init__(self, app=None, spec_kwargs=None, decorators=None, tags: Dict[str,
         self.app = None
         self._fields = []
         # Use lists to enforce order
-        self._definitions = []
         self._fields = []
         self._converters = []
 
@@ -69,12 +68,6 @@ def after_init_plugin(self, *args, app=None, **kwargs):
         # Register custom fields in spec
         for args in self._fields:
             self.spec.register_field(*args)
-        # Register schema definitions in spec
-        for name, schema_cls, kwargs in self._definitions:
-            if APISPEC_VERSION_MAJOR < 1:
-                self.spec.definition(create_schema_name(schema=schema_cls), schema=schema_cls, **kwargs)
-            else:
-                self.spec.components.schema(create_schema_name(schema=schema_cls), schema=schema_cls, **kwargs)
         # Register custom converters in spec
         for args in self._converters:
             self.spec.register_converter(*args)
@@ -143,7 +136,8 @@ def param_id(self) -> dict:
             "format": "int32",
         }
 
-    def _get_operations_for_all(self, tag_name, default_parameters) -> Dict[str, Any]:
+    @classmethod
+    def _get_operations_for_all(cls, tag_name: str, default_parameters: list) -> Dict[str, Any]:
         """
         Creating base dict
 
@@ -153,11 +147,12 @@ def _get_operations_for_all(self, tag_name, default_parameters) -> Dict[str, Any
         """
         return {
             "tags": [tag_name],
-            "produces": ["application/json",],
+            "produces": ["application/json"],
             "parameters": default_parameters if default_parameters else [],
         }
 
-    def __get_parameters_for_include_models(self, resource) -> dict:
+    @classmethod
+    def __get_parameters_for_include_models(cls, resource: Resource) -> dict:
         fields_names = [
             i_field_name
             for i_field_name, i_field in resource.schema._declared_fields.items()
@@ -174,15 +169,16 @@ def __get_parameters_for_include_models(self, resource) -> dict:
             "description": f"Related relationships to include.\nAvailable:\n{example_models_for_include}",
         }
 
-    def __get_parameters_for_sparse_fieldsets(self, resource, description) -> dict:
+    @classmethod
+    def __get_parameters_for_sparse_fieldsets(cls, resource: Resource, description: str) -> dict:
         # Sparse Fieldsets
         return {
             "name": f"fields[{resource.schema.Meta.type_}]",
             "in": "query",
             "type": "array",
             "required": False,
             "description": description.format(resource.schema.Meta.type_),
-            "items": {"type": "string", "enum": list(resource.schema._declared_fields.keys()),},
+            "items": {"type": "string", "enum": list(resource.schema._declared_fields.keys())},
         }
 
     def __get_parameters_for_declared_fields(self, resource, description) -> Generator[dict, None, None]:
@@ -234,7 +230,8 @@ def __list_filters_data(self) -> tuple:
             },
         )
 
-    def __update_parameter_for_field_spec(self, new_param: dict, fld_sped: dict) -> None:
+    @classmethod
+    def _update_parameter_for_field_spec(cls, new_param: dict, fld_sped: dict) -> None:
         """
         :param new_param:
         :param fld_sped:
@@ -256,7 +253,7 @@ def __get_parameter_for_not_nested(self, field_name, field_spec) -> dict:
             "required": False,
             "description": f"{field_name} attribute filter",
         }
-        self.__update_parameter_for_field_spec(new_parameter, field_spec)
+        self._update_parameter_for_field_spec(new_parameter, field_spec)
         return new_parameter
 
     def __get_parameter_for_nested_with_filtering(self, field_name, field_jsonb_name, field_jsonb_spec):
@@ -267,7 +264,7 @@ def __get_parameter_for_nested_with_filtering(self, field_name, field_jsonb_name
             "required": False,
             "description": f"{field_name}{SPLIT_REL}{field_jsonb_name} attribute filter",
         }
-        self.__update_parameter_for_field_spec(new_parameter, field_jsonb_spec)
+        self._update_parameter_for_field_spec(new_parameter, field_jsonb_spec)
         return new_parameter
 
     def __get_parameters_for_nested_with_filtering(self, field, field_name) -> Generator[dict, None, None]:
@@ -326,6 +323,60 @@ def _get_operations_for_get(self, resource, tag_name, default_parameters):
 
         return operations_get
 
+    def _get_operations_for_post(self, schema: dict, tag_name: str, default_parameters: list) -> dict:
+        operations = self._get_operations_for_all(tag_name, default_parameters)
+        operations["responses"] = {
+            "201": {"description": "Created"},
+            "202": {"description": "Accepted"},
+            "403": {"description": "This implementation does not accept client-generated IDs"},
+            "404": {"description": "Not Found"},
+            "409": {"description": "Conflict"},
+        }
+        operations["parameters"].append(
+            {
+                "name": "POST body",
+                "in": "body",
+                "schema": schema,
+                "required": True,
+                "description": f"{tag_name} attributes",
+            }
+        )
+        return operations
+
+    def _get_operations_for_patch(self, schema: dict, tag_name: str, default_parameters: list) -> dict:
+        operations = self._get_operations_for_all(tag_name, default_parameters)
+        operations["responses"] = {
+            "200": {"description": "Success"},
+            "201": {"description": "Created"},
+            "204": {"description": "No Content"},
+            "403": {"description": "Forbidden"},
+            "404": {"description": "Not Found"},
+            "409": {"description": "Conflict"},
+        }
+        operations["parameters"].append(self.param_id)
+        operations["parameters"].append(
+            {
+                "name": "POST body",
+                "in": "body",
+                "schema": schema,
+                "required": True,
+                "description": f"{tag_name} attributes",
+            }
+        )
+        return operations
+
+    def _get_operations_for_delete(self, tag_name: str, default_parameters: list) -> dict:
+        operations = self._get_operations_for_all(tag_name, default_parameters)
+        operations["parameters"].append(self.param_id)
+        operations["responses"] = {
+            "200": {"description": "Success"},
+            "202": {"description": "Accepted"},
+            "204": {"description": "No Content"},
+            "403": {"description": "Forbidden"},
+            "404": {"description": "Not Found"},
+        }
+        return operations
+
     def _add_paths_in_spec(
         self,
         path: str = "",
@@ -372,53 +423,11 @@ def _add_paths_in_spec(
         if "get" in methods:
             operations["get"] = self._get_operations_for_get(resource, tag_name, default_parameters)
         if "post" in methods:
-            operations["post"] = self._get_operations_for_all(tag_name, default_parameters)
-            operations["post"]["responses"] = {
-                "201": {"description": "Created"},
-                "202": {"description": "Accepted"},
-                "403": {"description": "This implementation does not accept client-generated IDs"},
-                "404": {"description": "Not Found"},
-                "409": {"description": "Conflict"},
-            }
-            operations["post"]["parameters"].append(
-                {
-                    "name": "POST body",
-                    "in": "body",
-                    "schema": schema,
-                    "required": True,
-                    "description": f"{tag_name} attributes",
-                }
-            )
+            operations["post"] = self._get_operations_for_post(schema, tag_name, default_parameters)
         if "patch" in methods:
-            operations["patch"] = self._get_operations_for_all(tag_name, default_parameters)
-            operations["patch"]["responses"] = {
-                "200": {"description": "Success"},
-                "201": {"description": "Created"},
-                "204": {"description": "No Content"},
-                "403": {"description": "Forbidden"},
-                "404": {"description": "Not Found"},
-                "409": {"description": "Conflict"},
-            }
-            operations["patch"]["parameters"].append(self.param_id)
-            operations["patch"]["parameters"].append(
-                {
-                    "name": "POST body",
-                    "in": "body",
-                    "schema": schema,
-                    "required": True,
-                    "description": f"{tag_name} attributes",
-                }
-            )
+            operations["patch"] = self._get_operations_for_patch(schema, tag_name, default_parameters)
         if "delete" in methods:
-            operations["delete"] = self._get_operations_for_all(tag_name, default_parameters)
-            operations["delete"]["parameters"].append(self.param_id)
-            operations["delete"]["responses"] = {
-                "200": {"description": "Success"},
-                "202": {"description": "Accepted"},
-                "204": {"description": "No Content"},
-                "403": {"description": "Forbidden"},
-                "404": {"description": "Not Found"},
-            }
+            operations["delete"] = self._get_operations_for_delete(tag_name, default_parameters)
         rule = None
         for i_rule in self.app.url_map._rules:
             if i_rule.rule == path:

tests/test_spec/__init__.py

@@ -0,0 +1,85 @@
+from flask import Flask
+from flask_combo_jsonapi import ResourceList, ResourceDetail
+from marshmallow import Schema, fields
+from sqlalchemy import Integer, Column, String, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from combojsonapi.utils import Relationship
+
+Base = declarative_base()
+
+engine = create_engine("sqlite:///:memory:")
+session = sessionmaker(bind=engine)()
+
+
+class RelatedModel(Base):
+    __tablename__ = 'related_model'
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+
+
+class SomeModel(Base):
+    __tablename__ = 'some_model'
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    type = Column(Integer)
+    flags = Column(Integer)
+    description = Column(String)
+    settings = Column(String)
+    related_model_id = Column(Integer)
+
+
+class RelatedModelSchema(Schema):
+    class Meta:
+        model = RelatedModel
+        type_ = 'related_model'
+        filtering = True
+
+    id = fields.Integer()
+    name = fields.String()
+
+
+class SomeSchema(Schema):
+    class Meta:
+        model = SomeModel
+        type_ = 'some_schema'
+
+    id = fields.Integer()
+    name = fields.String()
+    type = fields.Integer()
+    flags = fields.Integer()
+    description = fields.Integer()
+    related_model_id = Relationship(nested=RelatedModelSchema, schema=RelatedModelSchema)
+
+
+class SchemaReversedName(Schema):
+    class Meta:
+        model = SomeModel
+        type_ = 'schema_reversed_name'
+
+    id = fields.Integer(description='just id field')
+    name = fields.String(description='just name field')
+    array_field = fields.List(fields.Integer, description='just array field with integers')
+
+
+class SomeResourceDetail(ResourceDetail):
+    schema = SomeSchema
+    data_layer = {
+        'session': session,
+        'model': SomeModel,
+    }
+
+
+class SomeResourceList(ResourceList):
+    schema = SomeSchema
+    data_layer = {
+        'session': session,
+        'model': SomeModel,
+    }
+
+
+app = Flask(__name__)
+app.add_url_rule('/apispec/some_url', view_func=SomeResourceDetail.as_view('some_view123'))