invenio-app-rdm 13.0.0b4.dev1__py2.py3-none-any.whl → 14.0.0b1.dev8__py2.py3-none-any.whl

tests/test_tasks.py

@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2022-2024 CERN.
-# Copyright (C) 2025 Northwestern University.
-#
-# Invenio App RDM 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 invenio-app-rdm celery tasks."""
-
-from io import BytesIO
-
-import pytest
-from invenio_access.permissions import system_identity
-from invenio_db import db
-from invenio_files_rest.models import Bucket, FileInstance, Location, ObjectVersion
-from invenio_rdm_records.proxies import current_rdm_records
-
-from invenio_app_rdm.tasks import file_integrity_report
-
-# Fixtures
-
-
-@pytest.fixture
-def draft_with_file_instance(running_app, minimal_record):
-    """Create draft with file and return (Draft, FileInstance)."""
-    minimal_record["files"] = {"enabled": True}
-
-    record_service = current_rdm_records.records_service
-    file_service = record_service.draft_files
-
-    draft = record_service.create(system_identity, minimal_record)
-    file_to_initialise = [
-        {
-            "key": "article.txt",
-            "checksum": "md5:c785060c866796cc2a1708c997154c8e",
-            "size": 17,  # 2kB
-            "metadata": {
-                "description": "Published article PDF.",
-            },
-        }
-    ]
-    file_service.init_files(system_identity, draft.id, file_to_initialise)
-    content = BytesIO(b"test file content")
-    file_service.set_file_content(
-        system_identity,
-        draft.id,
-        file_to_initialise[0]["key"],
-        content,
-        content.getbuffer().nbytes,
-    )
-    file_item = file_service.commit_file(system_identity, draft.id, "article.txt")
-    # fmt: off
-    id_of_file_instance = (
-        file_item
-        ._record
-        .files
-        .entries["article.txt"]
-        .object_version.file_id
-    )
-    # fmt: on
-    f = FileInstance.query.get(id_of_file_instance)
-    return draft, f
-
-
-@pytest.fixture
-def draft_with_invalid_file_instance(draft_with_file_instance):
-    # Force an invalid checksum
-    draft, f = draft_with_file_instance
-    f.checksum = "invalid"
-    f.verify_checksum()
-    db.session.commit()
-
-    # Retrieve the file instance (with updated last_check)
-    f = FileInstance.query.get(f.id)
-
-    return draft, f
-
-
-@pytest.fixture
-def record_with_invalid_file_instance(draft_with_invalid_file_instance):
-    draft, f = draft_with_invalid_file_instance
-    record_service = current_rdm_records.records_service
-    return record_service.publish(system_identity, draft.id), f
-
-
-@pytest.fixture
-def invalid_file_instance(record_with_invalid_file_instance):
-    draft, f = record_with_invalid_file_instance
-    return f
-
-
-# Tests
-
-
-def test_task_file_integrity_report(
-    app, record_with_invalid_file_instance, set_app_config_fn_scoped
-):
-    """Test celery task for file integrity reports."""
-    record, invalid_file_instance = record_with_invalid_file_instance
-    assert invalid_file_instance.last_check is False
-
-    # A report must be generated for the file
-    mail = app.extensions.get("mail")
-    assert mail
-
-    recipients = "test@invenio.org"
-    sender = "test@invenio.org"
-
-    uri = invalid_file_instance.uri
-    file_id = invalid_file_instance.id
-    file_name = invalid_file_instance.objects[0].key
-    checksum = invalid_file_instance.checksum
-
-    with mail.record_messages() as outbox:
-        # Configure email and validate that email was sent
-        set_app_config_fn_scoped(
-            {
-                "APP_RDM_FILES_INTEGRITY_REPORT_TEMPLATE": "mock_mail.html",
-                "APP_RDM_ADMIN_EMAIL_RECIPIENT": recipients,
-                "MAIL_DEFAULT_SENDER": sender,
-            }
-        )
-
-        file_integrity_report()
-        assert len(outbox) == 1
-        mail_sent = outbox[0]
-        assert mail_sent.recipients == [recipients]
-        assert mail_sent.sender == sender
-        assert "Checksum: {}".format(checksum) in mail_sent.body
-        assert "URI: {}".format(uri) in mail_sent.body
-        assert "ID: {}".format(str(file_id)) in mail_sent.body
-        assert "Name: {}".format(file_name) in mail_sent.body
-        assert f"Record: https://127.0.0.1:5000/records/{record.id}" in mail_sent.body
-
-
-def test_integrity_report_invalid_template(
-    app, invalid_file_instance, set_app_config_fn_scoped
-):
-    """Test non-existant e-mail template."""
-    assert invalid_file_instance.last_check is False
-
-    mail = app.extensions.get("mail")
-    assert mail
-
-    with mail.record_messages() as outbox:
-        # Remove the template, no e-mail is sent
-        set_app_config_fn_scoped({"APP_RDM_FILES_INTEGRITY_REPORT_TEMPLATE": None})
-
-        file_integrity_report()
-        assert len(outbox) == 0
-
-
-def test_integrity_report_invalid_addresses(
-    app, invalid_file_instance, set_app_config_fn_scoped
-):
-    """Test invalid recipient address."""
-    assert invalid_file_instance.last_check is False
-
-    mail = app.extensions.get("mail")
-    assert mail
-
-    with mail.record_messages() as outbox:
-        set_app_config_fn_scoped(
-            {
-                # Use mock template
-                "APP_RDM_FILES_INTEGRITY_REPORT_TEMPLATE": "mock_mail.html",
-                # Recipient is not set, mail is not sent.
-                "APP_RDM_ADMIN_EMAIL_RECIPIENT": None,
-            }
-        )
-
-        file_integrity_report()
-        assert len(outbox) == 0
-
-
-def test_integrity_report_default_template(
-    app, draft_with_invalid_file_instance, set_app_config_fn_scoped
-):
-    """Test invalid recipient address."""
-    draft, invalid_file_instance = draft_with_invalid_file_instance
-    assert invalid_file_instance.last_check is False
-
-    mail = app.extensions.get("mail")
-    assert mail
-
-    recipients = "test@invenio.org"
-    sender = "test@invenio.org"
-
-    uri = invalid_file_instance.uri
-    file_id = invalid_file_instance.id
-    file_name = invalid_file_instance.objects[0].key
-    checksum = invalid_file_instance.checksum
-
-    with mail.record_messages() as outbox:
-        # Use default template
-        set_app_config_fn_scoped(
-            {"APP_RDM_ADMIN_EMAIL_RECIPIENT": recipients, "MAIL_DEFAULT_SENDER": sender}
-        )
-
-        file_integrity_report()
-        assert len(outbox) == 1
-        mail_sent = outbox[0]
-        assert mail_sent.recipients == [recipients]
-        assert mail_sent.sender == sender
-        assert "Checksum: {}".format(checksum) in mail_sent.body
-        assert "URI: {}".format(uri) in mail_sent.body
-        assert "ID: {}".format(str(file_id)) in mail_sent.body
-        assert "Name: {}".format(file_name) in mail_sent.body
-        assert f"Draft: https://127.0.0.1:5000/uploads/{draft.id}" in mail_sent.body

tests/test_utils.py

@@ -1,67 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 TU Wien.
-#
-# Invenio App RDM 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 utility functions."""
-
-from datetime import datetime
-
-from invenio_app_rdm.records_ui.utils import set_default_value
-
-
-def test_set_default_value__value():
-    """Test setting a value."""
-    dict_ = {"metadata": {"publication_date": None}}
-    value = "1939-01-01"
-    path = "publication_date"
-
-    set_default_value(dict_, value, path)
-
-    assert dict_["metadata"]["publication_date"] == value
-
-
-def test_set_default_value__callable():
-    """Test setting a value via a callable."""
-    dict_ = {"metadata": {"publication_date": None}}
-
-    def func():
-        return datetime.now().strftime("%Y-%m-%d")
-
-    path = "publication_date"
-    today = func()
-
-    set_default_value(dict_, func, path)
-
-    assert dict_["metadata"]["publication_date"] == today
-
-
-def test_set_default_value__no_path_prefix():
-    """Test setting a value for an unprefixed path."""
-    dict_ = {"metadata": {"publication_date": None}}
-    value = "1939-01-01"
-    path = ".publication_date"
-
-    set_default_value(dict_, value, path)
-
-    assert dict_["metadata"]["publication_date"] is None
-    assert dict_["publication_date"] == value
-
-
-def test_set_default_value__explicit_and_automatic_prefix():
-    """Compare values set with auto-prefix and explicit prefix."""
-    dict1 = {"metadata": {"publication_date": None}}
-    dict2 = dict1.copy()
-    value = "1939-01-01"
-    path1 = "publication_date"
-    path2 = ".metadata.publication_date"
-
-    set_default_value(dict1, value, path1)
-    set_default_value(dict2, value, path2)
-
-    assert (
-        dict1["metadata"]["publication_date"] == dict2["metadata"]["publication_date"]
-    )
-    assert dict1["metadata"]["publication_date"] == value

tests/test_version.py

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2019 CERN.
-# Copyright (C) 2019 Northwestern University.
-#
-# Invenio App RDM is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Simple test of version import."""
-
-
-def test_version():
-    """Test version import."""
-    from invenio_app_rdm import __version__
-
-    assert __version__

tests/test_views.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2024 CERN.
-# Copyright (C) 2024 KTH Royal Institute of Technology.
-#
-# Invenio-RDM is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-
-from unittest.mock import Mock, patch
-
-import pytest
-
-from invenio_app_rdm.theme.views import add_static_page_routes
-
-
-def test_add_static_page_routes():
-    """Test add_static_page_routes function."""
-
-    # Mocking the blueprint and app objects
-    mock_blueprint = Mock()
-    mock_app = Mock()
-    mock_app.config = {"APP_RDM_PAGES": {"endpoint1": "/path1", "endpoint2": "/path2"}}
-
-    # Mocking the create_page_view function
-    with patch("invenio_app_rdm.theme.views.create_page_view") as mock_create_page_view:
-        mock_create_page_view.side_effect = lambda x: f"view_func_{x}"
-
-        add_static_page_routes(mock_blueprint, mock_app)
-
-    mock_blueprint.add_url_rule.assert_any_call(
-        "/path1", endpoint="endpoint1", view_func="view_func_/path1"
-    )
-    mock_blueprint.add_url_rule.assert_any_call(
-        "/path2", endpoint="endpoint2", view_func="view_func_/path2"
-    )
-
-    # Check if was called with the right arguments
-    mock_create_page_view.assert_any_call("/path1")
-    mock_create_page_view.assert_any_call("/path2")
-
-    # Check if was called the right number of times
-    assert mock_blueprint.add_url_rule.call_count == 2

tests/ui/__init__.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2025 Graz University of Technology.
-#
-# Invenio App RDM 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."""

tests/ui/conftest.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2019 CERN.
-# Copyright (C) 2019 Northwestern University.
-# Copyright (C) 2024 Graz University of Technology.
-#
-# Invenio App RDM is free software; you can redistribute it and/or modify it
-# under the terms of the MIT License; see LICENSE file for more details.
-
-"""Pytest fixtures and plugins for the UI application."""
-
-from io import BytesIO
-
-import pytest
-from flask_principal import Identity
-from flask_webpackext.manifest import (
-    JinjaManifest,
-    JinjaManifestEntry,
-    JinjaManifestLoader,
-)
-from invenio_access.permissions import any_user, authenticated_user, system_identity
-from invenio_app.factory import create_ui
-from invenio_rdm_records.proxies import current_rdm_records_service
-from invenio_search import current_search
-
-
-#
-# Mock the webpack manifest to avoid having to compile the full assets.
-#
-class MockJinjaManifest(JinjaManifest):
-    """Mock manifest."""
-
-    def __getitem__(self, key):
-        """Get a manifest entry."""
-        return JinjaManifestEntry(key, [key])
-
-    def __getattr__(self, name):
-        """Get a manifest entry."""
-        return JinjaManifestEntry(name, [name])
-
-
-class MockManifestLoader(JinjaManifestLoader):
-    """Manifest loader creating a mocked manifest."""
-
-    def load(self, filepath):
-        """Load the manifest."""
-        return MockJinjaManifest()
-
-
-@pytest.fixture(scope="module")
-def app_config(app_config):
-    """Create test app."""
-    app_config["WEBPACKEXT_MANIFEST_LOADER"] = MockManifestLoader
-    return app_config
-
-
-@pytest.fixture(scope="module")
-def create_app():
-    """Create test app."""
-    return create_ui
-
-
-@pytest.fixture()
-def index_templates(running_app):
-    """Ensure the index templates are in place."""
-    list(current_search.put_templates(ignore=[400]))
-
-
-@pytest.fixture()
-def record(running_app, minimal_record, create_record):
-    """Create and publish a record."""
-    return create_record(data=minimal_record)
-
-
-@pytest.fixture()
-def draft_with_file(running_app, minimal_record, users):
-    """Create a draft with a file."""
-    minimal_record["files"] = {"enabled": True}
-
-    # Use a user's identity to make sure the record has an owner
-    user_identity = Identity(users["user1"].id)
-    user_identity.provides.add(any_user)
-    user_identity.provides.add(authenticated_user)
-    record_service = current_rdm_records_service
-    file_service = record_service.draft_files
-
-    draft = record_service.create(user_identity, minimal_record)
-    file_to_initialise = [
-        {
-            "key": "article.txt",
-            "checksum": "md5:c785060c866796cc2a1708c997154c8e",
-            "size": 17,  # 2kB
-            "metadata": {
-                "description": "Published article PDF.",
-            },
-        },
-    ]
-    file_service.init_files(system_identity, draft.id, file_to_initialise)
-    content = BytesIO(b"test file content")
-    file_service.set_file_content(
-        system_identity,
-        draft.id,
-        file_to_initialise[0]["key"],
-        content,
-        content.getbuffer().nbytes,
-    )
-    file_service.commit_file(system_identity, draft.id, "article.txt")
-    return draft
-
-
-@pytest.fixture()
-def record_with_file(draft_with_file):
-    """Create and publish a record with file."""
-    record_service = current_rdm_records_service
-    return record_service.publish(system_identity, draft_with_file.id)

tests/ui/test_deposits.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 Northwestern University.
-#
-# Invenio-App-RDM 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 deposit views."""
-
-import pytest
-from invenio_access.permissions import system_identity
-from invenio_search.engine import dsl
-from invenio_vocabularies.proxies import current_service as vocabulary_service
-from invenio_vocabularies.records.api import Vocabulary
-
-from invenio_app_rdm.records_ui.views.deposits import VocabulariesOptions
-
-
-@pytest.fixture()
-def additional_resource_types(running_app):
-    """Resource type vocabulary record."""
-    vocabulary_service.create(
-        system_identity,
-        {
-            "id": "publication",
-            "icon": "file alternate",
-            "props": {
-                "csl": "report",
-                "datacite_general": "Text",
-                "datacite_type": "",
-                "eurepo": "info:eu-repo/semantics/other",
-                "openaire_resourceType": "17",
-                "openaire_type": "publication",
-                "schema.org": "https://schema.org/CreativeWork",
-                "subtype": "",
-                "type": "publication",
-            },
-            "title": {"en": "Publication"},
-            "tags": ["depositable", "linkable"],
-            "type": "resourcetypes",
-        },
-    )
-    vocabulary_service.create(
-        system_identity,
-        {
-            "id": "publication-annotationcollection",
-            "icon": "file alternate",
-            "props": {
-                "csl": "report",
-                "datacite_general": "Collection",
-                "datacite_type": "",
-                "eurepo": "info:eu-repo/semantics/technicalDocumentation",
-                "openaire_resourceType": "9",
-                "openaire_type": "publication",
-                "schema.org": "https://schema.org/Collection",
-                "subtype": "publication-annotationcollection",
-                "type": "publication",
-            },
-            "title": {"en": "Annotation collection"},
-            "tags": ["depositable", "linkable"],
-            "type": "resourcetypes",
-        },
-    )
-
-    Vocabulary.index.refresh()
-
-
-def test_resource_types(app, client_with_login, additional_resource_types):
-    options = VocabulariesOptions()
-    expected = [
-        # If no corresponding parent type entry (e.g. image-photo), type_name
-        # is own title and subtype_name is empty.
-        {
-            "icon": "chart bar outline",
-            "id": "image-photo",
-            "subtype_name": "",
-            "type_name": "Photo",
-        },
-        # If parent type is itself (e.g. Publication), type_name is own title
-        # and subtype_name is empty.
-        {
-            "icon": "file alternate",
-            "id": "publication",
-            "subtype_name": "",
-            "type_name": "Publication",
-        },
-        # If corresponding parent type entry, type_name is parent's title
-        # and subtype_name is own title.
-        {
-            "icon": "file alternate",
-            "id": "publication-annotationcollection",
-            "subtype_name": "Annotation collection",
-            "type_name": "Publication",
-        },
-    ]
-
-    # the choice of this filter isn't important for the test
-    result = options._resource_types(dsl.Q("term", tags="depositable"))
-
-    sorted_result = sorted(result, key=lambda e: e["id"])
-    assert expected == sorted_result
-
-
-def test_dump_subjects_vocabulary(running_app):
-    options = VocabulariesOptions()
-    expected = {
-        "limit_to": [
-            {"text": "All", "value": "all"},
-            {"text": "MeSH", "value": "MeSH"},
-        ]
-    }
-
-    result = options.subjects()
-
-    assert expected == result

tests/ui/test_export_formats.py

@@ -1,37 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2021 CERN.
-#
-# Invenio-App-RDM 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 that all export formats are working."""
-
-import pytest
-from invenio_cache import current_cache
-
-
-@pytest.fixture(scope="function")
-def cache():
-    """Clean cache"""
-    try:
-        current_cache.clear()
-        yield current_cache
-    finally:
-        current_cache.clear()
-
-
-def test_export_formats(client, running_app, cache, record):
-    """Test that all expected export formats are working."""
-    # Expected export formats:
-    formats = [
-        "json",
-        "json-ld",
-        "csl",
-        "datacite-json",
-        "datacite-xml",
-        "dublincore",
-    ]
-    for f in formats:
-        res = client.get(f"/records/{record.id}/export/{f}")
-        assert res.status_code == 200

tests/ui/test_file_download.py

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2025 CERN.
-# Copyright (C) 2025 KTH Royal Institute of Technology.
-#
-# Invenio-App-RDM is free software; you can redistribute it and/or modify
-# it under the terms of the MIT License; see LICENSE file for more details.
-
-from flask import url_for
-
-
-def test_file_download_with_and_without_preview_flag(
-    client_with_login, draft_with_file
-):
-    """Test file download both with and without preview flag."""
-    client = client_with_login
-    draft_id = draft_with_file["id"]
-    file_name = "article.txt"
-
-    # The draft's owner should be able to download its file from the preview page
-    url_with_preview = url_for(
-        "invenio_app_rdm_records.record_file_download",
-        pid_value=draft_id,
-        filename=file_name,
-        download=1,
-        preview=1,
-    )
-    response = client.get(url_with_preview)
-    assert (
-        response.status_code == 200
-    ), "File download with preview flag should return 200"
-
-    # But since the draft isn't published yet, it can't be found without preview=1
-    url_without_preview = url_for(
-        "invenio_app_rdm_records.record_file_download",
-        pid_value=draft_id,
-        filename=file_name,
-        download=1,
-    )
-    response = client.get(url_without_preview)
-    assert (
-        response.status_code == 404
-    ), "File download without preview flag should return 404"
-
-
-def test_nonexistent_file_returns_404(client_with_login, draft_with_file):
-    """Test that requesting a non-existent file returns 404 via the NoResultFound handler."""
-    client = client_with_login
-    draft_id = draft_with_file["id"]
-    fake_file = "nonexistent-file.pdf"
-
-    # Downloads for files that don't exist should return a 404, both without...
-    url_without_preview = url_for(
-        "invenio_app_rdm_records.record_file_download",
-        pid_value=draft_id,
-        filename=fake_file,
-        download=1,
-    )
-    response = client.get(url_without_preview)
-    assert response.status_code == 404, "Non-existent file should return 404"
-
-    # ... as well as with the preview=1 flag
-    url_with_preview = url_for(
-        "invenio_app_rdm_records.record_file_download",
-        pid_value=draft_id,
-        filename=fake_file,
-        download=1,
-        preview=1,
-    )
-    response = client.get(url_with_preview)
-    assert (
-        response.status_code == 404
-    ), "Non-existent file with preview flag should return 404"