def init_vcxdemo(path): try: Vcxdemo.init(path) except VcxError as e: print('Error Initializing Vcx: ' + str(e)) assert False
def util_create_schema(source_id, schema_name): attr_names = ['name', 'account'] version = '1.0' schema_skeleton = { "name": schema_name, "version": version, "attr_names": attr_names, } size = len(Vcxdemo.schemas) Vcxdemo.create_schema(source_id, schema_name, schema_skeleton) assert len(Vcxdemo.schemas) == size + 1
def test_deserialize_accepted_credential_and_issue_credential(): init_vcxdemo() frank = Vcxdemo(SOURCE_ID, details=DETAILS) frank.deserialize_connection('connection.dat') frank.deserialize_credential('credential2.dat') assert type(frank.credential) == IssuerCredential frank.send_issuer_credential() assert frank.state['credential'] == State.Accepted
def test_format_proof_attr(): did = ENTERPRISE_DID schema_seq_number = 555 attr_list = ['name', 'account'] id = '12345' Vcxdemo.set_did(ENTERPRISE_DID) assert Vcxdemo.get_did() == ENTERPRISE_DID leela = Vcxdemo('leela') formatted_attr = Vcxdemo._create_attr(attr_list[0], did, schema_seq_number) assert formatted_attr['schema_seq_no'] == schema_seq_number assert formatted_attr['issuer_did'] == did assert formatted_attr['name'] == attr_list[0] proof_attr = Vcxdemo.format_proof_attrs(did, schema_seq_number, attr_list) assert len(proof_attr) == len(attr_list) assert proof_attr[0]['schema_seq_no'] == schema_seq_number leela.create_proof_request(id, 'Club Membership Proof', proof_attr) assert len(leela.proof_requests) > 0 assert isinstance(leela.get_proof_request(id), Proof)
def test_insert_credential_def_into_wallet(): init_vcxdemo() schema_name = 'Account Ledger' attr_names = ['name', 'account'] source_id = 'Planet Express' version = '1.0' schema_skeleton = { "name": source_id, "version": version, "attr_names": attr_names, } Vcxdemo.create_schema(source_id, schema_name, schema_skeleton) assert len(Vcxdemo.schemas) > 0 Vcxdemo.create_schema(source_id, schema_name, schema_skeleton) assert len(Vcxdemo.schemas) == 2 write_json_to_file(Vcxdemo.serialize_schema(0), 'schema.dat') # Credential Def name = 'Customer' schema_number = Vcxdemo.get_schema_sequence_number(0) Vcxdemo.create_credential_def(source_id, name, schema_number) assert len(Vcxdemo.credential_defs) > 0 assert Vcxdemo.credential_defs[name]
def test_demo(): random_enterprise_name = get_random_name() genesis_path = settings['genesis_path'] enterprise_config = { 'institution_name': random_enterprise_name, 'institution_logo_url': 'https://robohash.org/' + random_enterprise_name, 'genesis_path': genesis_path, 'wallet_name': settings['wallet_name'], 'wallet_key': settings['wallet_key'] } vcx_config_json = update_json_values(enterprise_config, config_dev) assert vcx_config_json['institution_name'] == random_enterprise_name write_json_to_file(vcx_config_json, 'utils/vcxconfig.json', sort_keys=True) schema_name = 'Club Membership' init_vcxdemo(VCXCONFIG_PATH) credential_name = 'Club Membership' schema_source_id = random_enterprise_name credential_def_source_id = random_enterprise_name connection_source_id = random_enterprise_name assert len(Vcxdemo.schemas) == 0 util_create_schema(schema_source_id, schema_name) write_json_to_file(Vcxdemo.serialize_schema(0), 'schema.dat') # Write Connection to file assert len(Vcxdemo.schemas) == 1 s0 = Vcxdemo.get_schema_attr_list(0) # Create Credential Def on Ledger (and wallet) schema_sequence_number = Vcxdemo.get_schema_sequence_number(0) Vcxdemo.create_credential_def(credential_def_source_id, credential_name, schema_sequence_number) assert len(Vcxdemo.credential_defs) > 0 assert Vcxdemo.credential_defs[credential_name] customer1 = Vcxdemo(connection_source_id) # Connection assert customer1.state['connection'] == State.Undefined customer1.connect() assert type(customer1.connection) == Connection assert customer1.state['connection'] == State.Accepted # Write Connection to file write_json_to_file(customer1.serialize_connection(), 'connection.dat') # Credential customer1.create_credential(Vcxdemo.get_schema_sequence_number(0), DETAILS[0], credential_name) assert type(customer1.credential) == IssuerCredential customer1.update_credential_state() assert customer1.state['credential'] == State.Initialized # Write Credential to file write_json_to_file(customer1.serialize_credential(), 'credential.dat') customer1.update_credential_state() assert customer1.state['credential'] == State.Initialized customer1.issue_credential_offer() customer1.update_credential_state() assert customer1.state['credential'] == State.OfferSent customer1.wait_for_credential_state(State.RequestReceived) print("About to send credential offer...") # time.sleep(5) customer1.send_issuer_credential() print("Waiting for credential state to become accepted") customer1.wait_for_credential_state(State.Accepted) print("Credential State became accepted") time.sleep(5) # Proof proof_id = '222' proof_attr = Vcxdemo.format_proof_attrs( Vcxdemo.did, Vcxdemo.get_schema_sequence_number(0), Vcxdemo.get_schema_attr_list(0)['attr_names']) source_id = 'Club Membership' request_proof(customer1, source_id, proof_attr, proof_id)
def test_lookup(): schema_filename = 'schema.dat' schema = None with open(schema_filename) as in_file: schema = json.load(in_file) Vcxdemo.init(VCXCONFIG_PATH) customer1 = Vcxdemo('Fry') customer1.deserialize_connection('connection.dat') assert isinstance(customer1.connection, Connection) customer1.deserialize_credential('credential.dat') Vcxdemo.deserialize_schema(schema_filename) lookup_schema = Vcxdemo.lookup_schema( 'FindSchema', Vcxdemo.get_schema_sequence_number(0)) Vcxdemo.schemas.append(lookup_schema) assert len(Vcxdemo.schemas) == 2 assert schema['sequence_num'] == Vcxdemo.get_schema_sequence_number(1)
def test_request_proof(): Vcxdemo.init(VCXCONFIG_PATH) customer1 = Vcxdemo('Fry') customer1.deserialize_connection('connection.dat') assert isinstance(customer1.connection, Connection) customer1.deserialize_credential('credential.dat') Vcxdemo.deserialize_schema('schema.dat') proof_id = '222' proof_attr = Vcxdemo.format_proof_attrs( Vcxdemo.did, Vcxdemo.get_schema_sequence_number(0), Vcxdemo.get_schema_attr_list(0)['attr_names']) customer1.create_proof_request(proof_id, 'Club Membership', proof_attr) customer1.wait_for_proof_state(proof_id, State.Initialized) assert customer1.get_proof_state(proof_id) == State.Initialized customer1.request_proof(proof_id) customer1.wait_for_proof_state(proof_id, State.OfferSent) assert customer1.get_proof_state(proof_id) == State.OfferSent customer1.wait_for_proof_state(proof_id, State.Accepted) assert customer1.get_proof_state(proof_id) == State.Accepted customer1.retrieve_proof(proof_id)
def test_schema(): expected_attrs = { "name": "Planet Express", "version": "1.0", "attr_names": ["name", "account"] } Vcxdemo.init(VCXCONFIG_PATH) filename = 'schema.dat' data = None try: with open(filename) as in_file: data = json.load(in_file) except IOError as e: print('error reading/opening %s: %s', (filename, e)) # deserialize from schema.dat file Vcxdemo.deserialize_schema(filename) assert len(Vcxdemo.schemas) == 1 assert isinstance(Vcxdemo.schemas[0], Schema) assert Vcxdemo.get_schema_sequence_number(0) == data['sequence_num'] s0 = Vcxdemo.get_schema_attr_list(0) s1 = data['data']['data'] assert s0 == s1 assert len(Vcxdemo.schemas) > 0 assert isinstance(Vcxdemo.get_schema(0), Schema) util_create_schema('Third Schema') assert len(Vcxdemo.schemas) == 2 s_created = Vcxdemo.get_schema_attr_list(1) Vcxdemo.deserialize_schema('schema.dat') assert len(Vcxdemo.schemas) == 3 s_deserialized = Vcxdemo.get_schema_attr_list(2) assert s_deserialized == s0 assert s_created == s0
def test_vcx_deserialize_connection_fulfill_credential(): try: Vcxdemo.init(VCXCONFIG_PATH) except VcxError as e: assert False frank = Vcxdemo(SOURCE_ID, details=DETAILS) frank.deserialize_connection('connection.dat') assert type(frank.connection) == Connection # Credential frank.create_credential(SCHEMA_SEQ_NUMBER, DETAILS[1], 'Planet Express Info') assert type(frank.credential) == IssuerCredential frank.update_credential_state() assert frank.state['credential'] == State.Initialized frank.issue_credential_offer() assert frank.state['credential'] == State.OfferSent frank.wait_for_credential_state(State.RequestReceived) assert frank.state['credential'] == State.RequestReceived # write credential out to credential2.dat try: with open('credential.dat', 'w') as out_file: json.dump(frank.serialize_credential(), out_file) except IOError as e: print('error writing to credential.dat: %s' % e)