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

tests/api/ils/test_closures.py

@@ -1,353 +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
-import pytest
-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"
-_CLOSURE_PERIODS_ENDPOINT = "invenio_app_ils_closures.location_closure_periods"
-_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,
-    )
-
-
-@pytest.fixture
-def location_closures_testdata(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
-
-    """
-    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)
-
-
-def test_find_next_open_date(app, location_closures_testdata):
-    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
-
-    _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")
-
-
-def test_get_closure_periods(client, location_closures_testdata, json_headers):
-    """Test get closure periods."""
-    url = url_for(
-        _CLOSURE_PERIODS_ENDPOINT,
-        pid_value=_LOCATION_PID,
-        year=2000,
-    )
-    res = client.get(url, headers=json_headers)
-    assert res.status_code in _HTTP_OK
-
-    hits = json.loads(res.data.decode("utf-8"))["closure_periods"]
-    hits = [
-        (_date_from_string(hit["start"]), _date_from_string(hit["end"])) for hit in hits
-    ]
-
-    def _is_in_interval(date, interval):
-        return interval[0] <= date <= interval[1]
-
-    def _test(date, closed):
-        date = _date_from_string(date)
-        assert (
-            any(_is_in_interval(date, hit) for hit in hits) == closed
-        ), f"Date {date} is wrongfully marked as {'Open' if closed else 'Closed'}"
-
-    _test("2000-01-01", True)
-    _test("2000-01-06", False)
-    _test("2000-01-22", True)
-    _test("2000-01-23", True)
-    _test("2000-01-30", False)
-    _test("2000-02-01", False)
-    _test("2000-02-05", True)

tests/api/ils/test_errors.py

@@ -1,125 +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 errors."""
-
-import pytest
-
-from invenio_app_ils.errors import (
-    ItemHasActiveLoanError,
-    NotImplementedConfigurationError,
-    PatronHasLoanOnItemError,
-    PatronNotFoundError,
-    RecordHasReferencesError,
-    SearchQueryError,
-    UnauthorizedSearchError,
-)
-
-
-def test_unauthorized_search_with_patron_pid(app):
-    """Test UnauthorizedSearchError with patron_pid defined."""
-    query = "test query"
-    pid = "1"
-    msg = "Search '{query}' not allowed by 'patron_pid:{patron_pid}'"
-    with pytest.raises(UnauthorizedSearchError) as ex:
-        raise UnauthorizedSearchError(query=query, patron_pid=pid)
-    assert ex.value.code == 403
-    assert ex.value.description == msg.format(query=query, patron_pid=pid)
-
-
-def test_unauthorized_search_without_patron_pid(app):
-    """Test UnauthorizedSearchError without patron_pid defined."""
-    query = "test query"
-    msg = "Search '{query}' not allowed by 'patron_pid:None'"
-    with pytest.raises(UnauthorizedSearchError) as ex:
-        raise UnauthorizedSearchError(query=query)
-    assert ex.value.code == 401
-    assert ex.value.description == msg.format(query=query)
-
-
-def test_invalid_search_query(app):
-    """Test SearchQueryError."""
-    query = "invalid query"
-    msg = "Invalid query syntax: '{query}'"
-    with pytest.raises(SearchQueryError) as ex:
-        raise SearchQueryError(query=query)
-    assert ex.value.code == SearchQueryError.code
-    assert ex.value.description == msg.format(query=query)
-
-
-def test_not_implemented(app):
-    """Test NotImplementedConfigurationError."""
-    config_variable = "CONFIG_VAR"
-    msg = (
-        "Function is not implemented. Implement this function in your module "
-        "and pass it to the config variable '{}'".format(config_variable)
-    )
-    with pytest.raises(NotImplementedConfigurationError) as ex:
-        raise NotImplementedConfigurationError(config_variable="CONFIG_VAR")
-    assert ex.value.code == NotImplementedConfigurationError.code
-    assert ex.value.description == msg
-
-
-def test_patron_not_found(app):
-    """Test PatronNotFoundError."""
-    patron_pid = "1"
-    msg = "Patron with ID '{patron_pid}' was not found."
-    with pytest.raises(PatronNotFoundError) as ex:
-        raise PatronNotFoundError(patron_pid)
-    assert ex.value.code == PatronNotFoundError.code
-    assert ex.value.description == msg.format(patron_pid=patron_pid)
-
-
-def test_patron_has_loan_on_item(app):
-    """Test PatronHasLoanOnItemError."""
-    patron_pid = "1"
-    item_pid = dict(type="pitmid", value="2")
-    msg = "Patron '{0}' has already an active loan on item '{1}:{2}'"
-    with pytest.raises(PatronHasLoanOnItemError) as ex:
-        raise PatronHasLoanOnItemError(patron_pid, item_pid)
-    assert ex.value.code == PatronHasLoanOnItemError.code
-    assert ex.value.description == msg.format(
-        patron_pid, item_pid["type"], item_pid["value"]
-    )
-
-
-def test_record_has_references_error(app):
-    """Test RecordHasReferencesError."""
-    record_type = "Item"
-    record_id = "item-1"
-    ref_type = "RecordType"
-    ref_ids = ["1", "2", "3"]
-    msg = (
-        "Cannot delete the {record_type} {record_id} record because it has "
-        "references from {ref_type} records with ids: {ref_ids}."
-    ).format(
-        record_type=record_type,
-        record_id=record_id,
-        ref_type=ref_type,
-        ref_ids=ref_ids,
-    )
-
-    with pytest.raises(RecordHasReferencesError) as ex:
-        raise RecordHasReferencesError(
-            record_type=record_type,
-            record_id=record_id,
-            ref_type=ref_type,
-            ref_ids=ref_ids,
-        )
-    assert ex.value.code == RecordHasReferencesError.code
-    assert ex.value.description == msg
-
-
-def test_item_has_active_loan_error(app):
-    loan_pid = "1"
-    msg = (
-        "Could not update item because it has an active loan with " "pid: {loan_pid}."
-    ).format(loan_pid=loan_pid)
-    with pytest.raises(ItemHasActiveLoanError) as ex:
-        raise ItemHasActiveLoanError(loan_pid=loan_pid)
-    assert ex.value.code == ItemHasActiveLoanError.code
-    assert ex.value.description == msg

tests/api/ils/test_facets.py

@@ -1,88 +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.
-
-"""Facets tests."""
-
-from datetime import timedelta
-
-import arrow
-import pytest
-from flask import current_app
-from invenio_search.engine import dsl
-
-from invenio_app_ils.facets import (
-    date_range_filter,
-    default_value_when_missing_filter,
-    keyed_range_filter,
-    overdue_loans_filter,
-)
-
-
-def test_keyed_range_filter():
-    """Test range filter."""
-    range_query = {"None": {"lt": 1}, "1+": {"gte": 1}}
-    rfilter = keyed_range_filter("field", range_query)
-
-    assert rfilter(["None"]) == dsl.query.Range(field={"lt": 1})
-    assert rfilter(["1+"]) == dsl.query.Range(field={"gte": 1})
-    assert rfilter(["None", "1+"]) == dsl.query.Range(field={"gte": 1, "lt": 1})
-
-
-def test_current_ranged_loans_filter(app):
-    """Test ranged current loans filter."""
-    with app.app_context():
-        rfilter = overdue_loans_filter("field")
-
-        current_loans_query = dsl.query.Terms(
-            state=current_app.config["CIRCULATION_STATES_LOAN_ACTIVE"]
-        )
-
-        overdue = rfilter(["Overdue"])
-        field = {"lt": str(arrow.utcnow().date())}
-        assert overdue == dsl.query.Bool(
-            must=[dsl.query.Range(field=field), current_loans_query]
-        )
-
-        upcoming = rfilter(["Upcoming return"])
-        field = {
-            "gte": str(arrow.utcnow().date()),
-            "lte": str((arrow.utcnow() + timedelta(days=7)).date()),
-        }
-        assert upcoming == dsl.query.Bool(
-            must=[dsl.query.Range(field=field), current_loans_query]
-        )
-
-
-def test_default_value_when_missing_filter(app):
-    """Test custom exists filter."""
-    with app.app_context():
-        rfilter = default_value_when_missing_filter("field", "missing val")
-
-        assert rfilter("test") == dsl.query.Terms(field="test")
-        assert rfilter("missing val") == dsl.query.Bool(
-            **{"must_not": {"exists": {"field": "field"}}}
-        )
-
-
-def test_date_range_filter(app):
-    """Test date range filter date validation and query."""
-
-    tests = ["", "a string", "2020-02-02"]
-
-    for input_date in tests:
-        from_filter = date_range_filter("field", "gte")
-        to_filter = date_range_filter("field", "lte")
-
-        try:
-            assert from_filter([input_date]) == dsl.RangeField(
-                field={"gte": input_date}
-            )
-            assert to_filter([input_date]) == dsl.RangeField(field={"lte": input_date})
-        except (ValueError, AssertionError):
-            with pytest.raises(ValueError):
-                from_filter([input_date])
-                to_filter([input_date])

tests/api/ils/test_internal_locations.py

@@ -1,96 +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 internal locations."""
-
-import json
-
-import pytest
-from flask import url_for
-
-from invenio_app_ils.errors import LocationNotFoundError
-from invenio_app_ils.internal_locations.api import InternalLocation
-from tests.helpers import user_login
-
-_HTTP_OK = [200, 201, 204]
-_INTERNAL_LOCATION_PID = "ilocid-1"
-_INTERNAL_LOCATION_NAME = "A location"
-_ITEM_ENDPOINT = "invenio_records_rest.ilocid_item"
-_LIST_ENDPOINT = "invenio_records_rest.ilocid_list"
-
-
-def test_internal_locations_validation(db, testdata):
-    """Test validation when updating an Internal Location."""
-    intloc_pid = testdata["internal_locations"][0]["pid"]
-    intloc = InternalLocation.get_record_by_pid(intloc_pid)
-
-    intloc["location_pid"] = "not_found_pid"
-    with pytest.raises(LocationNotFoundError):
-        intloc.commit()
-
-
-def test_internal_locations_permissions(client, testdata, json_headers, users):
-    """Test internal locations endpoints permissions."""
-    dummy_internal_location = dict(
-        location_pid=testdata["locations"][0]["pid"],
-        name=_INTERNAL_LOCATION_NAME,
-    )
-    tests = [
-        ("admin", _HTTP_OK, dummy_internal_location),
-        ("librarian", _HTTP_OK, dummy_internal_location),
-        ("patron1", [403], dummy_internal_location),
-        ("anonymous", [401], dummy_internal_location),
-    ]
-
-    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"] == _INTERNAL_LOCATION_NAME
-            return record["pid"]
-
-    def _test_update(expected_status, data, pid):
-        """Test record update."""
-        pid_value = pid or _INTERNAL_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"] == _INTERNAL_LOCATION_NAME
-
-    def _test_read(expected_status, pid):
-        """Test record read."""
-        pid_value = pid or _INTERNAL_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 _INTERNAL_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(expected_status)
-        pid = _test_create(expected_status, data)
-        _test_update(expected_status, data, pid)
-        _test_read(expected_status, pid)
-        _test_delete(expected_status, pid)