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

udata/tests/test_notifications.py

@@ -20,38 +20,38 @@ class NotificationsActionsTest(NotificationsMixin, TestCase, DBTestMixin):
         def fake_provider(user):
             return []
 
-        actions.register_provider('fake', fake_provider)
+        actions.register_provider("fake", fake_provider)
 
-        self.assertIn('fake', actions.list_providers())
+        self.assertIn("fake", actions.list_providers())
 
     def test_registered_provider_with_decorator_is_listed(self):
-        @actions.notifier('fake')
+        @actions.notifier("fake")
         def fake_provider(user):
             return []
 
-        self.assertIn('fake', actions.list_providers())
+        self.assertIn("fake", actions.list_providers())
 
     def test_registered_provider_provide_values(self):
         dt = datetime.utcnow()
 
         def fake_provider(user):
-            return [(dt, {'some': 'value'})]
+            return [(dt, {"some": "value"})]
 
-        actions.register_provider('fake', fake_provider)
+        actions.register_provider("fake", fake_provider)
 
         user = UserFactory()
         notifs = actions.get_notifications(user)
 
         self.assertEqual(len(notifs), 1)
-        self.assertEqual(notifs[0]['type'], 'fake')
-        self.assertEqual(notifs[0]['details'], {'some': 'value'})
-        self.assertEqualDates(notifs[0]['created_on'], dt)
+        self.assertEqual(notifs[0]["type"], "fake")
+        self.assertEqual(notifs[0]["details"], {"some": "value"})
+        self.assertEqualDates(notifs[0]["created_on"], dt)
 
 
 class NotificationsAPITest(NotificationsMixin, APITestCase):
     def test_no_notifications(self):
         self.login()
-        response = self.get(url_for('api.notifications'))
+        response = self.get(url_for("api.notifications"))
         self.assert200(response)
 
         self.assertEqual(len(response.json), 0)
@@ -60,17 +60,17 @@ class NotificationsAPITest(NotificationsMixin, APITestCase):
         self.login()
         dt = datetime.utcnow()
 
-        @actions.notifier('fake')
+        @actions.notifier("fake")
         def fake_notifier(user):
-            return [(dt, {'some': 'value'}), (dt, {'another': 'value'})]
+            return [(dt, {"some": "value"}), (dt, {"another": "value"})]
 
-        response = self.get(url_for('api.notifications'))
+        response = self.get(url_for("api.notifications"))
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
 
         for notification in response.json:
-            self.assertEqual(notification['created_on'], pytz.utc.localize(dt).isoformat())
-            self.assertEqual(notification['type'], 'fake')
-        self.assertEqual(response.json[0]['details'], {'some': 'value'})
-        self.assertEqual(response.json[1]['details'], {'another': 'value'})
+            self.assertEqual(notification["created_on"], pytz.utc.localize(dt).isoformat())
+            self.assertEqual(notification["type"], "fake")
+        self.assertEqual(response.json[0]["details"], {"some": "value"})
+        self.assertEqual(response.json[1]["details"], {"another": "value"})

udata/tests/test_owned.py

@@ -1,13 +1,12 @@
 from mongoengine import post_save
 
+import udata.core.owned as owned
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Organization
 from udata.core.user.factories import UserFactory
 from udata.core.user.models import User
-
 from udata.mongo import db
-import udata.core.owned as owned
-from udata.tests import TestCase, DBTestMixin
+from udata.tests import DBTestMixin, TestCase
 
 
 class Owned(owned.Owned, db.Document):
@@ -17,9 +16,9 @@ class Owned(owned.Owned, db.Document):
 class OwnedPostSave(owned.Owned, db.Document):
     @classmethod
     def post_save(cls, sender, document, **kwargs):
-        if 'post_save' in kwargs.get('ignores', []):
+        if "post_save" in kwargs.get("ignores", []):
             return
-        if kwargs.get('created'):
+        if kwargs.get("created"):
             pass
         else:
             # on update
@@ -28,7 +27,7 @@ class OwnedPostSave(owned.Owned, db.Document):
 
 def compute_some_metrics(document, **kwargs):
     document.metric = 0
-    document.save(signal_kwargs={'ignores': ['post_save']})
+    document.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 class TestOwnedMixin(DBTestMixin, TestCase):
@@ -55,7 +54,7 @@ class TestOwnedMixin(DBTestMixin, TestCase):
             owned.owner = second_owner
             owned.save()
 
-        self.assertTrue(getattr(handler, 'called', False))
+        self.assertTrue(getattr(handler, "called", False))
 
     def test_owner_changed_from_user_to_org(self):
         owner = UserFactory()
@@ -73,7 +72,7 @@ class TestOwnedMixin(DBTestMixin, TestCase):
             owned.organization = org
             owned.save()
 
-        self.assertTrue(getattr(handler, 'called', False))
+        self.assertTrue(getattr(handler, "called", False))
 
     def test_owner_changed_from_org_to_org(self):
         first_org = OrganizationFactory()
@@ -91,7 +90,7 @@ class TestOwnedMixin(DBTestMixin, TestCase):
             owned.organization = second_org
             owned.save()
 
-        self.assertTrue(getattr(handler, 'called', False))
+        self.assertTrue(getattr(handler, "called", False))
 
     def test_owner_changed_from_org_to_user(self):
         user = UserFactory()
@@ -109,7 +108,7 @@ class TestOwnedMixin(DBTestMixin, TestCase):
             owned.owner = user
             owned.save()
 
-        self.assertTrue(getattr(handler, 'called', False))
+        self.assertTrue(getattr(handler, "called", False))
 
     def test_owner_changed_from_org_to_user_with_owned_postsave_signal(self):
         # Test with an additionnal post save signal that will retriger save signals
@@ -153,10 +152,11 @@ class OwnedQuerysetTest(DBTestMixin, TestCase):
     def test_owned_by_org_or_user(self):
         user = UserFactory()
         org = OrganizationFactory()
-        owneds = [Owned.objects.create(owner=user),
-                  Owned.objects.create(organization=org)]
-        excluded = [Owned.objects.create(owner=UserFactory()),
-                    Owned.objects.create(organization=OrganizationFactory())]
+        owneds = [Owned.objects.create(owner=user), Owned.objects.create(organization=org)]
+        excluded = [
+            Owned.objects.create(owner=UserFactory()),
+            Owned.objects.create(organization=OrganizationFactory()),
+        ]
 
         result = Owned.objects.owned_by(org, user)
 

udata/tests/test_rdf.py

@@ -1,53 +1,55 @@
 import pytest
 
-from udata.tests import TestCase
-
-
 from udata.rdf import (
-    guess_format, negociate_content, want_rdf, ACCEPTED_MIME_TYPES, FORMAT_MAP
+    ACCEPTED_MIME_TYPES,
+    FORMAT_MAP,
+    guess_format,
+    negociate_content,
+    want_rdf,
 )
+from udata.tests import TestCase
 
 
 class ContentNegociationTest(TestCase):
     def test_find_format_from_accept_header(self):
         for mime, expected in ACCEPTED_MIME_TYPES.items():
-            headers = {'accept': mime}
+            headers = {"accept": mime}
             with self.app.test_request_context(headers=headers):
                 self.assertEqual(negociate_content(), expected)
 
     def test_default_format_if_no_accept_header(self):
         with self.app.test_request_context():
-            self.assertEqual(negociate_content(default='json-ld'), 'json-ld')
+            self.assertEqual(negociate_content(default="json-ld"), "json-ld")
 
     def test_default_format_if_unkown_accept_header(self):
-        headers = {'accept': 'what/ever'}
+        headers = {"accept": "what/ever"}
         with self.app.test_request_context(headers=headers):
-            self.assertEqual(negociate_content(default='json-ld'), 'json-ld')
+            self.assertEqual(negociate_content(default="json-ld"), "json-ld")
 
     def test_support_accept_header_multiple_form(self):
-        headers = {'accept': 'application/xml, application/json'}
+        headers = {"accept": "application/xml, application/json"}
         with self.app.test_request_context(headers=headers):
-            self.assertEqual(negociate_content(), 'xml')
+            self.assertEqual(negociate_content(), "xml")
 
     def test_support_accept_header_multiple_form_with_ponderation(self):
-        headers = {'accept': 'application/xml;q=0.8, application/json;q=0.9'}
+        headers = {"accept": "application/xml;q=0.8, application/json;q=0.9"}
         with self.app.test_request_context(headers=headers):
-            self.assertEqual(negociate_content(), 'json-ld')
+            self.assertEqual(negociate_content(), "json-ld")
 
     def test_match_known_format_in_accept_header(self):
-        headers = {'accept': 'what/ever, application/xml'}
+        headers = {"accept": "what/ever, application/xml"}
         with self.app.test_request_context(headers=headers):
-            self.assertEqual(negociate_content(), 'xml')
+            self.assertEqual(negociate_content(), "xml")
 
     def test_want_rdf(self):
-        for mimetype in 'application/xml', 'application/json':
-            headers = {'accept': mimetype}
+        for mimetype in "application/xml", "application/json":
+            headers = {"accept": mimetype}
             with self.app.test_request_context(headers=headers):
                 self.assertTrue(want_rdf())
 
     def test_want_html(self):
-        for mimetype in 'text/html', 'application/xhtml+xml':
-            headers = {'accept': mimetype}
+        for mimetype in "text/html", "application/xhtml+xml":
+            headers = {"accept": mimetype}
             with self.app.test_request_context(headers=headers):
                 self.assertFalse(want_rdf())
 
@@ -56,16 +58,16 @@ class ContentNegociationTest(TestCase):
 
 
 class GuessFormatTest(object):
-    @pytest.mark.parametrize('suffix,expected', FORMAT_MAP.items())
+    @pytest.mark.parametrize("suffix,expected", FORMAT_MAP.items())
     def test_guess_from_extension(self, suffix, expected):
-        assert guess_format('resource.{0}'.format(suffix)) == expected
+        assert guess_format("resource.{0}".format(suffix)) == expected
 
-    @pytest.mark.parametrize('mime,expected', ACCEPTED_MIME_TYPES.items())
+    @pytest.mark.parametrize("mime,expected", ACCEPTED_MIME_TYPES.items())
     def test_guess_from_mime_type(self, mime, expected):
         assert guess_format(mime) == expected
 
     def test_unkown_extension(self):
-        assert guess_format('resource.unknonn') is None
+        assert guess_format("resource.unknonn") is None
 
     def test_unkown_mime(self):
-        assert guess_format('unknown/mime') is None
+        assert guess_format("unknown/mime") is None

udata/tests/test_routing.py

@@ -1,13 +1,12 @@
-import pytest
-
-from bson import ObjectId
 from uuid import uuid4
 
+import pytest
+from bson import ObjectId
 from flask import url_for
 
 from udata import routing
-from udata.core.spatial.models import GeoZone
 from udata.core.spatial.factories import GeoZoneFactory
+from udata.core.spatial.models import GeoZone
 from udata.mongo import db
 from udata.mongo.slug_fields import SlugFollow
 from udata.tests.helpers import assert200, assert404, assert_redirects
@@ -16,33 +15,32 @@ from udata.tests.helpers import assert200, assert404, assert_redirects
 class UUIDConverterTest:
     @pytest.fixture(autouse=True)
     def setup(self, app):
-
-        @app.route('/uuid/<uuid:uuid>')
+        @app.route("/uuid/<uuid:uuid>")
         def uuid_tester(uuid):
-            return 'ok'
+            return "ok"
 
     def test_serialize_uuid_to_url(self):
         uuid = uuid4()
-        url = url_for('uuid_tester', uuid=uuid)
-        assert url == '/uuid/{0}'.format(str(uuid))
+        url = url_for("uuid_tester", uuid=uuid)
+        assert url == "/uuid/{0}".format(str(uuid))
 
     def test_serialize_string_uuid_to_url(self):
         uuid = uuid4()
-        url = url_for('uuid_tester', uuid=str(uuid))
-        assert url == '/uuid/{0}'.format(str(uuid))
+        url = url_for("uuid_tester", uuid=str(uuid))
+        assert url == "/uuid/{0}".format(str(uuid))
 
     def test_resolve_uuid(self, client):
         uuid = uuid4()
-        url = '/uuid/{0}'.format(str(uuid))
+        url = "/uuid/{0}".format(str(uuid))
         assert200(client.get(url))
 
     def test_resolve_uuid_with_spaces(self, client):
         uuid = uuid4()
-        url = '/uuid/{0} '.format(str(uuid))
+        url = "/uuid/{0} ".format(str(uuid))
         assert200(client.get(url))
 
     def test_bad_uuid_is_404(self, client):
-        assert404(client.get('/uuid/bad'))
+        assert404(client.get("/uuid/bad"))
 
 
 class Tester(db.Document):
@@ -69,53 +67,53 @@ class RedirectTesterConverter(routing.ModelConverter):
     model = RedirectTester
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class ModelConverterMixin:
     @pytest.fixture(autouse=True)
     def setup(self, app):
-        app.url_map.converters['tester'] = self.converter
+        app.url_map.converters["tester"] = self.converter
 
-        @app.route('/model/<tester:model>')
+        @app.route("/model/<tester:model>")
         def model_tester(model):
             assert isinstance(model, self.model)
             return str(model.id)
 
     def test_serialize_model_id_to_url(self):
         tester = self.model.objects.create()
-        url = url_for('model_tester', model=tester)
-        assert url == '/model/{0}'.format(str(tester.id))
+        url = url_for("model_tester", model=tester)
+        assert url == "/model/{0}".format(str(tester.id))
 
     def test_serialize_model_slug_to_url(self):
-        tester = self.model.objects.create(slug='slug')
-        url = url_for('model_tester', model=tester)
-        assert url == '/model/slug'
+        tester = self.model.objects.create(slug="slug")
+        url = url_for("model_tester", model=tester)
+        assert url == "/model/slug"
 
     def test_serialize_object_id_to_url(self):
         id = ObjectId()
-        url = url_for('model_tester', model=id)
-        assert url == '/model/{0}'.format(str(id))
+        url = url_for("model_tester", model=id)
+        assert url == "/model/{0}".format(str(id))
 
     def test_serialize_string_to_url(self):
-        slug = 'slug'
-        url = url_for('model_tester', model=slug)
-        assert url == '/model/slug'
+        slug = "slug"
+        url = url_for("model_tester", model=slug)
+        assert url == "/model/slug"
 
     def test_cant_serialize_model_to_url(self):
         tester = self.model()
         with pytest.raises(ValueError):
-            url_for('model_tester', model=tester)
+            url_for("model_tester", model=tester)
 
     def test_resolve_model_from_id(self, client):
-        tester = self.model.objects.create(slug='slug')
-        url = '/model/{0}'.format(str(tester.id))
+        tester = self.model.objects.create(slug="slug")
+        url = "/model/{0}".format(str(tester.id))
         assert200(client.get(url))
 
     def test_resolve_model_from_slug(self, client):
-        self.model.objects.create(slug='slug')
-        assert200(client.get('/model/slug'))
+        self.model.objects.create(slug="slug")
+        assert200(client.get("/model/slug"))
 
     def test_model_not_found(self, client):
-        assert404(client.get('/model/not-found'))
+        assert404(client.get("/model/not-found"))
 
 
 class SlugAsStringFieldTest(ModelConverterMixin):
@@ -123,42 +121,42 @@ class SlugAsStringFieldTest(ModelConverterMixin):
     converter = TesterConverter
 
     def test_quote_model_slug_with_unicode_to_url(self):
-        tester = Tester.objects.create(slug='slüg')
-        url = url_for('model_tester', model=tester)
-        assert url == '/model/sl%C3%BCg'
+        tester = Tester.objects.create(slug="slüg")
+        url = url_for("model_tester", model=tester)
+        assert url == "/model/sl%C3%BCg"
 
     def test_quote_unicode_string_to_url(self):
-        slug = 'slüg'
-        url = url_for('model_tester', model=slug)
-        assert url == '/model/sl%C3%BCg'
+        slug = "slüg"
+        url = url_for("model_tester", model=slug)
+        assert url == "/model/sl%C3%BCg"
 
     def test_match_utf8_slug(self, client):
-        slug = 'slüg'
+        slug = "slüg"
         Tester.objects.create(slug=slug)
-        assert200(client.get('/model/slüg'))
+        assert200(client.get("/model/slüg"))
 
     def test_match_normalized_utf8_slug(self, client):
-        slug = 'slüg'
+        slug = "slüg"
         Tester.objects.create(slug=slug)
-        assert200(client.get('/model/sl%C3%BCg'))
+        assert200(client.get("/model/sl%C3%BCg"))
 
 
 class AsSlugMixin(ModelConverterMixin):
     def test_serialize_model_slug_with_unicode_to_url(self):
-        tester = self.model.objects.create(slug='slüg')
-        url = url_for('model_tester', model=tester)
-        assert url == '/model/slug'
+        tester = self.model.objects.create(slug="slüg")
+        url = url_for("model_tester", model=tester)
+        assert url == "/model/slug"
 
     def test_serialize_unicode_string_to_url(self):
-        slug = 'slüg'
-        url = url_for('model_tester', model=slug)
-        assert url == '/model/slug'
+        slug = "slüg"
+        url = url_for("model_tester", model=slug)
+        assert url == "/model/slug"
 
     def test_redirect_to_normalized_utf8_slug(self, client):
-        slug = 'slüg'
-        url = url_for('model_tester', model=slug)
+        slug = "slüg"
+        url = url_for("model_tester", model=slug)
         self.model.objects.create(slug=slug)
-        assert_redirects(client.get('/model/slüg'), url)
+        assert_redirects(client.get("/model/slüg"), url)
 
 
 class SlugAndIdTest(AsSlugMixin):
@@ -169,9 +167,9 @@ class SlugAndIdTest(AsSlugMixin):
         """Tests for url hijack. If a object is created with"""
         """an existing object's id as it's slug,"""
         """the endpoint should return the first one"""
-        tester = self.model.objects.create(slug='test_slug')
+        tester = self.model.objects.create(slug="test_slug")
         tester2 = self.model.objects.create(slug=str(tester.id))
-        model_url = url_for('model_tester', model=tester2)
+        model_url = url_for("model_tester", model=tester2)
         model_id = client.get(model_url)
         assert model_id.get_data() != str(tester2.id)
 
@@ -181,13 +179,13 @@ class SlugAsSlugFieldTest(AsSlugMixin):
     converter = SlugTesterConverter
 
     def test_renaming(self, client):
-        tester = self.model.objects.create(slug='old')
-        old_url = url_for('model_tester', model=tester)
+        tester = self.model.objects.create(slug="old")
+        old_url = url_for("model_tester", model=tester)
         assert200(client.get(old_url))
 
-        tester.slug = 'new'
+        tester.slug = "new"
         tester.save()
-        new_url = url_for('model_tester', model=tester)
+        new_url = url_for("model_tester", model=tester)
         assert200(client.get(new_url))
         assert404(client.get(old_url))
 
@@ -197,53 +195,53 @@ class SlugAsSLugFieldWithFollowTest(AsSlugMixin):
     converter = RedirectTesterConverter
 
     def test_renaming_redirect(self, client):
-        tester = self.model.objects.create(slug='old')
-        old_url = url_for('model_tester', model=tester)
+        tester = self.model.objects.create(slug="old")
+        old_url = url_for("model_tester", model=tester)
         assert200(client.get(old_url))
 
-        tester.slug = 'new'
+        tester.slug = "new"
         tester.save().reload()
 
-        new_url = url_for('model_tester', model=tester)
+        new_url = url_for("model_tester", model=tester)
         assert200(client.get(new_url))
         assert_redirects(client.get(old_url), new_url)
 
     def test_multiple_renaming_redirect(self, client):
-        tester = self.model.objects.create(slug='first')
-        first_url = url_for('model_tester', model=tester)
+        tester = self.model.objects.create(slug="first")
+        first_url = url_for("model_tester", model=tester)
 
-        tester.slug = 'second'
+        tester.slug = "second"
         tester.save().reload()
-        second_url = url_for('model_tester', model=tester)
+        second_url = url_for("model_tester", model=tester)
         assert200(client.get(second_url))
         assert_redirects(client.get(first_url), second_url)
 
-        tester.slug = 'last'
+        tester.slug = "last"
         tester.save().reload()
-        last_url = url_for('model_tester', model=tester)
+        last_url = url_for("model_tester", model=tester)
         assert200(client.get(last_url))
         assert_redirects(client.get(first_url), last_url)
         assert_redirects(client.get(second_url), last_url)
 
     def test_last_slug_has_priority(self, client):
-        tester = self.model.objects.create(slug='first')
-        first_url = url_for('model_tester', model=tester)
+        tester = self.model.objects.create(slug="first")
+        first_url = url_for("model_tester", model=tester)
 
-        tester.slug = 'second'
+        tester.slug = "second"
         tester.save().reload()
-        second_url = url_for('model_tester', model=tester)
+        second_url = url_for("model_tester", model=tester)
 
-        tester.slug = 'third'
+        tester.slug = "third"
         tester.save().reload()
-        third_url = url_for('model_tester', model=tester)
+        third_url = url_for("model_tester", model=tester)
 
-        new_tester = self.model.objects.create(slug='second')
+        new_tester = self.model.objects.create(slug="second")
         # Second slug should not be redirected anymore
         assert200(client.get(second_url))
 
-        new_tester.slug = 'last'
+        new_tester.slug = "last"
         new_tester.save().reload()
-        last_url = url_for('model_tester', model=new_tester)
+        last_url = url_for("model_tester", model=new_tester)
 
         # Current state should be:
         # - first redirects to third (tester)
@@ -259,16 +257,16 @@ class SlugAsSLugFieldWithFollowTest(AsSlugMixin):
         assert_redirects(client.get(first_url), third_url)
 
     def test_redirects_destroyed_on_object_deleted(self, client):
-        tester = self.model.objects.create(slug='first')
-        first_url = url_for('model_tester', model=tester)
+        tester = self.model.objects.create(slug="first")
+        first_url = url_for("model_tester", model=tester)
 
-        tester.slug = 'second'
+        tester.slug = "second"
         tester.save().reload()
-        second_url = url_for('model_tester', model=tester)
+        second_url = url_for("model_tester", model=tester)
 
-        tester.slug = 'last'
+        tester.slug = "last"
         tester.save().reload()
-        last_url = url_for('model_tester', model=tester)
+        last_url = url_for("model_tester", model=tester)
 
         tester.delete()
         assert404(client.get(first_url))
@@ -278,35 +276,33 @@ class SlugAsSLugFieldWithFollowTest(AsSlugMixin):
         assert SlugFollow.objects.count() is 0
 
 
-@pytest.mark.usefixtures('clean_db')
-@pytest.mark.options(TERRITORY_DEFAULT_PREFIX='fr')  # Not implemented
+@pytest.mark.usefixtures("clean_db")
+@pytest.mark.options(TERRITORY_DEFAULT_PREFIX="fr")  # Not implemented
 class TerritoryConverterTest:
-
     @pytest.fixture(autouse=True)
     def setup(self, app):
-
-        @app.route('/territory/<territory:territory>')
+        @app.route("/territory/<territory:territory>")
         def territory_tester(territory):
             assert isinstance(territory, GeoZone)
             return territory.id
 
     def test_serialize_zone_with_validity(self):
         zone = GeoZoneFactory()
-        url = url_for('territory_tester', territory=zone)
-        expected = '/territory/{level}/{code}/{slug}'
+        url = url_for("territory_tester", territory=zone)
+        expected = "/territory/{level}/{code}/{slug}"
         assert url == expected.format(**zone._data)
 
     def test_resolve_zone_without_optional_slug(self, client):
         zone = GeoZoneFactory()
-        url = '/territory/{level}/{code}/'
+        url = "/territory/{level}/{code}/"
         response = client.get(url.format(**zone._data))
         assert200(response)
 
     def test_resolve_zone_without_slug_nor_trailing_slash(self, client):
         zone = GeoZoneFactory()
-        url = '/territory/{level}/{code}'
+        url = "/territory/{level}/{code}"
         response = client.get(url.format(**zone._data))
         assert200(response)
 
     def test_model_not_found(self, client):
-        assert404(client.get('/territory/l/c'))
+        assert404(client.get("/territory/l/c"))