def test_dumps_and_loads_response_command():
response = offchain.CommandResponseObject(
status=offchain.CommandResponseStatus.success,
cid="3185027f-0574-6f55-2668-3a38fdb5de98",
)
assert offchain.from_json(offchain.to_json(response),
offchain.CommandResponseObject) == response
assert json.loads(offchain.to_json(response)) == json.loads("""{
"status": "success",
"_ObjectType": "CommandResponseObject",
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98"
}""")
response = offchain.CommandResponseObject(
status=offchain.CommandResponseStatus.failure,
error=offchain.OffChainErrorObject(
type=offchain.OffChainErrorType.command_error,
code="code2",
field="signature",
message="abc",
),
cid="3185027f-0574-6f55-2668-3a38fdb5de98",
)
assert offchain.from_json(offchain.to_json(response),
offchain.CommandResponseObject) == response
assert json.loads(offchain.to_json(response)) == json.loads("""{
"status": "failure",
"_ObjectType": "CommandResponseObject",
"error": {
"type": "command_error",
"code": "code2",
"field": "signature",
"message": "abc"
},
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98"
}""")
def test_field_value_because_of_invalid_object_type_for_command():
request_json = """{
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98",
"command_type": "PaymentCommand",
"command": "invalid",
"_ObjectType": "CommandRequestObject"
}"""
with pytest.raises(offchain.FieldError, match="expect type dict, but got str") as e:
offchain.from_json(request_json)
assert e.value.code == "invalid_field_value"
def test_invalid_object():
request_json = "1111"
with pytest.raises(offchain.FieldError, match="expect json object, but got int: ") as e:
offchain.from_json(request_json)
assert e.value.code == "invalid_object"
request_json = "[22]"
with pytest.raises(offchain.FieldError, match="expect json object, but got list: ") as e:
offchain.from_json(request_json)
assert e.value.code == "invalid_object"
def test_invalid_object_type():
request_json = """{
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98",
"command_type": "PaymentCommand",
"command": {
"_ObjectType": "InvalidCommand"
},
"_ObjectType": "CommandRequestObject"
}"""
with pytest.raises(offchain.FieldError, match="could not find object type: InvalidCommand") as e:
offchain.from_json(request_json)
assert e.value.code == "invalid_field_value"
def assert_field_error(json_dic, code, field, match, command_type=offchain.PaymentCommandObject):
with pytest.raises(offchain.FieldError, match=match) as e:
req = offchain.from_json(json.dumps(json_dic))
offchain.from_dict(req.command, field_path="command")
assert e.value.code == code
assert e.value.field == field
def test_match_kyc_data():
ks = KycSample.gen("foo")
obj = offchain.from_json(ks.soft_match, offchain.KycDataObject)
assert ks.match_kyc_data("soft_match", obj)
assert not ks.match_kyc_data("reject", obj)
obj = replace(obj, legal_entity_name="hello")
assert ks.match_kyc_data("soft_match", obj)
obj = replace(obj, given_name="hello")
assert not ks.match_kyc_data("soft_match", obj)
def test_reference_id_command_result_object():
# Test can encode and decode correct response format
ref_id_command_result = offchain.ReferenceIDCommandResultObject(
receiver_address="dm1p7ujcndcl7nudzwt8fglhx6wxnvqqqqqqqqqqqqelu3xv", )
response = offchain.CommandResponseObject(
status=offchain.CommandResponseStatus.success,
cid="3185027f-0574-6f55-2668-3a38fdb5de98",
result=offchain.to_dict(ref_id_command_result),
)
assert offchain.from_json(offchain.to_json(response),
offchain.CommandResponseObject) == response
assert offchain.from_json(offchain.to_json(response)) == response
assert json.loads(offchain.to_json(response)) == json.loads("""{
"status": "success",
"_ObjectType": "CommandResponseObject",
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98",
"result": {
"_ObjectType": "ReferenceIDCommandResponse",
"receiver_address": "dm1p7ujcndcl7nudzwt8fglhx6wxnvqqqqqqqqqqqqelu3xv"
}
}""")
def _txn_payment_command(txn: Transaction) -> offchain.PaymentCommand:
return offchain.from_json(txn.command_json, offchain.PaymentCommand)
def test_to_json(factory):
cmd = factory.new_sender_payment_command()
assert cmd == offchain.from_json(offchain.to_json(cmd),
offchain.PaymentCommand)
def test_dumps_and_loads_request_command():
kyc_data = offchain.individual_kyc_data(
given_name="hello",
surname="world",
address=offchain.AddressObject(city="San Francisco"),
national_id=offchain.NationalIdObject(id_value="234121234"),
legal_entity_name="foo bar",
)
assert offchain.from_json(offchain.to_json(kyc_data), offchain.KycDataObject) == kyc_data
payment = offchain.PaymentObject(
reference_id="4185027f-0574-6f55-2668-3a38fdb5de98",
sender=offchain.PaymentActorObject(
address="lbr1p7ujcndcl7nudzwt8fglhx6wxn08kgs5tm6mz4usw5p72t",
status=offchain.StatusObject(status=offchain.Status.needs_kyc_data),
kyc_data=kyc_data,
metadata=["hello", "world"],
),
receiver=offchain.PaymentActorObject(
address="lbr1p7ujcndcl7nudzwt8fglhx6wxnvqqqqqqqqqqqqelu3xv",
status=offchain.StatusObject(
status=offchain.Status.abort,
abort_code="code1",
abort_message="code1 message",
),
),
action=offchain.PaymentActionObject(amount=1_000_000_000_000, currency="XUS", timestamp=1604902048),
original_payment_reference_id="0185027f-0574-6f55-2668-3a38fdb5de98",
)
assert offchain.from_json(offchain.to_json(payment), offchain.PaymentObject) == payment
request = offchain.CommandRequestObject(
command_type=offchain.CommandType.PaymentCommand,
command=offchain.to_dict(
offchain.PaymentCommandObject(
_ObjectType=offchain.CommandType.PaymentCommand,
payment=payment,
)
),
cid="3185027f-0574-6f55-2668-3a38fdb5de98",
)
assert offchain.from_json(offchain.to_json(request), offchain.CommandRequestObject) == request
assert offchain.from_json(offchain.to_json(request)) == request
assert json.loads(offchain.to_json(request)) == json.loads(
"""{
"cid": "3185027f-0574-6f55-2668-3a38fdb5de98",
"command_type": "PaymentCommand",
"command": {
"_ObjectType": "PaymentCommand",
"payment": {
"reference_id": "4185027f-0574-6f55-2668-3a38fdb5de98",
"sender": {
"address": "lbr1p7ujcndcl7nudzwt8fglhx6wxn08kgs5tm6mz4usw5p72t",
"status": {
"status": "needs_kyc_data"
},
"kyc_data": {
"type": "individual",
"payload_version": 1,
"given_name": "hello",
"surname": "world",
"address": {
"city": "San Francisco"
},
"national_id": {
"id_value": "234121234"
},
"legal_entity_name": "foo bar"
},
"metadata": [
"hello",
"world"
]
},
"receiver": {
"address": "lbr1p7ujcndcl7nudzwt8fglhx6wxnvqqqqqqqqqqqqelu3xv",
"status": {
"status": "abort",
"abort_code": "code1",
"abort_message": "code1 message"
}
},
"action": {
"amount": 1000000000000,
"currency": "XUS",
"action": "charge",
"timestamp": 1604902048
},
"original_payment_reference_id": "0185027f-0574-6f55-2668-3a38fdb5de98"
}
},
"_ObjectType": "CommandRequestObject"
}"""
)
def test_new_payment_request_and_object(factory):
sender = LocalAccount.generate()
receiver = LocalAccount.generate()
payment = factory.new_payment_object(sender, receiver)
request = offchain.new_payment_request(payment)
reference_id = payment.reference_id
assert reference_id
assert_cid(request.cid)
assert uuid.UUID(reference_id)
assert "-" in reference_id
payment = offchain.from_dict(request.command, offchain.PaymentCommandObject).payment
address, subaddress = identifier.decode_account(payment.sender.address, identifier.TDM)
assert subaddress is not None
assert address == sender.account_address
address, subaddress = identifier.decode_account(payment.receiver.address, identifier.TDM)
assert subaddress is not None
assert address == receiver.account_address
expected = f"""{{
"cid": "{request.cid}",
"command_type": "PaymentCommand",
"command": {{
"_ObjectType": "PaymentCommand",
"payment": {{
"reference_id": "{reference_id}",
"sender": {{
"address": "{payment.sender.address}",
"status": {{
"status": "needs_kyc_data"
}},
"kyc_data": {{
"type": "individual",
"payload_version": 1,
"given_name": "Jack",
"surname": "G",
"address": {{
"city": "San Francisco"
}}
}}
}},
"receiver": {{
"address": "{payment.receiver.address}",
"status": {{
"status": "none"
}}
}},
"action": {{
"amount": 1000000000000,
"currency": "XUS",
"action": "charge",
"timestamp": {payment.action.timestamp}
}}
}}
}},
"_ObjectType": "CommandRequestObject"
}}"""
assert json.loads(offchain.to_json(request)) == json.loads(expected)
assert request == offchain.from_json(expected, offchain.CommandRequestObject)
assert request == offchain.from_json(expected)
def assert_field_error(json_dic, code, field, match):
with pytest.raises(offchain.FieldError, match=match) as e:
offchain.from_json(json.dumps(json_dic))
assert e.value.code == code
assert e.value.field == field
