def setUp(self):
self.storage = BasicStorage()
self.cache = BasicCache()
self.wallet = BasicWallet()
self.responder = MockResponder()
self.responder.send = async_mock.CoroutineMock()
self.context = InjectionContext(enforce_typing=False)
self.context.injector.bind_instance(BaseStorage, self.storage)
self.context.injector.bind_instance(BaseWallet, self.wallet)
self.context.injector.bind_instance(BaseResponder, self.responder)
self.context.injector.bind_instance(BaseCache, self.cache)
self.context.injector.bind_instance(BaseLedger, async_mock.MagicMock())
self.context.update_settings({
"default_endpoint":
"http://aries.ca/endpoint",
"default_label":
"This guy",
"additional_endpoints": ["http://aries.ca/another-endpoint"],
"debug.auto_accept_invites":
True,
"debug.auto_accept_requests":
True,
})
self.manager = OutOfBandManager(self.context)
self.test_conn_rec = ConnectionRecord(
my_did=self.test_did,
their_did=self.test_target_did,
their_role=None,
state=ConnectionRecord.STATE_ACTIVE,
)
async def setUp(self):
self.context: InjectionContext = InjectionContext()
storage = BasicStorage()
self.wallet = BasicWallet()
await self.wallet.create_public_did()
public_did = await self.wallet.get_public_did()
assert public_did != None
self.holder = PDSHolder(self.wallet, storage, self.context)
issuer = PDSIssuer(self.wallet)
self.context.injector.bind_instance(BaseWallet, self.wallet)
self.context.injector.bind_instance(BaseStorage, storage)
self.context.settings.set_value(
"personal_storage_registered_types",
{"local": "aries_cloudagent.pdstorage_thcf.local.LocalPDS"},
)
pds = LocalPDS()
self.context.injector.bind_instance(BasePDS, pds)
new_storage = SavedPDS(state=SavedPDS.ACTIVE)
await new_storage.save(self.context)
self.credential = await create_test_credential(issuer)
self.cred_id = await self.holder.store_credential({}, self.credential,
{})
requested_credentials["credential_id"] = self.cred_id
async def test_properties(self, wallet):
assert wallet.name
assert wallet.type == "basic"
assert wallet.handle is None
none_wallet = BasicWallet()
assert none_wallet.name is None
assert "BasicWallet" in str(wallet)
assert wallet.created
async def setUp(self):
self.wallet = BasicWallet()
self.example_schema = {
"@context": [
"https://www.w3.org/2018/credentials/v1",
"https://www.w3.org/2018/credentials/examples/v1",
],
"type": ["VerifiablePresentation"],
"verifiableCredential": [{}],
}
async def test_make_model(self):
connection_response = ConnectionResponse(connection=ConnectionDetail(
did=self.test_did, did_doc=self.make_did_doc()))
wallet = BasicWallet()
key_info = await wallet.create_signing_key()
await connection_response.sign_field("connection", key_info.verkey,
wallet)
data = connection_response.serialize()
model_instance = ConnectionResponse.deserialize(data)
assert type(model_instance) is type(connection_response)
async def setUp(self):
self.context = InjectionContext(enforce_typing=False)
self.storage = async_mock.create_autospec(BaseStorage)
self.context.injector.bind_instance(BaseStorage, self.storage)
self.wallet = self.wallet = BasicWallet()
self.did_info = await self.wallet.create_local_did()
self.context.injector.bind_instance(BaseWallet, self.wallet)
self.app = {
"request_context": self.context,
}
async def test_is_handler_saving_record(self):
context = RequestContext()
# wallet is required for issuer to sign stuff cause it holds keys
wallet = BasicWallet()
# storage is required to save exchange record and save credential
storage = BasicStorage(wallet)
# issuer required to create credential
issuer = PDSIssuer(wallet)
# holder requiered to save credential
holder = PDSHolder(context)
context.injector.bind_instance(BaseWallet, wallet)
context.injector.bind_instance(BaseStorage, storage)
context.injector.bind_instance(BaseIssuer, issuer)
context.injector.bind_instance(BaseHolder, holder)
record = CredentialExchangeRecord(
connection_id=connection_id,
initiator=CredentialExchangeRecord.INITIATOR_SELF,
role=CredentialExchangeRecord.ROLE_HOLDER,
state=CredentialExchangeRecord.STATE_REQUEST_SENT,
thread_id=thread_id,
credential_request=credential_request,
)
await record.save(context)
credential = await create_credential(context,
credential_request,
their_public_did="1234-theirdid")
context.message: CredentialIssue = CredentialIssue(
credential=credential)
context.message.assign_thread_id(thread_id)
context.connection_ready = True
handler_inst = CredentialIssueHandler()
responder = MockResponder()
responder.connection_id = connection_id
await handler_inst.handle(context, responder)
credential_id = responder.webhooks[0][1]["credential_id"]
assert credential_id
credential = await holder.get_credential(credential_id)
credential = json.loads(credential)
assert credential["credentialSubject"]
for key in credential_request["credential_values"]:
if (credential["credentialSubject"][key] !=
credential_request["credential_values"][key]):
raise Exception(
f"""Requested Credential VALUES differ from Issued Credential,
RequestedCredential: {credential_request},
IssuedCredential: {credential}""")
def setUp(self):
self.storage = BasicStorage()
self.context = InjectionContext()
self.context.injector.bind_instance(BaseStorage, self.storage)
self.context.injector.bind_instance(BaseWallet, BasicWallet())
self.manager = ConnectionManager(self.context)
self.test_info = ConnectionRecord(
my_did=self.test_did,
their_did=self.test_target_did,
their_role=None,
state=ConnectionRecord.STATE_ACTIVE,
)
async def basic_wallet():
wallet = BasicWallet()
await wallet.open()
yield wallet
await wallet.close()
async def wallet():
wallet = BasicWallet({"name": "basic"})
await wallet.open()
yield wallet
await wallet.close()
async def test_save_retrieve_delete_connection_menu(self):
self.storage = BasicStorage()
self.context = InjectionContext()
self.context.injector.bind_instance(BaseStorage, self.storage)
self.context.injector.bind_instance(BaseWallet, BasicWallet())
self.responder = MockResponder()
self.context.injector.bind_instance(test_module.BaseResponder,
self.responder)
menu = test_module.Menu(
title="title",
description="description",
errormsg=None,
options=[
MenuOption(
name=f"name-{i}",
title=f"option-title-{i}",
description=f"option-description-{i}",
disabled=bool(i % 2),
form=MenuForm(
title=f"form-title-{i}",
description=f"form-description-{i}",
params=[
MenuFormParam(
name=f"param-name-{i}-{j}",
title=f"param-title-{i}-{j}",
default=f"param-default-{i}-{j}",
description=f"param-description-{i}-{j}",
input_type="int",
required=bool((i + j) % 2),
) for j in range(2)
],
),
) for i in range(3)
],
)
connection_id = "connid"
for i in range(2): # once to add, once to update
await test_module.save_connection_menu(menu, connection_id,
self.context)
webhooks = self.responder.webhooks
assert len(webhooks) == 1
(result, target) = webhooks[0]
assert result == "actionmenu"
assert target["connection_id"] == connection_id
assert target["menu"] == menu.serialize()
self.responder.webhooks.clear()
# retrieve connection menu
assert (await test_module.retrieve_connection_menu(
connection_id, self.context)).serialize() == menu.serialize()
# delete connection menu
await test_module.save_connection_menu(None, connection_id,
self.context)
webhooks = self.responder.webhooks
assert len(webhooks) == 1
(result, target) = webhooks[0]
assert result == "actionmenu"
assert target == {"connection_id": connection_id, "menu": None}
self.responder.webhooks.clear()
# retrieve no menu
assert (await test_module.retrieve_connection_menu(
connection_id, self.context) is None)
async def setUp(self):
self.context: InjectionContext = InjectionContext()
wallet = BasicWallet()
self.verifier = PDSVerifier(wallet)