Merge from upstream

.readthedocs.yaml

@@ -8,3 +8,7 @@ build:
 sphinx:
   builder: dirhtml
   configuration: docs/conf.py
+
+python:
+  install:
+    - requirements: docs/requirements.txt

Endorser.md

@@ -2,7 +2,7 @@
 
 ACA-Py supports an [Endorser Protocol](https://github.com/hyperledger/aries-rfcs/pull/586), that allows an un-privileged agent (an "Author") to request another agent (the "Endorser") to sign their transactions so they can write these transactions to the ledger.  This is required on Indy ledgers, where new agents will typically be granted only "Author" privileges.
 
-Transaction Endorsement is built into the protocols for Schema, Credential Definition and Revocation, and endorsements can be explicitely requested, or ACA-Py can be configured to automate the endorsement workflow.
+Transaction Endorsement is built into the protocols for Schema, Credential Definition and Revocation, and endorsements can be explicitly requested, or ACA-Py can be configured to automate the endorsement workflow.
 
 ## Setting up Connections between Authors and Endorsers
 
@@ -12,7 +12,7 @@ Once the connection is established and `active`, the "role" (either Author or En
 
 ## Requesting Transaction Endorsement
 
-Transaction Endorsement is built into the protocols for Schema, Credential Definition and Revocation.  When executing one of the endpoints that will trigger a ledger write, an endorsement protocol can be explicitely requested by specifying the `connection_id` (of the Endorser connection) and `create_transaction_for_endorser`.
+Transaction Endorsement is built into the protocols for Schema, Credential Definition and Revocation.  When executing one of the endpoints that will trigger a ledger write, an endorsement protocol can be explicitly requested by specifying the `connection_id` (of the Endorser connection) and `create_transaction_for_endorser`.
 
 (Note that endorsement requests can be automated, see the secion on "Configuring ACA-Py" below.)
 

UnitTests.md

@@ -130,7 +130,7 @@ class TestDidExchangeManager(AsyncTestCase, TestConfig):
         self.responder = MockResponder()
 
         self.oob_mock = async_mock.MagicMock(
-            clean_finished_oob_record=async_mock.CoroutineMock(return_value=None)
+            clean_finished_oob_record=async_mock.AsyncMock(return_value=None)
         )
 
         self.route_manager = async_mock.MagicMock(RouteManager)

UpgradingACA-Py.md

@@ -76,7 +76,19 @@ In case, running multiple tags [say test1 & test2]:
  ./scripts/run_docker upgrade --force-upgrade --named-tag test1 --named-tag test2
 ```
 
+## Subwallet upgrades
+With multitenant enabled, there is a subwallet associated with each tenant profile, so there is a need to upgrade those sub wallets in addition to the base wallet associated with root profile.
 
+There are 2 options to perform such upgrades:
+  - `--upgrade-all-subwallets`
+
+    This will apply the upgrade steps to all sub wallets [tenant profiles] and the base wallet [root profiles].
+
+  - `--upgrade-subwallet`
+
+    This will apply the upgrade steps to specified sub wallets [identified by wallet id] and the base wallet.
+
+    Note: multiple specification allowed
 
 ## Exceptions
 

aries_cloudagent/admin/tests/test_admin_server.py

@@ -1,7 +1,7 @@
 import json
 
 import pytest
-import mock as async_mock
+from aries_cloudagent.tests import mock
 from unittest import IsolatedAsyncioTestCase
 from aiohttp import ClientSession, DummyCookieJar, TCPConnector, web
 from aiohttp.test_utils import unused_port
@@ -36,66 +36,62 @@ async def asyncTearDown(self):
             self.client_session = None
 
     async def test_debug_middleware(self):
-        with async_mock.patch.object(
-            test_module, "LOGGER", async_mock.MagicMock()
-        ) as mock_logger:
-            mock_logger.isEnabledFor = async_mock.MagicMock(return_value=True)
-            mock_logger.debug = async_mock.MagicMock()
+        with mock.patch.object(test_module, "LOGGER", mock.MagicMock()) as mock_logger:
+            mock_logger.isEnabledFor = mock.MagicMock(return_value=True)
+            mock_logger.debug = mock.MagicMock()
 
-            request = async_mock.MagicMock(
+            request = mock.MagicMock(
                 method="GET",
                 path_qs="/hello/world?a=1&b=2",
                 match_info={"match": "info"},
-                text=async_mock.AsyncMock(return_value="abc123"),
+                text=mock.CoroutineMock(return_value="abc123"),
             )
-            handler = async_mock.AsyncMock()
+            handler = mock.CoroutineMock()
 
             await test_module.debug_middleware(request, handler)
             mock_logger.isEnabledFor.assert_called_once()
             assert mock_logger.debug.call_count == 3
 
     async def test_ready_middleware(self):
-        with async_mock.patch.object(
-            test_module, "LOGGER", async_mock.MagicMock()
-        ) as mock_logger:
-            mock_logger.isEnabledFor = async_mock.MagicMock(return_value=True)
-            mock_logger.debug = async_mock.MagicMock()
-            mock_logger.info = async_mock.MagicMock()
-            mock_logger.error = async_mock.MagicMock()
-
-            request = async_mock.MagicMock(
-                rel_url="/", app=async_mock.MagicMock(_state={"ready": False})
+        with mock.patch.object(test_module, "LOGGER", mock.MagicMock()) as mock_logger:
+            mock_logger.isEnabledFor = mock.MagicMock(return_value=True)
+            mock_logger.debug = mock.MagicMock()
+            mock_logger.info = mock.MagicMock()
+            mock_logger.error = mock.MagicMock()
+
+            request = mock.MagicMock(
+                rel_url="/", app=mock.MagicMock(_state={"ready": False})
             )
-            handler = async_mock.AsyncMock(return_value="OK")
+            handler = mock.CoroutineMock(return_value="OK")
             with self.assertRaises(test_module.web.HTTPServiceUnavailable):
                 await test_module.ready_middleware(request, handler)
 
             request.app._state["ready"] = True
             assert await test_module.ready_middleware(request, handler) == "OK"
 
             request.app._state["ready"] = True
-            handler = async_mock.AsyncMock(
+            handler = mock.CoroutineMock(
                 side_effect=test_module.LedgerConfigError("Bad config")
             )
             with self.assertRaises(test_module.LedgerConfigError):
                 await test_module.ready_middleware(request, handler)
 
             request.app._state["ready"] = True
-            handler = async_mock.AsyncMock(
+            handler = mock.CoroutineMock(
                 side_effect=test_module.web.HTTPFound(location="/api/doc")
             )
             with self.assertRaises(test_module.web.HTTPFound):
                 await test_module.ready_middleware(request, handler)
 
             request.app._state["ready"] = True
-            handler = async_mock.AsyncMock(
+            handler = mock.CoroutineMock(
                 side_effect=test_module.asyncio.CancelledError("Cancelled")
             )
             with self.assertRaises(test_module.asyncio.CancelledError):
                 await test_module.ready_middleware(request, handler)
 
             request.app._state["ready"] = True
-            handler = async_mock.AsyncMock(side_effect=KeyError("No such thing"))
+            handler = mock.CoroutineMock(side_effect=KeyError("No such thing"))
             with self.assertRaises(KeyError):
                 await test_module.ready_middleware(request, handler)
 
@@ -110,10 +106,8 @@ def get_admin_server(
         # middleware is task queue xor collector: cover both over test suite
         task_queue = (settings or {}).pop("task_queue", None)
 
-        plugin_registry = async_mock.MagicMock(
-            test_module.PluginRegistry, autospec=True
-        )
-        plugin_registry.post_process_routes = async_mock.MagicMock()
+        plugin_registry = mock.MagicMock(test_module.PluginRegistry, autospec=True)
+        plugin_registry.post_process_routes = mock.MagicMock()
         context.injector.bind_instance(test_module.PluginRegistry, plugin_registry)
 
         collector = Collector()
@@ -129,10 +123,10 @@ def get_admin_server(
             profile,
             self.outbound_message_router,
             self.webhook_router,
-            conductor_stop=async_mock.AsyncMock(),
+            conductor_stop=mock.CoroutineMock(),
             task_queue=TaskQueue(max_active=4) if task_queue else None,
             conductor_stats=(
-                None if task_queue else async_mock.AsyncMock(return_value={"a": 1})
+                None if task_queue else mock.CoroutineMock(return_value={"a": 1})
             ),
         )
 
@@ -165,16 +159,16 @@ async def test_start_stop(self):
         server = self.get_admin_server(settings)
         await server.start()
         assert server.app._client_max_size == 4 * 1024 * 1024
-        with async_mock.patch.object(
-            server, "websocket_queues", async_mock.MagicMock()
+        with mock.patch.object(
+            server, "websocket_queues", mock.MagicMock()
         ) as mock_wsq:
-            mock_wsq.values = async_mock.MagicMock(
-                return_value=[async_mock.MagicMock(stop=async_mock.MagicMock())]
+            mock_wsq.values = mock.MagicMock(
+                return_value=[mock.MagicMock(stop=mock.MagicMock())]
             )
             await server.stop()
 
-        with async_mock.patch.object(
-            web.TCPSite, "start", async_mock.AsyncMock()
+        with mock.patch.object(
+            web.TCPSite, "start", mock.CoroutineMock()
         ) as mock_start:
             mock_start.side_effect = OSError("Failure to launch")
             with self.assertRaises(AdminSetupError):
@@ -199,7 +193,7 @@ async def test_import_routes_multitenant_middleware(self):
         context.injector.bind_instance(GoalCodeRegistry, GoalCodeRegistry())
         context.injector.bind_instance(
             test_module.BaseMultitenantManager,
-            async_mock.MagicMock(spec=test_module.BaseMultitenantManager),
+            mock.MagicMock(spec=test_module.BaseMultitenantManager),
         )
         await DefaultContextBuilder().load_plugins(context)
         server = self.get_admin_server(
@@ -220,66 +214,66 @@ async def test_import_routes_multitenant_middleware(self):
             m for m in app.middlewares if ".check_multitenant_authorization" in str(m)
         ]
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={"Authorization": "Bearer ..."},
             path="/multitenancy/etc",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
         with self.assertRaises(test_module.web.HTTPUnauthorized):
             await mt_authz_middle(mock_request, None)
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={},
             path="/protected/non-multitenancy/non-server",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
         with self.assertRaises(test_module.web.HTTPUnauthorized):
             await mt_authz_middle(mock_request, None)
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={"Authorization": "Bearer ..."},
             path="/protected/non-multitenancy/non-server",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
-        mock_handler = async_mock.AsyncMock()
+        mock_handler = mock.CoroutineMock()
         await mt_authz_middle(mock_request, mock_handler)
-        assert mock_handler.called_once_with(mock_request)
+        mock_handler.assert_called_once_with(mock_request)
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={"Authorization": "Non-bearer ..."},
             path="/test",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
-        mock_handler = async_mock.AsyncMock()
+        mock_handler = mock.CoroutineMock()
         await mt_authz_middle(mock_request, mock_handler)
-        assert mock_handler.called_once_with(mock_request)
+        mock_handler.assert_called_once_with(mock_request)
 
         # multitenant setup context exception paths
         [setup_ctx_middle] = [m for m in app.middlewares if ".setup_context" in str(m)]
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={"Authorization": "Non-bearer ..."},
             path="/protected/non-multitenancy/non-server",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
         with self.assertRaises(test_module.web.HTTPUnauthorized):
             await setup_ctx_middle(mock_request, None)
 
-        mock_request = async_mock.MagicMock(
+        mock_request = mock.MagicMock(
             method="GET",
             headers={"Authorization": "Bearer ..."},
             path="/protected/non-multitenancy/non-server",
-            text=async_mock.AsyncMock(return_value="abc123"),
+            text=mock.CoroutineMock(return_value="abc123"),
         )
-        with async_mock.patch.object(
+        with mock.patch.object(
             server.multitenant_manager,
             "get_profile_for_token",
-            async_mock.AsyncMock(),
+            mock.CoroutineMock(),
         ) as mock_get_profile:
             mock_get_profile.side_effect = [
                 test_module.MultitenantManagerError("corrupt token"),
@@ -493,8 +487,8 @@ async def server():
 )
 async def test_on_record_event(server, event_topic, webhook_topic):
     profile = InMemoryProfile.test_profile()
-    with async_mock.patch.object(
-        server, "send_webhook", async_mock.AsyncMock()
+    with mock.patch.object(
+        server, "send_webhook", mock.CoroutineMock()
     ) as mock_send_webhook:
         await server._on_record_event(profile, Event(event_topic, None))
         mock_send_webhook.assert_called_once_with(profile, webhook_topic, None)

aries_cloudagent/admin/tests/test_request_context.py

@@ -1,4 +1,4 @@
-from asynctest import TestCase as AsyncTestCase
+from unittest import IsolatedAsyncioTestCase
 
 from ...core.in_memory import InMemoryProfile
 from ...core.profile import ProfileSession
@@ -7,7 +7,7 @@
 from .. import request_context as test_module
 
 
-class TestAdminRequestContext(AsyncTestCase):
+class TestAdminRequestContext(IsolatedAsyncioTestCase):
     def setUp(self):
         self.ctx = test_module.AdminRequestContext(InMemoryProfile.test_profile())
         assert self.ctx.__class__.__name__ in str(self.ctx)

aries_cloudagent/askar/didcomm/tests/test_v2.py

@@ -1,6 +1,6 @@
 import json
 
-from asynctest import mock as async_mock
+from unittest import mock
 import pytest
 
 from aries_askar import AskarError, Key, KeyAlg, Session
@@ -70,19 +70,19 @@ async def test_es_encrypt_x(self, session: Session):
         ):
             _ = test_module.ecdh_es_encrypt({}, MESSAGE)
 
-        with async_mock.patch(
+        with mock.patch(
             "aries_askar.Key.generate",
-            async_mock.MagicMock(side_effect=AskarError(99, "")),
+            mock.MagicMock(side_effect=AskarError(99, "")),
         ):
             with pytest.raises(
                 test_module.DidcommEnvelopeError,
                 match="Error creating content encryption key",
             ):
                 _ = test_module.ecdh_es_encrypt({BOB_KID: bob_pk}, MESSAGE)
 
-        with async_mock.patch(
+        with mock.patch(
             "aries_askar.Key.aead_encrypt",
-            async_mock.MagicMock(side_effect=AskarError(99, "")),
+            mock.MagicMock(side_effect=AskarError(99, "")),
         ):
             with pytest.raises(
                 test_module.DidcommEnvelopeError,
@@ -188,9 +188,9 @@ async def test_1pu_encrypt_x(self, session: Session):
                 {BOB_KID: bob_pk, "alt": alt_pk}, ALICE_KID, alice_sk, MESSAGE
             )
 
-        with async_mock.patch(
+        with mock.patch(
             "aries_askar.Key.generate",
-            async_mock.MagicMock(side_effect=AskarError(99, "")),
+            mock.MagicMock(side_effect=AskarError(99, "")),
         ):
             with pytest.raises(
                 test_module.DidcommEnvelopeError,
@@ -200,9 +200,9 @@ async def test_1pu_encrypt_x(self, session: Session):
                     {BOB_KID: bob_pk}, ALICE_KID, alice_sk, MESSAGE
                 )
 
-        with async_mock.patch(
+        with mock.patch(
             "aries_askar.Key.aead_encrypt",
-            async_mock.MagicMock(side_effect=AskarError(99, "")),
+            mock.MagicMock(side_effect=AskarError(99, "")),
         ):
             with pytest.raises(
                 test_module.DidcommEnvelopeError,

aries_cloudagent/askar/tests/test_profile.py

@@ -1,7 +1,7 @@
 import asyncio
 import pytest
 
-from asynctest import mock
+from unittest import mock
 
 from ...askar.profile import AskarProfile
 from ...config.injection_context import InjectionContext

aries_cloudagent/askar/tests/test_store.py

@@ -1,11 +1,11 @@
-from asynctest import TestCase as AsyncTestCase
+from unittest import IsolatedAsyncioTestCase
 
 from ...core.error import ProfileError
 
 from ..store import AskarStoreConfig
 
 
-class TestStoreConfig(AsyncTestCase):
+class TestStoreConfig(IsolatedAsyncioTestCase):
     key_derivation_method = "Raw"
     key = "key"
     storage_type = "postgres"