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)