async def store(
self, mediation_invite: MediationInviteRecord
) -> MediationInviteRecord:
"""
Store the mediator's invite for further use when starting the agent.
Update the currently stored invite if one already exists.
This assumes a new invite and as such, marks it as unused.
:param mediation_invite: mediation invite url
:return: stored mediation invite
"""
current_invite_record = await self.__retrieve_record(self.MEDIATION_INVITE_ID)
if current_invite_record is None:
await self.__storage.add_record(
StorageRecord(
type=self.INVITE_RECORD_CATEGORY,
id=self.MEDIATION_INVITE_ID,
value=mediation_invite.to_json(),
)
)
else:
await self.__storage.update_record(
current_invite_record,
mediation_invite.to_json(),
tags=current_invite_record.tags,
)
return mediation_invite
async def test_resolve_responder_fail(ResolveDIDMock, send_wait_Mock, resolver,
profile):
did_example = "did:sov:201029023831"
mock_inject = MagicMock()
mock_inject.inject.return_value = True
records = AsyncMock()
records.find_all_records.return_value = [
StorageRecord(
type="connection_metadata",
value={"methods": ["sov"]},
tags={
"key": "didcomm_uniresolver",
"connection_id": "1732d18d-c6f6-4e68-b3a7-56cc31d3313b",
},
id="5b9b78a061e6435bbbd7d5cde02d4192",
)
]
def inject_aux(*args):
result = None
if str(args[0]).find("BaseResponder") < 0:
result = records
return result
profile.session.return_value.__aenter__.return_value.inject.side_effect = inject_aux
async def aux(*args, **kwargs):
raise DIDNotFound()
send_wait_Mock.side_effect = aux
with pytest.raises(ResolverError):
await resolver.resolve(profile, did_example)
def _storage_record_for(value: str, used: bool = False) -> StorageRecord:
return StorageRecord(
type=MediationInviteStore.INVITE_RECORD_CATEGORY,
value=f"""{{"invite": "{value}", "used": {str(used).lower()}}}""",
tags={},
id=MediationInviteStore.MEDIATION_INVITE_ID,
)
async def test_postgres_wallet_storage_works(self):
"""
Ensure that postgres wallet operations work (create and open wallet, store and search, drop wallet)
"""
postgres_url = os.environ.get("POSTGRES_URL")
if not postgres_url:
pytest.fail("POSTGRES_URL not configured")
load_postgres_plugin()
postgres_wallet = IndyWallet({
"auto_create":
False,
"auto_remove":
False,
"name":
"test_pg_wallet",
"key":
"my_postgres",
"storage_type":
"postgres_storage",
"storage_config":
'{"url":"' + postgres_url + '", "max_connections":5}',
"storage_creds":
'{"account":"postgres","password":"******","admin_account":"postgres","admin_password":"******"}',
})
await postgres_wallet.create()
await postgres_wallet.open()
storage = IndyStorage(postgres_wallet)
# add and then fetch a record
record = StorageRecord(
value=
'{"initiator": "self", "invitation_key": "9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg", "state": "invitation", "routing_state": "none", "error_msg": null, "their_label": null, "created_at": "2019-05-14 21:58:24.143260+00:00", "updated_at": "2019-05-14 21:58:24.143260+00:00"}',
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
type="connection",
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
)
await storage.add_record(record)
g_rec = await storage.get_record(record.type, record.id)
# now try search
search = None
try:
search = storage.search_records("connection")
await search.open()
records = await search.fetch(10)
finally:
if search:
await search.close()
await postgres_wallet.close()
await postgres_wallet.remove()
def test_create(self):
record_type = "TYPE"
record_value = "VALUE"
record = StorageRecord(record_type, record_value)
assert record.type == record_type
assert record.value == record_value
assert record.id and type(record.id) is str
assert record.tags == {}
async def add_key_for_did(self, did: str, key: str):
"""Store a verkey for lookup against a DID.
Args:
did: The DID to associate with this key
key: The verkey to be added
"""
record = StorageRecord(self.RECORD_TYPE_DID_KEY, key, {
"did": did,
"key": key
})
storage: BaseStorage = await self.context.inject(BaseStorage)
await storage.add_record(record)
async def store_did_document(self, did_doc: DIDDoc):
"""Store a DID document.
Args:
did_doc: The `DIDDoc` instance to be persisted
"""
assert did_doc.did
storage: BaseStorage = await self.context.inject(BaseStorage)
try:
stored_doc, record = await self.fetch_did_document(did_doc.did)
except StorageNotFoundError:
record = StorageRecord(self.RECORD_TYPE_DID_DOC, did_doc.to_json(),
{"did": did_doc.did})
await storage.add_record(record)
else:
await storage.update_record_value(record, did_doc.to_json())
await self.remove_keys_for_did(did_doc.did)
for key in did_doc.pubkey.values():
if key.controller == did_doc.did:
await self.add_key_for_did(did_doc.did, key.value)
async def test_resolve_not_supported(ResolveDIDMock, send_wait_Mock, resolver,
profile):
did_example = "did:sov:201029023831"
mock_inject = MagicMock()
mock_inject.inject.return_value = True
records = AsyncMock()
records.find_all_records.return_value = [
StorageRecord(
type="connection_metadata",
value='{"methods": ["example"]}',
tags={
"key": "didcomm_uniresolver",
"connection_id": "1732d18d-c6f6-4e68-b3a7-56cc31d3313b",
},
id="5b9b78a061e6435bbbd7d5cde02d4192",
)
]
profile.session.return_value.__aenter__.return_value.inject.return_value = records
with pytest.raises(DIDMethodNotSupported):
await resolver.resolve(profile, did_example)
async def test_resolve_diddoc_json(ResolveDIDMock, send_wait_Mock, resolver,
profile):
did_example = "did:sov:201029023831"
mock_inject = MagicMock()
mock_inject.inject.return_value = True
records = AsyncMock()
records.find_all_records.return_value = [
StorageRecord(
type="connection_metadata",
value={"methods": ["sov"]},
tags={
"key": "didcomm_uniresolver",
"connection_id": "1732d18d-c6f6-4e68-b3a7-56cc31d3313b",
},
id="5b9b78a061e6435bbbd7d5cde02d4192",
)
]
def inject_aux(*args):
result = True
if str(args[0]).find("BaseResponder") < 0:
result = records
return result
profile.session.return_value.__aenter__.return_value.inject.side_effect = inject_aux
async def aux(*args, **kwargs):
mock = MagicMock()
mock.did_document = json.dumps(DOC)
return mock
send_wait_Mock.side_effect = aux
result = await resolver.resolve(profile, did_example)
assert result.serialize() == DOC
def vc_to_storage_record(cred: VCRecord) -> StorageRecord:
"""Convert a VC record into an in-memory stored record."""
tags = {}
for ctx_val in cred.contexts:
tags[f"ctxt:{ctx_val}"] = "1"
for type_val in cred.types:
tags[f"type:{type_val}"] = "1"
for schema_val in cred.schema_ids:
tags[f"schm:{schema_val}"] = "1"
for subj_id in cred.subject_ids:
tags[f"subj:{subj_id}"] = "1"
if cred.issuer_id:
tags["issuer_id"] = cred.issuer_id
if cred.given_id:
tags["given_id"] = cred.given_id
if cred.cred_tags:
tags.update(cred.cred_tags)
return StorageRecord(
VC_CRED_RECORD_TYPE,
json.dumps(cred.cred_value),
tags,
cred.record_id,
)
def test_missing_record(tags={}):
return StorageRecord(type="__MISSING__", value="000000000")
def test_record(tags={}):
return StorageRecord(type="TYPE", value="TEST", tags=tags)
async def test_record(self):
with async_mock.patch.object(
test_wallet, "load_postgres_plugin",
async_mock.MagicMock()) as mock_load, async_mock.patch.object(
indy.wallet, "create_wallet", async_mock.CoroutineMock(
)) as mock_create, async_mock.patch.object(
indy.wallet, "open_wallet", async_mock.CoroutineMock()
) as mock_open, async_mock.patch.object(
indy.anoncreds, "prover_create_master_secret",
async_mock.CoroutineMock()
) as mock_master, async_mock.patch.object(
indy.wallet, "close_wallet", async_mock.CoroutineMock(
)) as mock_close, async_mock.patch.object(
indy.wallet, "delete_wallet",
async_mock.CoroutineMock()) as mock_delete:
fake_wallet = IndyWallet({
"auto_create":
True,
"auto_remove":
True,
"name":
"test_pg_wallet",
"key":
await IndyWallet.generate_wallet_key(),
"key_derivation_method":
"RAW",
"storage_type":
"postgres_storage",
"storage_config":
json.dumps({"url": "dummy"}),
"storage_creds":
json.dumps({
"account": "postgres",
"password": "******",
"admin_account": "postgres",
"admin_password": "******",
}),
})
await fake_wallet.open()
storage = IndyStorage(fake_wallet)
for record_x in [
None,
StorageRecord(
type="connection",
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id=None,
),
StorageRecord(
type=None,
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
),
StorageRecord(
type="connection",
value=None,
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
),
]:
with pytest.raises(StorageError):
await storage.add_record(record_x)
with pytest.raises(StorageError):
await storage.get_record(None, "dummy-id")
with pytest.raises(StorageError):
await storage.get_record("connection", None)
with async_mock.patch.object(
test_module.non_secrets, "get_wallet_record",
async_mock.CoroutineMock()) as mock_get_record:
mock_get_record.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
with pytest.raises(test_module.StorageError):
await storage.get_record("connection", "dummy-id")
with async_mock.patch.object(
test_module.non_secrets,
"update_wallet_record_value",
async_mock.CoroutineMock(),
) as mock_update_value, async_mock.patch.object(
test_module.non_secrets,
"update_wallet_record_tags",
async_mock.CoroutineMock(),
) as mock_update_tags, async_mock.patch.object(
test_module.non_secrets,
"delete_wallet_record",
async_mock.CoroutineMock(),
) as mock_delete:
mock_update_value.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
mock_update_tags.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
mock_delete.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
rec = StorageRecord(
type="connection",
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
)
with pytest.raises(test_module.StorageError):
await storage.update_record(rec, "dummy-value",
{"tag": "tag"})
with pytest.raises(test_module.StorageError):
await storage.delete_record(rec)
