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

tests/api/ils/series/test_series_permissions.py

@@ -1,95 +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 Series permissions."""
-
-import json
-
-from flask import url_for
-
-from tests.helpers import user_login
-
-_HTTP_OK = [200, 201, 204]
-SERIES_PID = "serid-1"
-ITEM_ENDPOINT = "invenio_records_rest.serid_item"
-LIST_ENDPOINT = "invenio_records_rest.serid_list"
-
-
-def test_series_read_permissions(client, testdata, json_headers, users):
-    """Test Series endpoints read permissions."""
-    tests = [
-        ("admin", _HTTP_OK),
-        ("librarian", _HTTP_OK),
-        ("patron1", _HTTP_OK),
-        ("anonymous", _HTTP_OK),
-    ]
-
-    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, pid):
-        """Test record read."""
-        url = url_for(ITEM_ENDPOINT, pid_value=pid)
-        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)
-        _test_read(expected_status, SERIES_PID)
-
-
-def test_series_edit_permissions(client, testdata, json_headers, users):
-    """Test series endpoints permissions."""
-    dummy_series = dict(
-        title="The Gulf: The Making of An American Sea",
-        authors=["Einstein, Albert", "Stachel, John J et al."],
-        mode_of_issuance="MULTIPART_MONOGRAPH",
-    )
-    tests = [
-        ("admin", _HTTP_OK, dummy_series),
-        ("librarian", _HTTP_OK, dummy_series),
-        ("patron1", [403], dummy_series),
-        ("anonymous", [401], dummy_series),
-    ]
-
-    def _test_create(expected_status, data):
-        """Test record creation."""
-        url = url_for(LIST_ENDPOINT)
-        res = client.post(url, headers=json_headers, data=json.dumps(data))
-        assert res.status_code in expected_status
-
-        if res.status_code < 400:
-            record = res.get_json()["metadata"]
-            assert record
-            return record["pid"]
-
-    def _test_update(expected_status, data, pid):
-        """Test record update."""
-        pid_value = pid or SERIES_PID
-        url = url_for(ITEM_ENDPOINT, pid_value=pid_value)
-        res = client.put(url, headers=json_headers, data=json.dumps(data))
-        assert res.status_code in expected_status
-        if res.status_code < 400:
-            record = res.get_json()["metadata"]
-            assert record
-
-    def _test_delete(expected_status, pid):
-        """Test record delete."""
-        pid_value = pid or SERIES_PID
-        url = url_for(ITEM_ENDPOINT, pid_value=pid_value)
-        res = client.delete(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    for username, expected_status, data in tests:
-        user_login(client, username, users)
-        pid = _test_create(expected_status, data)
-        _test_update(expected_status, data, pid)
-        _test_delete(expected_status, pid)

tests/api/ils/test_anonymization.py

@@ -1,189 +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 anonymization of users."""
-
-from copy import deepcopy
-
-import pytest
-from flask import url_for
-from invenio_accounts.models import User
-from invenio_circulation.api import Loan
-from invenio_circulation.proxies import current_circulation
-from invenio_db import db
-from invenio_oauthclient.models import RemoteAccount, UserIdentity
-from invenio_search import current_search
-from invenio_userprofiles.models import UserProfile
-
-from invenio_app_ils.acquisition.api import Order
-from invenio_app_ils.acquisition.search import OrderSearch
-from invenio_app_ils.circulation.search import (
-    get_active_loans_by_patron_pid,
-    get_loans_by_patron_pid,
-)
-from invenio_app_ils.document_requests.api import DocumentRequest
-from invenio_app_ils.document_requests.search import DocumentRequestSearch
-from invenio_app_ils.errors import AnonymizationActiveLoansError
-from invenio_app_ils.ill.api import BorrowingRequest
-from invenio_app_ils.ill.search import BorrowingRequestsSearch
-from invenio_app_ils.patrons.anonymization import anonymize_patron_data
-from invenio_app_ils.patrons.api import patron_exists
-from tests.helpers import user_login, user_logout
-
-
-def check_user_deleted(user_pid):
-    """ Check if user was deleted from database. """
-    with db.session.begin_nested():
-        user_identity = UserIdentity.query.filter(
-            UserIdentity.id_user == user_pid
-        ).first()
-
-        assert user_identity is None
-
-        remote_account = RemoteAccount.query.filter(
-            RemoteAccount.user_id == user_pid
-        ).first()
-        assert remote_account is None
-
-        user_profile = UserProfile.query.filter(
-            UserProfile.user_id == user_pid
-        ).first()
-        assert user_profile is None
-
-        user = User.query.filter(User.id == user_pid).first()
-        assert user is None
-
-
-def check_user_exists(user_pid):
-    """ Check if user exists in database. """
-    with db.session.begin_nested():
-        assert patron_exists(user_pid)
-
-
-def check_user_activity(app, user_pid, client, json_headers):
-    """ Check if there are records related to the user. """
-    # wait ES refresh
-    current_search.flush_and_refresh(index="*")
-
-    AnonymousPatron = app.config["ILS_PATRON_ANONYMOUS_CLASS"]
-    anonymous_patron_fields = AnonymousPatron().dumps_loader()
-
-    loans = get_loans_by_patron_pid(user_pid).scan()
-    for hit in loans:
-        # test ES
-        assert hit["patron"] == anonymous_patron_fields
-        # test DB
-        loan = Loan.get_record_by_pid(hit.pid)
-        assert loan["patron"] == anonymous_patron_fields
-        # test REST
-        url = url_for("invenio_records_rest.loanid_item", pid_value=hit.pid)
-        res = client.get(url, headers=json_headers)
-        assert res.get_json()["metadata"]["patron"] == anonymous_patron_fields
-
-    borrowing_requests = (
-        BorrowingRequestsSearch().search_by_patron_pid(user_pid).scan()
-    )
-    for hit in borrowing_requests:
-        # test ES
-        assert hit["patron"] == anonymous_patron_fields
-        # test DB
-        borrowing_request = BorrowingRequest.get_record_by_pid(hit.pid)
-        assert borrowing_request["patron"] == anonymous_patron_fields
-        # test REST
-        url = url_for("invenio_records_rest.illbid_item", pid_value=hit.pid)
-        res = client.get(url, headers=json_headers)
-        assert res.get_json()["metadata"]["patron"] == anonymous_patron_fields
-
-    document_requests = (
-        DocumentRequestSearch().search_by_patron_pid(user_pid).scan()
-    )
-    for hit in document_requests:
-        # test ES
-        assert hit["patron"] == anonymous_patron_fields
-        # test DB
-        document_request = DocumentRequest.get_record_by_pid(hit.pid)
-        assert document_request["patron"] == anonymous_patron_fields
-        # test REST
-        url = url_for("invenio_records_rest.dreqid_item", pid_value=hit.pid)
-        res = client.get(url, headers=json_headers)
-        assert res.get_json()["metadata"]["patron"] == anonymous_patron_fields
-
-    acquisitions = OrderSearch().search_by_patron_pid(user_pid).scan()
-    for hit in acquisitions:
-        # test ES
-        assert hit["patron"] == anonymous_patron_fields
-        # test DB
-        acquisition = Order.get_record_by_pid(hit.pid)
-        assert acquisition["patron"] == anonymous_patron_fields
-        # test REST
-        url = url_for("invenio_records_rest.acqoid_item", pid_value=hit.pid)
-        res = client.get(url, headers=json_headers)
-        assert res.get_json()["metadata"]["patron"] == anonymous_patron_fields
-
-
-def cancel_active_loans(patron_pid, client, users):
-    """Cancel active loans of a patron."""
-    user = user_login(client, "admin", users)
-
-    active_loans = get_active_loans_by_patron_pid(patron_pid).scan()
-
-    for hit in active_loans:
-        loan = Loan.get_record_by_pid(hit.pid)
-        params = deepcopy(loan)
-        params.update(
-            dict(
-                cancel_reason="Loan cancelled to anonymize user.",
-                transaction_user_pid=str(user.id),
-            )
-        )
-        current_circulation.circulation.trigger(
-            loan, **dict(params, trigger="cancel")
-        )
-
-        loan.commit()
-        db.session.commit()
-        current_circulation.loan_indexer().index(loan)
-
-    current_search.flush_and_refresh(index="*")
-
-
-def test_anonymization(app, client, json_headers, users, testdata):
-    """Test anonymization of a user."""
-    # Anonymize patron
-    patron_pid = users["patron3"].id
-
-    check_user_exists(patron_pid)
-    cancel_active_loans(patron_pid, client, users)
-    anonymize_patron_data(patron_pid)
-    check_user_deleted(patron_pid)
-
-    user_login(client, "admin", users)
-    check_user_activity(app, patron_pid, client, json_headers)
-    user_logout(client)
-
-    # Anonymize librarian
-    librarian_pid = users["librarian"].id
-
-    check_user_exists(librarian_pid)
-    cancel_active_loans(librarian_pid, client, users)
-    anonymize_patron_data(librarian_pid)
-    check_user_deleted(librarian_pid)
-
-    # Anonymize patron while logged in
-    patron_pid = users["patron2"].id
-    user_login(client, "patron2", users)
-
-    check_user_exists(patron_pid)
-    cancel_active_loans(patron_pid, client, users)
-    anonymize_patron_data(patron_pid)
-    check_user_deleted(patron_pid)
-
-    # It should fail when anonymizing patron with active loans
-    patron_pid = users["patron1"].id
-    check_user_exists(patron_pid)
-    with pytest.raises(AnonymizationActiveLoansError):
-        assert anonymize_patron_data(patron_pid)

tests/api/ils/test_apis.py

@@ -1,76 +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 ILS APIs."""
-
-import pytest
-from flask import url_for
-from invenio_accounts.models import User
-
-from invenio_app_ils.documents.api import Document
-from invenio_app_ils.patrons.api import patron_exists
-from invenio_app_ils.proxies import current_app_ils
-from invenio_app_ils.records.api import IlsRecord
-from invenio_app_ils.series.api import Series
-from tests.helpers import get_test_record
-
-
-def test_apis(client, json_headers, testdata):
-    """Test various APIs."""
-
-    def test_patron_exists():
-        """Test return True if item exists."""
-        test_patron = User.query.all()[0]
-        assert patron_exists(int(test_patron.id))
-        assert patron_exists(str(test_patron.id))
-
-        with pytest.raises(AssertionError):
-            assert not patron_exists("not a number")
-            assert not patron_exists("-1")
-            assert not patron_exists("0")
-
-    def test_get_record_by_pid():
-        """Test get_record_by_pid."""
-        tests = [("docid-1", Document), ("serid-1", Series)]
-
-        for pid, cls in tests:
-            record = cls.get_record_by_pid(pid)
-
-            assert isinstance(record, cls)
-            assert record["pid"] == pid
-            assert record._pid_type == cls._pid_type
-
-    def test_get_record_by_pid_and_pid_type():
-        """Test get_record_by_pid with pid_type."""
-        tests = [("docid-1", "docid", Document), ("serid-1", "serid", Series)]
-
-        for pid, pid_type, expected_cls in tests:
-            record = IlsRecord.get_record_by_pid(pid, pid_type=pid_type)
-
-            assert isinstance(record, expected_cls)
-            assert record["pid"] == pid
-            assert record._pid_type == pid_type
-
-    def test_get_default_location_pid():
-        """Asset that the default location is the first created."""
-        first = get_test_record(testdata, "locations", "locid-1")
-        pid_value, _ = current_app_ils.get_default_location_pid
-        assert pid_value == first["pid"]
-
-    def test_no_etag():
-        """Assert that the response headers do not contain ETag."""
-        url = url_for("invenio_records_rest.docid_item", pid_value="docid-1")
-        res = client.get(url, headers=json_headers)
-        assert res.cache_control.no_cache
-        assert res.get_etag() == (None, None)
-        assert "Last-Modified" not in res.headers
-
-    test_patron_exists()
-    test_get_record_by_pid()
-    test_get_record_by_pid_and_pid_type()
-    test_get_default_location_pid()
-    test_no_etag()

tests/api/ils/test_closures.py

@@ -1,324 +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.
-
-"""Location closures tests."""
-
-import json
-
-import arrow
-from flask import url_for
-
-from invenio_app_ils.closures.api import find_next_open_date
-from invenio_app_ils.proxies import current_app_ils
-from tests.helpers import user_login
-
-_HTTP_OK = [200, 201, 204]
-_LOCATION_PID = "locid-1"
-_LOCATION_NAME = "Location name"
-_ITEM_ENDPOINT = "invenio_records_rest.locid_item"
-_LIST_ENDPOINT = "invenio_records_rest.locid_list"
-_WEEKDAYS = [
-    "monday",
-    "tuesday",
-    "wednesday",
-    "thursday",
-    "friday",
-    "saturday",
-    "sunday",
-]
-_DEFAULT_TIMES = [
-    {"start_time": "08:00", "end_time": "12:00"},
-    {"start_time": "13:00", "end_time": "18:00"},
-]
-
-
-def _build_location_closures_data(closed_weekdays, exceptions):
-    opening_weekdays = []
-    for name in _WEEKDAYS:
-        is_open = name not in closed_weekdays
-        obj = {"weekday": name, "is_open": is_open}
-        if is_open:
-            obj["times"] = _DEFAULT_TIMES
-        opening_weekdays.append(obj)
-
-    opening_exceptions = []
-    for start_date, end_date, is_open in exceptions:
-        opening_exceptions.append(
-            {
-                "title": "%s - %s" % (start_date, end_date),
-                "start_date": start_date,
-                "end_date": end_date,
-                "is_open": is_open,
-            }
-        )
-
-    return {
-        "opening_weekdays": opening_weekdays,
-        "opening_exceptions": opening_exceptions,
-    }
-
-
-def _date_from_string(date_string):
-    return arrow.get(date_string).date()
-
-
-def test_location_permissions(client, testdata, json_headers, users):
-    """Test location endpoints permissions."""
-    dummy_location = dict(
-        name=_LOCATION_NAME,
-        opening_weekdays=[
-            {"weekday": w, "is_open": True, "times": _DEFAULT_TIMES}
-            for w in _WEEKDAYS
-        ],
-        opening_exceptions=[],
-    )
-    tests = [
-        ("admin", _HTTP_OK, dummy_location),
-        ("librarian", _HTTP_OK, dummy_location),
-        ("patron1", [403], dummy_location),
-        ("anonymous", [401], dummy_location),
-    ]
-    read_statuses = [200]
-
-    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_create(expected_status, data):
-        """Test record creation."""
-        url = url_for(_LIST_ENDPOINT)
-        res = client.post(url, headers=json_headers, data=json.dumps(data))
-        assert res.status_code in expected_status
-
-        if res.status_code < 400:
-            record = res.get_json()["metadata"]
-            assert record["name"] == _LOCATION_NAME
-            return record["pid"]
-
-    def _test_update(expected_status, data, pid):
-        """Test record update."""
-        pid_value = pid or _LOCATION_PID
-        url = url_for(_ITEM_ENDPOINT, pid_value=pid_value)
-        res = client.put(url, headers=json_headers, data=json.dumps(data))
-        assert res.status_code in expected_status
-        if res.status_code < 400:
-            record = res.get_json()["metadata"]
-            assert record["name"] == _LOCATION_NAME
-
-    def _test_read(expected_status, pid):
-        """Test record read."""
-        pid_value = pid or _LOCATION_PID
-        url = url_for(_ITEM_ENDPOINT, pid_value=pid_value)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    def _test_delete(expected_status, pid):
-        """Test record delete."""
-        pid_value = pid or _LOCATION_PID
-        url = url_for(_ITEM_ENDPOINT, pid_value=pid_value)
-        res = client.delete(url, headers=json_headers)
-        assert res.status_code in expected_status
-
-    for username, expected_status, data in tests:
-        user_login(client, username, users)
-        _test_list(read_statuses)
-        pid = _test_create(expected_status, data)
-        _test_update(expected_status, data, pid)
-        _test_read(read_statuses, pid)
-        _test_delete(expected_status, pid)
-
-
-def test_location_validation(client, json_headers, users, testdata):
-    def _test_update_location_closures(data, expected_code):
-        url = url_for(
-            "invenio_records_rest.locid_item", pid_value=_LOCATION_PID
-        )
-        res = client.get(url, headers=json_headers)
-        assert res.status_code == 200
-        metadata = res.get_json()["metadata"]
-        metadata.update(data)
-        res = client.put(url, headers=json_headers, data=json.dumps(metadata))
-        assert res.status_code == expected_code
-
-    def _test_update_weekdays(weekdays, expected_code):
-        data = [
-            {
-                "weekday": name,
-                "is_open": is_open,
-                **({"times": _DEFAULT_TIMES} if is_open else {}),
-            }
-            for name, is_open in weekdays
-        ]
-        _test_update_location_closures(
-            {"opening_weekdays": data, "opening_exceptions": []}, expected_code
-        )
-
-    def _test_update_times(times, expected_code):
-        ref = "monday"
-        times_data = [
-            {"start_time": start, "end_time": end} for start, end in times
-        ]
-        data = [
-            {
-                "weekday": w,
-                "is_open": w == ref,
-                **({"times": times_data} if w == ref else {}),
-            }
-            for w in _WEEKDAYS
-        ]
-        _test_update_location_closures(
-            {"opening_weekdays": data, "opening_exceptions": []}, expected_code
-        )
-
-    def _test_update_exceptions(closed_weekdays, exceptions, expected_code):
-        _test_update_location_closures(
-            _build_location_closures_data(closed_weekdays, exceptions),
-            expected_code,
-        )
-
-    user_login(client, "librarian", users)
-
-    # Weekdays
-
-    _test_update_weekdays([[w, True] for w in _WEEKDAYS], 200)
-    _test_update_weekdays([[w, True] for w in _WEEKDAYS[::-1]], 200)
-    _test_update_weekdays([[w, False] for w in _WEEKDAYS], 400)
-    _test_update_weekdays([[w, True] for w in _WEEKDAYS[:6]], 400)
-    _test_update_weekdays([[w, True] for w in _WEEKDAYS[:6] + ["monday"]], 400)
-    _test_update_weekdays([["foobar", True]], 400)
-
-    # Hours
-
-    _test_update_times([["08:00", "12:00"], ["13:00", "18:00"]], 200)
-    _test_update_times([["13:00", "18:00"], ["08:00", "12:00"]], 200)
-    _test_update_times([["08:00", "18:00"]], 200)
-    _test_update_times([], 400)
-    _test_update_times(
-        [["08:00", "10:00"], ["11:00", "12:00"], ["13:00", "18:00"]], 400
-    )
-    _test_update_times([["8:00", "12:00"], ["13:00", "18:00"]], 400)
-    _test_update_times([["08:00", "12:0"], ["13:00", "18:00"]], 400)
-    _test_update_times([["08:00", ""], ["13:00", "18:00"]], 400)
-    _test_update_times([["08:00", "12:00"], ["12:00", "18:00"]], 400)
-    _test_update_times([["08:00", "12:00"], ["09:00", "11:00"]], 400)
-
-    # Exceptions
-
-    _test_update_exceptions(
-        ["saturday", "sunday"],
-        [
-            ["2000-01-01", "2000-01-05", False],
-            ["2000-01-07", "2000-01-09", True],
-            ["2000-01-10", "2000-01-15", True],
-        ],
-        200,
-    )
-
-    _test_update_exceptions(
-        ["saturday", "sunday"],
-        [
-            ["2000-01-12", "2000-01-17", True],
-            ["2000-01-07", "2000-01-11", False],
-            ["2000-01-02", "2000-01-04", True],
-        ],
-        200,
-    )
-
-    _test_update_exceptions(
-        [],
-        [
-            ["2000-01-01", "2000-01-05", False],
-            ["2000-01-04", "2000-01-08", False],
-        ],
-        400,
-    )
-
-    _test_update_exceptions(
-        [],
-        [
-            ["2000-01-01", "2000-01-05", False],
-            ["2000-01-04", "2000-01-08", True],
-        ],
-        400,
-    )
-
-    _test_update_exceptions(
-        [],
-        [
-            ["2000-01-01", "2000-01-01", False],
-            ["2000-01-01", "2000-01-01", False],
-        ],
-        400,
-    )
-
-    _test_update_exceptions(
-        [],
-        [
-            ["2000-01-02", "2000-01-01", True],
-        ],
-        400,
-    )
-
-
-def test_find_next_open_date(app, db, testdata):
-    def _update_location_closures_data(closed_weekdays, exceptions):
-        Location = current_app_ils.location_record_cls
-        record = Location.get_record_by_pid(_LOCATION_PID)
-
-        record.update(
-            _build_location_closures_data(closed_weekdays, exceptions)
-        )
-        record.commit()
-        db.session.commit()
-        current_app_ils.location_indexer.index(record)
-
-        return record
-
-    def _test(start_date, expected_next_open_date):
-        next_open = find_next_open_date(
-            _LOCATION_PID, _date_from_string(start_date)
-        )
-        if expected_next_open_date:
-            assert next_open == _date_from_string(expected_next_open_date)
-        else:
-            assert next_open is None
-
-    """
-    Mon. Tue. Wed. Thu. Fri. Sat. Sun.
-     27   28   29   30   31  -01  -02
-    x03  x04  x05   06   07  -08  -09
-    x10  x11  x12  x13  x14  x15  x16
-    x17  x18  x19  x20  x21  x22  -23
-    x24   25   26  x27  x28  o29  o30
-     31   01   02   03   04  -05  -06
-    """
-
-    closed_weekdays = ["saturday", "sunday"]
-    exceptions = [
-        ["2000-01-03", "2000-01-05", False],  # Mon. - Wed.
-        ["2000-01-09", "2000-01-22", False],  # Sun. - Sat.
-        ["2000-01-24", "2000-01-24", False],  # Mon.
-        ["2000-01-27", "2000-01-28", False],  # Thu. - Fri.
-        ["2000-01-29", "2000-01-30", True],  # Sat. - Sun.
-    ]
-    _update_location_closures_data(closed_weekdays, exceptions)
-
-    _test("2000-01-01", "2000-01-06")
-    _test("2000-01-04", "2000-01-06")
-    _test("2000-01-06", "2000-01-06")
-    _test("2000-01-07", "2000-01-07")
-
-    _test("2000-01-09", "2000-01-25")
-    _test("2000-01-13", "2000-01-25")
-
-    _test("2000-01-26", "2000-01-26")
-    _test("2000-01-27", "2000-01-29")
-    _test("2000-01-30", "2000-01-30")
-
-    _test("2000-02-05", "2000-02-07")