udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30454__py2.py3-none-any.whl

udata/tests/site/test_site_rdf.py

@@ -1,9 +1,7 @@
 import pytest
-
 from flask import url_for
-
-from rdflib import URIRef, Literal, Graph
-from rdflib.namespace import RDF, FOAF
+from rdflib import Graph, Literal, URIRef
+from rdflib.namespace import FOAF, RDF
 from rdflib.resource import Resource
 
 from udata.core.dataservices.factories import DataserviceFactory, HarvestMetadataFactory
@@ -16,17 +14,15 @@ from udata.core.user.factories import UserFactory
 from udata.rdf import CONTEXT, DCAT, DCT, HYDRA
 from udata.tests.helpers import assert200, assert404, assert_redirects
 
-
-pytestmark = pytest.mark.usefixtures('clean_db')
+pytestmark = pytest.mark.usefixtures("clean_db")
 
 
 @pytest.mark.frontend
 class CatalogTest:
-
     def test_minimal(self, app):
         site = SiteFactory()
-        home_url = url_for('api.site', _external=True)
-        uri = url_for('api.site_rdf_catalog', _external=True)
+        home_url = url_for("api.site", _external=True)
+        uri = url_for("api.site_rdf_catalog", _external=True)
         datasets = DatasetFactory.create_batch(3)
         catalog = build_catalog(site, datasets)
         graph = catalog.graph
@@ -41,7 +37,7 @@ class CatalogTest:
         assert str(catalog.identifier) == uri
         assert catalog.value(DCT.title) == Literal(site.title)
         assert catalog.value(DCT.description) == Literal(f"{site.title}")
-        lang = app.config['DEFAULT_LANGUAGE']
+        lang = app.config["DEFAULT_LANGUAGE"]
         assert catalog.value(DCT.language) == Literal(lang)
 
         assert len(list(catalog.objects(DCAT.dataset))) == len(datasets)
@@ -50,7 +46,7 @@ class CatalogTest:
 
         org = catalog.value(DCT.publisher)
         assert org.value(RDF.type).identifier == FOAF.Organization
-        assert org.value(FOAF.name) == Literal(app.config['SITE_AUTHOR'])
+        assert org.value(FOAF.name) == Literal(app.config["SITE_AUTHOR"])
 
         graph = catalog.graph
         graph_datasets = graph.subjects(RDF.type, DCAT.Dataset)
@@ -78,16 +74,26 @@ class CatalogTest:
         site = SiteFactory()
         page_size = 3
         total = 4
-        uri = url_for('api.site_rdf_catalog', _external=True)
-        uri_first = url_for('api.site_rdf_catalog_format', format='json',
-                            page=1, page_size=page_size, _external=True)
-        uri_last = url_for('api.site_rdf_catalog_format', format='json',
-                           page=2, page_size=page_size, _external=True)
+        uri = url_for("api.site_rdf_catalog", _external=True)
+        uri_first = url_for(
+            "api.site_rdf_catalog_format",
+            format="json",
+            page=1,
+            page_size=page_size,
+            _external=True,
+        )
+        uri_last = url_for(
+            "api.site_rdf_catalog_format",
+            format="json",
+            page=2,
+            page_size=page_size,
+            _external=True,
+        )
         DatasetFactory.create_batch(total)
 
         # First page
         datasets = Dataset.objects.paginate(1, page_size)
-        catalog = build_catalog(site, datasets, format='json')
+        catalog = build_catalog(site, datasets, format="json")
         graph = catalog.graph
 
         assert isinstance(catalog, Resource)
@@ -100,8 +106,7 @@ class CatalogTest:
 
         assert len(list(catalog.objects(DCAT.dataset))) == page_size
 
-        paginations = list(graph.subjects(RDF.type,
-                                          HYDRA.PartialCollectionView))
+        paginations = list(graph.subjects(RDF.type, HYDRA.PartialCollectionView))
         assert len(paginations) == 1
         pagination = graph.resource(paginations[0])
         assert pagination.identifier == URIRef(uri_first)
@@ -112,7 +117,7 @@ class CatalogTest:
 
         # Second page
         datasets = Dataset.objects.paginate(2, page_size)
-        catalog = build_catalog(site, datasets, format='json')
+        catalog = build_catalog(site, datasets, format="json")
         graph = catalog.graph
 
         assert isinstance(catalog, Resource)
@@ -125,8 +130,7 @@ class CatalogTest:
 
         assert len(list(catalog.objects(DCAT.dataset))) == 1
 
-        paginations = list(graph.subjects(RDF.type,
-                                          HYDRA.PartialCollectionView))
+        paginations = list(graph.subjects(RDF.type, HYDRA.PartialCollectionView))
         assert len(paginations) == 1
         pagination = graph.resource(paginations[0])
         assert pagination.identifier == URIRef(uri_last)
@@ -138,128 +142,132 @@ class CatalogTest:
 
 @pytest.mark.frontend
 class SiteRdfViewsTest:
-
     def test_expose_jsonld_context(self, client):
-        url = url_for('api.site_jsonld_context')
-        assert url == '/api/1/site/context.jsonld'
+        url = url_for("api.site_jsonld_context")
+        assert url == "/api/1/site/context.jsonld"
 
-        response = client.get(url, headers={'Accept': 'application/ld+json'})
+        response = client.get(url, headers={"Accept": "application/ld+json"})
         assert200(response)
-        assert response.content_type == 'application/ld+json'
+        assert response.content_type == "application/ld+json"
         assert response.json == CONTEXT
 
     def test_catalog_default_to_jsonld(self, client):
-        expected = url_for('api.site_rdf_catalog_format', format='json')
-        response = client.get(url_for('api.site_rdf_catalog'))
+        expected = url_for("api.site_rdf_catalog_format", format="json")
+        response = client.get(url_for("api.site_rdf_catalog"))
         assert_redirects(response, expected)
 
     def test_rdf_perform_content_negociation(self, client):
-        expected = url_for('api.site_rdf_catalog_format', format='xml')
-        url = url_for('api.site_rdf_catalog')
-        headers = {'accept': 'application/xml'}
+        expected = url_for("api.site_rdf_catalog_format", format="xml")
+        url = url_for("api.site_rdf_catalog")
+        headers = {"accept": "application/xml"}
         response = client.get(url, headers=headers)
         assert_redirects(response, expected)
 
-    @pytest.mark.parametrize('fmt', ('json', 'jsonld'))
+    @pytest.mark.parametrize("fmt", ("json", "jsonld"))
     def test_catalog_rdf_json_ld(self, fmt, client):
-        url = url_for('api.site_rdf_catalog_format', format=fmt)
-        response = client.get(url, headers={'Accept': 'application/ld+json'})
+        url = url_for("api.site_rdf_catalog_format", format=fmt)
+        response = client.get(url, headers={"Accept": "application/ld+json"})
         assert200(response)
-        assert response.content_type == 'application/ld+json'
-        assert response.json['@context']['@vocab'] == 'http://www.w3.org/ns/dcat#'
+        assert response.content_type == "application/ld+json"
+        assert response.json["@context"]["@vocab"] == "http://www.w3.org/ns/dcat#"
 
     def test_catalog_rdf_n3(self, client):
-        url = url_for('api.site_rdf_catalog_format', format='n3')
-        response = client.get(url, headers={'Accept': 'text/n3'})
+        url = url_for("api.site_rdf_catalog_format", format="n3")
+        response = client.get(url, headers={"Accept": "text/n3"})
         assert200(response)
-        assert response.content_type == 'text/n3'
+        assert response.content_type == "text/n3"
 
     def test_catalog_rdf_turtle(self, client):
-        url = url_for('api.site_rdf_catalog_format', format='ttl')
-        response = client.get(url, headers={'Accept': 'application/x-turtle'})
+        url = url_for("api.site_rdf_catalog_format", format="ttl")
+        response = client.get(url, headers={"Accept": "application/x-turtle"})
         assert200(response)
-        assert response.content_type == 'application/x-turtle'
+        assert response.content_type == "application/x-turtle"
 
-    @pytest.mark.parametrize('fmt', ('xml', 'rdf', 'owl'))
+    @pytest.mark.parametrize("fmt", ("xml", "rdf", "owl"))
     def test_catalog_rdf_rdfxml(self, fmt, client):
-        url = url_for('api.site_rdf_catalog_format', format=fmt)
-        response = client.get(url, headers={'Accept': 'application/rdf+xml'})
+        url = url_for("api.site_rdf_catalog_format", format=fmt)
+        response = client.get(url, headers={"Accept": "application/rdf+xml"})
         assert200(response)
-        assert response.content_type == 'application/rdf+xml'
+        assert response.content_type == "application/rdf+xml"
 
     def test_catalog_rdf_n_triples(self, client):
-        url = url_for('api.site_rdf_catalog_format', format='nt')
-        response = client.get(url, headers={'Accept': 'application/n-triples'})
+        url = url_for("api.site_rdf_catalog_format", format="nt")
+        response = client.get(url, headers={"Accept": "application/n-triples"})
         assert200(response)
-        assert response.content_type == 'application/n-triples'
+        assert response.content_type == "application/n-triples"
 
     def test_catalog_rdf_trig(self, client):
-        url = url_for('api.site_rdf_catalog_format', format='trig')
-        response = client.get(url, headers={'Accept': 'application/trig'})
+        url = url_for("api.site_rdf_catalog_format", format="trig")
+        response = client.get(url, headers={"Accept": "application/trig"})
         assert200(response)
-        assert response.content_type == 'application/trig'
+        assert response.content_type == "application/trig"
 
-    @pytest.mark.parametrize('fmt', ('json', 'xml', 'ttl'))
+    @pytest.mark.parametrize("fmt", ("json", "xml", "ttl"))
     def test_dataportal_compliance(self, fmt, client):
-        url = url_for('api.site_dataportal', format=fmt)
-        assert url == '/api/1/site/data.{0}'.format(fmt)
-        expected_url = url_for('api.site_rdf_catalog_format', format=fmt)
+        url = url_for("api.site_dataportal", format=fmt)
+        assert url == "/api/1/site/data.{0}".format(fmt)
+        expected_url = url_for("api.site_rdf_catalog_format", format=fmt)
 
         response = client.get(url)
         assert_redirects(response, expected_url)
 
     def test_catalog_rdf_paginate(self, client):
         DatasetFactory.create_batch(4)
-        url = url_for('api.site_rdf_catalog_format', format='n3', page_size=3)
-        next_url = url_for('api.site_rdf_catalog_format', format='n3',
-                           page=2, page_size=3, _external=True)
+        url = url_for("api.site_rdf_catalog_format", format="n3", page_size=3)
+        next_url = url_for(
+            "api.site_rdf_catalog_format", format="n3", page=2, page_size=3, _external=True
+        )
 
-        response = client.get(url, headers={'Accept': 'text/n3'})
+        response = client.get(url, headers={"Accept": "text/n3"})
         assert200(response)
 
-        graph = Graph().parse(data=response.data, format='n3')
-        pagination = graph.value(predicate=RDF.type,
-                                 object=HYDRA.PartialCollectionView)
+        graph = Graph().parse(data=response.data, format="n3")
+        pagination = graph.value(predicate=RDF.type, object=HYDRA.PartialCollectionView)
         assert pagination is not None
         pagination = graph.resource(pagination)
         assert not pagination.value(HYDRA.previous)
         assert pagination.value(HYDRA.next).identifier == URIRef(next_url)
 
     def test_catalog_format_unknown(self, client):
-        url = url_for('api.site_rdf_catalog_format', format='unknown')
+        url = url_for("api.site_rdf_catalog_format", format="unknown")
         response = client.get(url)
         assert404(response)
 
     def test_catalog_rdf_filter_tag(self, client):
-        DatasetFactory.create_batch(4, tags=['my-tag'])
+        DatasetFactory.create_batch(4, tags=["my-tag"])
         DatasetFactory.create_batch(3)
-        url = url_for('api.site_rdf_catalog_format', format='xml', tag='my-tag')
+        url = url_for("api.site_rdf_catalog_format", format="xml", tag="my-tag")
 
-        response = client.get(url, headers={'Accept': 'application/xml'})
+        response = client.get(url, headers={"Accept": "application/xml"})
         assert200(response)
 
-        graph = Graph().parse(data=response.data, format='xml')
+        graph = Graph().parse(data=response.data, format="xml")
 
         datasets = list(graph.subjects(RDF.type, DCAT.Dataset))
         assert len(datasets) == 4
 
         for dat in datasets:
-            assert graph.value(dat, DCAT.keyword) == Literal('my-tag')
+            assert graph.value(dat, DCAT.keyword) == Literal("my-tag")
 
     def test_catalog_rdf_dataservices(self, client):
         dataset_a = DatasetFactory.create()
         dataset_b = DatasetFactory.create()
         dataset_c = DatasetFactory.create()
 
-        dataservice_a = DataserviceFactory.create(datasets=[dataset_a.id], harvest=HarvestMetadataFactory())
+        dataservice_a = DataserviceFactory.create(
+            datasets=[dataset_a.id], harvest=HarvestMetadataFactory()
+        )
         dataservice_b = DataserviceFactory.create(datasets=[dataset_b.id])
         dataservice_x = DataserviceFactory.create(datasets=[dataset_a.id, dataset_c.id])
         dataservice_y = DataserviceFactory.create(datasets=[])
 
-        response = client.get(url_for('api.site_rdf_catalog_format', format='xml'), headers={'Accept': 'application/xml'})
+        response = client.get(
+            url_for("api.site_rdf_catalog_format", format="xml"),
+            headers={"Accept": "application/xml"},
+        )
         assert200(response)
 
-        graph = Graph().parse(data=response.data, format='xml')
+        graph = Graph().parse(data=response.data, format="xml")
 
         datasets = list(graph.subjects(RDF.type, DCAT.Dataset))
         assert len(datasets) == 3
@@ -268,10 +276,13 @@ class SiteRdfViewsTest:
         assert len(dataservices) == 4
 
         # Test first page contains the dataservice without dataset
-        response = client.get(url_for('api.site_rdf_catalog_format', format='xml', page_size=1), headers={'Accept': 'application/xml'})
+        response = client.get(
+            url_for("api.site_rdf_catalog_format", format="xml", page_size=1),
+            headers={"Accept": "application/xml"},
+        )
         assert200(response)
 
-        graph = Graph().parse(data=response.data, format='xml')
+        graph = Graph().parse(data=response.data, format="xml")
 
         datasets = list(graph.subjects(RDF.type, DCAT.Dataset))
         assert len(datasets) == 1
@@ -279,13 +290,18 @@ class SiteRdfViewsTest:
 
         dataservices = list(graph.subjects(RDF.type, DCAT.DataService))
         assert len(dataservices) == 2
-        assert sorted([str(d.id) for d in [dataservice_x, dataservice_y]]) == sorted([str(graph.value(d, DCT.identifier)) for d in dataservices])
+        assert sorted([str(d.id) for d in [dataservice_x, dataservice_y]]) == sorted(
+            [str(graph.value(d, DCT.identifier)) for d in dataservices]
+        )
 
         # Test second page doesn't contains the dataservice without dataset
-        response = client.get(url_for('api.site_rdf_catalog_format', format='xml', page_size=1, page=2), headers={'Accept': 'application/xml'})
+        response = client.get(
+            url_for("api.site_rdf_catalog_format", format="xml", page_size=1, page=2),
+            headers={"Accept": "application/xml"},
+        )
         assert200(response)
 
-        graph = Graph().parse(data=response.data, format='xml')
+        graph = Graph().parse(data=response.data, format="xml")
 
         datasets = list(graph.subjects(RDF.type, DCAT.Dataset))
         assert len(datasets) == 1

udata/tests/test_activity.py

@@ -1,8 +1,8 @@
-from udata.models import db, Activity
-from udata.tests import TestCase, DBTestMixin, WebTestMixin
-from udata.core.user.factories import UserFactory
-from udata.core.organization.factories import OrganizationFactory
 from udata.auth import login_user
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.user.factories import UserFactory
+from udata.models import Activity, db
+from udata.tests import DBTestMixin, TestCase, WebTestMixin
 
 
 class FakeSubject(db.Document):
@@ -10,13 +10,13 @@ class FakeSubject(db.Document):
 
 
 class FakeActivity(Activity):
-    key = 'fake'
+    key = "fake"
     related_to = db.ReferenceField(FakeSubject)
 
 
 class ActivityTest(WebTestMixin, DBTestMixin, TestCase):
     def setUp(self):
-        self.fake = FakeSubject.objects.create(name='fake')
+        self.fake = FakeSubject.objects.create(name="fake")
         self.login()
 
     def test_create_and_retrieve_for_user(self):
@@ -28,21 +28,22 @@ class ActivityTest(WebTestMixin, DBTestMixin, TestCase):
         self.assertIsInstance(activities[0], FakeActivity)
 
     def test_create_and_retrieve_with_extras(self):
-        FakeActivity.objects.create(actor=self.user, related_to=self.fake, extras={'some_key': 'some_value',
-                                                                                   'other_key': 'other_value'})
+        FakeActivity.objects.create(
+            actor=self.user,
+            related_to=self.fake,
+            extras={"some_key": "some_value", "other_key": "other_value"},
+        )
 
         activities = Activity.objects(actor=self.user)
 
         self.assertEqual(len(activities), 1)
-        self.assertEqual(activities[0].extras['some_key'], 'some_value')
-        self.assertEqual(activities[0].extras['other_key'], 'other_value')
+        self.assertEqual(activities[0].extras["some_key"], "some_value")
+        self.assertEqual(activities[0].extras["other_key"], "other_value")
         self.assertIsInstance(activities[0], FakeActivity)
 
-
     def test_create_and_retrieve_for_org(self):
         org = OrganizationFactory()
-        FakeActivity.objects.create(
-            actor=self.user, related_to=self.fake, organization=org)
+        FakeActivity.objects.create(actor=self.user, related_to=self.fake, organization=org)
 
         activities = Activity.objects(organization=org)
 
@@ -51,8 +52,7 @@ class ActivityTest(WebTestMixin, DBTestMixin, TestCase):
 
     def test_create_and_retrieve_for_related(self):
         org = OrganizationFactory()
-        FakeActivity.objects.create(
-            actor=self.user, related_to=self.fake, organization=org)
+        FakeActivity.objects.create(actor=self.user, related_to=self.fake, organization=org)
         FakeActivity.objects.create(actor=UserFactory(), related_to=self.fake)
 
         activities = Activity.objects(related_to=self.fake)
@@ -67,7 +67,7 @@ class ActivityTest(WebTestMixin, DBTestMixin, TestCase):
         self.emitted = True
 
     def test_emit_signal(self):
-        '''It should emit a signal on new activity'''
+        """It should emit a signal on new activity"""
         self.emitted = False
         with FakeActivity.on_new.connected_to(self.check_emitted):
             FakeActivity.objects.create(actor=self.user, related_to=self.fake)
@@ -75,7 +75,7 @@ class ActivityTest(WebTestMixin, DBTestMixin, TestCase):
         self.assertTrue(self.emitted)
 
     def test_class_shortcut(self):
-        '''It should emit a signal on new activity'''
+        """It should emit a signal on new activity"""
         self.emitted = False
         self.login()
         with self.app.app_context():

udata/tests/test_cors.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+
+import pytest
+from flask import url_for
+
+from udata.core.dataset.factories import DatasetFactory
+from udata.core.topic.factories import TopicFactory
+from udata.search import reindex
+from udata.tests.api import APITestCase
+from udata.tests.helpers import assert_status
+
+
+class CorsTest(APITestCase):
+    modules = []
+
+    def test_cors_redirects(self):
+        dataset = DatasetFactory(title="Old title")
+        old_slug = dataset.slug
+
+        # New slug to force a redirect from old slug
+        dataset.title = "New title"
+        dataset.save()
+
+        response = self.get(url_for("api.dataset", dataset=old_slug))
+        assert_status(response, 308)
+
+        response = self.options(
+            url_for("api.dataset", dataset=old_slug),
+            headers={
+                "Origin": "http://localhost",
+                "Access-Control-Request-Method": "GET",
+            },
+        )
+        assert_status(response, 204)
+
+    def test_cors_404(self):
+        response = self.get(url_for("api.dataset", dataset="unknown-dataset"))
+        assert_status(response, 404)
+
+        response = self.options(
+            url_for("api.dataset", dataset="unknown-dataset"),
+            headers={
+                "Origin": "http://localhost",
+                "Access-Control-Request-Method": "GET",
+            },
+        )
+        assert_status(response, 204)
+
+    def test_cors_410_with_api_abort(self):
+        dataset = DatasetFactory(deleted=datetime.now())
+
+        response = self.get(url_for("api.dataset", dataset=dataset.id))
+        assert_status(response, 410)
+
+        response = self.options(
+            url_for("api.dataset", dataset=dataset.id),
+            headers={
+                "Origin": "http://localhost",
+                "Access-Control-Request-Method": "GET",
+            },
+        )
+        assert_status(response, 204)