udata 14.0.0__py3-none-any.whl → 14.4.1.dev7__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_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/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/frontend/test_auth.py

@@ -1,7 +1,7 @@
 from flask import current_app, url_for
 from flask_security.utils import hash_data
 
-from udata.core.user.factories import AdminFactory
+from udata.core.user.factories import AdminFactory, UserFactory
 from udata.tests.api import APITestCase
 
 
@@ -22,3 +22,26 @@ class AuthTest(APITestCase):
 
         user.reload()
         assert user.email == new_email
+
+    def test_change_mail_already_taken(self):
+        """Should not allow changing email to one already taken by another user"""
+        user = self.login(AdminFactory())
+        original_email = user.email
+
+        # Create another user with the target email
+        existing_user = UserFactory(email="taken@example.com")
+        new_email = existing_user.email
+
+        security = current_app.extensions["security"]
+
+        data = [str(user.fs_uniquifier), hash_data(user.email), new_email]
+        token = security.confirm_serializer.dumps(data)
+        confirmation_link = url_for("security.confirm_change_email", token=token)
+
+        resp = self.get(confirmation_link)
+        assert resp.status_code == 302
+        assert "change_email_already_taken" in resp.location
+
+        # Email should not have changed
+        user.reload()
+        assert user.email == original_email

udata/tests/frontend/test_csv.py

@@ -269,7 +269,6 @@ class CsvTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -327,7 +326,6 @@ class CsvTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -349,7 +347,6 @@ class CsvTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)

udata/tests/helpers.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 from io import BytesIO
 from urllib.parse import parse_qs, urlparse
 
-import mock
 from flask import current_app, json
 from flask_security.babel import FsDomain
 from PIL import Image
@@ -35,51 +34,50 @@ def assert_json_equal(first, second):
 
 
 @contextmanager
-def mock_signals(callback, *signals):
+def mock_signals(*signals):
     __tracebackhide__ = True
-    specs = []
 
-    def handler(sender, **kwargs):
-        pass
+    callbacks_by_signal = {}
+    calls_kwargs_by_signal = {}
 
-    for signal in signals:
-        m = mock.Mock(spec=handler)
-        signal.connect(m, weak=False)
-        specs.append((signal, m))
+    for requestSignal in signals:
+        # We capture requestSignal with a default argument
+        def callback(*args, requestSignal=requestSignal, **kwargs):
+            calls_kwargs_by_signal.setdefault(requestSignal, [])
+            calls_kwargs_by_signal[requestSignal].append(kwargs)
+
+        callbacks_by_signal[requestSignal] = callback
+        requestSignal.connect(callback, weak=False)
 
-    yield
+    yield calls_kwargs_by_signal
 
-    for signal, mock_handler in specs:
-        signal.disconnect(mock_handler)
-        signal_name = getattr(signal, "name", str(signal))
-        callback(signal_name, mock_handler)
+    for sig in signals:
+        sig.disconnect(callbacks_by_signal[sig])
 
 
 @contextmanager
 def assert_emit(*signals, assertions_callback=None):
     __tracebackhide__ = True
-    msg = 'Signal "{0}" should have been emitted'
-
-    def callback(name, handler):
-        assert handler.called, msg.format(name)
-        if assertions_callback is not None:
-            assertions_callback(handler.call_args)
 
-    with mock_signals(callback, *signals):
+    with mock_signals(*signals) as calls_kwargs_by_signal:
         yield
 
+    for signal in signals:
+        assert signal in calls_kwargs_by_signal, f'Signal "{signal}" should have been emitted'
+        if assertions_callback is not None:
+            for kwargs in calls_kwargs_by_signal[signal]:
+                assertions_callback(kwargs)
+
 
 @contextmanager
 def assert_not_emit(*signals):
     __tracebackhide__ = True
-    msg = 'Signal "{0}" should NOT have been emitted'
-
-    def callback(name, handler):
-        assert not handler.called, msg.format(name)
-
-    with mock_signals(callback, *signals):
+    with mock_signals(*signals) as calls_args_by_signal:
         yield
 
+    for signal in signals:
+        assert signal not in calls_args_by_signal, f'Signal "{signal}" should not have been emitted'
+
 
 @contextmanager
 def capture_mails():