Add filter endpoint tests, switch to unittest provided asserts, make pylint happier

Author: cdhorn

.pylintrc

@@ -6,7 +6,7 @@
 extension-pkg-whitelist=
 
 # Specify a score threshold to be exceeded before program exits with error.
-fail-under=10.0
+fail-under=10
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
@@ -589,6 +589,3 @@ valid-metaclass-classmethod-first-arg=cls
 # "BaseException, Exception".
 overgeneral-exceptions=BaseException,
                        Exception
-
-[MESSAGES CONTROL]
-disable = C0330, C0326

gramps_webapi/api/__init__.py

@@ -80,7 +80,8 @@ def register_endpt(resource: Type[Resource], url: str, name: str):
 register_endpt(BookmarkResource, "/bookmarks/<string:namespace>", "bookmark")
 register_endpt(BookmarksResource, "/bookmarks/", "bookmarks")
 # Filter
-register_endpt(FilterResource, "/filters/<string:namespace>", "filter")
+register_endpt(FilterResource, "/filters/<string:namespace>/<string:name>", "filter")
+register_endpt(FilterResource, "/filters/<string:namespace>", "filters")
 # Translate
 register_endpt(TranslationResource, "/translations/<string:isocode>", "translation")
 register_endpt(TranslationsResource, "/translations/", "translations")

gramps_webapi/api/resources/filters.py

@@ -7,8 +7,8 @@
 from flask import Response, abort
 from gramps.gen.db.base import DbReadBase
 from gramps.gen.filters import GenericFilter
-from marshmallow import Schema, ValidationError, fields
-from webargs import validate
+from marshmallow import Schema
+from webargs import ValidationError, fields, validate
 from webargs.flaskparser import use_args
 
 from ...const import GRAMPS_NAMESPACES
@@ -34,8 +34,9 @@ def get_filter_rules(args: Dict[str, str], namespace: str) -> List[Dict]:
     rule_list = []
     for rule_class in _RULES_LOOKUP[namespace]:
         add_rule = True
-        if args.get("rule") and args["rule"] != rule_class.__name__:
-            add_rule = False
+        if "rules" in args and args["rules"]:
+            if rule_class.__name__ not in args["rules"]:
+                add_rule = False
         if add_rule:
             rule_list.append(
                 {
@@ -46,6 +47,8 @@ def get_filter_rules(args: Dict[str, str], namespace: str) -> List[Dict]:
                     "rule": rule_class.__name__,
                 }
             )
+    if "rules" in args and len(args["rules"]) != len(rule_list):
+        abort(404)
     return rule_list
 
 
@@ -55,8 +58,9 @@ def get_custom_filters(args: Dict[str, str], namespace: str) -> List[Dict]:
     filters.reload_custom_filters()
     for filter_class in filters.CustomFilters.get_filters(namespace):
         add_filter = True
-        if args.get("filter") and args["filter"] != filter_class.get_name():
-            add_filter = False
+        if "filters" in args and args["filters"]:
+            if filter_class.get_name() not in args["filters"]:
+                add_filter = False
         if add_filter:
             filter_list.append(
                 {
@@ -74,6 +78,8 @@ def get_custom_filters(args: Dict[str, str], namespace: str) -> List[Dict]:
                     ],
                 }
             )
+    if "filters" in args and len(args["filters"]) != len(filter_list):
+        abort(404)
     return filter_list
 
 
@@ -113,7 +119,7 @@ def apply_filter(db_handle: DbReadBase, args: Dict, namespace: str) -> List[Hand
         for filter_class in filters.CustomFilters.get_filters(namespace):
             if args["filter"] == filter_class.get_name():
                 return filter_class.apply(db_handle)
-        abort(400)
+        abort(404)
 
     try:
         filter_parms = FilterSchema().load(json.loads(args["rules"]))
@@ -143,21 +149,31 @@ class FilterSchema(Schema):
         validate=validate.OneOf(["and", "or", "xor", "one"]),
     )
     invert = fields.Boolean(required=False, missing=False)
-    rules = fields.List(fields.Nested(RuleSchema))
+    rules = fields.List(
+        fields.Nested(RuleSchema), required=True, validate=validate.Length(min=1)
+    )
 
 
 class CustomFilterSchema(FilterSchema):
     """Structure for a custom filter."""
 
     name = fields.Str(required=True, validate=validate.Length(min=1))
     comment = fields.Str(required=False)
+    rules = fields.List(
+        fields.Nested(RuleSchema), required=True, validate=validate.Length(min=1)
+    )
 
 
 class FilterResource(ProtectedResource, GrampsJSONEncoder):
     """Filter resource."""
 
     @use_args(
-        {"filter": fields.Str(), "rule": fields.Str()},
+        {
+            "filters": fields.DelimitedList(
+                fields.Str(validate=validate.Length(min=1))
+            ),
+            "rules": fields.DelimitedList(fields.Str(validate=validate.Length(min=1))),
+        },
         location="query",
     )
     def get(self, args: Dict[str, str], namespace: str) -> Response:
@@ -168,10 +184,10 @@ def get(self, args: Dict[str, str], namespace: str) -> Response:
             abort(404)
 
         rule_list = get_filter_rules(args, namespace)
-        if args.get("rule") and not args.get("filter"):
+        if "rules" in args and "filters" not in args:
             return self.response(200, {"rules": rule_list})
         filter_list = get_custom_filters(args, namespace)
-        if args.get("filter") and not args.get("rule"):
+        if "filters" in args and "rules" not in args:
             return self.response(200, {"filters": filter_list})
         return self.response(200, {"filters": filter_list, "rules": rule_list})
 
@@ -214,12 +230,11 @@ def put(self, args: Dict, namespace: str) -> Response:
 
     @use_args(
         {
-            "name": fields.Str(required=True),
-            "force": fields.Boolean(required=False, missing=False),
+            "force": fields.Str(validate=validate.Length(equal=0)),
         },
-        location="json",
+        location="query",
     )
-    def delete(self, args: Dict, namespace: str) -> Response:
+    def delete(self, args: Dict, namespace: str, name: str) -> Response:
         """Delete a custom filter."""
         try:
             namespace = GRAMPS_NAMESPACES[namespace]
@@ -229,17 +244,15 @@ def delete(self, args: Dict, namespace: str) -> Response:
         filters.reload_custom_filters()
         custom_filters = filters.CustomFilters.get_filters(namespace)
         for custom_filter in custom_filters:
-            if args["name"] == custom_filter.get_name():
+            if name == custom_filter.get_name():
                 filter_set = set()
                 self._find_dependent_filters(namespace, custom_filter, filter_set)
                 if len(filter_set) > 1:
                     if "force" not in args or not args["force"]:
                         abort(405)
                 list(map(custom_filters.remove, filter_set))
                 filters.CustomFilters.save()
-                return self.response(
-                    200, {"message": "Deleted filter: " + args["name"]}
-                )
+                return self.response(200, {"message": "Deleted filter: " + name})
         return abort(404)
 
     def _find_dependent_filters(

gramps_webapi/data/apispec.yaml

@@ -1825,16 +1825,16 @@ paths:
         required: true
         type: string
         description: "The namespace or category for the filters."
-      - name: rule
+      - name: rules
         in: query
         required: false
         type: string
-        description: "The name of a specific filter rule to be returned."
-      - name: filter
+        description: "A comma delimited list of specific filter rules to be returned."
+      - name: filters
         in: query
         required: false
         type: string
-        description: "The name of a specific custom filter to be returned."
+        description: "A comma delimited list of specific custom filters to be returned."
       responses:
         200:
           description: "OK: Successful operation."
@@ -1908,6 +1908,7 @@ paths:
         403:
           description: "Forbidden: Bad credentials, authentication failed."
 
+  /filters/{namespace}/{name}:    
     delete:
       tags:
       - filters
@@ -1921,12 +1922,16 @@ paths:
         required: true
         type: string
         description: "The namespace or category for the custom filter."
-      - name: filter
-        in: body
+      - name: name
+        in: path
         required: true
-        description: "The custom filter to delete."
-        schema:
-          $ref: "#/definitions/CustomFilterObject"    
+        type: string
+        description: "The name of the custom filter."
+      - name: force
+        in: query
+        required: false
+        type: string
+        description: "Force delete custom filter and all filters that depend upon it."
       responses:
         200:
           description: "OK: Successful operation."
@@ -4045,24 +4050,6 @@ definitions:
         items:
           $ref: "#/definitions/FilterRule"
 
-##############################################################################
-# Model - CustomFilterObject    
-##############################################################################
-
-  CustomFilterObject:
-    type: object
-    required:
-      - name
-    properties:
-      name:
-        type: string
-        description: "Name of the custom rule to delete."
-        example: "MyTestRule"
-      force:
-        type: boolean
-        description: "Indicator to approve deletion of all dependent filters if any exist."
-        example: true
-                         
 ##############################################################################
 # Model - Translations
 ##############################################################################

tests/test_endpoints/__init__.py

@@ -13,8 +13,7 @@
 import gramps_webapi.app
 from gramps_webapi.app import create_app
 from gramps_webapi.const import ENV_CONFIG_FILE, TEST_EXAMPLE_GRAMPS_CONFIG
-
-from .. import TEST_GRAMPSHOME, ExampleDbSQLite
+from tests import TEST_GRAMPSHOME, ExampleDbSQLite
 
 
 def get_object_count(gramps_object):