udata 11.1.2.dev8__py3-none-any.whl → 11.1.2.dev11__py3-none-any.whl

udata/tests/dataset/test_dataset_rdf.py

@@ -10,6 +10,7 @@ from rdflib.resource import Resource as RdfResource
 
 from udata.core.contact_point.factories import ContactPointFactory
 from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.dataset.constants import UpdateFrequency
 from udata.core.dataset.factories import DatasetFactory, LicenseFactory, ResourceFactory
 from udata.core.dataset.models import (
     Checksum,
@@ -20,7 +21,8 @@ from udata.core.dataset.models import (
     Resource,
 )
 from udata.core.dataset.rdf import (
-    EU_RDF_REQUENCIES,
+    EUFREQ_TERM_TO_UDATA,
+    FREQ_TERM_TO_UDATA,
     dataset_from_rdf,
     dataset_to_rdf,
     frequency_from_rdf,
@@ -38,6 +40,7 @@ from udata.rdf import (
     DCAT,
     DCATAP,
     DCT,
+    EUFREQ,
     FREQ,
     GEODCAT,
     HVD_LEGISLATION,
@@ -54,13 +57,6 @@ from udata.utils import faker
 
 pytestmark = pytest.mark.usefixtures("app")
 
-FREQ_SAMPLE = [
-    (FREQ.annual, "annual"),
-    (FREQ.monthly, "monthly"),
-    (FREQ.daily, "daily"),
-    (FREQ.continuous, "continuous"),
-]
-
 GOV_UK_REF = "http://reference.data.gov.uk/id/year/2017"
 
 try:
@@ -104,7 +100,7 @@ class DatasetToRdfTest:
         dataset = DatasetFactory(
             tags=faker.tags(nb=3),
             resources=resources,
-            frequency="daily",
+            frequency=UpdateFrequency.DAILY,
             acronym="acro",
             organization=org,
             contact_points=[contact],
@@ -178,19 +174,19 @@ class DatasetToRdfTest:
         assert org_rdf.value(RDF.type).identifier == FOAF.Organization
         assert org_rdf.value(FOAF.name) == Literal("organization")
 
-    def test_map_unkownn_frequencies(self):
-        assert frequency_to_rdf("hourly") == FREQ.continuous
-
-        assert frequency_to_rdf("fourTimesADay") == FREQ.daily
-        assert frequency_to_rdf("threeTimesADay") == FREQ.daily
-        assert frequency_to_rdf("semidaily") == FREQ.daily
-
-        assert frequency_to_rdf("fourTimesAWeek") == FREQ.threeTimesAWeek
+    def test_map_null_frequency(self):
+        assert frequency_to_rdf(None) is None
 
-        assert frequency_to_rdf("punctual") is None
-        assert frequency_to_rdf("unknown") is None
+    @pytest.mark.parametrize("term,freq", FREQ_TERM_TO_UDATA.items())
+    def test_map_dublin_core_frequencies(self, term, freq):
+        assert frequency_to_rdf(freq) == term
 
-        assert frequency_to_rdf("quinquennial") is None  # Better idea ?
+    @pytest.mark.parametrize(
+        "term,freq",
+        [(k, v) for k, v in EUFREQ_TERM_TO_UDATA.items() if v not in FREQ_TERM_TO_UDATA.values()],
+    )
+    def test_map_european_frequencies(self, term, freq):
+        assert frequency_to_rdf(freq) == term
 
     def test_minimal_resource_fields(self):
         resource = ResourceFactory()
@@ -462,7 +458,7 @@ class RdfToDatasetTest:
         g.set((node, DCT.title, Literal(title)))
         g.set((node, SKOS.altLabel, Literal(acronym)))
         g.set((node, DCT.description, Literal(description)))
-        g.set((node, DCT.accrualPeriodicity, FREQ.daily))
+        g.set((node, DCT.accrualPeriodicity, EUFREQ.DAILY))
         pot = BNode()
         g.add((node, DCT.temporal, pot))
         g.set((pot, RDF.type, DCT.PeriodOfTime))
@@ -478,7 +474,7 @@ class RdfToDatasetTest:
         assert dataset.title == title
         assert dataset.acronym == acronym
         assert dataset.description == description
-        assert dataset.frequency == "daily"
+        assert dataset.frequency == UpdateFrequency.DAILY
         assert set(dataset.tags) == set(tags)
         assert isinstance(dataset.temporal_coverage, db.DateRange)
         assert dataset.temporal_coverage.start == start
@@ -539,31 +535,34 @@ class RdfToDatasetTest:
         assert isinstance(dataset, Dataset)
         assert set(dataset.tags) == set(tags + themes)
 
-    @pytest.mark.parametrize("freq,expected", FREQ_SAMPLE)
+    def test_parse_null_frequency(self):
+        assert frequency_from_rdf(None) is None
+
+    @pytest.mark.parametrize("freq,expected", FREQ_TERM_TO_UDATA.items())
     def test_parse_dublin_core_frequencies(self, freq, expected):
         assert frequency_from_rdf(freq) == expected
 
-    @pytest.mark.parametrize("freq,expected", FREQ_SAMPLE)
+    @pytest.mark.parametrize("freq,expected", FREQ_TERM_TO_UDATA.items())
     def test_parse_dublin_core_frequencies_as_resource(self, freq, expected):
         g = Graph()
         resource = RdfResource(g, freq)
         assert frequency_from_rdf(resource) == expected
 
-    @pytest.mark.parametrize("freq,expected", FREQ_SAMPLE)
+    @pytest.mark.parametrize("freq,expected", FREQ_TERM_TO_UDATA.items())
     def test_parse_dublin_core_frequencies_as_url(self, freq, expected):
         assert frequency_from_rdf(str(freq)) == expected
 
-    @pytest.mark.parametrize("freq,expected", EU_RDF_REQUENCIES.items())
+    @pytest.mark.parametrize("freq,expected", EUFREQ_TERM_TO_UDATA.items())
     def test_parse_european_frequencies(self, freq, expected):
         assert frequency_from_rdf(freq) == expected
 
-    @pytest.mark.parametrize("freq,expected", EU_RDF_REQUENCIES.items())
+    @pytest.mark.parametrize("freq,expected", EUFREQ_TERM_TO_UDATA.items())
     def test_parse_european_frequencies_as_resource(self, freq, expected):
         g = Graph()
         resource = RdfResource(g, freq)
         assert frequency_from_rdf(resource) == expected
 
-    @pytest.mark.parametrize("freq,expected", EU_RDF_REQUENCIES.items())
+    @pytest.mark.parametrize("freq,expected", EUFREQ_TERM_TO_UDATA.items())
     def test_parse_european_frequencies_as_url(self, freq, expected):
         assert frequency_from_rdf(str(freq)) == expected