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

tests/api/ils/documents/test_document_permissions.py

@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2020 CERN.
-#
-# Invenio-Circulation is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-"""Tests documents REST APIs permissions."""
-
-import json
-
-from flask import url_for
-from invenio_db import db
-from invenio_indexer.api import RecordIndexer
-from invenio_search import current_search
-
-from invenio_app_ils.documents.api import Document
-from tests.helpers import user_login
-
-
-def test_open_access_permissions(client, json_headers, testdata, users):
-    """Test GET open/close access documents."""
-    # set the documents to have read access only by patron2. `_access` should
-    # be totally ignored.
-    indexer = RecordIndexer()
-    doc1 = Document.get_record_by_pid("docid-open-access")
-    doc2 = Document.get_record_by_pid("docid-closed-access")
-    for doc in [doc1, doc2]:
-        doc.update(dict(_access=dict(read=["patron2"])))
-        doc.commit()
-        db.session.commit()
-        indexer.index(doc)
-    current_search.flush_and_refresh(index="documents")
-
-    test_data = [
-        ("anonymous", "docid-open-access", 200, 1),
-        ("patron1", "docid-open-access", 200, 1),
-        ("patron2", "docid-open-access", 200, 1),
-        ("librarian", "docid-open-access", 200, 1),
-        ("admin", "docid-open-access", 200, 1),
-        ("anonymous", "docid-closed-access", 401, 0),
-        ("patron1", "docid-closed-access", 403, 0),
-        ("patron2", "docid-closed-access", 403, 0),
-        ("librarian", "docid-closed-access", 200, 1),
-        ("admin", "docid-closed-access", 200, 1),
-    ]
-    for user, pid, status_code, n_hits in test_data:
-        # item endpoint
-        user_login(client, user, users)
-        url = url_for("invenio_records_rest.docid_item", pid_value=pid)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code == status_code
-
-        # list endpoint
-        user_login(client, user, users)
-        url = url_for(
-            "invenio_records_rest.docid_list", q="pid:{}".format(pid)
-        )
-        res = client.get(url, headers=json_headers)
-        hits = json.loads(res.data.decode("utf-8"))
-        assert hits["hits"]["total"] == n_hits
-
-
-def test_access_permissions(
-    client, json_headers, testdata, users, with_access
-):
-    """Test GET documents with `_access` ignoring `restricted`."""
-    # set the documents to have read access only by patron2. `_access` should
-    # be taken into account and take precedence over `restricted`.
-    indexer = RecordIndexer()
-    doc1 = Document.get_record_by_pid("docid-open-access")
-    doc2 = Document.get_record_by_pid("docid-closed-access")
-    for doc in [doc1, doc2]:
-        doc.update(dict(_access=dict(read=[users["patron2"].id])))
-        doc.commit()
-        db.session.commit()
-        indexer.index(doc)
-    current_search.flush_and_refresh(index="documents")
-
-    test_data = [
-        ("anonymous", "docid-open-access", 401, 0),
-        ("patron1", "docid-open-access", 403, 0),
-        ("patron2", "docid-open-access", 200, 1),  # should have access
-        ("librarian", "docid-open-access", 200, 1),
-        ("admin", "docid-open-access", 200, 1),
-        ("anonymous", "docid-closed-access", 401, 0),
-        ("patron1", "docid-closed-access", 403, 0),
-        ("patron2", "docid-closed-access", 200, 1),  # should have access
-        ("librarian", "docid-closed-access", 200, 1),
-        ("admin", "docid-closed-access", 200, 1),
-    ]
-    for user, pid, status_code, n_hits in test_data:
-        # item endpoint
-        user_login(client, user, users)
-        url = url_for("invenio_records_rest.docid_item", pid_value=pid)
-        res = client.get(url, headers=json_headers)
-        assert res.status_code == status_code
-
-        # list endpoint
-        user_login(client, user, users)
-        url = url_for(
-            "invenio_records_rest.docid_list", q="pid:{}".format(pid)
-        )
-        res = client.get(url, headers=json_headers)
-        hits = json.loads(res.data.decode("utf-8"))
-        assert hits["hits"]["total"] == n_hits

tests/api/ils/documents/test_document_resolvers.py

@@ -1,35 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2019 CERN.
-#
-# Invenio-Circulation is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-"""Tests for document resolvers."""
-
-from invenio_app_ils.documents.api import Document
-
-
-def test_document_resolvers(app, testdata):
-    """Test item resolving from loan."""
-    doc_pid = testdata["documents"][0]["pid"]
-    document = Document.get_record_by_pid(doc_pid)
-    document = document.replace_refs()
-
-    # relations
-    assert "relations" in document
-
-    # circulation
-    assert "active_loans_count" in document["circulation"]
-    assert "pending_loans_count" in document["circulation"]
-    assert "overdue_loans_count" in document["circulation"]
-    assert "past_loans_count" in document["circulation"]
-
-    # item and eitems
-    assert document["items"]["total"] == 9 and document["items"]["hits"]
-    assert document["eitems"]["total"] == 3 and document["eitems"]["hits"]
-
-    # stock
-    mediums = set([item["medium"] for item in document["items"]["hits"]])
-    mediums.add("E-BOOK")
-    assert set(document["stock"]["mediums"]) == mediums

tests/api/ils/eitems/__init__.py

@@ -1,8 +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.
-
-"""Eitems API Tests."""

tests/api/ils/eitems/test_eitems_crud.py

@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 CERN.
-#
-# Invenio-Circulation is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-"""Tests eitems CRUD."""
-
-import pytest
-
-from invenio_app_ils.eitems.api import EItem
-from invenio_app_ils.errors import DocumentNotFoundError
-
-
-def test_eitem_refs(app, testdata):
-    """Test creation of an eitem."""
-    eitem = EItem.create(
-        dict(
-            pid="eitemid-99",
-            document_pid="docid-1",
-            created_by=dict(type="script", value="demo"),
-        )
-    )
-    assert "$schema" in eitem
-    assert "document" in eitem and "$ref" in eitem["document"]
-
-    eitem = EItem.get_record_by_pid("eitemid-4")
-    eitem = eitem.replace_refs()
-    assert "document" in eitem and eitem["document"]["title"]
-
-
-def test_eitem_validation(db, testdata):
-    """Test validation when updating an eitem."""
-    eitem_pid = testdata["eitems"][0]["pid"]
-    eitem = EItem.get_record_by_pid(eitem_pid)
-
-    # change document pid
-    eitem["document_pid"] = "not_found_doc"
-    with pytest.raises(DocumentNotFoundError):
-        eitem.commit()

tests/api/ils/eitems/test_eitems_permissions.py

@@ -1,84 +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 Eitems permissions."""
-
-import json
-
-from flask import url_for
-
-from tests.helpers import user_login
-
-_HTTP_OK = [200, 201, 204]
-EITEM_PID = "eitemid-1"
-ITEM_ENDPOINT = "invenio_records_rest.eitmid_item"
-LIST_ENDPOINT = "invenio_records_rest.eitmid_list"
-
-
-def test_eitems_permissions(client, testdata, json_headers, users):
-    """Test eitems endpoints permissions."""
-    dummy_eitem = dict(
-        document_pid="docid-1",
-        internal_notes="An internal note",
-        description="Description of the electronic item",
-        open_access=True,
-    )
-    tests = [
-        ("admin", _HTTP_OK, dummy_eitem),
-        ("librarian", _HTTP_OK, dummy_eitem),
-        ("patron1", [403], dummy_eitem),
-        ("anonymous", [401], dummy_eitem),
-    ]
-
-    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
-            return record["pid"]
-
-    def _test_update(expected_status, data, pid):
-        """Test record update."""
-        pid_value = pid or EITEM_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_read(expected_status, pid):
-        """Test record read."""
-        pid_value = pid or EITEM_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 EITEM_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/eitems/test_files.py

@@ -1,172 +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 files."""
-
-import json
-
-from flask import url_for
-from invenio_search import current_search
-from six import BytesIO
-
-from tests.helpers import user_login
-
-
-def _test_response(
-    client,
-    req_method,
-    url,
-    headers,
-    data,
-    expected_resp_code,
-    input_stream=None,
-):
-    """Util function testing response code."""
-    kwargs = {}
-    if input_stream:
-        kwargs["input_stream"] = input_stream
-    if data:
-        res = getattr(client, req_method)(
-            url, headers=headers, data=json.dumps(data), **kwargs
-        )
-    else:
-        res = getattr(client, req_method)(url, headers=headers, **kwargs)
-    assert expected_resp_code == res.status_code
-    return res
-
-
-def _test_data_exists(key, res):
-    """Util function for testing output data."""
-    data = json.loads(res.data.decode("utf-8"))["metadata"]
-    assert key in data
-
-
-def test_create_bucket_endpoint(
-    client, json_headers, location, testdata, users
-):
-    """Test GET permissions."""
-    user_login(client, "admin", users)
-
-    url_with_bucket_id = url_for(
-        "invenio_app_ils_files.eitmid_bucket", pid_value="eitemid-3"
-    )
-    url_without_bucket_id = url_for(
-        "invenio_app_ils_files.eitmid_bucket", pid_value="eitemid-4"
-    )
-
-    res1 = _test_response(
-        client, "post", url_with_bucket_id, json_headers, None, 200
-    )
-    _test_data_exists("bucket_id", res1)
-    res2 = _test_response(
-        client, "post", url_without_bucket_id, json_headers, None, 201
-    )
-    _test_data_exists("bucket_id", res2)
-
-
-def test_create_bucket_permissions(
-    client, json_headers, location, testdata, users
-):
-    """Test create bucket permissions."""
-    url = url_for("invenio_app_ils_files.eitmid_bucket", pid_value="eitemid-1")
-    _test_response(client, "post", url, json_headers, None, 401)
-
-    test_data = [
-        ("admin", "eitemid-1", 201),
-        ("librarian", "eitemid-2", 201),
-        ("patron1", "eitemid-2", 403),
-    ]
-    for user, pid, status_code in test_data:
-        user_login(client, user, users)
-        url = url_for("invenio_app_ils_files.eitmid_bucket", pid_value=pid)
-        _test_response(client, "post", url, json_headers, None, status_code)
-
-
-def test_upload_files_permissions(
-    client, json_headers, bucket, testdata, users
-):
-    """Test upload files permissions."""
-    filename = "myfile.txt"
-    data = b"hello world"
-    url = url_for(
-        "invenio_files_rest.object_api", bucket_id=str(bucket.id), key=filename
-    )
-
-    test_data = [
-        ("anonymous", 404),
-        ("admin", 200),
-        ("librarian", 200),
-        ("patron1", 404),
-    ]
-    for user, status_code in test_data:
-        user_login(client, user, users)
-        _test_response(
-            client,
-            "put",
-            url,
-            json_headers,
-            None,
-            status_code,
-            input_stream=BytesIO(data),
-        )
-
-
-def test_download_files_permissions(
-    client, json_headers, location, testdata, users
-):
-    """Test download files permissions."""
-
-    tests = [
-        (
-            "eitemid-4",
-            [
-                ("anonymous", 200),
-                ("admin", 200),
-                ("librarian", 200),
-                ("patron1", 200),
-            ],
-        ),
-        (
-            "eitemid-5",
-            [
-                ("anonymous", 404),
-                ("admin", 200),
-                ("librarian", 200),
-                ("patron1", 200),
-            ],
-        ),
-    ]
-
-    for pid, expected in tests:
-        # Create e-item bucket
-        user_login(client, "admin", users)
-        url = url_for("invenio_app_ils_files.eitmid_bucket", pid_value=pid)
-        res = _test_response(client, "post", url, json_headers, None, 201)
-        bucket_id = json.loads(res.data)["metadata"]["bucket_id"]
-
-        # Upload file to e-item bucket
-        filename = "myfile.txt"
-        data = b"hello world"
-        url = url_for(
-            "invenio_files_rest.object_api", bucket_id=bucket_id, key=filename
-        )
-        _test_response(
-            client,
-            "put",
-            url,
-            json_headers,
-            None,
-            200,
-            input_stream=BytesIO(data),
-        )
-
-        current_search.flush_and_refresh(index="eitems")
-
-        # Download file
-        for user, status_code in expected:
-            user_login(client, user, users)
-            _test_response(client, "get", url, None, None, status_code)

tests/api/ils/items/__init__.py

@@ -1,8 +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.
-
-"""Items API Tests."""

tests/api/ils/items/test_apis.py

@@ -1,43 +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 APIs."""
-
-from invenio_app_ils.items.api import (
-    ITEM_PID_TYPE,
-    get_document_pid_by_item_pid,
-    get_item_pids_by_document_pid,
-    item_exists,
-)
-
-
-def test_get_item_pids_by_document_pid(testdata):
-    """Test retrieve Items PIDs for the given Document PID."""
-    first_doc_pid = testdata["documents"][0]["pid"]
-    items_pids = get_item_pids_by_document_pid(first_doc_pid)
-    assert len(list(items_pids)) == 9
-
-
-def test_get_document_pid_by_item_pid(testdata):
-    """Test retrieve Document PID for the given Item."""
-    first_item_pid = testdata["items"][0]["pid"]
-    item_pid = dict(type=ITEM_PID_TYPE, value=first_item_pid)
-    doc_pid = get_document_pid_by_item_pid(item_pid)
-    assert doc_pid == "docid-1"
-
-
-def test_item_exists(testdata):
-    """Test return True if item exists."""
-    first_item_pid = testdata["items"][0]["pid"]
-    item_pid = dict(type=ITEM_PID_TYPE, value=first_item_pid)
-    assert item_exists(item_pid)
-
-
-def test_item_not_exist(testdata):
-    """Test return False if item does not exist."""
-    item_pid = dict(type=ITEM_PID_TYPE, value="not-existing-item-pid")
-    assert not item_exists(item_pid)

tests/api/ils/items/test_items_crud.py

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 CERN.
-#
-# Invenio-Circulation is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-"""Tests items CRUD."""
-
-from copy import deepcopy
-
-import pytest
-
-from invenio_app_ils.errors import (
-    DocumentNotFoundError,
-    InternalLocationNotFoundError,
-)
-from invenio_app_ils.items.api import Item
-
-
-def test_item_refs(app, testdata):
-    """Test creation of an item."""
-    item = Item.create(
-        dict(
-            pid="itemid-99",
-            document_pid="docid-1",
-            internal_location_pid="ilocid-4",
-            created_by=dict(type="script", value="demo"),
-            barcode="348048",
-            status="CAN_CIRCULATE",
-            circulation_restriction="NO_RESTRICTION",
-            medium="PAPER",
-        )
-    )
-    assert "$schema" in item
-    assert "document" in item and "$ref" in item["document"]
-    assert "internal_location" in item and "$ref" in item["internal_location"]
-
-    item = Item.get_record_by_pid("itemid-1")
-    item = item.replace_refs()
-    assert "document" in item and item["document"]["title"]
-    assert "internal_location" in item and item["internal_location"]["name"]
-
-
-def test_item_validation(db, testdata):
-    """Test validation when updating an item."""
-    item_pid = testdata["items"][0]["pid"]
-    orginal_item = Item.get_record_by_pid(item_pid)
-
-    # change document pid
-    item = deepcopy(orginal_item)
-    item["document_pid"] = "not_found_doc"
-    with pytest.raises(DocumentNotFoundError):
-        item.commit()
-
-    # change internal location pid
-    item = deepcopy(orginal_item)
-    item["internal_location_pid"] = "not_found_pid"
-    with pytest.raises(InternalLocationNotFoundError):
-        item.commit()

tests/api/ils/items/test_items_permissions.py

@@ -1,107 +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 accessibility of resource endpoints."""
-
-import copy
-import json
-
-from flask import url_for
-
-from tests.helpers import user_login, validate_response
-
-_HTTP_OK = [200, 201, 204]
-ITEM_PID = "itemid-1"
-ITEM_ENDPOINT = "invenio_records_rest.pitmid_item"
-LIST_ENDPOINT = "invenio_records_rest.pitmid_list"
-
-
-def test_items_permissions(client, testdata, item_record, json_headers, users):
-    """Test items endpoints permissions."""
-    dummy_item = copy.deepcopy(item_record)
-    tests = [
-        ("admin", _HTTP_OK, dummy_item),
-        ("librarian", _HTTP_OK, dummy_item),
-        ("patron1", [403], dummy_item),
-        ("anonymous", [401], dummy_item),
-    ]
-
-    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"]
-            return record["pid"]
-
-    def _test_update(expected_status, data, pid):
-        """Test record update."""
-        pid_value = pid or ITEM_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"]
-
-    def _test_read(expected_status, pid):
-        """Test record read."""
-        pid_value = pid or ITEM_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 ITEM_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)
-
-
-def test_item_circulation(client, json_headers, testdata, users):
-    """Test item circulation filtering."""
-
-    tests = [
-        ("patron1", "itemid-56", 403, False),
-        ("patron2", "itemid-56", 403, True),
-        ("patron1", "itemid-57", 403, True),
-        ("patron2", "itemid-57", 403, False),
-        ("librarian", "itemid-56", 200, False),
-        ("admin", "itemid-57", 200, False),
-    ]
-
-    for username, pid, expected_resp_code, filtered in tests:
-        user_login(client, username, users)
-        url = url_for("invenio_records_rest.pitmid_item", pid_value=pid)
-        res = validate_response(
-            client, "get", url, json_headers, None, expected_resp_code
-        )
-        if res.status_code < 400:
-            circulation = res.json["metadata"]["circulation"]
-            filter_keys = ["loan_pid", "patron_pid"]
-            if filtered:
-                for key in filter_keys:
-                    assert key not in circulation
-            else:
-                for key in filter_keys:
-                    assert key in circulation