invenio-app-ils 1.0.0a54__py2.py3-none-any.whl → 6.1.0__py2.py3-none-any.whl

tests/api/ils/test_notifications.py

@@ -1,183 +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 jinja2 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,39 +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,106 +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,46 +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

tests/api/ils/test_record_permissions.py

@@ -1,135 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018-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 record permissions."""
-
-import uuid
-
-import pytest
-from flask_principal import RoleNeed, identity_loaded
-from invenio_access.models import ActionRoles
-from invenio_accounts.models import Role
-from invenio_records.api import Record
-from invenio_search.api import RecordsSearch
-
-from invenio_app_ils.errors import UnauthorizedSearchError
-from invenio_app_ils.records.permissions import (
-    RecordPermission,
-    create_records_action,
-)
-from invenio_app_ils.search_permissions import _filter_by_patron
-from tests.helpers import user_login
-
-
-@pytest.mark.parametrize(
-    "patron_pid,qs,should_raise",
-    [
-        ("1", None, False),
-        ("1", "", False),
-        ("1", "pid:1234", False),
-        ("1", "patron_pid:2", True),
-        ("1", "patron_pid: 2", True),
-        ("1", "patron_pid: '2'", False),
-        ("1", "pid:1234 AND patron_pid:2", True),
-    ],
-)
-def test_filter_by_patron(app, patron_pid, qs, should_raise):
-    """Test the function filter_by_patron."""
-    search = RecordsSearch()
-    if should_raise:
-        with pytest.raises(UnauthorizedSearchError):
-            _filter_by_patron(patron_pid, search, qs)
-    else:
-        _search, _qs = _filter_by_patron(patron_pid, search, qs)
-        term = _search.to_dict()["query"]["bool"]["filter"][0]["term"]
-        assert term == {"patron_pid": patron_pid}
-
-
-def test_record_generic_access(client, db, users, with_access):
-    """Test access control for records."""
-
-    tests = [
-        ({"foo": "bar"}, "read", True),
-        ({"foo": "bar"}, "update", False),
-        ({"_access": {"read": [1]}}, "read", True),
-        ({"_access": {"read": [2]}}, "read", False),
-        ({"_access": {"read": ["records-readers"]}}, "read", True),
-        # permission for specific user to create
-        ({"_access": {"update": [1]}}, "update", True),
-        # checks if the access works for different actions
-        ({"_access": {"update": [1]}}, "create", False),
-        ({"_access": {"delete": [1]}}, "update", False),
-        # delete access for user and librarian
-        ({"_access": {"delete": [1, "librarian"]}}, "delete", True),
-    ]
-
-    @identity_loaded.connect
-    def add_roles_to_identity(sender, identity):
-        """Provide additional role to the user."""
-        roles = [RoleNeed("records-readers")]
-        identity.provides |= set(roles)
-
-    def login_and_test(username):
-        user = user_login(client, username, users)
-        # Create record
-        id = uuid.uuid4()
-        record = Record.create(access, id_=id)
-        factory = RecordPermission(record, action)
-        if user.has_role("admin"):
-            # super user can do EVERYTHING
-            assert factory.can()
-        elif user.has_role("librarian") and action != "delete":
-            # librarian should be able to update, create, and read everything
-            assert factory.can()
-        else:
-            assert factory.can() if is_allowed else not factory.can()
-
-    for access, action, is_allowed in tests:
-        # Test standard user
-        login_and_test("patron1")
-        # Test librarian access
-        login_and_test("librarian")
-        # Test superuser access
-        login_and_test("admin")
-
-
-@pytest.fixture()
-def with_role_creator(db):
-    """"Create a new role and assign action."""
-    role = Role(name="records-creators")
-    db.session.add(role)
-    db.session.commit()
-    # assign role to the action "create-records"
-    ar = ActionRoles.allow(create_records_action, role_id=role.id)
-    db.session.add(ar)
-    db.session.commit()
-
-
-def test_record_patron_create(client, db, users, with_role_creator):
-    """Test patron create."""
-
-    tests = [
-        ({"foo": "bar"}, "create", True),
-        ({"foo": "bar"}, "update", False),
-        ({"foo": "bar"}, "delete", False),
-    ]
-
-    @identity_loaded.connect
-    def add_roles_to_identity(sender, identity):
-        """Provide additional role to the user."""
-        roles = [RoleNeed("records-creators")]
-        identity.provides |= set(roles)
-
-    for access, action, is_allowed in tests:
-        # create role to be able to create records
-        user_login(client, "patron1", users)
-
-        id = uuid.uuid4()
-        record = Record.create(access, id_=id)
-        factory = RecordPermission(record, action)
-
-        assert factory.can() if is_allowed else not factory.can()