pyupgrade: run pyupgrade --py36-plus and black on jupyterhub/tests

jupyterhub/tests/conftest.py

@@ -205,7 +205,7 @@ def new_username(prefix='testuser'):
     """Return a new unique username"""
     global _username_counter
     _username_counter += 1
-    return '{}-{}'.format(prefix, _username_counter)
+    return f'{prefix}-{_username_counter}'
 
 
 @fixture
@@ -241,7 +241,7 @@ def new_group_name(prefix='testgroup'):
     """Return a new unique group name"""
     global _groupname_counter
     _groupname_counter += 1
-    return '{}-{}'.format(prefix, _groupname_counter)
+    return f'{prefix}-{_groupname_counter}'
 
 
 @fixture

jupyterhub/tests/mocking.py

@@ -217,9 +217,7 @@ class MockPAMAuthenticator(PAMAuthenticator):
             close_session=mock_open_session,
             check_account=mock_check_account,
         ):
-            username = await super(MockPAMAuthenticator, self).authenticate(
+            username = await super().authenticate(*args, **kwargs)
-                *args, **kwargs
-            )
         if username is None:
             return
         elif self.auth_state:

jupyterhub/tests/test_api.py

@@ -323,9 +323,12 @@ async def test_get_users_state_filter(app, state):
     # has_zero: no Spawners registered at all
     has_zero = add_user(db, app=app, name='has_zero')
 
-    test_usernames = set(
+    test_usernames = {
-        ("has_one_active", "has_two_active", "has_two_inactive", "has_zero")
+        "has_one_active",
-    )
+        "has_two_active",
+        "has_two_inactive",
+        "has_zero",
+    }
 
     user_states = {
         "inactive": ["has_two_inactive", "has_zero"],
@@ -361,7 +364,7 @@ async def test_get_users_state_filter(app, state):
     add_spawner(has_one_active, active=True, ready=False)
     add_spawner(has_one_active, "inactive", active=False)
 
-    r = await api_request(app, 'users?state={}'.format(state))
+    r = await api_request(app, f'users?state={state}')
     if state == "invalid":
         assert r.status_code == 400
         return
@@ -989,7 +992,7 @@ async def test_progress(request, app, no_patience, slow_spawn):
     url = app_user.url
     assert evt == {
         'progress': 100,
-        'message': 'Server ready at {}'.format(url),
+        'message': f'Server ready at {url}',
         'html_message': 'Server ready at <a href="{0}">{0}</a>'.format(url),
         'url': url,
         'ready': True,
@@ -1682,7 +1685,7 @@ async def test_group_add_delete_users(app):
         assert [g.name for g in user.groups] == ['alphaflight']
 
     group = orm.Group.find(db, name='alphaflight')
-    assert sorted([u.name for u in group.users]) == sorted(names)
+    assert sorted(u.name for u in group.users) == sorted(names)
 
     r = await api_request(
         app,
@@ -1698,7 +1701,7 @@ async def test_group_add_delete_users(app):
         assert [g.name for g in user.groups] == ['alphaflight']
 
     group = orm.Group.find(db, name='alphaflight')
-    assert sorted([u.name for u in group.users]) == sorted(names[2:])
+    assert sorted(u.name for u in group.users) == sorted(names[2:])
 
 
 # -----------------
@@ -1812,8 +1815,8 @@ async def test_update_activity_403(app, user, admin_user):
     token = user.new_api_token()
     r = await api_request(
         app,
-        "users/{}/activity".format(admin_user.name),
+        f"users/{admin_user.name}/activity",
-        headers={"Authorization": "token {}".format(token)},
+        headers={"Authorization": f"token {token}"},
         data="{}",
         method="post",
     )
@@ -1824,8 +1827,8 @@ async def test_update_activity_admin(app, user, admin_user):
     token = admin_user.new_api_token(roles=['admin'])
     r = await api_request(
         app,
-        "users/{}/activity".format(user.name),
+        f"users/{user.name}/activity",
-        headers={"Authorization": "token {}".format(token)},
+        headers={"Authorization": f"token {token}"},
         data=json.dumps({"last_activity": utcnow().isoformat()}),
         method="post",
     )
@@ -1861,8 +1864,8 @@ async def test_update_server_activity(app, user, server_name, fresh):
 
     r = await api_request(
         app,
-        "users/{}/activity".format(user.name),
+        f"users/{user.name}/activity",
-        headers={"Authorization": "token {}".format(token)},
+        headers={"Authorization": f"token {token}"},
         data=json.dumps(
             {"servers": {server_name: {"last_activity": activity.isoformat()}}}
         ),

jupyterhub/tests/test_app.py

@@ -252,10 +252,10 @@ async def test_load_groups(tmpdir, request):
     db = hub.db
     blue = orm.Group.find(db, name='blue')
     assert blue is not None
-    assert sorted([u.name for u in blue.users]) == sorted(to_load['blue'])
+    assert sorted(u.name for u in blue.users) == sorted(to_load['blue'])
     gold = orm.Group.find(db, name='gold')
     assert gold is not None
-    assert sorted([u.name for u in gold.users]) == sorted(to_load['gold'])
+    assert sorted(u.name for u in gold.users) == sorted(to_load['gold'])
 
 
 async def test_resume_spawners(tmpdir, request):

jupyterhub/tests/test_auth_expiry.py

@@ -127,7 +127,7 @@ async def test_refresh_pre_spawn(app, user, refresh_pre_spawn):
 
     # auth is fresh, but should be forced to refresh by spawn
     r = await api_request(
-        app, 'users/{}/server'.format(user.name), method='post', name=user.name
+        app, f'users/{user.name}/server', method='post', name=user.name
     )
     assert 200 <= r.status_code < 300
     assert user._auth_refreshed > before
@@ -141,7 +141,7 @@ async def test_refresh_pre_spawn_expired(app, user, refresh_pre_spawn, disable_r
 
     # auth is fresh, doesn't trigger expiry
     r = await api_request(
-        app, 'users/{}/server'.format(user.name), method='post', name=user.name
+        app, f'users/{user.name}/server', method='post', name=user.name
     )
     assert r.status_code == 403
     assert user._auth_refreshed == before

jupyterhub/tests/test_named_servers.py

@@ -108,7 +108,7 @@ async def test_create_named_server(app, named_servers):
     env = r.json()
     prefix = env.get('JUPYTERHUB_SERVICE_PREFIX')
     assert prefix == user.spawners[servername].server.base_url
-    assert prefix.endswith('/user/%s/%s/' % (username, servername))
+    assert prefix.endswith(f'/user/{username}/{servername}/')
 
     r = await api_request(app, 'users', username)
     r.raise_for_status()
@@ -254,11 +254,9 @@ async def test_named_server_spawn_form(app, username, named_servers):
     cookies = await app.login_user(username)
     user = app.users[username]
     with mock.patch.dict(app.users.settings, {'spawner_class': FormSpawner}):
-        r = await get_page(
+        r = await get_page(f'spawn/{username}/{server_name}', app, cookies=cookies)
-            'spawn/%s/%s' % (username, server_name), app, cookies=cookies
-        )
         r.raise_for_status()
-        assert r.url.endswith('/spawn/%s/%s' % (username, server_name))
+        assert r.url.endswith(f'/spawn/{username}/{server_name}')
         assert FormSpawner.options_form in r.text
 
         # submit the form
@@ -314,7 +312,7 @@ async def test_user_redirect_default_server_name(
         r = await async_requests.get(r.url, cookies=cookies)
         path = urlparse(r.url).path
     assert path == url_path_join(
-        app.base_url, '/user/{}/{}/notebooks/test.ipynb'.format(name, server_name)
+        app.base_url, f'/user/{name}/{server_name}/notebooks/test.ipynb'
     )
 
 

jupyterhub/tests/test_objects.py

@@ -48,8 +48,8 @@ _hostname = socket.gethostname()
             {
                 'ip': '',
                 'port': 123,
-                'host': 'http://{}:123'.format(_hostname),
+                'host': f'http://{_hostname}:123',
-                'url': 'http://{}:123/x/'.format(_hostname),
+                'url': f'http://{_hostname}:123/x/',
                 'bind_url': 'http://*:123/x/',
             },
         ),

jupyterhub/tests/test_pages.py

@@ -218,7 +218,7 @@ async def test_spawn_admin_access(app, admin_access):
         r.raise_for_status()
 
     assert (r.url.split('?')[0] + '/').startswith(public_url(app, user))
-    r = await get_page('user/{}/env'.format(name), app, hub=False, cookies=cookies)
+    r = await get_page(f'user/{name}/env', app, hub=False, cookies=cookies)
 
     r.raise_for_status()
     env = r.json()
@@ -255,7 +255,7 @@ async def test_spawn_page_admin(app, admin_access):
         r = await get_page('spawn/' + u.name, app, cookies=cookies)
         assert r.url.endswith('/spawn/' + u.name)
         assert FormSpawner.options_form in r.text
-        assert "Spawning server for {}".format(u.name) in r.text
+        assert f"Spawning server for {u.name}" in r.text
 
 
 async def test_spawn_with_query_arguments(app):

jupyterhub/tests/test_proxy.py

@@ -101,7 +101,7 @@ async def test_external_proxy(request):
     print(app.base_url, user_path)
     host = ''
     if app.subdomain_host:
-        host = '%s.%s' % (name, urlparse(app.subdomain_host).hostname)
+        host = f'{name}.{urlparse(app.subdomain_host).hostname}'
     user_spec = host + user_path
     assert sorted(routes.keys()) == [app.hub.routespec, user_spec]
 
@@ -148,7 +148,7 @@ async def test_external_proxy(request):
     await wait_for_proxy()
 
     # tell the hub where the new proxy is
-    new_api_url = 'http://{}:{}'.format(proxy_ip, proxy_port)
+    new_api_url = f'http://{proxy_ip}:{proxy_port}'
     r = await api_request(
         app,
         'proxy',

jupyterhub/tests/test_roles.py

@@ -879,7 +879,7 @@ async def test_server_role_api_calls(
         username = 'otheruser'
 
     if api_endpoint == 'activity':
-        path = "users/{}/activity".format(username)
+        path = f"users/{username}/activity"
         data = json.dumps({"servers": {"": {"last_activity": utcnow().isoformat()}}})
     elif api_endpoint == 'users':
         path = "users"
@@ -888,7 +888,7 @@ async def test_server_role_api_calls(
     r = await api_request(
         app,
         path,
-        headers={"Authorization": "token {}".format(api_token)},
+        headers={"Authorization": f"token {api_token}"},
         data=data,
         method=api_method,
     )

jupyterhub/tests/test_scopes.py

@@ -32,8 +32,8 @@ def test_scope_constructor():
     user2 = 'michael'
     scope_list = [
         'users',
-        'read:users!user={}'.format(user1),
+        f'read:users!user={user1}',
-        'read:users!user={}'.format(user2),
+        f'read:users!user={user2}',
     ]
     parsed_scopes = parse_scopes(scope_list)
 
@@ -331,7 +331,7 @@ async def test_request_user_outside_group(app, create_user_with_scopes):
 async def test_user_filter(app, create_user_with_scopes):
     name_in_scope = {'lindsay', 'oscar', 'gob'}
     user = create_user_with_scopes(
-        *[f'list:users!user={name}' for name in name_in_scope]
+        *(f'list:users!user={name}' for name in name_in_scope)
     )
     outside_scope = {'maeby', 'marta'}
     group_name = 'bluth'
@@ -417,7 +417,7 @@ async def test_vertical_filter(app, create_user_with_scopes):
     r = await api_request(app, 'users', headers=auth_header(app.db, user.name))
     assert r.status_code == 200
     allowed_keys = {'name', 'kind', 'admin'}
-    assert set([key for user in r.json() for key in user.keys()]) == allowed_keys
+    assert {key for user in r.json() for key in user.keys()} == allowed_keys
 
 
 async def test_stacked_vertical_filter(app, create_user_with_scopes):
@@ -778,64 +778,64 @@ async def test_roles_access(app, create_service_with_scopes, create_user_with_sc
     "left, right, expected, should_warn",
     [
         (set(), set(), set(), False),
-        (set(), set(["users"]), set(), False),
+        (set(), {"users"}, set(), False),
         # no warning if users and groups only on the same side
         (
-            set(["users!user=x", "users!group=y"]),
+            {"users!user=x", "users!group=y"},
-            set([]),
+            set(),
-            set([]),
+            set(),
             False,
         ),
         # no warning if users are on both sizes
         (
-            set(["users!user=x", "users!user=y", "users!group=y"]),
+            {"users!user=x", "users!user=y", "users!group=y"},
-            set(["users!user=x"]),
+            {"users!user=x"},
-            set(["users!user=x"]),
+            {"users!user=x"},
             False,
         ),
         # no warning if users and groups are both defined
         # on both sides
         (
-            set(["users!user=x", "users!group=y"]),
+            {"users!user=x", "users!group=y"},
-            set(["users!user=x", "users!group=y", "users!user=z"]),
+            {"users!user=x", "users!group=y", "users!user=z"},
-            set(["users!user=x", "users!group=y"]),
+            {"users!user=x", "users!group=y"},
             False,
         ),
         # warn if there's a user on one side and a group on the other
         # which *may* intersect
         (
-            set(["users!group=y", "users!user=z"]),
+            {"users!group=y", "users!user=z"},
-            set(["users!user=x"]),
+            {"users!user=x"},
-            set([]),
+            set(),
             True,
         ),
         # same for group->server
         (
-            set(["users!group=y", "users!user=z"]),
+            {"users!group=y", "users!user=z"},
-            set(["users!server=x/y"]),
+            {"users!server=x/y"},
-            set([]),
+            set(),
             True,
         ),
         # this one actually shouldn't warn because server=x/y is under user=x,
         # but we don't need to overcomplicate things just for a warning
         (
-            set(["users!group=y", "users!user=x"]),
+            {"users!group=y", "users!user=x"},
-            set(["users!server=x/y"]),
+            {"users!server=x/y"},
-            set(["users!server=x/y"]),
+            {"users!server=x/y"},
             True,
         ),
         # resolves server under user, without warning
         (
-            set(["read:servers!user=abc"]),
+            {"read:servers!user=abc"},
-            set(["read:servers!server=abc/xyz"]),
+            {"read:servers!server=abc/xyz"},
-            set(["read:servers!server=abc/xyz"]),
+            {"read:servers!server=abc/xyz"},
             False,
         ),
         # user->server, no match
         (
-            set(["read:servers!user=abc"]),
+            {"read:servers!user=abc"},
-            set(["read:servers!server=abcd/xyz"]),
+            {"read:servers!server=abcd/xyz"},
-            set([]),
+            set(),
             False,
         ),
     ],
@@ -895,9 +895,9 @@ def test_intersect_expanded_scopes(left, right, expected, should_warn, recwarn):
 )
 def test_intersect_groups(request, db, left, right, expected, groups):
     if isinstance(left, str):
-        left = set([left])
+        left = {left}
     if isinstance(right, str):
-        right = set([right])
+        right = {right}
 
     # if we have a db connection, we can actually resolve
     created = []

jupyterhub/tests/test_services.py

@@ -69,7 +69,7 @@ async def test_proxy_service(app, mockservice_url):
     await app.proxy.get_all_routes()
     url = public_url(app, service) + '/foo'
     r = await async_requests.get(url, allow_redirects=False)
-    path = '/services/{}/foo'.format(name)
+    path = f'/services/{name}/foo'
     r.raise_for_status()
 
     assert r.status_code == 200