invenio-app-ils 4.5.0__py2.py3-none-any.whl → 5.0.0__py2.py3-none-any.whl

tests/api/ils/test_loaders.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test accesibility of resource endpoints."""
-
-import json
-
-from flask import url_for
-
-from tests.helpers import user_login, validate_response
-
-NEW_INTERNAL_LOCATION = {
-    "location_pid": "locid-1",
-    "legacy_ids": ["Test legacy id"],
-    "name": "My test internal location",
-    "physical_location": "Left from the right building",
-    "notes": "In house",
-}
-
-
-def test_post_internal_location(client, json_headers, testdata, users):
-    """Test POST of internal_location."""
-    user_login(client, "admin", users)
-    url = url_for("invenio_records_rest.ilocid_list")
-    res = validate_response(
-        client, "post", url, json_headers, NEW_INTERNAL_LOCATION, 201
-    )
-    data = json.loads(res.data.decode("utf-8"))["metadata"]
-    assert "name" in data["location"]
-
-
-def test_post_partial_internal_location(client, json_headers, testdata, users):
-    """Test POST of internal_location without all required data."""
-    user_login(client, "admin", users)
-    del NEW_INTERNAL_LOCATION["location_pid"]
-    url = url_for("invenio_records_rest.ilocid_list")
-    validate_response(client, "post", url, json_headers, NEW_INTERNAL_LOCATION, 400)
-
-
-def test_post_item(client, json_headers, testdata, users, item_record):
-    """Test POST of an item."""
-    user_login(client, "admin", users)
-    url = url_for("invenio_records_rest.pitmid_list")
-    del item_record["pid"]
-    res = validate_response(client, "post", url, json_headers, item_record, 201)
-    data = json.loads(res.data.decode("utf-8"))["metadata"]
-    assert "name" in data["internal_location"]

tests/api/ils/test_metadata_extensions.py

@@ -1,206 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018-2020 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test metadata extensions."""
-
-import pytest
-from invenio_indexer.api import RecordIndexer
-from invenio_records_rest.schemas.fields import DateString, SanitizedUnicode
-from marshmallow import ValidationError
-from marshmallow.fields import Bool, Integer, List
-
-from invenio_app_ils.documents.api import Document
-from invenio_app_ils.records.metadata_extensions import MetadataExtensions
-
-
-@pytest.fixture(scope="module")
-def app_config(app_config):
-    """Override conftest.py's app_config"""
-    app_config["ILS_RECORDS_METADATA_NAMESPACES"] = {
-        "document": {
-            "accelerator_experiments": {
-                "@context": "https://example.com/accelerator_experiments/terms"
-            },
-            "standard_status": {
-                "@context": "https://example.com/standard_status/terms"
-            },
-        }
-    }
-
-    app_config["ILS_RECORDS_METADATA_EXTENSIONS"] = {
-        "document": {
-            "schema": Document._schema,
-            "fields": {
-                "accelerator_experiments_accelerator": {
-                    "elasticsearch": "keyword",
-                    "marshmallow": SanitizedUnicode(required=True),
-                },
-                "accelerator_experiments_project": {
-                    "elasticsearch": "text",
-                    "marshmallow": SanitizedUnicode(),
-                },
-                "accelerator_experiments_number_in_sequence": {
-                    "elasticsearch": "long",
-                    "marshmallow": Integer(),
-                },
-                "accelerator_experiments_scientific_sequence": {
-                    "elasticsearch": "long",
-                    "marshmallow": List(Integer()),
-                },
-                "standard_status_original_presentation_date": {
-                    "elasticsearch": "date",
-                    "marshmallow": DateString(),
-                },
-                "standard_status_right_or_wrong": {
-                    "elasticsearch": "boolean",
-                    "marshmallow": Bool(),
-                },
-            },
-        }
-    }
-
-    return app_config
-
-
-def assert_unordered_equality(array_dict1, array_dict2):
-    array1 = sorted(array_dict1, key=lambda d: d["key"])
-    array2 = sorted(array_dict2, key=lambda d: d["key"])
-    assert array1 == array2
-
-
-def test_metadata_extensions(db, es, testdata):
-    """Tests that a Record is indexed into Elasticsearch properly.
-    - Tests that the before_record_index_hook is registered properly.
-    - Tests add_es_metadata_extensions.
-    - Tests jsonschema validates correctly
-    - Tests that retrieved record document is fine.
-    NOTE:
-        - es fixture depends on appctx fixture, so we are in app context
-        - this test requires a running ES instance
-    """
-    document = testdata["documents"][0]
-    data = {
-        "extensions": {
-            "accelerator_experiments_accelerator": "LHCb",
-            "accelerator_experiments_project": "A project for experiment.",
-            "accelerator_experiments_number_in_sequence": 3,
-            "accelerator_experiments_scientific_sequence": [1, 1, 2, 3, 5, 8],
-            "standard_status_original_presentation_date": "2019-02-14",
-            "standard_status_right_or_wrong": True,
-        }
-    }
-    document.update(data)
-    document.validate()
-    db.session.commit()
-    indexer = RecordIndexer()
-    index_result = indexer.index(document)
-
-    _index = index_result["_index"]
-    _id = index_result["_id"]
-    es_doc = es.get(index=_index, id=_id)
-    source = es_doc["_source"]
-    expected_keywords = [
-        {"key": "accelerator_experiments_accelerator", "value": "LHCb"},
-    ]
-    expected_texts = [
-        {
-            "key": "accelerator_experiments_project",
-            "value": "A project for experiment.",
-        },
-    ]
-    expected_longs = [
-        {"key": "accelerator_experiments_number_in_sequence", "value": 3},
-        {
-            "key": "accelerator_experiments_scientific_sequence",
-            "value": [1, 1, 2, 3, 5, 8],
-        },
-    ]
-    expected_dates = [
-        {
-            "key": "standard_status_original_presentation_date",
-            "value": "2019-02-14",
-        },
-    ]
-    expected_booleans = [
-        {"key": "standard_status_right_or_wrong", "value": True},
-    ]
-    assert_unordered_equality(source["extensions_keywords"], expected_keywords)
-    assert_unordered_equality(source["extensions_texts"], expected_texts)
-    assert_unordered_equality(source["extensions_longs"], expected_longs)
-    assert_unordered_equality(source["extensions_dates"], expected_dates)
-    assert_unordered_equality(source["extensions_booleans"], expected_booleans)
-
-
-def test_extensions():
-    """Test metadata extensions schema."""
-    ILS_RECORDS_METADATA_NAMESPACES = {
-        "accelerator_experiments": {
-            "@context": "https://example.com/accelerator_experiments/terms"
-        },
-        "standard_status": {"@context": "https://example.com/standard_status/terms"},
-    }
-
-    ILS_RECORDS_METADATA_EXTENSIONS = {
-        "accelerator_experiments_accelerator": {
-            "elasticsearch": "keyword",
-            "marshmallow": SanitizedUnicode(required=True),
-        },
-        "accelerator_experiments_project": {
-            "elasticsearch": "text",
-            "marshmallow": SanitizedUnicode(),
-        },
-        "accelerator_experiments_number_in_sequence": {
-            "elasticsearch": "long",
-            "marshmallow": Integer(),
-        },
-        "accelerator_experiments_scientific_sequence": {
-            "elasticsearch": "long",
-            "marshmallow": List(Integer()),
-        },
-        "standard_status_original_presentation_date": {
-            "elasticsearch": "date",
-            "marshmallow": DateString(),
-        },
-        "standard_status_right_or_wrong": {
-            "elasticsearch": "boolean",
-            "marshmallow": Bool(),
-        },
-    }
-
-    extensions = MetadataExtensions(
-        ILS_RECORDS_METADATA_NAMESPACES, ILS_RECORDS_METADATA_EXTENSIONS
-    )
-    ExtensionsSchema = extensions.to_schema()
-
-    # Minimal if not absent
-    valid_minimal = {"accelerator_experiments_accelerator": "LHCb"}
-
-    data = ExtensionsSchema().load(valid_minimal)
-
-    assert data == valid_minimal
-
-    # Full
-    valid_full = {
-        "accelerator_experiments_accelerator": "LHCb",
-        "accelerator_experiments_project": "A project for experiment.",
-        "accelerator_experiments_number_in_sequence": 3,
-        "accelerator_experiments_scientific_sequence": [1, 1, 2, 3, 5, 8],
-        "standard_status_original_presentation_date": "2019-02-14",
-        "standard_status_right_or_wrong": True,
-    }
-
-    data = ExtensionsSchema().load(valid_full)
-
-    assert data == valid_full
-
-    # Invalid
-    invalid_number_in_sequence = {
-        "accelerator_experiments_accelerator": "LHCb",
-        "accelerator_experiments_scientific_sequence": [1, "l", 2, 3, 5, 8],
-    }
-    with pytest.raises(ValidationError):
-        data = ExtensionsSchema().load(invalid_number_in_sequence)

tests/api/ils/test_notifications.py

@@ -1,173 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018-2021 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test notifications."""
-
-import pytest
-from flask import url_for
-from jinja2.exceptions import TemplateError, TemplateNotFound
-
-from invenio_app_ils.notifications.api import (
-    log_error_notification,
-    log_successful_notification,
-    send_notification,
-)
-from invenio_app_ils.notifications.messages import NotificationMsg
-from invenio_app_ils.notifications.models import NotificationsLogs
-from invenio_app_ils.patrons.api import Patron
-from tests.helpers import user_login
-
-
-def test_message_full(app_with_notifs):
-    """Test that the title, body and html are read correctly."""
-    with app_with_notifs.app_context():
-        # remove footer
-        app_with_notifs.config["ILS_NOTIFICATIONS_TEMPLATES"] = {}
-
-        full = NotificationMsg("notifications/title_body_html.html")
-        assert full.title == "Test title."
-        assert "Test body." == full.body_plain
-        assert "Test html." == full.body_html
-
-
-def test_message_body_same_as_html(app_with_notifs):
-    """Test that the title and body are read correctly."""
-    with app_with_notifs.app_context():
-        # remove footer
-        app_with_notifs.config["ILS_NOTIFICATIONS_TEMPLATES"] = {}
-
-        blank = NotificationMsg("notifications/title_body.html")
-        assert blank.title == "Test title."
-        assert "Test body." == blank.body_plain
-        assert "Test body." == blank.body_html
-
-
-def test_invalid_message_templates(app_with_notifs):
-    """Test invalid templates."""
-    with app_with_notifs.app_context():
-        with pytest.raises(TemplateError) as ex:
-            NotificationMsg("notifications/blank.html")
-        assert "No block with name 'title'" in str(ex.value)
-
-        with pytest.raises(TemplateError) as ex:
-            NotificationMsg("notifications/title_only.html")
-        assert "No block with name 'body_plain'" in str(ex.value)
-
-
-def test_message_templates_escaping(app_with_notifs):
-    """Test templates escaping."""
-    title = (
-        "Spèciâl chäráctèrs: "
-        "`,~,!,@,#,$,%,^,&,*,(,),_,-,+,=,{,[,},},|,\\,:,;,',<,>,.,?,/,º,ª "
-        "<script>alert('test');</script>"
-    )
-    ctx = dict(title=title)
-    with app_with_notifs.app_context():
-        # remove footer
-        app_with_notifs.config["ILS_NOTIFICATIONS_TEMPLATES"] = {}
-
-        full = NotificationMsg("notifications/title_body_html_ctx.html", ctx)
-
-        assert full.title == 'Test "{0}" title.'.format(title)
-
-        from markupsafe import escape
-
-        escaped = escape(title)
-        assert 'Test "{0}" body.'.format(escaped) == full.body_plain
-        assert 'Test "{0}" html.'.format(escaped) == full.body_html
-
-
-def test_message_with_missing_template(app_with_notifs):
-    """Test that a missing template raises an exception."""
-    with app_with_notifs.app_context():
-        with pytest.raises(TemplateNotFound):
-            NotificationMsg("missing.html")
-
-
-def test_send_message_backend(app_with_notifs, users, testdata, mocker):
-    """Test that notifications backend is called when sending."""
-    send_mocked = mocker.patch("invenio_app_ils.notifications.backends.mail.send")
-    send_mocked.__name__ = "send"
-    send_mocked.__annotations__ = "send"
-    backends = mocker.patch(
-        "invenio_app_ils.notifications.api._get_notification_backends",
-        return_value=[send_mocked],
-    )
-    with app_with_notifs.app_context():
-        # remove footer
-        app_with_notifs.config["ILS_NOTIFICATIONS_TEMPLATES"] = {}
-
-        msg = NotificationMsg("notifications/title_body_html.html")
-        patrons = [Patron(users["patron1"].id)]
-        send_notification(patrons, msg)
-
-        assert send_mocked.apply_async.called
-
-
-class FakeMessage(NotificationMsg):
-    def __init__(self, *args, **kwargs):
-        template = kwargs.pop("template", "notifications/title_body_html.html")
-        super().__init__(template, **kwargs)
-
-
-def test_log_successful_error_mail_task(app_with_notifs, users, testdata, mocker):
-    """Test that a successfully sent email is logged."""
-    # !attention the mocker has to patch function where it is used, not defined
-    succ = mocker.patch("invenio_app_ils.notifications.api.log_successful_notification")
-    err = mocker.patch("invenio_app_ils.notifications.api.log_error_notification")
-
-    patron = Patron(users["patron1"].id)
-
-    assert not succ.s.called
-    assert not err.s.called
-    send_notification([patron], FakeMessage())
-    assert succ.s.called
-    assert err.s.called
-
-
-def test_notifications_db_table_and_endpoint(
-    users, client, json_headers, app_with_notifs
-):
-    """Test logging of notifs in db table and read from endpoint."""
-    request = {"id": "test-id", "task": "test-task"}
-    data = {
-        "id": "test-id",
-        "recipients": ["patron1@test.com"],
-        "is_manually_triggered": True,
-        "message_id": "1",
-        "patron_id": "1",
-    }
-    exc = "An error occurred."
-    log_successful_notification(None, data)
-
-    log_error_notification(request=request, exc=exc, traceback=None, data=data)
-
-    assert NotificationsLogs.query.filter_by(id=1).one().send_log == "Success"
-    assert (
-        NotificationsLogs.query.filter_by(id=2).one().send_log
-        == "Error: 'An error occurred.'"
-    )
-
-    ITEM_ENDPOINT = "invenio_app_ils_notifications.get_notification"
-    LIST_ENDPOINT = "invenio_app_ils_notifications.get_notifications"
-
-    user_login(client, "librarian", users)
-    url = url_for(LIST_ENDPOINT)
-    res = client.get(url, headers=json_headers)
-    assert res.get_json()["hits"][0]["send_log"] == "Error: 'An error occurred.'"
-    assert res.get_json()["hits"][1]["send_log"] == "Success"
-
-    url = url_for(ITEM_ENDPOINT, id=1)
-    res = client.get(url, headers=json_headers)
-    assert res.get_json()["send_log"] == "Success"
-    assert res.get_json()["id"] == 1
-
-    url = url_for(ITEM_ENDPOINT, id=2)
-    res = client.get(url, headers=json_headers)
-
-    assert res.get_json()["send_log"] == "Error: 'An error occurred.'"
-    assert res.get_json()["id"] == 2

tests/api/ils/test_notifications_mails.py

@@ -1,37 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test notifications backend emails."""
-
-from invenio_app_ils.notifications.api import send_notification
-from invenio_app_ils.notifications.messages import NotificationMsg
-from invenio_app_ils.patrons.api import Patron
-
-
-class FakeMessage(NotificationMsg):
-    def __init__(self, *args, **kwargs):
-        template = kwargs.pop("template", "notifications/title_body_html.html")
-        super().__init__(template, **kwargs)
-
-
-def test_send_only_to_test_recipients(app_with_notifs, users, testdata, mocker):
-    """Tests that send only to test recipients works."""
-    app_with_notifs.config["ILS_MAIL_ENABLE_TEST_RECIPIENTS"] = True
-    succ = mocker.patch("invenio_app_ils.notifications.api.log_successful_notification")
-
-    msg = FakeMessage()
-    patron = Patron(users["patron1"].id)
-
-    fake_recipients = app_with_notifs.config["ILS_MAIL_NOTIFY_TEST_RECIPIENTS"]
-    with app_with_notifs.extensions["mail"].record_messages() as outbox:
-        assert len(outbox) == 0
-        send_notification([patron], msg)
-        assert succ.s.called
-        assert len(outbox) == 1
-        assert outbox[0].recipients == fake_recipients
-
-    app_with_notifs.config["ILS_MAIL_ENABLE_TEST_RECIPIENTS"] = False

tests/api/ils/test_notifications_permissions.py

@@ -1,55 +0,0 @@
-# Copyright (C) 2021 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test notifications permissions."""
-
-from flask import url_for
-
-from tests.helpers import user_login
-
-_HTTP_OK = [200, 201, 204]
-_HTTP_UNAUTHORIZED = [401]
-_HTTP_FORBIDDEN = [403]
-_HTTP_NOT_FOUND = [404]
-MAIL_ID = 1
-ITEM_ENDPOINT = "invenio_app_ils_notifications.get_notification"
-LIST_ENDPOINT = "invenio_app_ils_notifications.get_notifications"
-
-
-def test_notifications_read_permissions(client, json_headers, users):
-    """Test notifications endpoints read permissions."""
-    list_tests = [
-        ("admin", _HTTP_OK),
-        ("librarian", _HTTP_OK),
-        ("patron1", _HTTP_FORBIDDEN),
-        ("anonymous", _HTTP_UNAUTHORIZED),
-    ]
-
-    item_tests = [
-        ("admin", _HTTP_NOT_FOUND),
-        ("librarian", _HTTP_NOT_FOUND),
-        ("patron1", _HTTP_FORBIDDEN),
-        ("anonymous", _HTTP_UNAUTHORIZED),
-    ]
-
-    def _test_list(expected_status):
-        """Test get list."""
-        url = url_for(LIST_ENDPOINT)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    def _test_read(expected_status, id):
-        """Test record read."""
-        url = url_for(ITEM_ENDPOINT, id=id)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    for username, expected_status in list_tests:
-        user_login(client, username, users)
-        _test_list(expected_status)
-
-    for username, expected_status in item_tests:
-        user_login(client, username, users)
-        _test_read(expected_status, MAIL_ID)

tests/api/ils/test_patrons.py

@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2019 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test patrons endpoint."""
-
-import json
-
-from flask import url_for
-
-from tests.helpers import user_login
-
-_LIST_ENDPOINT = "invenio_records_rest.patid_list"
-
-
-def _patron_loans_request(client, json_headers, document_pid):
-    """Perform a patron loans request."""
-    response = client.get(
-        url_for(
-            "invenio_app_ils_patrons.get_user_information",
-            document_pid=document_pid,
-        ),
-        headers=json_headers,
-    )
-    return json.loads(response.data.decode("utf-8"))
-
-
-def _assert_patron_loans_information(client, json_headers, document_pid, expect):
-    """Assert patron loan information."""
-    resp = _patron_loans_request(client, json_headers, document_pid)
-    assert resp == expect
-
-
-def _assert_error_when_not_authenticated(client, json_headers, document_pid):
-    """Assert user is not logged in."""
-    resp = _patron_loans_request(client, json_headers, document_pid)
-    assert resp["status"] == 401
-
-
-def test_patrons_permissions(client, testdata, json_headers, users):
-    """Test patron endpoints permissions."""
-    tests = [
-        ("admin", [200]),
-        ("librarian", [200]),
-        ("patron1", [403]),
-        ("anonymous", [401]),
-    ]
-
-    def _test_list(expected_status):
-        """Test get list."""
-        url = url_for(_LIST_ENDPOINT)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    for username, expected_status in tests:
-        user_login(client, username, users)
-        _test_list(expected_status)
-
-
-def test_patron_loans_information(client, json_headers, testdata_most_loaned, users):
-    """Test patron loans information API endpoint."""
-    _assert_error_when_not_authenticated(client, json_headers, "docid-1")
-    user_login(client, "librarian", users)
-
-    _assert_patron_loans_information(
-        client,
-        json_headers,
-        "docid-1",
-        expect={
-            "has_active_loan": False,
-            "is_requested": False,
-            "last_loan": None,
-        },
-    )
-
-    user_login(client, "patron1", users)
-
-    _assert_patron_loans_information(
-        client,
-        json_headers,
-        "docid-1",
-        expect={
-            "has_active_loan": False,
-            "is_requested": True,
-            "last_loan": "2019-04-02",
-        },
-    )
-
-    user_login(client, "patron2", users)
-    _assert_patron_loans_information(
-        client,
-        json_headers,
-        "docid-3",
-        expect={
-            "has_active_loan": False,
-            "is_requested": True,
-            "last_loan": None,
-        },
-    )

tests/api/ils/test_record_delete.py

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018-19 CERN.
-#
-# invenio-app-ils is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Test record delete."""
-
-from flask import url_for
-
-from tests.helpers import user_login
-
-
-def test_delete_location(client, users, json_headers, testdata):
-    """Test DELETE existing location."""
-    user_login(client, "admin", users)
-
-    location_pid = "locid-1"
-    url = url_for("invenio_records_rest.locid_item", pid_value=location_pid)
-    res = client.delete(url, headers=json_headers)
-    assert res.status_code == 400
-
-    location_pid = "locid-3"
-    url = url_for("invenio_records_rest.locid_item", pid_value=location_pid)
-    res = client.delete(url, headers=json_headers)
-    assert res.status_code == 204
-
-
-def test_delete_internal_location(client, users, json_headers, testdata):
-    """Test DELETE existing internal_location."""
-    user_login(client, "admin", users)
-
-    internal_location_pid = "ilocid-1"
-    url = url_for("invenio_records_rest.ilocid_item", pid_value=internal_location_pid)
-    res = client.delete(url, headers=json_headers)
-    assert res.status_code == 400
-
-    internal_location_pid = "ilocid-3"
-    url = url_for("invenio_records_rest.ilocid_item", pid_value=internal_location_pid)
-    res = client.delete(url, headers=json_headers)
-    assert res.status_code == 204