udata 14.0.0__py3-none-any.whl → 14.5.1.dev6__py3-none-any.whl

udata/tests/api/test_security_api.py

@@ -12,12 +12,12 @@ from udata.tests.helpers import capture_mails
 
 class SecurityAPITest(PytestOnlyAPITestCase):
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
-    def test_register(self, api):
+    def test_register(self):
         # We cannot test for mail sending since they are sent with Flask
         # directly and not with our system but if the sending is working
         # we test the rendering of the mail.
 
-        response = api.post(
+        response = self.post(
             url_for("security.register"),
             {
                 "first_name": "Jane",
@@ -32,13 +32,13 @@ class SecurityAPITest(PytestOnlyAPITestCase):
         self.assertStatus(response, 200)
 
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None, SECURITY_RETURN_GENERIC_RESPONSES=True)
-    def test_register_existing(self, api):
+    def test_register_existing(self):
         # We cannot test for mail sending since they are sent with Flask
         # directly and not with our system but if the sending is working
         # we test the rendering of the mail.
 
         UserFactory(email="jane@example.org", confirmed_at=datetime.now())
-        response = api.post(
+        response = self.post(
             url_for("security.register"),
             {
                 "first_name": "Jane",
@@ -53,20 +53,20 @@ class SecurityAPITest(PytestOnlyAPITestCase):
         self.assertStatus(response, 200)
 
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
-    def test_ask_for_reset(self, api):
+    def test_ask_for_reset(self):
         # We cannot test for mail sending since they are sent with Flask
         # directly and not with our system but if the sending is working
         # we test the rendering of the mail.
 
         UserFactory(email="jane@example.org", confirmed_at=datetime.now())
 
-        response = api.post(
+        response = self.post(
             url_for("security.forgot_password"), {"email": "jane@example.org", "submit": True}
         )
         self.assertStatus(response, 200)
 
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
-    def test_change_notice_mail(self, api):
+    def test_change_notice_mail(self):
         # We cannot test for mail sending since they are sent with Flask
         # directly and not with our system but if the sending is working
         # we test the rendering of the mail.
@@ -76,7 +76,7 @@ class SecurityAPITest(PytestOnlyAPITestCase):
         )
         self.login(user)
 
-        response = api.post(
+        response = self.post(
             url_for("security.change_password"),
             {
                 "password": "password",
@@ -88,12 +88,12 @@ class SecurityAPITest(PytestOnlyAPITestCase):
         self.assertStatus(response, 200)
 
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
-    def test_change_email_confirmation(self, api):
+    def test_change_email_confirmation(self):
         user = UserFactory(email="jane@example.org", confirmed_at=datetime.now())
         self.login(user)
 
         with capture_mails() as mails:
-            response = api.post(
+            response = self.post(
                 url_for("security.change_email"),
                 {
                     "new_email": "jane2@example.org",
@@ -109,11 +109,11 @@ class SecurityAPITest(PytestOnlyAPITestCase):
         assert mails[0].subject == _("Confirm your email address")
 
     @pytest.mark.options(CAPTCHETAT_BASE_URL=None, SECURITY_RETURN_GENERIC_RESPONSES=True)
-    def test_reset_password(self, api):
+    def test_reset_password(self):
         user = UserFactory(email="jane@example.org", confirmed_at=datetime.now())
         token = generate_reset_password_token(user)
 
-        response = api.post(
+        response = self.post(
             url_for("security.reset_password", token=token),
             {
                 "password": "Password123",

udata/tests/api/test_swagger.py

@@ -8,16 +8,16 @@ from udata.tests.helpers import assert200
 
 
 class SwaggerBlueprintTest(PytestOnlyAPITestCase):
-    def test_swagger_resource_type(self, api):
-        response = api.get(url_for("api.specs"))
+    def test_swagger_resource_type(self):
+        response = self.get(url_for("api.specs"))
         assert200(response)
         swagger = json.loads(response.data)
         expected = swagger["paths"]["/datasets/{dataset}/resources/"]
         expected = expected["put"]["responses"]["200"]["schema"]["type"]
         assert expected == "array"
 
-    def test_swagger_specs_validate(self, api):
-        response = api.get(url_for("api.specs"))
+    def test_swagger_specs_validate(self):
+        response = self.get(url_for("api.specs"))
         try:
             schemas.validate(response.json)
         except schemas.SchemaValidationError as e:

udata/tests/api/test_tags_api.py

@@ -9,7 +9,7 @@ from udata.utils import faker
 
 
 class TagsAPITest(PytestOnlyAPITestCase):
-    def test_suggest_tags_api(self, api):
+    def test_suggest_tags_api(self):
         """It should suggest tags"""
         for i in range(3):
             tags = [faker.tag(), faker.tag(), "test", "test-{0}".format(i)]
@@ -18,7 +18,7 @@ class TagsAPITest(PytestOnlyAPITestCase):
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags", q="tes", size=5))
+        response = self.get(url_for("api.suggest_tags", q="tes", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -29,7 +29,7 @@ class TagsAPITest(PytestOnlyAPITestCase):
             assert "text" in suggestion
             assert "tes" in suggestion["text"]
 
-    def test_suggest_tags_api_with_unicode(self, api):
+    def test_suggest_tags_api_with_unicode(self):
         """It should suggest tags"""
         for i in range(3):
             tags = [faker.tag(), faker.tag(), "testé", "testé-{0}".format(i)]
@@ -38,7 +38,7 @@ class TagsAPITest(PytestOnlyAPITestCase):
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags", q="testé", size=5))
+        response = self.get(url_for("api.suggest_tags", q="testé", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -49,7 +49,7 @@ class TagsAPITest(PytestOnlyAPITestCase):
             assert "text" in suggestion
             assert "teste" in suggestion["text"]
 
-    def test_suggest_tags_api_no_match(self, api):
+    def test_suggest_tags_api_no_match(self):
         """It should not provide tag suggestion if no match"""
         for i in range(3):
             tags = ["aaaa", "aaaa-{0}".format(i)]
@@ -58,12 +58,12 @@ class TagsAPITest(PytestOnlyAPITestCase):
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags", q="bbbb", size=5))
+        response = self.get(url_for("api.suggest_tags", q="bbbb", size=5))
         assert200(response)
         assert len(response.json) == 0
 
-    def test_suggest_tags_api_empty(self, api):
+    def test_suggest_tags_api_empty(self):
         """It should not provide tag suggestion if no data"""
-        response = api.get(url_for("api.suggest_tags", q="bbbb", size=5))
+        response = self.get(url_for("api.suggest_tags", q="bbbb", size=5))
         assert200(response)
         assert len(response.json) == 0

udata/tests/api/test_user_api.py

@@ -382,7 +382,7 @@ class UserAPITest(APITestCase):
             response = self.delete(url_for("api.user", user=user_to_delete))
             self.assertEqual(list(storages.avatars.list_files()), [])
             self.assert204(response)
-            self.assertEquals(len(mails), 1)
+            self.assertEqual(len(mails), 1)
 
         user_to_delete.reload()
         response = self.delete(url_for("api.user", user=user_to_delete))

udata/tests/apiv2/test_search.py

@@ -0,0 +1,30 @@
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.reuse.factories import ReuseFactory
+from udata.tests.api import APITestCase
+
+
+class SearchAPIV2Test(APITestCase):
+    def test_dataservice_search_with_model_query_param(self):
+        """Searching dataservices with 'model' as query param should not crash.
+
+        Regression test for: TypeError: query() got multiple values for argument 'model'
+        """
+        DataserviceFactory.create_batch(3)
+
+        response = self.get("/api/2/dataservices/search/?model=malicious")
+        self.assert200(response)
+
+    def test_reuse_search_with_model_query_param(self):
+        """Searching reuses with 'model' as query param should not crash."""
+        ReuseFactory.create_batch(3)
+
+        response = self.get("/api/2/reuses/search/?model=malicious")
+        self.assert200(response)
+
+    def test_organization_search_with_model_query_param(self):
+        """Searching organizations with 'model' as query param should not crash."""
+        OrganizationFactory.create_batch(3)
+
+        response = self.get("/api/2/organizations/search/?model=malicious")
+        self.assert200(response)

udata/tests/apiv2/test_swagger.py

@@ -8,16 +8,16 @@ from udata.tests.helpers import assert200
 
 
 class SwaggerBlueprintTest(PytestOnlyAPITestCase):
-    def test_swagger_resource_type(self, api):
-        response = api.get(url_for("apiv2.specs"))
+    def test_swagger_resource_type(self):
+        response = self.get(url_for("apiv2.specs"))
         assert200(response)
         swagger = json.loads(response.data)
         expected = swagger["paths"]["/datasets/{dataset}/resources/"]
         expected = expected["get"]["responses"]["200"]["schema"]["$ref"]
         assert expected == "#/definitions/ResourcePage"
 
-    def test_swagger_specs_validate(self, api):
-        response = api.get(url_for("apiv2.specs"))
+    def test_swagger_specs_validate(self):
+        response = self.get(url_for("apiv2.specs"))
         try:
             schemas.validate(response.json)
         except schemas.SchemaValidationError as e:

udata/tests/cli/test_cli_base.py

@@ -2,17 +2,16 @@ from udata.tests import PytestOnlyTestCase
 
 
 class CliBaseTest(PytestOnlyTestCase):
-    def test_cli_help(self, cli):
+    def test_cli_help(self):
         """Should display help without errors"""
-        cli()
-        cli("-?")
-        cli("-h")
-        cli("--help")
+        self.cli("-?")
+        self.cli("-h")
+        self.cli("--help")
 
-    def test_cli_log_and_printing(self, cli):
+    def test_cli_log_and_printing(self):
         """Should properly log and print"""
-        cli("test log")
+        self.cli("test log")
 
-    def test_cli_version(self, cli):
+    def test_cli_version(self):
         """Should display version without errors"""
-        cli("--version")
+        self.cli("--version")

udata/tests/dataservice/test_dataservice_tasks.py

@@ -43,3 +43,32 @@ class DataserviceTasksTest(PytestOnlyDBTestCase):
         assert Discussion.objects.filter(id=discussion.id).count() == 0
         assert Follow.objects.filter(id=follower.id).count() == 0
         assert HarvestJob.objects.filter(items__dataservice=dataservices[0].id).count() == 0
+
+    def test_purge_dataservices_cleans_all_harvest_items_references(self):
+        """Test that purging dataservices cleans all HarvestItem references in a job.
+
+        The same dataservice can appear multiple times in a job's items (e.g. if the
+        harvest source has duplicates). The $ operator only updates the first match,
+        so we need to use $[] with array_filters to update all matches.
+        """
+        dataservice_to_delete = Dataservice.objects.create(
+            title="delete me", base_api_url="https://example.com/api", deleted_at="2016-01-01"
+        )
+        dataservice_keep = Dataservice.objects.create(
+            title="keep me", base_api_url="https://example.com/api"
+        )
+
+        job = HarvestJobFactory(
+            items=[
+                HarvestItem(dataservice=dataservice_to_delete, remote_id="1"),
+                HarvestItem(dataservice=dataservice_keep, remote_id="2"),
+                HarvestItem(dataservice=dataservice_to_delete, remote_id="3"),
+            ]
+        )
+
+        tasks.purge_dataservices()
+
+        job.reload()
+        assert job.items[0].dataservice is None
+        assert job.items[1].dataservice == dataservice_keep
+        assert job.items[2].dataservice is None

udata/tests/dataset/test_dataset_commands.py

@@ -5,22 +5,22 @@ from udata.tests.api import PytestOnlyDBTestCase
 
 
 class DatasetCommandTest(PytestOnlyDBTestCase):
-    def test_dataset_archive_one(self, cli):
+    def test_dataset_archive_one(self):
         dataset = DatasetFactory()
 
-        cli("dataset", "archive-one", str(dataset.id))
+        self.cli("dataset", "archive-one", str(dataset.id))
 
         dataset.reload()
         assert dataset.archived is not None
 
-    def test_dataset_archive(self, cli):
+    def test_dataset_archive(self):
         datasets = [DatasetFactory() for _ in range(2)]
 
         with NamedTemporaryFile(mode="w", encoding="utf8") as temp:
             temp.write("\n".join((str(d.id) for d in datasets)))
             temp.flush()
 
-            cli("dataset", "archive", temp.name)
+            self.cli("dataset", "archive", temp.name)
 
         for dataset in datasets:
             dataset.reload()

udata/tests/dataset/test_dataset_model.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta, timezone
 from uuid import uuid4
 
 import pytest
@@ -206,6 +206,18 @@ class DatasetModelTest(PytestOnlyDBTestCase):
         assert dataset.quality["update_fulfilled_in_time"] is False
         assert dataset.quality["score"] == Dataset.normalize_score(1)
 
+    def test_quality_frequency_update_with_harvest_timezone_aware(self):
+        """Test that update_fulfilled_in_time works with timezone-aware harvest dates."""
+        dataset = DatasetFactory(
+            description="",
+            frequency=UpdateFrequency.DAILY,
+            harvest=HarvestDatasetMetadata(
+                modified_at=datetime.now(timezone.utc) - timedelta(hours=1),
+            ),
+        )
+        assert dataset.quality["update_frequency"] is True
+        assert dataset.quality["update_fulfilled_in_time"] is True
+
     def test_quality_description_length(self):
         dataset = DatasetFactory(
             description="a" * (current_app.config.get("QUALITY_DESCRIPTION_LENGTH") - 1)
@@ -326,9 +338,11 @@ class DatasetModelTest(PytestOnlyDBTestCase):
 
         assert dataset_without_resources.resources_len == 0
 
-    def test_dataset_activities(self, api, mocker):
+    def test_dataset_activities(self, app, mocker):
         # A user must be authenticated for activities to be emitted
-        user = api.login()
+        from flask_login import login_user
+
+        user = UserFactory()
 
         mock_created = mocker.patch.object(UserCreatedDataset, "emit")
         mock_updated = mocker.patch.object(UserUpdatedDataset, "emit")
@@ -337,35 +351,38 @@ class DatasetModelTest(PytestOnlyDBTestCase):
         mock_resouce_updated = mocker.patch.object(UserUpdatedResource, "emit")
         mock_resouce_removed = mocker.patch.object(UserRemovedResourceFromDataset, "emit")
 
-        with assert_emit(Dataset.on_create):
-            dataset = DatasetFactory(owner=user)
-            mock_created.assert_called()
+        with app.test_request_context():
+            login_user(user)
 
-        with assert_emit(Dataset.on_update):
-            dataset.title = "new title"
-            dataset.save()
-            mock_updated.assert_called()
+            with assert_emit(Dataset.on_create):
+                dataset = DatasetFactory(owner=user)
+                mock_created.assert_called()
 
-        with assert_emit(Dataset.on_resource_added):
-            dataset.add_resource(ResourceFactory())
-            mock_resource_added.assert_called()
+            with assert_emit(Dataset.on_update):
+                dataset.title = "new title"
+                dataset.save()
+                mock_updated.assert_called()
 
-        dataset.reload()
+            with assert_emit(Dataset.on_resource_added):
+                dataset.add_resource(ResourceFactory())
+                mock_resource_added.assert_called()
 
-        with assert_emit(Dataset.on_resource_updated):
-            resource = dataset.resources[0]
-            resource.description = "New description"
-            dataset.update_resource(resource)
-            mock_resouce_updated.assert_called()
+            dataset.reload()
 
-        with assert_emit(Dataset.on_resource_removed):
-            dataset.remove_resource(dataset.resources[-1])
-            mock_resouce_removed.assert_called()
+            with assert_emit(Dataset.on_resource_updated):
+                resource = dataset.resources[0]
+                resource.description = "New description"
+                dataset.update_resource(resource)
+                mock_resouce_updated.assert_called()
 
-        with assert_emit(Dataset.on_delete):
-            dataset.deleted = datetime.utcnow()
-            dataset.save()
-            mock_deleted.assert_called()
+            with assert_emit(Dataset.on_resource_removed):
+                dataset.remove_resource(dataset.resources[-1])
+                mock_resouce_removed.assert_called()
+
+            with assert_emit(Dataset.on_delete):
+                dataset.deleted = datetime.utcnow()
+                dataset.save()
+                mock_deleted.assert_called()
 
     def test_dataset_metrics(self):
         # We need to init metrics module
@@ -867,3 +884,26 @@ class HarvestMetadataTest(PytestOnlyDBTestCase):
         resource.validate()
 
         assert resource.last_modified == resource.extras["analysis:last-modified-at"]
+
+    def test_quality_cached_next_update_with_date_last_update(self):
+        """Test that quality_cached with date (not datetime) last_update can be saved to MongoDB.
+
+        This reproduces a production bug where last_update could be a datetime.date instead
+        of datetime.datetime, causing next_update to also be a datetime.date, which BSON
+        cannot encode (it only supports datetime.datetime).
+
+        See error: bson.errors.InvalidDocument: cannot encode object: datetime.date(...), of type: <class 'datetime.date'>
+        """
+        dataset: Dataset = DatasetFactory(
+            frequency=UpdateFrequency.QUARTERLY,
+        )
+        # Set harvest metadata with modified_at as a date instead of datetime
+        # This simulates data coming from harvesting where dates might not be properly typed
+        dataset.harvest = HarvestDatasetMetadata(
+            created_at=datetime(2019, 1, 1),
+            modified_at=date(2019, 6, 7),  # Using date instead of datetime
+        )
+        # Also set last_update as date to fully simulate the production scenario
+        dataset.last_update = date(2019, 6, 7)
+
+        dataset.save()

udata/tests/dataset/test_dataset_rdf.py

@@ -643,10 +643,10 @@ class RdfToDatasetTest(PytestOnlyDBTestCase):
 
         assert len(dataset.contact_points) == 1
         assert dataset.contact_points[0].role == "contact"
-        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].name == "foo (bar)"
         assert dataset.contact_points[0].email == "foo@example.com"
 
-    def test_contact_point_organization_member_foaf(self):
+    def test_contact_point_organization_member_foaf_both_mails(self):
         g = Graph()
         node = URIRef("https://test.org/dataset")
         g.set((node, RDF.type, DCAT.Dataset))
@@ -673,10 +673,10 @@ class RdfToDatasetTest(PytestOnlyDBTestCase):
 
         assert len(dataset.contact_points) == 1
         assert dataset.contact_points[0].role == "creator"
-        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].name == "foo (bar)"
         assert dataset.contact_points[0].email == "foo@example.com"
 
-    def test_contact_point_organization_member_foaf_no_mail(self):
+    def test_contact_point_organization_member_foaf_no_org_mail(self):
         g = Graph()
         node = URIRef("https://test.org/dataset")
         g.set((node, RDF.type, DCAT.Dataset))
@@ -703,9 +703,39 @@ class RdfToDatasetTest(PytestOnlyDBTestCase):
 
         assert len(dataset.contact_points) == 1
         assert dataset.contact_points[0].role == "creator"
-        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].name == "foo (bar)"
         assert dataset.contact_points[0].email == "foo@example.com"
 
+    def test_contact_point_organization_member_foaf_no_agent_mail(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        org = BNode()
+        g.add((org, RDF.type, FOAF.Organization))
+        g.add((org, FOAF.name, Literal("bar")))
+        g.add((org, FOAF.mbox, Literal("bar@example.com")))
+        contact = BNode()
+        g.add((contact, RDF.type, FOAF.Person))
+        g.add((contact, FOAF.name, Literal("foo")))
+        # no agent email
+        g.add((contact, ORG.memberOf, org))
+        g.add((node, DCT.creator, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "creator"
+        assert dataset.contact_points[0].name == "foo (bar)"
+        assert dataset.contact_points[0].email == "bar@example.com"
+
     def test_theme_and_tags(self):
         node = BNode()
         g = Graph()
@@ -1364,6 +1394,70 @@ class DatasetRdfViewsTest(PytestOnlyAPITestCase):
         assert200(response)
         assert response.content_type == mime
 
+    @pytest.mark.parametrize(
+        "fmt,mime",
+        [
+            ("n3", "text/n3"),
+            ("nt", "application/n-triples"),
+            ("ttl", "application/x-turtle"),
+            ("xml", "application/rdf+xml"),
+            ("rdf", "application/rdf+xml"),
+            ("owl", "application/rdf+xml"),
+            ("trig", "application/trig"),
+        ],
+    )
+    def test_dont_fail_with_invalid_uri(self, client, fmt, mime):
+        """Invalid URIs (with spaces or curly brackets) shouldn't make rdf export fail in any format"""
+        invalid_uri_with_quote = 'https://test.org/dataset_with"quote"'
+        invalid_uri_with_curly_bracket = 'http://opendata-sig.saintdenis.re/datasets/identifiant.kml?outSR={"latestWkid":2975,"wkid":2975}'
+        invalid_uri_with_space = "https://catalogue.opendata-ligair.fr/geonetwork/srv/60678572-36e5-4e78-9af3-48f726670dfd fr-modelisation-sirane-vacarm_no2"
+        dataset = DatasetFactory(
+            resources=[
+                ResourceFactory(url=invalid_uri_with_quote),
+                ResourceFactory(url=invalid_uri_with_curly_bracket),
+            ],
+            harvest=HarvestDatasetMetadata(uri=invalid_uri_with_space),
+        )
+
+        url = url_for("api.dataset_rdf_format", dataset=dataset, _format=fmt)
+        response = client.get(url, headers={"Accept": mime})
+        assert200(response)
+
+    @pytest.mark.parametrize(
+        "fmt,mime",
+        [
+            ("n3", "text/n3"),
+            ("nt", "application/n-triples"),
+            ("ttl", "application/x-turtle"),
+            ("trig", "application/trig"),
+        ],
+    )
+    def test_invalid_uri_escape_in_n3_turtle_format(self, client, fmt, mime):
+        """Invalid URIs (with spaces or curly brackets) should be escaped in N3/turtle formats"""
+        invalid_uri_with_quote = 'https://test.org/dataset_with"quote"'
+        invalid_uri_with_curly_bracket = 'http://opendata-sig.saintdenis.re/datasets/identifiant.kml?outSR={"latestWkid":2975,"wkid":2975}'
+        invalid_uri_with_space = "https://catalogue.opendata-ligair.fr/geonetwork/srv/60678572-36e5-4e78-9af3-48f726670dfd fr-modelisation-sirane-vacarm_no2"
+        dataset = DatasetFactory(
+            resources=[
+                ResourceFactory(url=invalid_uri_with_quote),
+                ResourceFactory(url=invalid_uri_with_curly_bracket),
+            ],
+            harvest=HarvestDatasetMetadata(uri=invalid_uri_with_space),
+        )
+
+        url = url_for("api.dataset_rdf_format", dataset=dataset, _format=fmt)
+        response = client.get(url, headers={"Accept": mime})
+        assert200(response)
+        assert "https://test.org/dataset_with%22quote%22" in response.text
+        assert (
+            "http://opendata-sig.saintdenis.re/datasets/identifiant.kml?outSR=%7B%22latestWkid%22:2975,%22wkid%22:2975%7D"
+            in response.text
+        )
+        assert (
+            "https://catalogue.opendata-ligair.fr/geonetwork/srv/60678572-36e5-4e78-9af3-48f726670dfd%20fr-modelisation-sirane-vacarm_no2"
+            in response.text
+        )
+
 
 class DatasetFromRdfUtilsTest(PytestOnlyTestCase):
     def test_licenses_from_rdf(self):

udata/tests/dataset/test_dataset_tasks.py

@@ -60,6 +60,31 @@ class DatasetTasksTest(PytestOnlyDBTestCase):
         assert HarvestJob.objects.filter(items__dataset=datasets[0].id).count() == 0
         assert Dataservice.objects.filter(datasets=datasets[0].id).count() == 0
 
+    def test_purge_datasets_cleans_all_harvest_items_references(self):
+        """Test that purging datasets cleans all HarvestItem references in a job.
+
+        The same dataset can appear multiple times in a job's items (e.g. if the
+        harvest source has duplicates). The $ operator only updates the first match,
+        so we need to use $[] with array_filters to update all matches.
+        """
+        dataset_to_delete = Dataset.objects.create(title="delete me", deleted="2016-01-01")
+        dataset_keep = Dataset.objects.create(title="keep me")
+
+        job = HarvestJobFactory(
+            items=[
+                HarvestItem(dataset=dataset_to_delete, remote_id="1"),
+                HarvestItem(dataset=dataset_keep, remote_id="2"),
+                HarvestItem(dataset=dataset_to_delete, remote_id="3"),
+            ]
+        )
+
+        tasks.purge_datasets()
+
+        job.reload()
+        assert job.items[0].dataset is None
+        assert job.items[1].dataset == dataset_keep
+        assert job.items[2].dataset is None
+
     def test_purge_datasets_community(self):
         dataset = Dataset.objects.create(title="delete me", deleted="2016-01-01")
         community_resource1 = CommunityResourceFactory()