async def test_delete_credential_x(
self,
mock_nonsec_del_wallet_record,
mock_nonsec_get_wallet_record,
mock_prover_del_cred,
):
mock_wallet = async_mock.MagicMock()
holder = IndyHolder(mock_wallet)
mock_nonsec_get_wallet_record.side_effect = test_module.StorageNotFoundError()
mock_prover_del_cred.side_effect = IndyError(
error_code=ErrorCode.WalletItemNotFound
)
with self.assertRaises(test_module.WalletNotFoundError):
await holder.delete_credential("credential_id")
mock_prover_del_cred.assert_called_once_with(
mock_wallet.handle, "credential_id"
)
mock_prover_del_cred.side_effect = IndyError(
error_code=ErrorCode.CommonInvalidParam1
)
with self.assertRaises(test_module.HolderError):
await holder.delete_credential("credential_id")
assert mock_prover_del_cred.call_count == 2
async def test_verify_presentation_x_indy(self, mock_verify):
mock_verify.side_effect = IndyError(error_code=1)
with async_mock.patch.object(
self.verifier, "pre_verify", async_mock.CoroutineMock(
)) as mock_pre_verify, async_mock.patch.object(
self.verifier, "non_revoc_intervals", async_mock.MagicMock(
)) as mock_non_revox, async_mock.patch.object(
IndyLedgerRequestsExecutor,
"get_ledger_for_identifier") as mock_get_ledger:
mock_get_ledger.return_value = ("test", self.ledger)
verified = await self.verifier.verify_presentation(
INDY_PROOF_REQ_NAME,
INDY_PROOF_NAME,
"schemas",
{"LjgpST2rjsoxYegQDRm7EL:3:CL:19:tag": {
"value": {}
}},
REV_REG_DEFS,
"rev_reg_entries",
)
mock_verify.assert_called_once_with(
json.dumps(INDY_PROOF_REQ_NAME),
json.dumps(INDY_PROOF_NAME),
json.dumps("schemas"),
json.dumps({"LjgpST2rjsoxYegQDRm7EL:3:CL:19:tag": {
"value": {}
}}),
json.dumps(REV_REG_DEFS),
json.dumps("rev_reg_entries"),
)
assert not verified
async def test_verify_presentation_x_indy(self, mock_verify):
mock_verify.side_effect = IndyError(error_code=1)
with async_mock.patch.object(
self.verifier, "pre_verify", async_mock.CoroutineMock(
)) as mock_pre_verify, async_mock.patch.object(
self.verifier, "non_revoc_intervals",
async_mock.MagicMock()) as mock_non_revox:
verified = await self.verifier.verify_presentation(
INDY_PROOF_REQ_NAME,
INDY_PROOF_NAME,
"schemas",
"credential_definitions",
REV_REG_DEFS,
"rev_reg_entries",
)
mock_verify.assert_called_once_with(
json.dumps(INDY_PROOF_REQ_NAME),
json.dumps(INDY_PROOF_NAME),
json.dumps("schemas"),
json.dumps("credential_definitions"),
json.dumps(REV_REG_DEFS),
json.dumps("rev_reg_entries"),
)
assert not verified
async def test_verify_presentation_x_indy(self, mock_verify):
mock_verify.side_effect = IndyError(error_code=1)
verifier = IndyVerifier("wallet")
with async_mock.patch.object(verifier,
"pre_verify",
return_value=(PreVerifyResult.OK, None)):
verified = await verifier.verify_presentation(
{"nonce": "1234567890"},
"presentation",
"schemas",
"credential_definitions",
"rev_reg_defs",
"rev_reg_entries",
)
mock_verify.assert_called_once_with(
json.dumps({"nonce": "1234567890"}),
json.dumps("presentation"),
json.dumps("schemas"),
json.dumps("credential_definitions"),
json.dumps("rev_reg_defs"),
json.dumps("rev_reg_entries"),
)
assert not verified
async def test_get_credential_x(self, mock_get_cred):
mock_get_cred.side_effect = IndyError("unexpected failure")
mock_wallet = async_mock.MagicMock()
holder = IndyHolder(mock_wallet)
with self.assertRaises(test_module.HolderError):
await holder.get_credential("credential_id")
async def test_get_credential_not_found(self, mock_get_cred):
mock_get_cred.side_effect = IndyError(error_code=ErrorCode.WalletItemNotFound)
mock_wallet = async_mock.MagicMock()
holder = IndyHolder(mock_wallet)
with self.assertRaises(test_module.WalletNotFoundError):
await holder.get_credential("credential_id")
async def test_create_credential_x_indy(
self,
mock_tails_reader,
mock_indy_create_credential,
):
test_schema = {"attrNames": ["attr1"]}
test_offer = {
"schema_id": SCHEMA_ID,
"cred_def_id": CRED_DEF_ID,
"key_correctness_proof": {
"c": "...",
"xz_cap": "...",
"xr_cap": ["..."]
},
"nonce": "...",
}
test_request = {"test": "request"}
test_values = {"attr1": "value1"}
test_credential = {"test": "credential"}
test_cred_rev_id = "42"
test_rr_delta = TEST_RR_DELTA
mock_indy_create_credential.side_effect = IndyError(
error_code=ErrorCode.WalletInvalidHandle)
with async_mock.patch.object(
test_module, "IssuerCredRevRecord",
async_mock.MagicMock()) as mock_issuer_cr_rec:
mock_issuer_cr_rec.return_value.save = async_mock.CoroutineMock()
mock_issuer_cr_rec.retrieve_by_ids = async_mock.CoroutineMock(
return_value=async_mock.MagicMock(
set_state=async_mock.CoroutineMock(), ))
with self.assertRaises(test_module.IssuerError):
await self.issuer.create_credential(
test_schema,
test_offer,
test_request,
test_values,
"dummy-cxid",
)
async def register_storage_library(storage_type: str, c_library: str,
entry_point: str) -> None:
"""
Load a wallet storage plug-in.
An indy-sdk wallet storage plug-in is a shared library; relying parties must explicitly
load it before creating or opening a wallet with the plug-in.
The implementation loads a dynamic library and calls an entry point; internally,
the plug-in calls the indy-sdk wallet
async def register_wallet_storage_library(storage_type: str, c_library: str, fn_pfx: str).
:param storage_type: wallet storage type
:param c_library: plug-in library
:param entry_point: function to initialize the library
"""
LOGGER.debug(
'WalletManager.register_storage_library >>> storage_type %s, c_library %s, entry_point %s',
storage_type, c_library, entry_point)
try:
stg_lib = CDLL(c_library)
result = stg_lib[entry_point]()
if result:
LOGGER.debug(
'WalletManager.register_storage_library <!< indy error code %s on storage library entry at %s',
result, entry_point)
raise IndyError(result)
LOGGER.info('Loaded storage library type %s (%s)', storage_type,
c_library)
except IndyError as x_indy:
LOGGER.debug(
'WalletManager.register_storage_library <!< indy error code %s on load of storage library %s %s',
x_indy.error_code, storage_type, c_library)
raise
LOGGER.debug('WalletManager.register_storage_library <<<')
async def test_create_credential_x_indy(
self, mock_tails_reader, mock_indy_create_credential
):
test_schema = {"attrNames": ["attr1"]}
test_offer = {
"schema_id": SCHEMA_ID,
"cred_def_id": CRED_DEF_ID,
"key_correctness_proof": {"c": "...", "xz_cap": "...", "xr_cap": ["..."]},
"nonce": "...",
}
test_request = {"test": "request"}
test_values = {"attr1": "value1"}
test_credential = {"test": "credential"}
test_cred_rev_id = "42"
test_rr_delta = TEST_RR_DELTA
mock_indy_create_credential.side_effect = IndyError(
error_code=ErrorCode.WalletInvalidHandle
)
with self.assertRaises(IssuerError):
await self.issuer.create_credential(
test_schema, test_offer, test_request, test_values
)
async def test_create_revoke_credentials_x(
self,
mock_indy_merge_rr_deltas,
mock_indy_revoke_credential,
mock_tails_reader,
mock_indy_create_credential,
):
test_schema = {"attrNames": ["attr1"]}
test_offer = {
"schema_id": SCHEMA_ID,
"cred_def_id": CRED_DEF_ID,
"key_correctness_proof": {
"c": "...",
"xz_cap": "...",
"xr_cap": ["..."]
},
"nonce": "...",
}
test_request = {"test": "request"}
test_values = {"attr1": "value1"}
test_cred = {
"schema_id": SCHEMA_ID,
"cred_def_id": CRED_DEF_ID,
"rev_reg_id": REV_REG_ID,
"values": {
"attr1": {
"raw": "value1",
"encoded": "123456123899216581404"
}
},
"signature": {
"...": "..."
},
"signature_correctness_proof": {
"...": "..."
},
"rev_reg": {
"accum": "21 12E8..."
},
"witness": {
"omega": "21 1369..."
},
}
test_cred_rev_ids = ["42", "54", "103"]
test_rr_delta = TEST_RR_DELTA
mock_indy_create_credential.side_effect = [(
json.dumps(test_cred),
cr_id,
test_rr_delta,
) for cr_id in test_cred_rev_ids]
with self.assertRaises(test_module.IssuerError): # missing attribute
cred_json, revoc_id = await self.issuer.create_credential(
test_schema,
test_offer,
test_request,
{},
"dummy-cxid",
)
with async_mock.patch.object(
test_module, "IssuerCredRevRecord",
async_mock.MagicMock()) as mock_issuer_cr_rec:
mock_issuer_cr_rec.return_value.save = async_mock.CoroutineMock(
side_effect=test_module.StorageError(
"could not store" # not fatal; maximize coverage
))
mock_issuer_cr_rec.retrieve_by_ids = async_mock.CoroutineMock(
return_value=async_mock.MagicMock(
set_state=async_mock.CoroutineMock(
side_effect=test_module.StorageError(
"could not store" # not fatal; maximize coverage
)), ))
(cred_json,
cred_rev_id) = await self.issuer.create_credential( # main line
test_schema,
test_offer,
test_request,
test_values,
"dummy-cxid",
REV_REG_ID,
"/tmp/tails/path/dummy",
)
mock_indy_create_credential.assert_called_once()
(
call_wallet,
call_offer,
call_request,
call_values,
call_etc1,
call_etc2,
) = mock_indy_create_credential.call_args[0]
assert call_wallet is self.wallet.handle
assert json.loads(call_offer) == test_offer
assert json.loads(call_request) == test_request
values = json.loads(call_values)
assert "attr1" in values
mock_indy_revoke_credential.side_effect = [
json.dumps(TEST_RR_DELTA),
IndyError(
error_code=ErrorCode.AnoncredsInvalidUserRevocId,
error_details={"message": "already revoked"},
),
IndyError(
error_code=ErrorCode.UnknownCryptoTypeError,
error_details={"message": "truly an outlier"},
),
]
mock_indy_merge_rr_deltas.return_value = json.dumps(TEST_RR_DELTA)
(result, failed) = await self.issuer.revoke_credentials(
REV_REG_ID,
tails_file_path="dummy",
cred_rev_ids=test_cred_rev_ids)
assert json.loads(result) == TEST_RR_DELTA
assert failed == ["54", "103"]
assert mock_indy_revoke_credential.call_count == 3
mock_indy_merge_rr_deltas.assert_not_called()
async def test_credential_definition_in_wallet_x(self,
mock_indy_create_offer):
mock_indy_create_offer.side_effect = IndyError(
error_code=ErrorCode.WalletInvalidHandle)
with self.assertRaises(test_module.IssuerError):
await self.issuer.credential_definition_in_wallet(CRED_DEF_ID)
async def test_get_credential_x(self, mock_get_cred):
mock_get_cred.side_effect = IndyError("unexpected failure")
with self.assertRaises(test_module.IndyHolderError):
await self.holder.get_credential("credential_id")
