Update test suite

Author: AndrewEckart

servicex/servicex_adaptor.py

@@ -20,15 +20,6 @@
 servicex_status_poll_time = 5.0
 
 
-def servicex_adaptor_factory(c: ConfigView):
-    # It is an error if this is not specified somewhere.
-    endpoint = c['api_endpoint']['endpoint'].as_str_expanded()
-
-    # We can default these to "None"
-    refresh_token = c['api_endpoint']['token'].get(str) if 'token' in c['api_endpoint'] else None
-    return ServiceXAdaptor(endpoint, refresh_token)
-
-
 # Low level routines for interacting with a ServiceX instance via the WebAPI
 class ServiceXAdaptor:
     def __init__(self, endpoint, refresh_token=None):
@@ -42,21 +33,21 @@ def __init__(self, endpoint, refresh_token=None):
     async def _get_token(self, client: aiohttp.ClientSession):
         url = f'{self._endpoint}/token/refresh'
         headers = {'Authorization': f'Bearer {self._refresh_token}'}
-        async with client.post(url, headers=headers) as response:
+        async with client.post(url, headers=headers, json=None) as response:
             status = response.status
             if status == 200:
                 j = await response.json()
                 self._token = j['access_token']
             else:
-                raise ServiceXException(f'ServiceX login request rejected: {status}')
+                raise ServiceXException(f'ServiceX access token request rejected: {status}')
 
     async def _get_authorization(self, client: aiohttp.ClientSession):
+        if not self._refresh_token:
+            return {}
         now = datetime.utcnow().timestamp()
         if not self._token or jwt.decode(self._token, verify=False)['exp'] - now < 0:
             await self._get_token(client)
-        return {
-            'Authorization': f'Bearer {self._token}'
-        }
+        return {'Authorization': f'Bearer {self._token}'}
 
     async def submit_query(self, client: aiohttp.ClientSession,
                            json_query: Dict[str, str]) -> Dict[str, str]:
@@ -269,12 +260,10 @@ def servicex_adaptor_factory(c: ConfigView, backend_type: str) -> ServiceXAdapto
     for ep in endpoints:
         if ep['type'].as_str_expanded() == backend_type:
             endpoint = ep['endpoint'].as_str_expanded()
-            email = ep['email'].as_str_expanded() if 'email' in ep else None
-            password = ep['password'].as_str_expanded() if 'password' in ep \
-                else None
+            token = ep['token'].as_str_expanded() if 'token' in ep else None
 
             # We can default these to "None"
-            return ServiceXAdaptor(endpoint, email, password)
+            return ServiceXAdaptor(endpoint, refresh_token=token)
         else:
             seen_types.append(ep['type'].as_str_expanded())
 

tests/test_servicex_adaptor.py

@@ -85,12 +85,10 @@ def good_submit(mocker):
 
 
 @pytest.fixture
-def good_submit_with_login(mocker):
+def good_submit_with_auth(mocker):
     client = mocker.MagicMock()
     r = ClientSessionMocker([
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo",
-               'refresh_token': "jwt:bar"}),
+        dumps({'access_token': "jwt:access"}),
         dumps({'request_id': "111-222-333-444"})], [200, 200])
     client.post = mocker.MagicMock(return_value=r)
     return client
@@ -154,10 +152,9 @@ def servicex_status_unknown(mocker):
 
 
 @pytest.mark.asyncio
-async def test_status_no_login(servicex_status_request):
-
+async def test_status_no_auth(servicex_status_request):
     servicex_status_request(None, 0, 10)
-    sa = ServiceXAdaptor('http://localhost:500/sx')
+    sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx')
     async with aiohttp.ClientSession() as client:
         r = await sa.get_transform_status(client, '123-123-123-444')
         assert len(r) == 3
@@ -178,35 +175,32 @@ async def test_status_fatal_status(servicex_status_fatal):
 
 
 @pytest.mark.asyncio
-async def test_status_with_login(mocker):
+async def test_status_with_auth(mocker):
     client = mocker.MagicMock()
     client.post = mocker.Mock(return_value=ClientSessionMocker([
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo",
-               'refresh_token': "jwt:bar"})], [200]))
+        dumps({'access_token': "jwt:access"})], [200]))
 
     client.get = mocker.Mock(return_value=ClientSessionMocker([
         dumps({'files-remaining': 1,
                'files-skipped': 0,
                'files-processed': 0})], [200]))
 
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx',
-                         email="test@example.com",
-                         password="foobar")
+                         refresh_token='jwt:refresh')
 
     await sa.get_transform_status(client, '123-123-123-444')
-    client.post.assert_called_with("http://localhost:5000/sx/login",
-                                   json={'password': 'foobar', 'email': 'test@example.com'})
-
+    client.post.assert_called_with(
+        "http://localhost:5000/sx/token/refresh", json=None,
+        headers={'Authorization': 'Bearer jwt:refresh'})
     client.get.assert_called_with(
         "http://localhost:5000/sx/servicex/transformation/123-123-123-444/status",
-        headers={'Authorization': 'Bearer jwt:foo'})
+        headers={'Authorization': 'Bearer jwt:access'})
 
 
 @pytest.mark.asyncio
 async def test_status_unknown_request(servicex_status_unknown):
 
-    sa = ServiceXAdaptor('http://localhost:500/sx')
+    sa = ServiceXAdaptor('http://localhost:5000/sx')
     with pytest.raises(ServiceXUnknownRequestID) as e:
         async with aiohttp.ClientSession() as client:
             await sa.get_transform_status(client, '123-123-123-444')
@@ -281,7 +275,7 @@ async def test_watch_fail_start(short_status_poll_time, mocker):
 
 
 @pytest.mark.asyncio
-async def test_submit_good_no_login(good_submit):
+async def test_submit_good_no_auth(good_submit):
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx')
 
     rid = await sa.submit_query(good_submit, {'hi': 'there'})
@@ -306,17 +300,14 @@ async def test_submit_good_no_login(good_submit):
 
 
 @pytest.mark.asyncio
-async def test_submit_good_with_login(mocker):
+async def test_submit_good_with_auth(mocker):
     client = mocker.MagicMock()
     client.post = mocker.Mock(return_value=ClientSessionMocker([
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo",
-               'refresh_token': "jwt:bar"}),
+        dumps({'access_token': "jwt:access"}),
         dumps({'request_id': "111-222-333-444"})], [200, 200]))
 
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx',
-                         email="test@example.com",
-                         password="foobar")
+                         refresh_token='jwt:refresh')
 
     await sa.submit_query(client, {'hi': 'there'})
     r = client.post.mock_calls
@@ -325,29 +316,25 @@ async def test_submit_good_with_login(mocker):
 
     # Verify the login POST
     _, args, kwargs = r[0]
-    assert args[0] == 'http://localhost:5000/sx/login'
-    assert kwargs['json']['email'] == 'test@example.com'
-    assert kwargs['json']['password'] == 'foobar'
+    assert args[0] == 'http://localhost:5000/sx/token/refresh'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:refresh'
 
     # Verify the Submit POST
     _, args, kwargs = r[1]
     assert args[0] == 'http://localhost:5000/sx/servicex/transformation'
-    assert kwargs['headers']['Authorization'] == 'Bearer jwt:foo'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:access'
 
 
 @pytest.mark.asyncio
-async def test_submit_good_with_login_existing_token(mocker):
+async def test_submit_good_with_auth_existing_token(mocker):
     client = mocker.MagicMock()
     client.post = mocker.Mock(return_value=ClientSessionMocker([
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo",
-               'refresh_token': "jwt:bar"}),
+        dumps({'access_token': "jwt:access"}),
         dumps({'request_id': "111-222-333-444"}),
         dumps({'request_id': "222-333-444-555"})], [200, 200, 200]))
 
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx',
-                         email="test@example.com",
-                         password="foobar")
+                         refresh_token='jwt:refresh')
 
     mocker.patch('google.auth.jwt.decode', return_value={'exp': float('inf')})  # Never expires
     rid1 = await sa.submit_query(client, {'hi': 'there'})
@@ -360,39 +347,33 @@ async def test_submit_good_with_login_existing_token(mocker):
 
     assert len(r) == 3
 
-    # Verify the login POST
+    # Verify the access token POST
     _, args, kwargs = r[0]
-    assert args[0] == 'http://localhost:5000/sx/login'
-    assert kwargs['json']['email'] == 'test@example.com'
-    assert kwargs['json']['password'] == 'foobar'
+    assert args[0] == 'http://localhost:5000/sx/token/refresh'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:refresh'
 
     # Verify the Submit POST
     _, args, kwargs = r[1]
     assert args[0] == 'http://localhost:5000/sx/servicex/transformation'
-    assert kwargs['headers']['Authorization'] == 'Bearer jwt:foo'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:access'
 
     # Verify the second Submit POST
     _, args, kwargs = r[2]
     assert args[0] == 'http://localhost:5000/sx/servicex/transformation'
-    assert kwargs['headers']['Authorization'] == 'Bearer jwt:foo'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:access'
 
 
 @pytest.mark.asyncio
-async def test_submit_good_with_login_expired_token(mocker):
+async def test_submit_good_with_auth_expired_token(mocker):
     client = mocker.MagicMock()
     client.post = mocker.Mock(return_value=ClientSessionMocker([
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo",
-               'refresh_token': "jwt:bar"}),
+        dumps({'access_token': "jwt:access"}),
         dumps({'request_id': "111-222-333-444"}),
-        dumps({'message': "Login Successful",
-               'access_token': "jwt:foo2",
-               'refresh_token': "jwt:bar2"}),
+        dumps({'access_token': "jwt:access2"}),
         dumps({'request_id': "222-333-444-555"})], [200, 200, 200, 200]))
 
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx',
-                         email="test@example.com",
-                         password="foobar")
+                         refresh_token='jwt:refresh')
 
     mocker.patch('google.auth.jwt.decode', return_value={'exp': 0})  # Always expired
 
@@ -408,25 +389,23 @@ async def test_submit_good_with_login_expired_token(mocker):
 
     # Verify the login POST
     _, args, kwargs = r[0]
-    assert args[0] == 'http://localhost:5000/sx/login'
-    assert kwargs['json']['email'] == 'test@example.com'
-    assert kwargs['json']['password'] == 'foobar'
+    assert args[0] == 'http://localhost:5000/sx/token/refresh'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:refresh'
 
     # Verify the Submit POST
     _, args, kwargs = r[1]
     assert args[0] == 'http://localhost:5000/sx/servicex/transformation'
-    assert kwargs['headers']['Authorization'] == 'Bearer jwt:foo'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:access'
 
     # Verify the second login POST
     _, args, kwargs = r[2]
-    assert args[0] == 'http://localhost:5000/sx/login'
-    assert kwargs['json']['email'] == 'test@example.com'
-    assert kwargs['json']['password'] == 'foobar'
+    assert args[0] == 'http://localhost:5000/sx/token/refresh'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:refresh'
 
     # Verify the second Submit POST
     _, args, kwargs = r[3]
     assert args[0] == 'http://localhost:5000/sx/servicex/transformation'
-    assert kwargs['headers']['Authorization'] == 'Bearer jwt:foo2'
+    assert kwargs['headers']['Authorization'] == 'Bearer jwt:access2'
 
 
 @pytest.mark.asyncio
@@ -450,19 +429,18 @@ async def test_submit_bad_html(bad_submit_html):
 
 
 @pytest.mark.asyncio
-async def test_submit_good_with_bad_login(mocker):
+async def test_submit_good_with_bad_token(mocker):
     client = mocker.MagicMock()
     client.post = mocker.Mock(return_value=ClientSessionMocker(
         dumps({'message': 'Wrong credentials'}), 401))
 
     sa = ServiceXAdaptor(endpoint='http://localhost:5000/sx',
-                         email="test@example.com",
-                         password="XXXXX")
+                         refresh_token="XXXXX")
 
     with pytest.raises(ServiceXException) as e:
         await sa.submit_query(client, {'hi': 'there'})
 
-    assert "ServiceX login request rejected" in str(e.value)
+    assert "ServiceX access token request rejected" in str(e.value)
 
 
 @pytest.mark.asyncio
@@ -505,15 +483,12 @@ def test_servicex_adaptor_settings():
         {
             'type': 'my-type',
             'endpoint': 'http://my-left-foot.com:5000',
-            'email': 'thegoodplace@example.com',
-            'password': 'forkingshirtballs',
+            'token': 'forkingshirtballs.thegoodplace.bortles'
         }
     ]
-
     sx = servicex_adaptor_factory(c, 'my-type')
     assert sx._endpoint == 'http://my-left-foot.com:5000'
-    assert sx._email == 'thegoodplace@example.com'
-    assert sx._password == 'forkingshirtballs'
+    assert sx._refresh_token == 'forkingshirtballs.thegoodplace.bortles'
 
 
 def test_servicex_adaptor_settings_wrong_type():
@@ -524,8 +499,7 @@ def test_servicex_adaptor_settings_wrong_type():
         {
             'type': 'my-type',
             'endpoint': 'http://my-left-foot.com:5000',
-            'email': 'thegoodplace@example.com',
-            'password': 'forkingshirtballs',
+            'token': 'forkingshirtballs.thegoodplace.bortles'
         }
     ]
 
@@ -544,21 +518,18 @@ def test_servicex_adaptor_settings_env():
         {
             'type': '${SXTYPE}',
             'endpoint': '${ENDPOINT}:5000',
-            'email': '${SXUSER}',
-            'password': '${SXPASS}',
+            'token': '${SXTOKEN}',
         }
     ]
 
     from os import environ
     environ['ENDPOINT'] = 'http://tachi.com'
-    environ['SXUSER'] = 'Holden'
-    environ['SXPASS'] = 'protomolecule'
+    environ['SXTOKEN'] = 'protomolecule'
     environ['SXTYPE'] = 'mcrn'
 
     sx = servicex_adaptor_factory(c, 'mcrn')
     assert sx._endpoint == 'http://tachi.com:5000'
-    assert sx._email == 'Holden'
-    assert sx._password == 'protomolecule'
+    assert sx._refresh_token == 'protomolecule'
 
 
 @pytest.mark.asyncio

tests/test_utils.py

@@ -1,5 +1,4 @@
 from datetime import timedelta
-import os
 import tempfile
 from typing import Optional
 import aiohttp