schemas: cli tool to validate records based on schema

Signed-off-by: Ilias Koutsakis <ilias.koutsakis@cern.ch>

Author: Lilykos

cap/cli.py

@@ -25,9 +25,34 @@
 """CAP base Invenio configuration."""
 
 from __future__ import absolute_import, print_function
-
+from click import Option, UsageError
 from invenio_base.app import create_cli
 
 from cap.factory import create_api
 
+
+class MutuallyExclusiveOption(Option):
+    """
+    Class that allows the use of mutually exclusive arguments in cli commands.
+    """
+    def __init__(self, *args, **kwargs):
+        self.mutually_exclusive = set(kwargs.pop('mutually_exclusive', []))
+        self.help = kwargs.get('help', '')
+
+        if self.mutually_exclusive:
+            self.exclusives = ', '.join(self.mutually_exclusive)
+            kwargs['help'] = f'{self.help} NOTE: This argument is mutually ' \
+                             f'exclusive with arguments: [{self.exclusives}].'
+
+        super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx, opts, args):
+        if self.mutually_exclusive.intersection(opts) and self.name in opts:
+            raise UsageError(f'Illegal usage: `{self.name}` is mutually '
+                             f'exclusive with arguments [{self.exclusives}].')
+
+        return super(MutuallyExclusiveOption, self).\
+            handle_parse_result(ctx, opts, args)
+
+
 cli = create_cli(create_app=create_api)

cap/modules/mail/cli.py

@@ -24,40 +24,16 @@
 """Mail Cli."""
 
 import click
-from click import Option, UsageError
 from flask import current_app
 from flask_cli import with_appcontext
 
 from flask_mail import Message
 
+from cap.cli import MutuallyExclusiveOption
 from cap.modules.mail.users import get_all_users, get_users_by_record,\
     get_users_by_experiment
 
 
-class MutuallyExclusiveOption(Option):
-    def __init__(self, *args, **kwargs):
-        self.mutually_exclusive = set(kwargs.pop('mutually_exclusive', []))
-        help = kwargs.get('help', '')
-
-        if self.mutually_exclusive:
-            ex_str = ', '.join(self.mutually_exclusive)
-            kwargs['help'] = help + (
-                ' NOTE: This argument is mutually exclusive with'
-                ' arguments: [' + ex_str + '].'
-            )
-        super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
-
-    def handle_parse_result(self, ctx, opts, args):
-        if self.mutually_exclusive.intersection(opts) and self.name in opts:
-            raise UsageError(
-                f"Illegal usage: `{self.name}` is mutually exclusive with "
-                f"arguments `{', '.join(self.mutually_exclusive)}`."
-            )
-
-        return super(MutuallyExclusiveOption, self).\
-            handle_parse_result(ctx, opts, args)
-
-
 @click.group()
 def mail():
     """Mail commands."""

cap/modules/schemas/__init__.py

@@ -25,4 +25,4 @@
 
 from __future__ import absolute_import, print_function
 
-from .cli import schemas
+from .cli import schemas, validate

cap/modules/schemas/cli.py

@@ -21,7 +21,7 @@
 # In applying this license, CERN does not
 # waive the privileges and immunities granted to it by virtue of its status
 # as an Intergovernmental Organization or submit itself to any jurisdiction.
-"""CAP Cli."""
+"""CAP Schema cli."""
 
 import json
 import os
@@ -30,11 +30,113 @@
 from flask_cli import with_appcontext
 from invenio_db import db
 from invenio_jsonschemas.errors import JSONSchemaNotFound
+from invenio_search import current_search_client
 from sqlalchemy.exc import IntegrityError
 
+from cap.cli import MutuallyExclusiveOption
+from cap.modules.deposit.errors import DepositValidationError
 from cap.modules.fixtures.cli import fixtures
+from cap.modules.records.api import CAPRecord
+from cap.modules.schemas.models import Schema
+from cap.modules.schemas.resolvers import resolve_schema_by_url,\
+    resolve_schema_by_name_and_version, schema_name_to_url
 
-from .models import Schema
+
+@fixtures.command()
+@click.option('--schema-url', '-u',
+              cls=MutuallyExclusiveOption,
+              mutually_exclusive=["ana_type", "ana_version"],
+              help='The url of the schema used for validation.')
+@click.option('--ana-type', '-a',
+              cls=MutuallyExclusiveOption,
+              mutually_exclusive=["schema_url"],
+              help='The analysis type of the schema used for validation.')
+@click.option('--ana-version', '-v',
+              help='The analysis version of the records.')
+@click.option('--compare-with', '-c',
+              help='The schema version, that the '
+                   'records should be compared to.')
+@click.option('--status', '-s',
+              default='draft',
+              type=click.Choice(['draft', 'published'], case_sensitive=False),
+              help='The metadata type that will be used for validation.')
+@click.option('--export', '-e',
+              type=click.Path(),
+              help='A file where, the validation errors can be saved.')
+@with_appcontext
+def validate(schema_url, ana_type, ana_version, compare_with, status, export):
+    """
+    Validate deposit or record metadata based on their schema. Provide the
+    schema url OR ana-type and version, as well as the schema version that you
+    want to compare the records you get, to. E.g.
+
+    If you do not provide an ana-version, it will get the latest. If you do
+    not provide a -c parameter, the records will compare the data to their
+    own schema.
+
+    cap fixtures validate -u https://analysispreservation.cern.ch/schemas/deposits/records/test-v2.0.0.json -c 1.0.0  # noqa
+    cap fixtures validate -a test -c 1.0.0
+    """
+    try:
+        if schema_url:
+            schema = resolve_schema_by_url(schema_url)
+        elif ana_type:
+            schema = resolve_schema_by_name_and_version(ana_type, ana_version)
+        else:
+            raise click.UsageError(
+                'You need to provide the ana-type or the schema-url.')
+    except JSONSchemaNotFound:
+        raise click.UsageError(
+            'Schema not found.')
+    except ValueError:
+        raise click.UsageError(
+            'Version has to be passed as string <major>.<minor>.<patch>.')
+
+    # differentiate between drafts/published
+    from cap.modules.deposit.api import CAPDeposit
+    if status == 'draft':
+        search_path = 'deposits-records'
+        cap_record_class = CAPDeposit
+    else:
+        search_path = 'records'
+        cap_record_class = CAPRecord
+
+    # get all the records for this specific schema/type combination
+    records = current_search_client.search(
+        search_path,
+        q=f'_deposit.status: {status} AND '
+          f'$schema: "{schema_name_to_url(schema.name, schema.version)}"',
+        size=5000
+    )['hits']['hits']
+    pids = [rec['_id'] for rec in records]
+
+    click.secho(
+        f'{len(records)} record(s) of {schema.name} found.\n', fg='green')
+
+    total_errors = []
+    for pid in pids:
+        cap_record = cap_record_class.get_record(pid)
+
+        # get the url of the schema version, used for validation
+        if compare_with:
+            cap_record['$schema'] = schema_name_to_url(
+                schema.name, compare_with)
+        try:
+            cap_record.validate()
+            click.secho(f'No errors found in record {pid}', fg='green')
+        except DepositValidationError as exc:
+            error_list = '\n'.join(str(err.res) for err in exc.errors)
+            msg = f'Errors in {pid}:\n{error_list}'
+            click.secho(msg, fg='red')
+
+            if export:
+                total_errors.append(msg)
+
+    # export the errors in a file
+    if export:
+        with open(export, 'w') as out:
+            out.writelines('\n\n'.join(err for err in total_errors))
+        click.secho(f'Errors saved at {export}.', fg='red')
 
 
 @fixtures.command()

cap/modules/schemas/resolvers.py

@@ -98,14 +98,19 @@ def parse_path(string):
     return match.groups() if match else None
 
 
-def schema_name_to_url(schema_name):
+def schema_name_to_url(schema_name, version=None):
     """Return url eg. https://host.com/schemas/schema-v0.0.1.json."""
-    schema = Schema.get_latest(schema_name)
+    schema = resolve_schema_by_name_and_version(schema_name, version)
     url = current_jsonschemas.path_to_url(schema.deposit_path)
-
     return url
 
 
+def resolve_schema_by_name_and_version(schema_name, version=None):
+    """Get Schema object for given name and (optionally) version."""
+    return Schema.get(schema_name, version) if version \
+        else Schema.get_latest(schema_name)
+
+
 @lru_cache(maxsize=1024)
 def resolve_schema_by_url(url):
     """Get Schema object for given url."""

tests/conftest.py

@@ -31,8 +31,10 @@
 
 import pytest
 from flask import current_app
+from flask.cli import ScriptInfo
 from flask_principal import ActionNeed
 from flask_security import login_user
+
 from invenio_access.models import ActionRoles, ActionUsers
 from invenio_accounts.testutils import create_test_user
 from invenio_app.config import APP_DEFAULT_SECURE_HEADERS
@@ -47,9 +49,12 @@
 from invenio_oauthclient.models import RemoteAccount
 from invenio_pidstore.resolver import Resolver
 from invenio_search import current_search, current_search_client
+
+from click.testing import CliRunner
 from sqlalchemy_utils.functions import create_database, database_exists
 from werkzeug.local import LocalProxy
 
+from cap.cli import cli
 from cap.factory import create_api
 from cap.modules.auth.models import OAuth2Token
 from cap.modules.deposit.api import CAPDeposit as Deposit
@@ -69,6 +74,19 @@
 _datastore = LocalProxy(lambda: current_app.extensions['security'].datastore)
 
 
+@pytest.fixture()
+def cli_runner(app):
+    runner = CliRunner()
+    script_info = ScriptInfo(create_app=lambda info: app)
+
+    def run(command):
+        """Run the command from the CLI."""
+        command_args = command.split()
+        return runner.invoke(cli, command_args, obj=script_info)
+
+    yield run
+
+
 @pytest.fixture(scope='session')
 def instance_path():
     """Default instance path."""