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

tests/api/ils/test_record_permissions.py

@@ -1,132 +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()

tests/api/ils/test_resolvers.py

@@ -1,205 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 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 Items resolvers."""
-
-from invenio_circulation.pidstore.pids import CIRCULATION_LOAN_PID_TYPE
-
-from invenio_app_ils.acquisition.api import ORDER_PID_TYPE
-from invenio_app_ils.document_requests.api import DOCUMENT_REQUEST_PID_TYPE
-from invenio_app_ils.documents.api import DOCUMENT_PID_TYPE, Document
-from invenio_app_ils.documents.indexer import DocumentIndexer
-from invenio_app_ils.eitems.api import EITEM_PID_TYPE, EItem
-from invenio_app_ils.eitems.indexer import EItemIndexer
-from invenio_app_ils.ill.api import BORROWING_REQUEST_PID_TYPE
-from invenio_app_ils.internal_locations.indexer import InternalLocationIndexer
-from invenio_app_ils.items.api import ITEM_PID_TYPE, Item
-from invenio_app_ils.items.indexer import ItemIndexer
-from invenio_app_ils.locations.api import LOCATION_PID_TYPE, Location
-from invenio_app_ils.locations.indexer import LocationIndexer
-from invenio_app_ils.patrons.api import PATRON_PID_TYPE, Patron
-from invenio_app_ils.patrons.indexer import PatronIndexer
-
-from invenio_app_ils.internal_locations.api import (  # isort:skip
-    INTERNAL_LOCATION_PID_TYPE,
-    InternalLocation,
-)
-
-
-def test_jsonresolvers(testdata, mocker):
-    """Test that all records referencing a changed record are re-indexed."""
-
-    def _get_mock():
-        return mocker.patch("invenio_app_ils.indexer.ReferencedRecordsIndexer.index")
-
-    def _assert_origin(indexer, pid_type, pid_value):
-        """Assert that origin is called and return all referenced."""
-        assert indexer.called
-        all_calls = indexer.call_args_list
-        first_call = all_calls[0]
-        indexed, referenced = first_call[0]
-        assert indexed["pid_type"] == pid_type
-        assert indexed["record"]["pid"] == pid_value
-
-        # call[0] is the list of arguments passed to the function
-        # call[0][0] is the origin record, call[0][1] is the referenced record
-        all_referenced = []
-        for call in all_calls:
-            origin, referenced = call[0]
-            all_referenced += referenced
-        return all_referenced
-
-    def _assert_contains(referenced, pid_type):
-        """Assert that given PID is contained in one of the referenced."""
-        found = False
-        for r in referenced:
-            if r["pid_type"] == pid_type:
-                found = True
-                break
-        assert found
-
-    def test_on_document_update():
-        """Test document resolvers."""
-        indexer = _get_mock()
-
-        pid = "docid-2"
-        document = Document.get_record_by_pid(pid)
-        DocumentIndexer().index(document)
-
-        referenced = _assert_origin(indexer, DOCUMENT_PID_TYPE, pid)
-
-        # should re-index document request
-        n_doc_req = 1  # from test data
-        _assert_contains(referenced, DOCUMENT_REQUEST_PID_TYPE)
-
-        # should re-index eitem
-        n_eitems = 1  # from test data
-        _assert_contains(referenced, EITEM_PID_TYPE)
-
-        # should re-index item
-        n_items = 1  # from test data
-        _assert_contains(referenced, ITEM_PID_TYPE)
-
-        # should re-index acq
-        n_acq = 1  # from test data
-        _assert_contains(referenced, ORDER_PID_TYPE)
-
-        # should re-index ill
-        n_ill = 1  # from test data
-        _assert_contains(referenced, BORROWING_REQUEST_PID_TYPE)
-
-        expected_total = n_doc_req + n_eitems + n_items + n_acq + n_ill
-        assert len(referenced) == expected_total
-
-    def test_on_eitem_update():
-        """Test eitem resolvers."""
-        indexer = _get_mock()
-
-        pid = "eitemid-1"
-        eitem = EItem.get_record_by_pid(pid)
-        EItemIndexer().index(eitem)
-
-        referenced = _assert_origin(indexer, EITEM_PID_TYPE, pid)
-
-        # should re-index documents
-        n_documents = 1  # from test data
-        _assert_contains(referenced, DOCUMENT_PID_TYPE)
-
-        assert len(referenced) == n_documents
-
-    def test_on_internal_location_update():
-        """Test internal location resolvers."""
-        indexer = _get_mock()
-
-        pid = "ilocid-2"
-        intloc = InternalLocation.get_record_by_pid(pid)
-        InternalLocationIndexer().index(intloc)
-
-        referenced = _assert_origin(indexer, INTERNAL_LOCATION_PID_TYPE, pid)
-
-        # should re-index items
-        n_items = 4  # from test data
-        _assert_contains(referenced, ITEM_PID_TYPE)
-
-        assert len(referenced) == n_items
-
-    def test_on_item_update():
-        """Test item resolvers."""
-        indexer = _get_mock()
-
-        # item on loan
-        pid = "itemid-56"
-        item = Item.get_record_by_pid(pid)
-        ItemIndexer().index(item)
-
-        referenced = _assert_origin(indexer, ITEM_PID_TYPE, pid)
-
-        # should re-index loans
-        n_loans = 2  # from test data, including pending
-        _assert_contains(referenced, CIRCULATION_LOAN_PID_TYPE)
-
-        # should re-index document
-        n_documents = 1  # from test data
-        _assert_contains(referenced, DOCUMENT_PID_TYPE)
-
-        assert len(referenced) == n_loans + n_documents
-
-    def test_on_location_update():
-        """Test location resolvers."""
-        indexer = _get_mock()
-
-        pid = "locid-2"
-        loc = Location.get_record_by_pid(pid)
-        LocationIndexer().index(loc)
-
-        referenced = _assert_origin(indexer, LOCATION_PID_TYPE, pid)
-
-        # should re-index internal locations
-        n_intlocs = 1  # from test data
-        _assert_contains(referenced, INTERNAL_LOCATION_PID_TYPE)
-
-        # should re-index internal items
-        n_items = 1  # from test data
-        _assert_contains(referenced, ITEM_PID_TYPE)
-
-        assert len(referenced) == n_intlocs + n_items
-
-    def test_on_patron_update():
-        """Test patron resolvers."""
-        indexer = _get_mock()
-
-        pid = "2"
-        patron = Patron.get_patron(pid)
-        PatronIndexer().index(patron)
-
-        referenced = _assert_origin(indexer, PATRON_PID_TYPE, pid)
-
-        # should re-index loans
-        n_loans = 3  # from test data
-        _assert_contains(referenced, CIRCULATION_LOAN_PID_TYPE)
-
-        # should re-index document request
-        n_doc_req = 1  # from test data
-        _assert_contains(referenced, DOCUMENT_REQUEST_PID_TYPE)
-
-        # should re-index acq
-        n_acq = 1  # from test data
-        _assert_contains(referenced, ORDER_PID_TYPE)
-
-        # should re-index ill
-        n_ill = 3  # from test data
-        _assert_contains(referenced, BORROWING_REQUEST_PID_TYPE)
-
-        expected_total = n_loans + n_doc_req + n_acq + n_ill
-        assert len(referenced) == expected_total
-
-    test_on_document_update()
-    test_on_eitem_update()
-    test_on_internal_location_update()
-    test_on_item_update()
-    test_on_location_update()
-    test_on_patron_update()

tests/api/ils/test_stats.py

@@ -1,142 +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 records relations."""
-
-import json
-
-from flask import url_for
-from invenio_db import db
-
-from invenio_app_ils.signals import record_viewed
-from tests.helpers import user_login, user_logout
-
-
-def _most_loaned_request(client, json_headers, from_date=None, to_date=None):
-    """Perform a stats request."""
-    params = []
-    if from_date is not None:
-        params.append("from_date={}".format(from_date))
-    if to_date is not None:
-        params.append("to_date={}".format(to_date))
-    response = client.get(
-        "{}?{}".format(
-            url_for("invenio_app_ils_circulation_stats.most-loaned"),
-            "&".join(params),
-        ),
-        headers=json_headers,
-    )
-    return json.loads(response.data.decode("utf-8"))
-
-
-def _assert_most_loaned(client, json_headers, from_date, to_date, expect):
-    """Assert most loaned request."""
-    resp = _most_loaned_request(client, json_headers, from_date, to_date)
-    hits = resp["hits"]["hits"]
-    assert len(hits) == len(expect)
-    for hit in hits:
-        pid = hit["metadata"]["pid"]
-        assert hit["metadata"]["loan_count"] == expect[pid]["loans"]
-        assert hit["metadata"]["loan_extensions"] == expect[pid]["extensions"]
-
-
-def test_stats_most_loaned_documents(client, json_headers, testdata_most_loaned, users):
-    """Test most loaned documents API endpoint."""
-    user_login(client, "librarian", users)
-
-    # Dates covering all loans
-    _assert_most_loaned(
-        client,
-        json_headers,
-        "2019-01-01",
-        "2019-12-01",
-        expect={
-            "docid-1": dict(loans=3, extensions=0),
-            "docid-2": dict(loans=1, extensions=1),
-            "docid-3": dict(loans=2, extensions=6),
-            "docid-5": dict(loans=1, extensions=0),
-        },
-    )
-    # Test checking range which should be empty
-    _assert_most_loaned(client, json_headers, "2019-01-01", "2019-01-01", expect={})
-    # Test range only including the first loan
-    _assert_most_loaned(
-        client,
-        json_headers,
-        "2019-01-01",
-        "2019-01-03",
-        expect={"docid-1": dict(loans=1, extensions=0)},
-    )
-    _assert_most_loaned(
-        client,
-        json_headers,
-        "2019-02-02",
-        "2019-03-02",
-        expect={
-            "docid-1": dict(loans=2, extensions=0),
-            "docid-2": dict(loans=1, extensions=1),
-            "docid-3": dict(loans=1, extensions=3),
-        },
-    )
-    _assert_most_loaned(
-        client,
-        json_headers,
-        "2019-05-20",
-        "2019-08-22",
-        expect={"docid-3": dict(loans=1, extensions=3)},
-    )
-    # outside end range
-    _assert_most_loaned(client, json_headers, "2019-05-21", "2019-12-31", expect={})
-
-
-def test_stats_downloads_views_permissions(
-    client, json_headers, users, testdata, mocker
-):
-    """Test permissions on downloads/views stats."""
-
-    # mock record_viewed signal because travis timed out and the signal does
-    # not need to be tested here
-    mocker.patch(
-        "invenio_app_ils.signals.record_viewed.send",
-    )
-
-    url_open_access = url_for(
-        "ils_document_stats.docid_stats", pid_value="docid-open-access"
-    )
-    url_closed_access = url_for(
-        "ils_document_stats.docid_stats", pid_value="docid-closed-access"
-    )
-    params = {}
-    params["event"] = "record-view"
-
-    # permission for librarian
-    user_login(client, "librarian", users)
-    res = client.post(url_open_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 202
-
-    res = client.post(url_closed_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 202
-
-    user_logout(client)
-
-    # permission for patron
-    user_login(client, "patron1", users)
-
-    res = client.post(url_open_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 202
-
-    res = client.post(url_closed_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 403
-
-    user_logout(client)
-
-    # permission for unauthenticated user
-    res = client.post(url_open_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 202
-
-    res = client.post(url_closed_access, headers=json_headers, data=json.dumps(params))
-    assert res.status_code == 401

tests/api/ils/test_tasks.py

@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 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 location closure cronjobs."""
-
-import time
-
-import arrow
-from invenio_circulation.proxies import current_circulation
-
-from invenio_app_ils.circulation.search import get_active_loans
-from invenio_app_ils.closures.tasks import (
-    clean_locations_past_closures_exceptions,
-    extend_active_loans_location_closure,
-)
-from invenio_app_ils.proxies import current_app_ils
-
-_LOCATION_PID_1 = "locid-1"
-_LOCATION_PID_2 = "locid-2"
-_LOAN_PID_1 = "loanid-6"
-_LOAN_PID_2 = "loanid-5"
-
-
-_OPENING_EXCEPTIONS_WITH_PAST_EXCEPTIONS = [
-    {
-        "title": "Past holidays",
-        "is_open": False,
-        "start_date": "2010-01-01",
-        "end_date": "2010-01-06",
-    },
-    {
-        "title": "Past holidays",
-        "is_open": False,
-        "start_date": "2013-04-05",
-        "end_date": "2013-04-08",
-    },
-    {
-        "title": "Past holiday",
-        "is_open": False,
-        "start_date": "2005-05-14",
-        "end_date": "2005-05-16",
-    },
-    {
-        "title": "Past holidays",
-        "is_open": False,
-        "start_date": "2019-02-01",
-        "end_date": "2019-02-06",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2100-02-11",
-        "end_date": "2100-02-12",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2100-03-01",
-        "end_date": "2100-03-06",
-    },
-]
-
-_OPENING_EXCEPTIONS_WITHOUT_CHANGES = [
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2110-01-01",
-        "end_date": "2110-01-06",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2113-04-05",
-        "end_date": "2113-04-08",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2105-05-14",
-        "end_date": "2105-05-16",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2119-02-01",
-        "end_date": "2119-02-06",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2100-02-11",
-        "end_date": "2100-02-12",
-    },
-    {
-        "title": "Future holidays",
-        "is_open": False,
-        "start_date": "2100-03-01",
-        "end_date": "2100-03-06",
-    },
-]
-
-
-def prepare_data(db, location_pid, opening_exceptions):
-    """Adds some opening exceptions to a concrete location."""
-
-    location = current_app_ils.location_record_cls
-    record = location.get_record_by_pid(location_pid)
-
-    record.update({"opening_exceptions": opening_exceptions})
-    record.commit()
-    db.session.commit()
-    current_app_ils.location_indexer.index(record)
-
-
-def prepare_loans_data(db, testdata):
-    """Updates the expire date of a loan to match a closure day."""
-    loans = testdata["loans"]
-
-    def new_expiration_date(loan_test_data, date):
-        loan = current_circulation.loan_record_cls.get_record_by_pid(
-            loan_test_data["pid"]
-        )
-        loan.update(end_date=date.isoformat())
-        loan.commit()
-        db.session.commit()
-        current_circulation.loan_indexer().index(loan)
-
-    # Change expiration date to match closure
-    date = arrow.get("2100-03-03").date()
-    date_2 = arrow.get("2100-02-12").date()
-    new_expiration_date(loans[5], date)
-    new_expiration_date(loans[4], date_2)
-
-
-def opening_exceptions_cleaned():
-    """Prepare data that should match with the response."""
-    opening_exceptions = [
-        {
-            "title": "Future holidays",
-            "is_open": False,
-            "start_date": "2100-02-11",
-            "end_date": "2100-02-12",
-        },
-        {
-            "title": "Future holidays",
-            "is_open": False,
-            "start_date": "2100-03-01",
-            "end_date": "2100-03-06",
-        },
-    ]
-
-    return opening_exceptions
-
-
-def test_clean_locations_past_closures_exceptions(db, users, testdata):
-    """Test cleaning of past exceptions."""
-    prepare_data(db, _LOCATION_PID_1, _OPENING_EXCEPTIONS_WITH_PAST_EXCEPTIONS)
-    prepare_data(db, _LOCATION_PID_2, _OPENING_EXCEPTIONS_WITH_PAST_EXCEPTIONS)
-    clean_locations_past_closures_exceptions()
-    location = current_app_ils.location_record_cls
-    record = location.get_record_by_pid(_LOCATION_PID_1)
-    record_2 = location.get_record_by_pid(_LOCATION_PID_2)
-
-    assert record["opening_exceptions"] == opening_exceptions_cleaned()
-    assert record_2["opening_exceptions"] == opening_exceptions_cleaned()
-
-
-def test_no_changes_on_loans(db, users, testdata):
-    """Test that no changes are applied to the loans if not needed."""
-    prepare_data(db, _LOCATION_PID_1, _OPENING_EXCEPTIONS_WITHOUT_CHANGES)
-    loans = testdata["loans"]
-    clean_locations_past_closures_exceptions()
-    for hit in get_active_loans().scan():
-        for loan in loans:
-            if hit["pid"] == loan["pid"]:
-                assert hit["end_date"] == loan["end_date"]
-
-
-def test_no_changes_on_exceptions(db, users, testdata):
-    """Test that no changes are applied to the exceptions if not needed."""
-    prepare_data(db, _LOCATION_PID_1, _OPENING_EXCEPTIONS_WITHOUT_CHANGES)
-    extend_active_loans_location_closure(_LOCATION_PID_1)
-    location = current_app_ils.location_record_cls
-    record = location.get_record_by_pid(_LOCATION_PID_1)
-    record_2 = location.get_record_by_pid(_LOCATION_PID_2)
-
-    assert record["opening_exceptions"] == _OPENING_EXCEPTIONS_WITHOUT_CHANGES
-    assert record_2["opening_exceptions"] == []
-
-
-def test_extend_active_loans_location_closure(db, users, testdata, app_with_notifs):
-    """Test extension of active loans that finish on holidays."""
-    prepare_data(db, _LOCATION_PID_1, _OPENING_EXCEPTIONS_WITH_PAST_EXCEPTIONS)
-    prepare_loans_data(db, testdata)
-    time.sleep(3)
-
-    with app_with_notifs.extensions["mail"].record_messages() as outbox:
-        assert len(outbox) == 0
-        extend_active_loans_location_closure(_LOCATION_PID_1)
-        assert len(outbox) == 2
-
-    loan = current_circulation.loan_record_cls.get_record_by_pid(_LOAN_PID_1)
-    loan_2 = current_circulation.loan_record_cls.get_record_by_pid(_LOAN_PID_2)
-    assert loan["end_date"] == "2100-03-07"
-    assert loan_2["end_date"] == "2100-02-13"