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

tests/api/ils/test_errors.py

@@ -1,126 +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,84 +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 elasticsearch_dsl.query import Bool, Q, Range, Terms
-from flask import current_app
-
-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"]) == Range(field={"lt": 1})
-    assert rfilter(["1+"]) == Range(field={"gte": 1})
-    assert rfilter(["None", "1+"]) == 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 = Terms(
-            state=current_app.config["CIRCULATION_STATES_LOAN_ACTIVE"]
-        )
-
-        overdue = rfilter(["Overdue"])
-        field = {"lt": str(arrow.utcnow().date())}
-        assert overdue == 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 == 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") == Terms(field="test")
-        assert rfilter("missing val") == 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]) == Range(
-                field={"gte": input_date}
-            )
-            assert to_filter([input_date]) == Range(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)

tests/api/ils/test_loaders.py

@@ -1,55 +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,205 +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.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": {
-            "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"]
-    _doc = index_result["_type"]
-    _id = index_result["_id"]
-    es_doc = es.get(index=_index, doc_type=_doc, 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)