first piece of tests, fix compare sign, minor fixes

Author: Patryk Gałczyński

src/asyncopenstackclient/auth.py

@@ -7,6 +7,9 @@ class AuthModel:
     async def authenticate(self):
         raise NotImplementedError()
 
+    def verify(self):
+        return self.token_expires_at - time() < 3600
+
 
 class AuthPassword:
 
@@ -42,23 +45,25 @@ def __init__(self, auth_url, username, password, project_name, user_domain_name,
             }
         }
 
-    def verify(self):
-        return self.token_expires_at - time() < 3600
-
     async def get_token(self):
         async with aiohttp.ClientSession() as session:
             async with session.post(self.auth_url, json=self.auth_dict, headers=self.headers) as response:
                 result = await response.json()
                 return (
-                    response.headers['X-Subject-Token'], mktime(strptime(result['token']['expires_at'],
-                    "%Y-%m-%dT%H:%M:%S.000000Z")), result['token']['catalog']
+                    response.headers['X-Subject-Token'],
+                    mktime(strptime(result['token']['expires_at'], "%Y-%m-%dT%H:%M:%S.000000Z")),
+                    result['token']['catalog']
                 )
 
-    async def get_ednpoint_url(self, endpoint_name):
-        for endpoint in self.endpoints:
-            if endpoint['name'] == endpoint_name:
-                return endpoint['endpoints'][0]['url']
+    def get_endpoint_url(self, endpoint_name, prefered_interface="public"):
+        try:
+            for endpoint in self.endpoints:
+                if endpoint['name'] == endpoint_name:
+                    return [url['url'] for url in endpoint['endpoints'] if url['interface'] == prefered_interface][0]
+        except IndexError:
+            raise ValueError("could not find desired interface")
+        raise ValueError("endpoint %s not found" % endpoint_name)
 
     async def authenticate(self):
-        if self.token is None or self.token_expires_at - time() > 0:
+        if self.token is None or self.token_expires_at - time() < 0:
             self.token, self.token_expires_at, self.endpoints = await self.get_token()

src/asyncopenstackclient/client.py

@@ -1,18 +1,16 @@
-import logging
 from simple_rest_client.api import API
 from simple_rest_client.resource import AsyncResource
 
 
 class Client:
 
     def __init__(self, api_name, resources, api_version=None, session=None):
-        self.api_version = api_version or '2.26'
+        self.api_version = api_version
         self.api_name = api_name
         self.resources = resources
         self.session = session
         if self.session is None:
-            logging.error("provided session object is None, probably auth error?")
-            raise AttributeError()
+            raise AttributeError("provided session object is None, probably auth error?")
 
     async def init_api(self):
         await self.get_credentials()
@@ -26,4 +24,4 @@ async def init_api(self):
 
     async def get_credentials(self):
         await self.session.authenticate()
-        self.api_url = await self.session.get_ednpoint_url(self.api_name)
+        self.api_url = await self.session.get_endpoint_url(self.api_name)

test-requirements.txt

@@ -1 +1,2 @@
 aiounittest
+aioresponses

tests/__init__.py

@@ -0,0 +1,95 @@
+from unittest.mock import patch
+from aiounittest import AsyncTestCase, futurized
+from aioresponses import aioresponses
+from asyncopenstackclient import AuthPassword
+
+
+class TestAuth(AsyncTestCase):
+
+    def setUp(self):
+        self.auth_args = ('auth_url', 'username', 'password', 'mock_project_name',
+                          'mock_user_domain_name', 'mock_project_domain_name')
+        self.auth = AuthPassword(*self.auth_args)
+
+    def tearDown(self):
+        patch.stopall()
+
+    async def test_create_object(self):
+        self.assertTrue(self.auth.auth_url.endswith("/auth/tokens"))
+        self.assertTrue('Content-Type' in self.auth.headers)
+
+    async def test_get_token(self):
+        body = {
+            "token": {
+                "catalog": {
+                    "endpoints": [
+                        {"name": "mock_endpoint", "endpoints": [{"url": "mock_url", "interface": "public"}]}
+                    ]
+                },
+                "expires_at": "1970-01-01T01:00:00.000000Z"
+            }
+        }
+        headers = {
+            "Vary": "X-Auth-Token",
+            "x-openstack-request-id": "1234",
+            "Content-Type": "application/json",
+            "X-Subject-Token": "gAAAAABao"
+
+        }
+        with aioresponses() as req:
+            req.post('auth_url/auth/tokens', payload=body, headers=headers)
+
+            res = await self.auth.get_token()
+
+            self.assertEqual(res, (headers["X-Subject-Token"], 0, body["token"]["catalog"]))
+
+    def test_get_endpoint_url_existing_endpoint(self):
+        self.auth.endpoints = [
+            {"name": "mock_endpoint", "endpoints": [{"url": "mock_url", "interface": "public"}]}
+        ]
+
+        endpoint_url = self.auth.get_endpoint_url("mock_endpoint")
+
+        self.assertEqual(endpoint_url, "mock_url")
+
+    def test_get_endpoint_url_bad_endpoint_name(self):
+        self.auth.endpoints = [
+            {"name": "mock_endpoint", "endpoints": [{"url": "mock_url", "interface": "public"}]}
+        ]
+        with self.assertRaises(ValueError):
+            self.auth.get_endpoint_url("none_existing_endpoint")
+
+    def test_get_endpoint_url_bad_interface(self):
+        self.auth.endpoints = [
+            {"name": "mock_endpoint", "endpoints": [{"url": "mock_url", "interface": "public"}]}
+        ]
+        with self.assertRaises(ValueError):
+            self.auth.get_endpoint_url("mock_endpoint", prefered_interface="not_existing_interface")
+
+    async def test_authenticate_first_time(self):
+
+        mock_get_token_results = [
+            futurized(('mock-token1', 1000, 'whatever')),
+            futurized(('mock-token2', 1000, 'whatever')),
+        ]
+
+        # time is gonna be called 2 times becouse of Pythons lazy evaluation
+        mock_time_results = [
+            900,
+            1100
+        ]
+
+        patch('asyncopenstackclient.auth.AuthPassword.get_token', side_effect=mock_get_token_results).start()
+        patch('asyncopenstackclient.auth.time', side_effect=mock_time_results).start()
+
+        # first time token should be None and get_token shall be called
+        await self.auth.authenticate()
+        self.assertEqual(self.auth.token, 'mock-token1')
+
+        # second time, token is not None and current time is before token expiration, no change
+        await self.auth.authenticate()
+        self.assertEqual(self.auth.token, 'mock-token1')
+
+        # third time, token expires and should be renewed
+        await self.auth.authenticate()
+        self.assertEqual(self.auth.token, 'mock-token2')

tests/test_auth.py

@@ -0,0 +1,63 @@
+from unittest.mock import patch, Mock, call, ANY
+from aiounittest import AsyncTestCase, futurized
+from asyncopenstackclient import Client
+
+
+class TestClient(AsyncTestCase):
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        patch.stopall()
+
+    def test_create_object(self):
+        api_name = 'mock_api'
+        resources = 'mock_resource'
+        api_version = 'mock_api_version'
+        session = 'mock_session'
+        client = Client(api_name, resources, api_version=api_version, session=session)
+
+        self.assertEqual(client.api_name, api_name)
+        self.assertEqual(client.api_version, api_version)
+        self.assertEqual(client.resources, resources)
+        self.assertEqual(client.session, session)
+
+    def test_create_object_bad_session(self):
+        with self.assertRaises(AttributeError):
+            Client('mock_name', 'mock_version', session=None)
+
+    async def test_get_credentials(self):
+        session = Mock()
+        session.authenticate.return_value = futurized(None)
+        session.get_endpoint_url.return_value = futurized("mock_url")
+
+        client = Client("mock_name", "mock_version", session=session)
+        await client.get_credentials()
+
+        self.assertEqual(client.api_url, "mock_url")
+
+    async def test_init_api(self):
+        session = Mock()
+        session.authenticate.return_value = futurized(None)
+        session.get_endpoint_url.return_value = futurized("mock_url")
+        session.token = 'mock_token'
+        mock_api = Mock()
+
+        patch('asyncopenstackclient.client.API', new_callable=mock_api).start()
+
+        client = Client("mock_name", ['mock', 'resource', 'list'], session=session)
+        await client.init_api()
+
+        print(mock_api.mock_calls)
+        mock_api().assert_called_once_with(
+            api_root_url="mock_url",
+            headers={"X-Auth-Token": 'mock_token'},
+            json_encode_body=True
+        )
+
+        mock_api()().add_resource.assert_has_calls([
+            call(resource_name='mock', resource_class=ANY),
+            call(resource_name='resource', resource_class=ANY),
+            call(resource_name='list', resource_class=ANY),
+        ])