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

udata/tests/test_transfer.py

@@ -1,24 +1,23 @@
 import pytest
 
-from udata.auth import login_user, PermissionDenied
-
-from udata.features.transfer.factories import TransferFactory
-from udata.features.transfer.actions import request_transfer, accept_transfer
-from udata.features.transfer.notifications import (
-    transfer_request_notifications
-)
-from udata.models import Member, Dataset
-
-from udata.utils import faker
+from udata.auth import PermissionDenied, login_user
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.organization.factories import OrganizationFactory
-from udata.core.organization.metrics import update_org_metrics  # noqa needed to register signals
-from udata.core.user.factories import UserFactory 
-from udata.core.user.metrics import update_owner_metrics  # noqa needed to register signals
+from udata.core.organization.metrics import (
+    update_org_metrics,  # noqa needed to register signals
+)
+from udata.core.user.factories import UserFactory
+from udata.core.user.metrics import (
+    update_owner_metrics,  # noqa needed to register signals
+)
+from udata.features.transfer.actions import accept_transfer, request_transfer
+from udata.features.transfer.factories import TransferFactory
+from udata.features.transfer.notifications import transfer_request_notifications
+from udata.models import Dataset, Member
 from udata.tests.helpers import assert_emit
+from udata.utils import faker
 
-
-pytestmark = pytest.mark.usefixtures('clean_db')
+pytestmark = pytest.mark.usefixtures("clean_db")
 
 
 class TransferStartTest:
@@ -29,7 +28,7 @@ class TransferStartTest:
         assert transfer.recipient == recipient
         assert transfer.subject == subject
         assert transfer.comment == comment
-        assert transfer.status == 'pending'
+        assert transfer.status == "pending"
 
     def test_request_transfer_owner_to_user(self):
         user = UserFactory()
@@ -42,7 +41,7 @@ class TransferStartTest:
 
     def test_request_transfer_organization_to_user(self):
         user = UserFactory()
-        member = Member(user=user, role='admin')
+        member = Member(user=user, role="admin")
         org = OrganizationFactory(members=[member])
         dataset = DatasetFactory(owner=user, organization=org)
         recipient = UserFactory()
@@ -72,7 +71,7 @@ class TransferStartTest:
 
     def test_request_transfer_not_authorized_not_admin(self):
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         dataset = DatasetFactory(organization=org)
         recipient = UserFactory()
@@ -93,7 +92,7 @@ class TransferStartTest:
 
     def test_request_transfer_to_same_organization(self):
         user = UserFactory()
-        member = Member(user=user, role='admin')
+        member = Member(user=user, role="admin")
         org = OrganizationFactory(members=[member])
         dataset = DatasetFactory(owner=user, organization=org)
         comment = faker.sentence()
@@ -109,74 +108,68 @@ class TransferAcceptTest:
         owner = UserFactory()
         recipient = UserFactory()
         subject = DatasetFactory(owner=owner)
-        transfer = TransferFactory(owner=owner,
-                                   recipient=recipient,
-                                   subject=subject)
+        transfer = TransferFactory(owner=owner, recipient=recipient, subject=subject)
 
         owner.reload()  # Needs updated metrics
-        assert owner.get_metrics()['datasets'] == 1
+        assert owner.get_metrics()["datasets"] == 1
 
         recipient.reload()  # Needs updated metrics
-        assert recipient.get_metrics()['datasets'] == 0
+        assert recipient.get_metrics()["datasets"] == 0
 
         login_user(recipient)
         transfer = accept_transfer(transfer)
 
-        assert transfer.status == 'accepted'
+        assert transfer.status == "accepted"
 
         subject.reload()
         assert subject.owner == recipient
 
         recipient.reload()
-        assert recipient.get_metrics()['datasets'] == 1
+        assert recipient.get_metrics()["datasets"] == 1
 
         owner.reload()
-        assert owner.get_metrics()['datasets'] == 0
+        assert owner.get_metrics()["datasets"] == 0
 
     def test_org_admin_can_accept_transfer(self):
         owner = UserFactory()
         admin = UserFactory()
-        org = OrganizationFactory(members=[Member(user=admin, role='admin')])
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
         subject = DatasetFactory(owner=owner)
-        transfer = TransferFactory(owner=owner,
-                                   recipient=org,
-                                   subject=subject)
+        transfer = TransferFactory(owner=owner, recipient=org, subject=subject)
 
         owner.reload()  # Needs updated metrics
-        assert owner.get_metrics()['datasets'] == 1
+        assert owner.get_metrics()["datasets"] == 1
 
         org.reload()  # Needs updated metrics
-        assert org.get_metrics()['datasets'] == 0
+        assert org.get_metrics()["datasets"] == 0
 
         admin.reload()  # Needs updated metrics
-        assert admin.get_metrics()['datasets'] == 0
+        assert admin.get_metrics()["datasets"] == 0
 
         login_user(admin)
         transfer = accept_transfer(transfer)
 
-        assert transfer.status == 'accepted'
+        assert transfer.status == "accepted"
 
         subject.reload()
         assert subject.organization == org
         assert subject.owner is None
 
         org.reload()
-        assert org.get_metrics()['datasets'] == 1
+        assert org.get_metrics()["datasets"] == 1
 
         admin.reload()
-        assert admin.get_metrics()['datasets'] == 0
+        assert admin.get_metrics()["datasets"] == 0
 
         owner.reload()
-        assert owner.get_metrics()['datasets'] == 0
+        assert owner.get_metrics()["datasets"] == 0
 
     def test_org_editor_cant_accept_transfer(self):
         owner = UserFactory()
         editor = UserFactory()
-        org = OrganizationFactory(members=[Member(user=editor, role='editor')])
+        org = OrganizationFactory(members=[Member(user=editor, role="editor")])
         subject = DatasetFactory(organization=org)
-        transfer = TransferFactory(owner=owner,
-                                   recipient=org,
-                                   subject=subject)
+        transfer = TransferFactory(owner=owner, recipient=org, subject=subject)
 
         login_user(editor)
         with pytest.raises(PermissionDenied):
@@ -201,15 +194,15 @@ class TransferNotificationsTest:
         notifications = transfer_request_notifications(recipient)
         assert len(notifications) == len(datasets)
         for dt, details in notifications:
-            transfer = transfers[details['id']]
-            assert details['subject']['class'] == 'dataset'
-            assert details['subject']['id'] == transfer.subject.id
+            transfer = transfers[details["id"]]
+            assert details["subject"]["class"] == "dataset"
+            assert details["subject"]["id"] == transfer.subject.id
 
     def test_pending_transfer_request_for_org(self):
         user = UserFactory()
         datasets = DatasetFactory.create_batch(2, owner=user)
         recipient = UserFactory()
-        member = Member(user=recipient, role='editor')
+        member = Member(user=recipient, role="editor")
         org = OrganizationFactory(members=[member])
         comment = faker.sentence()
         transfers = {}
@@ -224,6 +217,6 @@ class TransferNotificationsTest:
         notifications = transfer_request_notifications(recipient)
         assert len(notifications) == len(datasets)
         for dt, details in notifications:
-            transfer = transfers[details['id']]
-            assert details['subject']['class'] == 'dataset'
-            assert details['subject']['id'] == transfer.subject.id
+            transfer = transfers[details["id"]]
+            assert details["subject"]["class"] == "dataset"
+            assert details["subject"]["id"] == transfer.subject.id

udata/tests/test_uris.py

@@ -3,290 +3,289 @@ import pytest
 from udata import uris
 from udata.settings import Defaults
 
-
 PUBLIC_HOSTS = [
-    'http://foo.com/blah_blah',
-    'http://foo.com/blah_blah/',
-    'http://foo.com/blah_blah_(wikipedia)',
-    'http://foo.com/blah_blah_(wikipedia)_(again)',
-    'http://www.example.com/wpstyle/?p=364',
-    'https://www.example.com/foo/?bar=baz&inga=42&quux',
-    'http://✪df.ws/123',
-    'http://➡.ws/䨹',
-    'http://⌘.ws',
-    'http://⌘.ws/',
-    'http://foo.com/blah_(wikipedia)#cite-1',
-    'http://foo.com/blah_(wikipedia)_blah#cite-1',
-    'http://foo.com/unicode_(✪)_in_parens',
-    'http://foo.com/(something)?after=parens',
-    'http://☺.damowmow.com/',
-    'http://code.google.com/events/#&product=browser',
-    'http://j.mp',
-    'ftp://foo.bar/baz',
-    'http://foo.bar/?q=Test%20URL-encoded%20stuff',
-    'http://مثال.إختبار.com',
-    'http://例子.测试.com',
-    'http://उदाहरण.परीक्षा.com',
-    'http://-.~_!$&\'()*+,;=:%40:80%2f::::::@example.com',
-    'http://1337.net',
-    'http://a.b-c.de',
-    'https://foo_bar.example.com/',
-    'ftps://foo.bar/',
-    '//foo.bar/',
+    "http://foo.com/blah_blah",
+    "http://foo.com/blah_blah/",
+    "http://foo.com/blah_blah_(wikipedia)",
+    "http://foo.com/blah_blah_(wikipedia)_(again)",
+    "http://www.example.com/wpstyle/?p=364",
+    "https://www.example.com/foo/?bar=baz&inga=42&quux",
+    "http://✪df.ws/123",
+    "http://➡.ws/䨹",
+    "http://⌘.ws",
+    "http://⌘.ws/",
+    "http://foo.com/blah_(wikipedia)#cite-1",
+    "http://foo.com/blah_(wikipedia)_blah#cite-1",
+    "http://foo.com/unicode_(✪)_in_parens",
+    "http://foo.com/(something)?after=parens",
+    "http://☺.damowmow.com/",
+    "http://code.google.com/events/#&product=browser",
+    "http://j.mp",
+    "ftp://foo.bar/baz",
+    "http://foo.bar/?q=Test%20URL-encoded%20stuff",
+    "http://مثال.إختبار.com",
+    "http://例子.测试.com",
+    "http://उदाहरण.परीक्षा.com",
+    "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com",
+    "http://1337.net",
+    "http://a.b-c.de",
+    "https://foo_bar.example.com/",
+    "ftps://foo.bar/",
+    "//foo.bar/",
 ]
 
 PUBLIC_HOSTS_IDN = [
-    'http://例子.中国',
-    'http://somewhere.укр',
+    "http://例子.中国",
+    "http://somewhere.укр",
 ]
 
 WITH_CREDENTIALS = [
-    'http://userid:password@example.com:8080',
-    'http://userid:password@example.com:8080/',
-    'http://userid@example.com',
-    'http://userid@example.com/',
-    'http://userid@example.com:8080',
-    'http://userid@example.com:8080/',
-    'http://userid:password@example.com',
-    'http://userid:password@example.com/',
+    "http://userid:password@example.com:8080",
+    "http://userid:password@example.com:8080/",
+    "http://userid@example.com",
+    "http://userid@example.com/",
+    "http://userid@example.com:8080",
+    "http://userid@example.com:8080/",
+    "http://userid:password@example.com",
+    "http://userid:password@example.com/",
 ]
 
 PUBLIC_IPS = [
-    'http://142.42.1.1/',
-    'http://142.42.1.1:8080',
-    'http://142.42.1.1:8080/',
-    'http://223.255.255.254',
-    'http://[2a00:1450:4007:80e::2004]',
-    'http://[2a00:1450:4007:80e::2004]:8080',
-    'http://[2a00:1450:4007:80e::2004]:8080/',
+    "http://142.42.1.1/",
+    "http://142.42.1.1:8080",
+    "http://142.42.1.1:8080/",
+    "http://223.255.255.254",
+    "http://[2a00:1450:4007:80e::2004]",
+    "http://[2a00:1450:4007:80e::2004]:8080",
+    "http://[2a00:1450:4007:80e::2004]:8080/",
 ]
 
 PUBLIC = PUBLIC_HOSTS + PUBLIC_HOSTS_IDN + PUBLIC_IPS + WITH_CREDENTIALS
 
 PRIVATE_IPS = [
-    'http://10.1.1.1',
-    'http://10.1.1.1:8080',
-    'http://10.1.1.1:8080/index.html',
-    'http://10.1.1.254',
-    'http://10.1.1.254:8080',
-    'http://10.1.1.254:8080/index.html',
-    'http://[fc00::1]',
-    'http://[fc00::1]:8080',
-    'http://[fc00::1]:8080/index.html',
+    "http://10.1.1.1",
+    "http://10.1.1.1:8080",
+    "http://10.1.1.1:8080/index.html",
+    "http://10.1.1.254",
+    "http://10.1.1.254:8080",
+    "http://10.1.1.254:8080/index.html",
+    "http://[fc00::1]",
+    "http://[fc00::1]:8080",
+    "http://[fc00::1]:8080/index.html",
 ]
 
 PRIVATE = PRIVATE_IPS
 
 LOCAL_HOSTS = [
-    'http://localhost',
-    'http://localhost:8080',
-    'http://localhost:8080/index.html',
-    'http://localhost.localdomain',
-    'http://localhost.localdomain:8080',
-    'http://localhost.localdomain:8080/index.html',
+    "http://localhost",
+    "http://localhost:8080",
+    "http://localhost:8080/index.html",
+    "http://localhost.localdomain",
+    "http://localhost.localdomain:8080",
+    "http://localhost.localdomain:8080/index.html",
 ]
 
 LOCAL_IPS = [
-    'http://127.0.0.1',
-    'http://127.0.0.1:8080',
-    'http://127.0.0.1:8080/index.html',
-    'http://127.0.1.1',
-    'http://127.0.1.1:8080',
-    'http://127.0.1.1:8080/index.html',
-    'http://[::1]',
-    'http://[::1]:8080',
-    'http://[::1]:8080/index.html',
+    "http://127.0.0.1",
+    "http://127.0.0.1:8080",
+    "http://127.0.0.1:8080/index.html",
+    "http://127.0.1.1",
+    "http://127.0.1.1:8080",
+    "http://127.0.1.1:8080/index.html",
+    "http://[::1]",
+    "http://[::1]:8080",
+    "http://[::1]:8080/index.html",
 ]
 
 LOCAL = LOCAL_HOSTS + LOCAL_IPS
 
 MULTICAST = [
-    'http://224.1.1.1',
-    'http://224.1.1.1:8080',
-    'http://224.1.1.1:8080/index.html',
-    'http://[ff00::1]',
-    'http://[ff00::1]:8080',
-    'http://[ff00::1]:8080/index.html',
+    "http://224.1.1.1",
+    "http://224.1.1.1:8080",
+    "http://224.1.1.1:8080/index.html",
+    "http://[ff00::1]",
+    "http://[ff00::1]:8080",
+    "http://[ff00::1]:8080/index.html",
 ]
 
 INVALID = [
-    'http://',
-    'h/://.',
-    'http://..',
-    'http://../',
-    'http://?',
-    'http://??',
-    'http://??/',
-    'http://#',
-    'http://##',
-    'http://##/',
-    'http://foo.bar?q=Spaces should be encoded',
-    'http://foo.bar?q=Spaces should be encoded with unicode é',
-    '//',
-    '//a',
-    '///a',
-    '///',
-    'http:///a',
-    'foo.com',
-    'rdar://1234',
-    'h://test',
-    'http:// shouldfail.com',
-    ':// should fail',
-    'http://foo.bar/foo(bar)baz quux',
-    'http://-error-.invalid/',
-    'http://_error_.invalid/',
-    'http://a.b--c.de/',
-    'http://-a.b.co',
-    'http://a.b-.co',
-    'http://0.0.0.0',
-    'http://10.1.1.0',
-    'http://10.1.1.255',
-    'http://1.1.1.1.1',
-    'http://123.123.123',
-    'http://3628126748',
-    'http://.www.foo.bar/',
-    'http://www.foo.bar./',
-    'http://.www.foo.bar./',
-    'http://[fffff:1450:4007:80e::2004]',
-    'http://[fffff:1450:4007:80e::2004]:8080',
-    'http://[fffff:1450:4007:80e::2004]:8080/index.html',
-    'http://[::]',
-    'http://[::]:8080',
-    'http://[::]:8080/index.html',
+    "http://",
+    "h/://.",
+    "http://..",
+    "http://../",
+    "http://?",
+    "http://??",
+    "http://??/",
+    "http://#",
+    "http://##",
+    "http://##/",
+    "http://foo.bar?q=Spaces should be encoded",
+    "http://foo.bar?q=Spaces should be encoded with unicode é",
+    "//",
+    "//a",
+    "///a",
+    "///",
+    "http:///a",
+    "foo.com",
+    "rdar://1234",
+    "h://test",
+    "http:// shouldfail.com",
+    ":// should fail",
+    "http://foo.bar/foo(bar)baz quux",
+    "http://-error-.invalid/",
+    "http://_error_.invalid/",
+    "http://a.b--c.de/",
+    "http://-a.b.co",
+    "http://a.b-.co",
+    "http://0.0.0.0",
+    "http://10.1.1.0",
+    "http://10.1.1.255",
+    "http://1.1.1.1.1",
+    "http://123.123.123",
+    "http://3628126748",
+    "http://.www.foo.bar/",
+    "http://www.foo.bar./",
+    "http://.www.foo.bar./",
+    "http://[fffff:1450:4007:80e::2004]",
+    "http://[fffff:1450:4007:80e::2004]:8080",
+    "http://[fffff:1450:4007:80e::2004]:8080/index.html",
+    "http://[::]",
+    "http://[::]:8080",
+    "http://[::]:8080/index.html",
 ]
 
 DEFAULT_SCHEMES = Defaults.URLS_ALLOWED_SCHEMES
 # Custom schemes not in uris.SCHEMES
-CUSTOM_SCHEMES = ['irc', 'unknown']
+CUSTOM_SCHEMES = ["irc", "unknown"]
 
 # Extract some default TLDs
 DEFAULT_TLDS = list(Defaults.URLS_ALLOWED_TLDS)[:2]
 # Custom TLDs not in IANA official list
-CUSTOM_TLDS = ['i2', 'unknown']
+CUSTOM_TLDS = ["i2", "unknown"]
 
 
 def test_validate_strip_url():
-    assert uris.validate('  http://somewhere.com  ') == 'http://somewhere.com'
+    assert uris.validate("  http://somewhere.com  ") == "http://somewhere.com"
 
 
-@pytest.mark.parametrize('url', PUBLIC_HOSTS)
+@pytest.mark.parametrize("url", PUBLIC_HOSTS)
 def test_default_should_validate_public_urls(url):
     assert uris.validate(url) == url
 
 
-@pytest.mark.parametrize('url', PUBLIC_HOSTS_IDN)
+@pytest.mark.parametrize("url", PUBLIC_HOSTS_IDN)
 def test_default_should_validate_public_urls_with_utf8_tld(url):
     assert uris.validate(url) == url
 
 
-@pytest.mark.parametrize('url', PUBLIC_IPS)
+@pytest.mark.parametrize("url", PUBLIC_IPS)
 def test_default_should_validate_public_ips(url):
     assert uris.validate(url) == url
 
 
-@pytest.mark.parametrize('scheme', DEFAULT_SCHEMES)
+@pytest.mark.parametrize("scheme", DEFAULT_SCHEMES)
 def test_default_should_validate_default_schemes(scheme):
-    url = '{0}://somewhere.com'.format(scheme)
+    url = "{0}://somewhere.com".format(scheme)
     assert uris.validate(url) == url
 
 
-@pytest.mark.parametrize('scheme', CUSTOM_SCHEMES)
+@pytest.mark.parametrize("scheme", CUSTOM_SCHEMES)
 def test_default_should_not_validate_non_default_schemes(scheme):
-    url = '{0}://somewhere.com'.format(scheme)
-    with pytest.raises(uris.ValidationError, match='Invalid scheme'):
+    url = "{0}://somewhere.com".format(scheme)
+    with pytest.raises(uris.ValidationError, match="Invalid scheme"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('tld', CUSTOM_TLDS)
+@pytest.mark.parametrize("tld", CUSTOM_TLDS)
 def test_default_should_not_validate_unknown_tlds(tld):
-    url = 'http://somewhere.{0}'.format(tld)
-    with pytest.raises(uris.ValidationError, match='Invalid TLD'):
+    url = "http://somewhere.{0}".format(tld)
+    with pytest.raises(uris.ValidationError, match="Invalid TLD"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('url', PRIVATE)
+@pytest.mark.parametrize("url", PRIVATE)
 def test_default_should_not_validate_private_urls(url):
-    with pytest.raises(uris.ValidationError, match='private URL'):
+    with pytest.raises(uris.ValidationError, match="private URL"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('url', LOCAL_HOSTS)
+@pytest.mark.parametrize("url", LOCAL_HOSTS)
 def test_default_should_not_validate_local_hosts(url):
-    with pytest.raises(uris.ValidationError, match='local URL'):
+    with pytest.raises(uris.ValidationError, match="local URL"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('url', INVALID)
+@pytest.mark.parametrize("url", INVALID)
 def test_should_not_validate_bad_urls(url):
-    with pytest.raises(uris.ValidationError, match='Invalid URL'):
+    with pytest.raises(uris.ValidationError, match="Invalid URL"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('url', MULTICAST)
+@pytest.mark.parametrize("url", MULTICAST)
 def test_should_not_validate_multicast_urls(url):
-    with pytest.raises(uris.ValidationError, match='multicast IP'):
+    with pytest.raises(uris.ValidationError, match="multicast IP"):
         uris.validate(url)
 
 
-@pytest.mark.parametrize('url', PUBLIC + PRIVATE)
+@pytest.mark.parametrize("url", PUBLIC + PRIVATE)
 def test_private_should_validate_public_and_private_urls(url):
     assert uris.validate(url, private=True) == url
 
 
-@pytest.mark.parametrize('url', LOCAL)
+@pytest.mark.parametrize("url", LOCAL)
 def test_private_should_not_validate_local_urls(url):
-    with pytest.raises(uris.ValidationError, match='local URL'):
+    with pytest.raises(uris.ValidationError, match="local URL"):
         uris.validate(url, private=True)
 
 
-@pytest.mark.parametrize('url', PUBLIC + LOCAL)
+@pytest.mark.parametrize("url", PUBLIC + LOCAL)
 def test_local_should_validate_public_and_local_urls(url):
     assert uris.validate(url, local=True) == url
 
 
-@pytest.mark.parametrize('url', PRIVATE)
+@pytest.mark.parametrize("url", PRIVATE)
 def test_local_should_not_validate_private_urls(url):
-    with pytest.raises(uris.ValidationError, match='private URL'):
+    with pytest.raises(uris.ValidationError, match="private URL"):
         uris.validate(url, local=True)
 
 
-@pytest.mark.parametrize('url', PUBLIC + LOCAL + PRIVATE)
+@pytest.mark.parametrize("url", PUBLIC + LOCAL + PRIVATE)
 def test_private_local_should_validate_any_valid_urls(url):
     assert uris.validate(url, local=True, private=True) == url
 
 
-@pytest.mark.parametrize('scheme', CUSTOM_SCHEMES)
+@pytest.mark.parametrize("scheme", CUSTOM_SCHEMES)
 def test_custom_schemes(scheme):
-    url = '{0}://somewhere.com'.format(scheme)
+    url = "{0}://somewhere.com".format(scheme)
     assert uris.validate(url, schemes=CUSTOM_SCHEMES) == url
 
 
-@pytest.mark.parametrize('scheme', DEFAULT_SCHEMES)
+@pytest.mark.parametrize("scheme", DEFAULT_SCHEMES)
 def test_custom_schemes_should_not_validate_defaults(scheme):
-    url = '{0}://somewhere.com'.format(scheme)
-    with pytest.raises(uris.ValidationError, match='Invalid scheme'):
+    url = "{0}://somewhere.com".format(scheme)
+    with pytest.raises(uris.ValidationError, match="Invalid scheme"):
         uris.validate(url, schemes=CUSTOM_SCHEMES)
 
 
-@pytest.mark.parametrize('tld', CUSTOM_TLDS)
+@pytest.mark.parametrize("tld", CUSTOM_TLDS)
 def test_custom_tlds(tld):
-    url = 'http://somewhere.{0}'.format(tld)
+    url = "http://somewhere.{0}".format(tld)
     assert uris.validate(url, tlds=CUSTOM_TLDS) == url
 
 
-@pytest.mark.parametrize('tld', DEFAULT_TLDS)
+@pytest.mark.parametrize("tld", DEFAULT_TLDS)
 def test_custom_tlds_should_not_validate_defaults(tld):
-    url = 'http://somewhere.{0}'.format(tld)
-    with pytest.raises(uris.ValidationError, match='Invalid '):
+    url = "http://somewhere.{0}".format(tld)
+    with pytest.raises(uris.ValidationError, match="Invalid "):
         uris.validate(url, tlds=CUSTOM_TLDS)
 
 
-@pytest.mark.parametrize('url', WITH_CREDENTIALS)
+@pytest.mark.parametrize("url", WITH_CREDENTIALS)
 def test_with_credentials(url):
     assert uris.validate(url) == url
 
 
-@pytest.mark.parametrize('url', WITH_CREDENTIALS)
+@pytest.mark.parametrize("url", WITH_CREDENTIALS)
 def test_with_credentials_disabled(url):
-    with pytest.raises(uris.ValidationError, match='Credentials in URL are not allowed'):
+    with pytest.raises(uris.ValidationError, match="Credentials in URL are not allowed"):
         uris.validate(url, credentials=False)