def groups():
app_mock = mock.MagicMock(spec_set=ControllerApplication)
groups = zigpy.group.Groups(app_mock)
groups.listener_event = mock.MagicMock()
groups.add_group(FIXTURE_GRP_ID, FIXTURE_GRP_NAME, suppress_event=True)
return groups
async def test_sign_credential(self):
POSTED_REQUEST = { # posted json
"verkey": self.did_info.verkey,
"doc": {
"credential": {
"@context": [
"https://www.w3.org/2018/credentials/v1",
"https://www.w3.org/2018/credentials/examples/v1",
],
"id": "http://example.gov/credentials/3732",
"type": [
"VerifiableCredential",
"UniversityDegreeCredential",
],
"issuer": (
"did:key:" "z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
),
"issuanceDate": "2020-03-10T04:24:12.164Z",
"credentialSubject": {
"id": (
"did:key:"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
),
"degree": {
"type": "BachelorDegree",
"name": u"Bachelor of Encyclopædic Arts",
},
},
},
"options": {
# "type": "Ed25519Signature2018", exercise default
# "created": exercise default of now
"creator": (
"did:key:"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd#"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
),
"verificationMethod": (
"did:key:"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd#"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
),
"proofPurpose": "assertionMethod",
},
},
}
self.request.json = async_mock.CoroutineMock(
return_value=POSTED_REQUEST)
with async_mock.patch.object(test_module.web,
"json_response") as mock_response:
result = await test_module.sign(self.request)
assert result == mock_response.return_value
mock_response.assert_called_once()
assert "signed_doc" in mock_response.call_args[0][0]
assert "error" not in mock_response.call_args[0][0]
# short circuit: does not reach expand/compact
posted_request_x = deepcopy(POSTED_REQUEST)
posted_request_x["doc"]["options"].pop("verificationMethod")
posted_request_x["doc"]["options"].pop("creator")
self.request.json = async_mock.CoroutineMock(
return_value=posted_request_x)
with async_mock.patch.object(test_module.web, "json_response",
async_mock.MagicMock()) as mock_response:
mock_response.side_effect = lambda x: json.dumps(x)
result = await test_module.sign(self.request)
assert "error" in json.loads(result)
# compact, expand take a LONG TIME: do them once above, mock for error cases
posted_request = deepcopy(POSTED_REQUEST)
self.request.json = async_mock.CoroutineMock(
return_value=posted_request)
with async_mock.patch.object(jsonld, "compact", async_mock.MagicMock(
)) as mock_compact, async_mock.patch.object(
jsonld, "expand", async_mock.MagicMock(
)) as mock_expand, async_mock.patch.object(
test_module.web, "json_response",
async_mock.MagicMock()) as mock_response:
mock_expand.return_value = [async_mock.MagicMock()]
mock_compact.return_value = {} # drop all attributes
mock_response.side_effect = lambda x: json.dumps(x)
result = await test_module.sign(self.request)
assert "error" in json.loads(result)
self.context.session_inject[BaseWallet] = None
with self.assertRaises(test_module.web.HTTPForbidden):
await test_module.sign(self.request)
def setUp(self):
self.mock_context = async_mock.MagicMock()
self.test_instance = test_module.PresentationManager(self.mock_context)
def test_reset_frame(app):
app._handle_reset_request = mock.MagicMock(spec_set=app._handle_reset_request)
app.ezsp_callback_handler("_reset_controller_application", (mock.sentinel.error,))
assert app._handle_reset_request.call_count == 1
assert app._handle_reset_request.call_args[0][0] is mock.sentinel.error
async def test_verify_bad_ver_meth_not_ver_meth(mock_resolver,
mock_verify_request,
mock_response):
mock_resolver.dereference.return_value = async_mock.MagicMock(spec=Service)
await test_module.verify(mock_verify_request)
assert "error" in mock_response.call_args[0][0]
def test_frame_handler_unknown_device(app, aps, ieee):
app.handle_join = mock.MagicMock()
app.add_device(ieee, 99)
_frame_handler(app, aps, ieee, 0)
assert app.handle_message.call_count == 0
assert app.handle_join.call_count == 0
def test_join_handler(app, ieee):
# Calls device.initialize, leaks a task
app.handle_join = mock.MagicMock()
app.ezsp_callback_handler("trustCenterJoinHandler", [1, ieee, None, None, None])
assert ieee not in app.devices
assert app.handle_join.call_count == 0
def test_add_custom_output_cluster(ep):
mock_cluster = mock.MagicMock()
ep.add_output_cluster(0, mock_cluster)
assert 0 in ep.out_clusters
assert ep.out_clusters[0] is mock_cluster
async def test_called_auto_present_x(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {
"0_favourite_uuid": {
"name": "favourite",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
"1_icon_uuid": {
"name": "icon",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
},
"requested_predicates": {},
}
)
request_context.message_receipt = MessageReceipt()
mock_px_rec = async_mock.MagicMock(
presentation_proposal_dict={
"presentation_proposal": {
"@type": DIDCommPrefix.qualify_current(
"present-proof/1.0/presentation-preview"
),
"attributes": [
{"name": "favourite", "cred_def_id": CD_ID, "value": "potato"},
{"name": "icon", "cred_def_id": CD_ID, "value": "cG90YXRv"},
],
"predicates": [],
}
},
auto_present=True,
save_error_state=async_mock.CoroutineMock(),
)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(
return_value=[{"cred_info": {"referent": "dummy"}}]
)
)
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = mock_px_rec
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=mock_px_rec
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=mock_px_rec
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
side_effect=[
test_module.IndyHolderError(),
test_module.StorageError(),
]
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
await handler.handle(request_context, responder)
mock_px_rec.save_error_state.assert_called_once()
def test_handle_request_unknown(ep):
hdr = mock.MagicMock()
hdr.command_id = mock.sentinel.command_id
ep.handle_message(mock.sentinel.profile, 99, hdr, mock.sentinel.args)
def ep():
dev = mock.MagicMock()
return endpoint.Endpoint(dev, 1)
def test_handle_message_output(ep):
c = ep.add_output_cluster(0)
c.handle_message = mock.MagicMock()
ep.handle_message(mock.sentinel.profile, 0, mock.sentinel.hdr, mock.sentinel.data)
c.handle_message.assert_called_once_with(mock.sentinel.hdr, mock.sentinel.data)
async def test_close_x(self):
context = InjectionContext()
mgr = InboundTransportManager(context, None)
mock_session = async_mock.MagicMock(response_buffer=async_mock.MagicMock())
mgr.closed_session(mock_session)
def group():
groups_mock = mock.MagicMock(spec_set=zigpy.group.Groups)
groups_mock.application.mrequest = CoroutineMock()
return zigpy.group.Group(FIXTURE_GRP_ID, FIXTURE_GRP_NAME, groups_mock)
async def test_generate_registry_etc(self):
CRED_DEF_ID = f"{TestRecord.test_did}:3:CL:1234:default"
REV_REG_ID = f"{TestRecord.test_did}:4:{CRED_DEF_ID}:CL_ACCUM:0"
rec = IssuerRevRegRecord(issuer_did=TestRecord.test_did,
cred_def_id=CRED_DEF_ID)
issuer = async_mock.MagicMock(BaseIssuer)
self.context.injector.bind_instance(BaseIssuer, issuer)
with async_mock.patch.object(
issuer, "create_and_store_revocation_registry",
async_mock.CoroutineMock()) as mock_create_store_rr:
mock_create_store_rr.side_effect = IssuerError("Not this time")
with self.assertRaises(RevocationError):
await rec.generate_registry(self.context, None)
issuer.create_and_store_revocation_registry.return_value = (
REV_REG_ID,
json.dumps({
"value": {
"tailsHash":
"59NY25UEV8a5CzNkXFQMppwofUxtYtf4FDp1h9xgeLcK",
"tailsLocation": "point at infinity",
}
}),
json.dumps({"revoc_reg_entry": "dummy-entry"}),
)
await rec.generate_registry(self.context, None)
assert rec.revoc_reg_id == REV_REG_ID
assert rec.state == IssuerRevRegRecord.STATE_GENERATED
assert rec.tails_hash == "59NY25UEV8a5CzNkXFQMppwofUxtYtf4FDp1h9xgeLcK"
assert rec.tails_local_path == "point at infinity"
rec.set_tails_file_public_uri("dummy")
assert rec.tails_public_uri == "dummy"
assert rec.revoc_reg_def["value"]["tailsLocation"] == "dummy"
ledger = await self.context.inject(BaseLedger)
await rec.publish_registry_definition(self.context)
ledger.send_revoc_reg_def.assert_called_once()
await rec.publish_registry_entry(self.context)
ledger.send_revoc_reg_entry.assert_called_once()
rev_reg = await rec.get_registry()
assert type(rev_reg) == RevocationRegistry
queried = await IssuerRevRegRecord.query_by_cred_def_id(
context=self.context,
cred_def_id=CRED_DEF_ID,
state=IssuerRevRegRecord.STATE_GENERATED,
)
assert len(queried) == 1
retrieved = await IssuerRevRegRecord.retrieve_by_revoc_reg_id(
context=self.context, revoc_reg_id=rec.revoc_reg_id)
assert retrieved.revoc_reg_id == rec.revoc_reg_id
await rec.mark_full(self.context)
assert rec.state == IssuerRevRegRecord.STATE_FULL
data = rec.serialize()
model_instance = IssuerRevRegRecord.deserialize(data)
assert isinstance(model_instance, IssuerRevRegRecord)
assert model_instance == rec
async def test_called_auto_present_pred_multi_match(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {},
"requested_predicates": {
"0_score_GE_uuid": {
"name": "score",
"p_type": ">=",
"p_value": 1000000,
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
}
},
}
)
request_context.message_receipt = MessageReceipt()
px_rec_instance = test_module.V10PresentationExchange(auto_present=True)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(
return_value=[
{"cred_info": {"referent": "dummy-0"}},
{"cred_info": {"referent": "dummy-1"}},
]
)
)
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = px_rec_instance
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
return_value=(px_rec_instance, "presentation_message")
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_presentation.assert_called_once()
mock_pres_mgr.return_value.receive_request.assert_called_once_with(
px_rec_instance
)
messages = responder.messages
assert len(messages) == 1
(result, target) = messages[0]
assert result == "presentation_message"
assert target == {}
async def test_credential_revoked(self):
mock_wallet = async_mock.MagicMock()
holder = test_module.IndySdkHolder(mock_wallet)
ledger = async_mock.MagicMock()
ledger.__aenter__ = async_mock.CoroutineMock(return_value=ledger)
ledger.get_revoc_reg_delta = async_mock.CoroutineMock(
return_value=(
{"value": {"...": "..."}},
1234567890,
)
)
with async_mock.patch.object( # no creds revoked
holder, "get_credential", async_mock.CoroutineMock()
) as mock_get_cred:
mock_get_cred.return_value = json.dumps(
{
"rev_reg_id": "dummy-rrid",
"cred_rev_id": "123",
"...": "...",
}
)
result = await holder.credential_revoked("credential_id", ledger)
assert not result
with async_mock.patch.object( # cred not revocable
holder, "get_credential", async_mock.CoroutineMock()
) as mock_get_cred:
mock_get_cred.return_value = json.dumps(
{
"rev_reg_id": None,
"cred_rev_id": None,
"...": "...",
}
)
result = await holder.credential_revoked("credential_id", ledger)
assert not result
ledger.get_revoc_reg_delta = async_mock.CoroutineMock(
return_value=(
{
"value": {
"revoked": [1, 2, 3],
"...": "...",
}
},
1234567890,
)
)
with async_mock.patch.object( # cred not revoked
holder, "get_credential", async_mock.CoroutineMock()
) as mock_get_cred:
mock_get_cred.return_value = json.dumps(
{
"rev_reg_id": "dummy-rrid",
"cred_rev_id": "123",
"...": "...",
}
)
result = await holder.credential_revoked("credential_id", ledger)
assert not result
with async_mock.patch.object( # cred revoked
holder, "get_credential", async_mock.CoroutineMock()
) as mock_get_cred:
mock_get_cred.return_value = json.dumps(
{
"rev_reg_id": "dummy-rrid",
"cred_rev_id": "2",
"...": "...",
}
)
result = await holder.credential_revoked("credential_id", ledger)
assert result
async def test_called_auto_present_bait_and_switch(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {
"0_favourite_uuid": {
"name": "favourite",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
}
},
"requested_predicates": {},
}
)
request_context.message_receipt = MessageReceipt()
px_rec_instance = test_module.V10PresentationExchange(
presentation_proposal_dict={
"presentation_proposal": {
"@type": DIDCommPrefix.qualify_current(
"present-proof/1.0/presentation-preview"
),
"attributes": [
{"name": "favourite", "cred_def_id": CD_ID, "value": "potato"}
],
"predicates": [],
}
},
auto_present=True,
)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
by_reft = async_mock.CoroutineMock(
return_value=[
{
"cred_info": {
"referent": "dummy-0",
"cred_def_id": CD_ID,
"attrs": {"ident": "zero", "favourite": "yam"},
}
},
{
"cred_info": {
"referent": "dummy-1",
"cred_def_id": CD_ID,
"attrs": {"ident": "one", "favourite": "turnip"},
}
},
{
"cred_info": {
"referent": "dummy-2",
"cred_def_id": CD_ID,
"attrs": {
"ident": "two",
"favourite": "the idea of a potato but not a potato",
},
}
},
]
)
mock_holder.get_credentials_for_presentation_request_by_referent = by_reft
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = px_rec_instance
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
return_value=(px_rec_instance, "presentation_message")
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_presentation.assert_not_called()
mock_pres_mgr.return_value.receive_request.assert_called_once_with(
px_rec_instance
)
assert not responder.messages
def test_dup_send_success(app, aps, ieee):
req = app._pending[253] = mock.MagicMock()
req.result.set_result.side_effect = asyncio.InvalidStateError()
app.ezsp_callback_handler("messageSentHandler", [None, 0xBEED, aps, 253, 0, b""])
assert req.result.set_exception.call_count == 0
assert req.result.set_result.call_count == 1
async def test_create_bound_offer(self):
TEST_DID = "LjgpST2rjsoxYegQDRm7EL"
schema_id = f"{TEST_DID}:2:bc-reg:1.0"
schema_id_parts = schema_id.split(":")
cred_def_id = f"{TEST_DID}:3:CL:18:tag"
connection_id = "test_conn_id"
comment = "comment"
preview = CredentialPreview(
attributes=(CredAttrSpec(name="attr", value="value"), ))
proposal = CredentialProposal(credential_proposal=preview)
exchange = V10CredentialExchange(
credential_proposal_dict=proposal.serialize(),
role=V10CredentialExchange.ROLE_ISSUER,
)
with async_mock.patch.object(
V10CredentialExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
V10CredentialExchange, "get_cached_key",
autospec=True) as get_cached_key, async_mock.patch.object(
V10CredentialExchange, "set_cached_key",
autospec=True) as set_cached_key:
self.ledger.get_credential_definition = async_mock.CoroutineMock(
return_value={"value": {}})
get_cached_key.return_value = None
cred_offer = {"cred_def_id": cred_def_id, "schema_id": schema_id}
issuer = async_mock.MagicMock(BaseIssuer, autospec=True)
issuer.create_credential_offer = async_mock.CoroutineMock(
return_value=json.dumps(cred_offer))
self.context.injector.bind_instance(BaseIssuer, issuer)
self.storage = BasicStorage()
self.context.injector.bind_instance(BaseStorage, self.storage)
cred_def_record = StorageRecord(
CRED_DEF_SENT_RECORD_TYPE,
cred_def_id,
{
"schema_id": schema_id,
"schema_issuer_did": schema_id_parts[0],
"schema_name": schema_id_parts[-2],
"schema_version": schema_id_parts[-1],
"issuer_did": TEST_DID,
"cred_def_id": cred_def_id,
"epoch": str(int(time())),
},
)
storage: BaseStorage = await self.context.inject(BaseStorage)
await storage.add_record(cred_def_record)
(ret_exchange, ret_offer) = await self.manager.create_offer(
credential_exchange_record=exchange, comment=comment)
assert ret_exchange is exchange
save_ex.assert_called_once()
issuer.create_credential_offer.assert_called_once_with(cred_def_id)
assert exchange.thread_id == ret_offer._thread_id
assert exchange.schema_id == schema_id
assert exchange.credential_definition_id == cred_def_id
assert exchange.role == V10CredentialExchange.ROLE_ISSUER
assert exchange.state == V10CredentialExchange.STATE_OFFER_SENT
assert exchange.credential_offer == cred_offer
# additionally check that credential preview was passed through
assert ret_offer.credential_preview.attributes == preview.attributes
def test_force_remove(app, ieee):
app._ezsp.removeDevice.side_effect = asyncio.coroutine(mock.MagicMock())
dev = mock.MagicMock()
loop = asyncio.get_event_loop()
loop.run_until_complete(app.force_remove(dev))
async def test_create_request(self):
schema_id = "LjgpST2rjsoxYegQDRm7EL:2:bc-reg:1.0"
cred_def_id = "LjgpST2rjsoxYegQDRm7EL:3:CL:18:tag"
connection_id = "test_conn_id"
nonce = "0"
indy_offer = {
"schema_id": schema_id,
"cred_def_id": cred_def_id,
"nonce": nonce,
}
indy_cred_req = {"schema_id": schema_id, "cred_def_id": cred_def_id}
thread_id = "thread-id"
holder_did = "did"
stored_exchange = V10CredentialExchange(
connection_id=connection_id,
credential_definition_id=cred_def_id,
credential_offer=indy_offer,
initiator=V10CredentialExchange.INITIATOR_SELF,
role=V10CredentialExchange.ROLE_HOLDER,
schema_id=schema_id,
thread_id=thread_id,
)
self.cache = BasicCache()
self.context.injector.bind_instance(BaseCache, self.cache)
with async_mock.patch.object(V10CredentialExchange,
"save",
autospec=True) as save_ex:
cred_def = {"cred": "def"}
self.ledger.get_credential_definition = async_mock.CoroutineMock(
return_value=cred_def)
cred_req_meta = {}
holder = async_mock.MagicMock()
holder.create_credential_request = async_mock.CoroutineMock(
return_value=(json.dumps(indy_cred_req),
json.dumps(cred_req_meta)))
self.context.injector.bind_instance(BaseHolder, holder)
ret_exchange, ret_request = await self.manager.create_request(
stored_exchange, holder_did)
holder.create_credential_request.assert_called_once_with(
indy_offer, cred_def, holder_did)
assert ret_request.indy_cred_req() == indy_cred_req
assert ret_request._thread_id == thread_id
assert ret_exchange.state == V10CredentialExchange.STATE_REQUEST_SENT
# cover case with request in cache
stored_exchange.credential_request = None
await self.manager.create_request(stored_exchange, holder_did)
# cover case with existing cred req
stored_exchange.credential_request = indy_cred_req
(
ret_existing_exchange,
ret_existing_request,
) = await self.manager.create_request(stored_exchange, holder_did)
assert ret_existing_exchange == ret_exchange
assert ret_existing_request._thread_id == thread_id
def mock_response():
json_response = async_mock.MagicMock()
temp_value = test_module.web.json_response
test_module.web.json_response = json_response
yield json_response
test_module.web.json_response = temp_value
async def test_issue_credential(self):
schema_id = "LjgpST2rjsoxYegQDRm7EL:2:bc-reg:1.0"
cred_def_id = "LjgpST2rjsoxYegQDRm7EL:3:CL:18:tag"
connection_id = "test_conn_id"
comment = "comment"
cred_values = {"attr": "value"}
indy_offer = {
"schema_id": schema_id,
"cred_def_id": cred_def_id,
"nonce": "0"
}
indy_cred_req = {"schema_id": schema_id, "cred_def_id": cred_def_id}
thread_id = "thread-id"
stored_exchange = V10CredentialExchange(
connection_id=connection_id,
credential_offer=indy_offer,
credential_request=indy_cred_req,
initiator=V10CredentialExchange.INITIATOR_SELF,
role=V10CredentialExchange.ROLE_ISSUER,
thread_id=thread_id,
)
schema = object()
self.ledger.get_schema = async_mock.CoroutineMock(return_value=schema)
issuer = async_mock.MagicMock()
cred = {"indy": "credential"}
cred_revoc = object()
issuer.create_credential = async_mock.CoroutineMock(
return_value=(json.dumps(cred), cred_revoc))
self.context.injector.bind_instance(BaseIssuer, issuer)
with async_mock.patch.object(V10CredentialExchange,
"save",
autospec=True) as save_ex:
ret_exchange, ret_cred_issue = await self.manager.issue_credential(
stored_exchange,
comment=comment,
credential_values=cred_values)
save_ex.assert_called_once()
issuer.create_credential.assert_called_once_with(
schema, indy_offer, indy_cred_req, cred_values, None, None)
assert ret_exchange.credential == cred
assert ret_cred_issue.indy_credential() == cred
assert ret_exchange.state == V10CredentialExchange.STATE_ISSUED
assert ret_cred_issue._thread_id == thread_id
# cover case with existing cred
stored_exchange.credential = cred
(
ret_existing_exchange,
ret_existing_cred,
) = await self.manager.issue_credential(
stored_exchange,
comment=comment,
credential_values=cred_values)
assert ret_existing_exchange == ret_exchange
assert ret_existing_cred._thread_id == thread_id
async def test_verify_credential(self):
POSTED_REQUEST = { # posted json
"verkey": (
# pulled from the did:key in example
"5yKdnU7ToTjAoRNDzfuzVTfWBH38qyhE1b9xh4v8JaWF"
),
"doc": {
"@context": [
"https://www.w3.org/2018/credentials/v1",
"https://www.w3.org/2018/credentials/examples/v1",
],
"id": "http://example.gov/credentials/3732",
"type": ["VerifiableCredential", "UniversityDegreeCredential"],
"issuer": ("did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"),
"issuanceDate": "2020-03-10T04:24:12.164Z",
"credentialSubject": {
"id": (
"did:key:" "z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
),
"degree": {
"type": "BachelorDegree",
"name": "Bachelor of Science and Arts",
},
},
"proof": {
"type": "Ed25519Signature2018",
"created": "2020-04-10T21:35:35Z",
"verificationMethod": (
"did:key:"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc"
"4tXLt9DoHd#z6MkjRagNiMu91DduvCvgEsqLZD"
"VzrJzFrwahc4tXLt9DoHd"
),
"proofPurpose": "assertionMethod",
"jws": (
"eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaX"
"QiOlsiYjY0Il19..l9d0YHjcFAH2H4dB9xlWFZQLUp"
"ixVCWJk0eOt4CXQe1NXKWZwmhmn9OQp6YxX0a2Lffe"
"gtYESTCJEoGVXLqWAA"
),
},
},
}
self.request.json = async_mock.CoroutineMock(
return_value=POSTED_REQUEST)
with async_mock.patch.object(test_module.web,
"json_response") as mock_response:
result = await test_module.verify(self.request)
assert result == mock_response.return_value
mock_response.assert_called_once_with({"valid":
True}) # expected response
# compact, expand take a LONG TIME: do them once above, mock for error cases
with async_mock.patch.object(jsonld, "compact", async_mock.MagicMock(
)) as mock_compact, async_mock.patch.object(
jsonld, "expand", async_mock.MagicMock(
)) as mock_expand, async_mock.patch.object(
test_module.web, "json_response",
async_mock.MagicMock()) as mock_response:
mock_expand.return_value = [async_mock.MagicMock()]
mock_compact.return_value = {
"@context": "...",
"id": "...",
"type": ["...", "..."],
"proof": {},
"https://www.w3.org/2018/credentials#credentialSubject": {
"id":
"did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd",
"https://example.org/examples#degree": {
"type": "https://example.org/examples#BachelorDegree",
"http://schema.org/name": {
"type":
"http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML",
"@value": "Bachelor of Science and Arts",
},
},
},
"https://www.w3.org/2018/credentials#issuanceDate": {
"type": "xsd:dateTime",
"@value": "2020-03-10T04:24:12.164Z",
},
"https://www.w3.org/2018/credentials#issuer": {
"id":
"did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
},
}
mock_response.side_effect = lambda x: json.dumps(x)
result = await test_module.verify(self.request)
assert "error" in json.loads(result)
with async_mock.patch.object(jsonld, "compact", async_mock.MagicMock(
)) as mock_compact, async_mock.patch.object(
jsonld, "expand", async_mock.MagicMock(
)) as mock_expand, async_mock.patch.object(
test_module.web, "json_response",
async_mock.MagicMock()) as mock_response:
mock_expand.return_value = [async_mock.MagicMock()]
mock_compact.return_value = {
"@context": "...",
"id": "...",
"type": ["...", "..."],
"proof": {
"type":
"Ed25519Signature2018",
"created":
"2020-04-10T21:35:35Z",
"jws":
("eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19"
".."
"l9d0YHjcFAH2H4dB9xlWFZQLUpixVCWJk0eOt4CXQe1NXKWZwmhmn9OQ"
"p6YxX0a2LffegtYESTCJEoGVXLqWAA"),
"proofPurpose":
"assertionMethod",
"verificationMethod":
("did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd#"
"z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"),
},
"https://www.w3.org/2018/credentials#credentialSubject": {
"id":
"did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd",
},
"https://www.w3.org/2018/credentials#issuanceDate": {
"type": "xsd:dateTime",
"@value": "2020-03-10T04:24:12.164Z",
},
"https://www.w3.org/2018/credentials#issuer": {
"id":
"did:key:z6MkjRagNiMu91DduvCvgEsqLZDVzrJzFrwahc4tXLt9DoHd"
},
}
mock_response.side_effect = lambda x: json.dumps(x)
result = await test_module.verify(self.request)
assert "error" in json.loads(result)
self.context.session_inject[BaseWallet] = None
with self.assertRaises(test_module.web.HTTPForbidden):
await test_module.verify(self.request)
async def test_store_credential(self):
schema_id = "LjgpST2rjsoxYegQDRm7EL:2:bc-reg:1.0"
cred_def_id = "LjgpST2rjsoxYegQDRm7EL:3:CL:18:tag"
connection_id = "test_conn_id"
cred = {"cred_def_id": cred_def_id}
cred_req_meta = {"req": "meta"}
thread_id = "thread-id"
stored_exchange = V10CredentialExchange(
connection_id=connection_id,
credential_definition_id=cred_def_id,
credential_request_metadata=cred_req_meta,
credential_proposal_dict={"credential_proposal": {}},
raw_credential=cred,
initiator=V10CredentialExchange.INITIATOR_EXTERNAL,
role=V10CredentialExchange.ROLE_HOLDER,
thread_id=thread_id,
)
cred_def = object()
self.ledger.get_credential_definition = async_mock.CoroutineMock(
return_value=cred_def)
cred_id = "cred-id"
holder = async_mock.MagicMock()
holder.store_credential = async_mock.CoroutineMock(
return_value=cred_id)
stored_cred = {"stored": "cred"}
holder.get_credential = async_mock.CoroutineMock(
return_value=json.dumps(stored_cred))
self.context.injector.bind_instance(BaseHolder, holder)
with async_mock.patch.object(
V10CredentialExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
CredentialPreview, "deserialize",
autospec=True) as mock_preview_deserialize:
ret_exchange, ret_cred_ack = await self.manager.store_credential(
stored_exchange)
save_ex.assert_called_once()
self.ledger.get_credential_definition.assert_called_once_with(
cred_def_id)
holder.store_credential.assert_called_once_with(
cred_def,
cred,
cred_req_meta,
mock_preview_deserialize.return_value.mime_types.return_value,
credential_id=None,
rev_reg_def=None,
)
holder.get_credential.assert_called_once_with(cred_id)
assert ret_exchange.credential_id == cred_id
assert ret_exchange.credential == stored_cred
assert ret_exchange.state == V10CredentialExchange.STATE_ACKED
assert ret_cred_ack._thread_id == thread_id
async def test_post_process_routes(self):
mock_app = async_mock.MagicMock(_state={"swagger_dict": {}})
test_module.post_process_routes(mock_app)
assert "tags" in mock_app._state["swagger_dict"]
async def test_generate_registry_etc(self):
rec = IssuerRevRegRecord(
issuer_did=TEST_DID,
cred_def_id=CRED_DEF_ID,
revoc_reg_id=REV_REG_ID,
)
issuer = async_mock.MagicMock(IndyIssuer)
self.profile.context.injector.bind_instance(IndyIssuer, issuer)
with async_mock.patch.object(
issuer, "create_and_store_revocation_registry",
async_mock.CoroutineMock()) as mock_create_store_rr:
mock_create_store_rr.side_effect = IndyIssuerError("Not this time")
with self.assertRaises(RevocationError):
await rec.generate_registry(self.profile)
issuer.create_and_store_revocation_registry.return_value = (
REV_REG_ID,
json.dumps(REV_REG_DEF),
json.dumps(REV_REG_ENTRY),
)
with async_mock.patch.object(test_module, "move",
async_mock.MagicMock()) as mock_move:
await rec.generate_registry(self.profile)
assert rec.revoc_reg_id == REV_REG_ID
assert rec.state == IssuerRevRegRecord.STATE_GENERATED
assert rec.tails_hash == TAILS_HASH
assert rec.tails_local_path == join(
indy_client_dir(join("tails", REV_REG_ID)), rec.tails_hash)
with self.assertRaises(RevocationError):
await rec.set_tails_file_public_uri(self.profile, "dummy")
await rec.set_tails_file_public_uri(self.profile, TAILS_URI)
assert rec.tails_public_uri == TAILS_URI
assert rec.revoc_reg_def.value.tails_location == TAILS_URI
await rec.send_def(self.profile)
assert rec.state == IssuerRevRegRecord.STATE_POSTED
self.ledger.send_revoc_reg_def.assert_called_once()
await rec.send_entry(self.profile)
assert rec.state == IssuerRevRegRecord.STATE_ACTIVE
self.ledger.send_revoc_reg_entry.assert_called_once()
rev_reg = await rec.get_registry()
assert type(rev_reg) == RevocationRegistry
async with self.profile.session() as session:
queried = await IssuerRevRegRecord.query_by_cred_def_id(
session=session,
cred_def_id=CRED_DEF_ID,
state=IssuerRevRegRecord.STATE_ACTIVE,
)
assert len(queried) == 1
retrieved = await IssuerRevRegRecord.retrieve_by_revoc_reg_id(
session=session, revoc_reg_id=rec.revoc_reg_id)
assert retrieved.revoc_reg_id == rec.revoc_reg_id
await rec.set_state(session)
assert rec.state == IssuerRevRegRecord.STATE_FULL
data = rec.serialize()
model_instance = IssuerRevRegRecord.deserialize(data)
assert isinstance(model_instance, IssuerRevRegRecord)
assert model_instance == rec
async def test_register(self):
mock_app = async_mock.MagicMock()
mock_app.add_routes = async_mock.MagicMock()
await test_module.register(mock_app)
mock_app.add_routes.assert_called_once()
def endpoint():
app_mock = mock.MagicMock(spec_set=ControllerApplication)
ieee = t.EUI64(map(t.uint8_t, [0, 1, 2, 3, 4, 5, 6, 7]))
dev = zigpy.device.Device(app_mock, ieee, 65535)
return zigpy.endpoint.Endpoint(dev, 3)
