Merge branch 'main' into improvement/yoma_193_presentation_tests

Author: lohanspies

.coverage

@@ -1 +1,4 @@
-from aries_cloudcontroller.aries_controller import AriesAgentController
+from aries_cloudcontroller.aries_controller import AriesAgentController
+from aries_cloudcontroller.aries_controller_base import AriesAgentControllerBase
+from aries_cloudcontroller.aries_tenant_controller import AriesTenantController
+from aries_cloudcontroller.aries_webhook_server import AriesWebhookServer

aries_cloudcontroller/__init__.py

@@ -63,7 +63,10 @@ async def listen_webhooks(self):
             await self.webhook_server.listen_webhooks()
             logger.info("Webhook server started.")
         except AttributeError:
-            logger.warning("Webhook server not initialised.")
+            warning = "Webhook server not initialised."
+            logger.warning(warning)
+            raise AttributeError(warning)
         except Exception as exc:
             logger.warning(
                 f"Listening webhooks failed! {exc!r} occurred.")
+            raise Exception(f"{exc!r}")

aries_cloudcontroller/aries_controller.py

@@ -238,6 +238,7 @@ async def listen_webhooks(self):
 
     async def terminate(self):
         await self.client_session.close()
+        logger.info("Client Session closed.")
         try:
             await self.webhook_server.terminate()
         except AttributeError:

aries_cloudcontroller/aries_controller_base.py

@@ -71,16 +71,19 @@ def add_listener(self, listener):
             "topic":"topicname" key-value pairs
         """
         try:
+            assert (type(wallet_id) is str), "wallet_id must be a string"
+            assert (wallet_id.__ne__("")), "Cannot add listener for empty wallet_id."
             pub_topic_path_base = listener['topic']
             pub_topic_path = f"{self.wallet_id}.{pub_topic_path_base}"
             pub.subscribe(listener["handler"], pub_topic_path)
             logger.debug("Lister added for topic : ", pub_topic_path)
-        except self.wallet_id == "":
-            logger.error(
-                "Cannot add listener for empty wallet_id.")
+        except AssertionError as err:
+            logger.error(err)
+            raise
         except Exception as exc:
             logger.warning(
                 f"Adding webhooks listener failed! {exc!r} occurred.")
+            raise
 
     def update_wallet_id(self, wallet_id: str):
         """This wallet_id is used to register for webhooks
@@ -92,9 +95,12 @@ def update_wallet_id(self, wallet_id: str):
             The tenant wallet identifier
         """
         try:
+            assert (type(wallet_id) is str), "wallet_id must be a string" 
+            assert (wallet_id.__ne__("")), "wallet_id must not be empty"
             self.wallet_id = wallet_id
-        except wallet_id == "":
-            raise Exception("wallet_id must not be empty")
+        except AssertionError as err:
+            logger.info(f"{err!r}")
+            raise
 
     def update_tenant_jwt(self, tenant_jwt: str, wallet_id: str):
         """Update the tenant JW token attribute and the header
@@ -107,18 +113,22 @@ def update_tenant_jwt(self, tenant_jwt: str, wallet_id: str):
             The tenant wallet identifier
         """
         try:
+            assert (type(tenant_jwt) is str), "tenant_jwt must be a string" 
+            assert (tenant_jwt.__ne__("")), "tenant_jwt must not be empty"
             self.tenant_jwt = tenant_jwt
             self.update_wallet_id(wallet_id)
             self.headers.update(
                 {'Authorization': 'Bearer ' + tenant_jwt,
                     'content-type': "application/json"})
             self.client_session.headers.update(self.headers)
-        except tenant_jwt == "":
-            raise Exception("tenant_jwt must not be empty")
+        except AssertionError as err:
+            logger.info(f"{err!r}")
+            raise
         except Exception as exc:
             logger.warning(
                 (f"Updating tenant JW token"
                     f" failed! {exc!r} occurred."))
+            raise
 
     def remove_tenant_jwt(self):
         """Removes the tenant's JW Token attribute and corresponding
@@ -134,3 +144,4 @@ def remove_tenant_jwt(self):
         except Exception as exc:
             logger.warning(
                 f"Removing JW token failed! {exc!r} occurred.")
+            raise

aries_cloudcontroller/aries_tenant_controller.py

@@ -51,8 +51,11 @@ async def listen_webhooks(self):
                 self.webhook_host,
                 self.webhook_port)
             await self.webhook_site.start()
+            logger.info(
+                f"Listening Webhooks on {self.webhook_host}:{self.webhook_port}")
         except Exception as exc:
             logger.warning(f"Listening webhooks failed! {exc!r} occurred.")
+            raise
 
     async def _receive_webhook(self, request: ClientRequest):
         """Helper to receive webhooks by requesting it
@@ -79,6 +82,7 @@ async def _receive_webhook(self, request: ClientRequest):
             return web.Response(status=200)
         except Exception as exc:
             logger.warning(f"Receiving webhooks failed! {exc!r} occurred.")
+            raise
 
     async def _handle_webhook(self, wallet_id, topic, payload):
         """Helper handling a webhook
@@ -103,14 +107,17 @@ async def _handle_webhook(self, wallet_id, topic, payload):
             logger.warning(
                 (f"Handling webhooks failed! {exc!r} occurred"
                     f" when trying to handle this topic: {topic}"))
+            raise
 
     async def terminate(self):
         """Terminate the controller client session and webhook listeners"""
         try:
             await self.webhook_site.stop()
+            logger.info("Webhook server terminated.")
         except AttributeError:
             # Do nothing if no webhook site server is running
             return
         except Exception as exc:
             logger.warning(
                 f"Terminating webhooks listener failed! {exc!r} occurred.")
+            raise

aries_cloudcontroller/aries_webhook_server.py

@@ -0,0 +1,86 @@
+import logging
+import pytest
+
+from aries_cloudcontroller import AriesAgentController
+from aries_cloudcontroller import AriesWebhookServer
+from aries_cloudcontroller.controllers.multitenant import MultitenancyController
+
+LOGGER = logging.getLogger(__name__)
+
+
+class TestAriesAgentController():
+
+    admin_url = "0.0.0.0"
+    webhook_host = ""
+    webhook_port = 8000
+    webhook_base = ""
+
+    @pytest.mark.asyncio
+    async def test_init_args_missing(self):
+        with pytest.raises(TypeError) as te:
+            AriesAgentController()
+            assert "__init__() missing 1 required positional argument: \
+                'admin_url'" in str(te.value)
+
+    @pytest.mark.asyncio
+    async def test_init_args_multi_default(self):
+        ac = AriesAgentController(admin_url=self.admin_url)
+        assert not ac.is_multitenant
+
+    @pytest.mark.asyncio
+    async def test_init_args_multi_true(self):
+        ac = AriesAgentController(
+            admin_url=self.admin_url,
+            is_multitenant=True)
+        assert ac.is_multitenant
+        assert type(ac.multitenant) == MultitenancyController
+        assert ac.multitenant.admin_url == self.admin_url
+        assert ac.multitenant.client_session.headers == {}
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_init_webhook_server(self):
+        ac = AriesAgentController(
+            admin_url=self.admin_url,
+            is_multitenant=True)
+        ac.init_webhook_server(
+            self.webhook_host,
+            self.webhook_port,
+            self.webhook_base
+        )
+        assert type(ac.webhook_server) == AriesWebhookServer
+        assert ac.webhook_server.webhook_base == self.webhook_base
+        assert ac.webhook_server.webhook_port == self.webhook_port
+        assert ac.webhook_server.webhook_host == self.webhook_host
+        assert ac.webhook_server.is_multitenant
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_listen_webhooks_error(self, caplog):
+        caplog.set_level(logging.WARNING)
+        ac = AriesAgentController(
+            admin_url=self.admin_url,
+            is_multitenant=True)
+        with pytest.raises(AttributeError) as ae:
+            await ac.listen_webhooks()
+        assert "Webhook server not initialised." in str(ae.value)
+        assert "Webhook server not initialised." in caplog.text
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_init_webhook_server_terminate(self, caplog):
+        caplog.set_level(logging.INFO)
+        ac = AriesAgentController(
+            admin_url=self.admin_url,
+            is_multitenant=True)
+        ac.init_webhook_server(
+            self.webhook_host,
+            self.webhook_port,
+            self.webhook_base
+        )
+        await ac.listen_webhooks()
+        assert "Webhook server started." in caplog.text
+        res = await ac.webhook_server.terminate()
+        assert "Webhook server terminated." in caplog.text
+        assert res is None
+        await ac.terminate()

tests/test_aries_controller.py

@@ -0,0 +1,136 @@
+import logging
+import pytest
+from aiohttp import (
+    ClientSession,
+)
+
+from aries_cloudcontroller import AriesAgentControllerBase
+from aries_cloudcontroller.controllers.connections import ConnectionsController
+from aries_cloudcontroller.controllers.messaging import MessagingController
+from aries_cloudcontroller.controllers.mediation import MediationController
+from aries_cloudcontroller.controllers.schema import SchemaController
+from aries_cloudcontroller.controllers.wallet import WalletController
+from aries_cloudcontroller.controllers.definitions import DefinitionsController
+from aries_cloudcontroller.controllers.issuer import IssuerController
+from aries_cloudcontroller.controllers.proof import ProofController
+from aries_cloudcontroller.controllers.ledger import LedgerController
+from aries_cloudcontroller.controllers.credential import CredentialController
+from aries_cloudcontroller.controllers.server import ServerController
+from aries_cloudcontroller.controllers.oob import OOBController
+from aries_cloudcontroller.controllers.action_menu import ActionMenuController
+from aries_cloudcontroller.controllers.revocation import RevocationController
+
+LOGGER = logging.getLogger(__name__)
+
+
+class TestAriesAgentControllerBase():
+
+    @pytest.mark.asyncio
+    async def test_init_args_missing(self):
+        with pytest.raises(TypeError) as te:
+            AriesAgentControllerBase()
+            assert "__init__() missing 1 required positional \
+                argument: 'admin_url'" in str(te.value)
+
+    @pytest.mark.asyncio
+    async def test_default_args(self):
+        ac = AriesAgentControllerBase(admin_url="0.0.0.0")
+        assert ac.admin_url == "0.0.0.0"
+        assert ac.api_key is None
+        assert ac.webhook_site is None
+        assert ac.connections_controller is None
+        assert type(ac.client_session) == ClientSession
+        assert type(ac.connections) == ConnectionsController
+        assert type(ac.messaging) == MessagingController
+        assert type(ac.proofs) == ProofController
+        assert type(ac.ledger) == LedgerController
+        assert type(ac.credentials) == CredentialController
+        assert type(ac.server) == ServerController
+        assert type(ac.oob) == OOBController
+        assert type(ac.mediation) == MediationController
+        assert type(ac.schema) == SchemaController
+        assert type(ac.wallet) == WalletController
+        assert type(ac.definitions) == DefinitionsController
+        assert type(ac.issuer) == IssuerController
+        assert type(ac.action_menu) == ActionMenuController
+        assert type(ac.revocations) == RevocationController
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_headers(self):
+        api_key = "123456789"
+        ac = AriesAgentControllerBase(admin_url="", api_key=api_key)
+        exp_headers = {"X-API-Key": api_key}
+        assert ac.headers == exp_headers
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_init_webhook_server(self):
+        ac = AriesAgentControllerBase(admin_url="0.0.0.0")
+        with pytest.raises(NotImplementedError):
+            ac.init_webhook_server()
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_update_api_key(self):
+        api_key = "123456789"
+        ac = AriesAgentControllerBase(admin_url="", api_key=api_key)
+        exp_headers = {"X-API-Key": api_key}
+        assert ac.headers == exp_headers
+        assert ac.client_session.headers == exp_headers
+
+        new_api_key = "987654321"
+        ac.update_api_key(new_api_key)
+        new_exp_headers = {"X-API-Key": new_api_key}
+        assert ac.headers == new_exp_headers
+        assert ac.client_session.headers == new_exp_headers
+
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_remove_api_key(self):
+        api_key = "123456789"
+
+        ac = AriesAgentControllerBase(admin_url="", api_key=api_key)
+        ac.remove_api_key()
+
+        assert ac.headers == {}
+        assert ac.client_session.headers == {}
+
+        await ac.terminate()
+
+    # TODO create mock for pubsub listening webhooks
+    # Maybe this makes more sense in aries_controller
+    @pytest.mark.asyncio
+    async def test_register_listners(self):
+        pass
+
+    @pytest.mark.asyncio
+    async def test_add_listener(self):
+        pass
+
+    @pytest.mark.asyncio
+    async def test_remove_listener(self):
+        pass
+
+    @pytest.mark.asyncio
+    async def test_remove_all_listeners(self):
+        pass
+
+    @pytest.mark.asyncio
+    async def test_listen_webhooks(self):
+        ac = AriesAgentControllerBase(admin_url="0.0.0.0")
+        with pytest.raises(NotImplementedError):
+            await ac.listen_webhooks()
+        await ac.terminate()
+
+    @pytest.mark.asyncio
+    async def test_terminate(self, caplog):
+        caplog.set_level(logging.INFO)
+        ac = AriesAgentControllerBase(admin_url="0.0.0.0")
+        await ac.terminate()
+        assert "Client Session closed." in caplog.text
+        assert ac.client_session.closed
+        with pytest.raises(AttributeError):
+            assert ac.webhook_server is None
+        await ac.terminate()