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)