async def test_delete_proof(acme_and_alice_connection: AcmeAliceConnect,
acme_client: AsyncClient):
# V1
proof_req_res = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
proof_id = (proof_req_res.json())["proof_id"]
response = await acme_client.delete(BASE_PATH + f"/proofs/{proof_id}", )
assert response.json() == None
# V2
proof_req_res = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v2",
"proof_request": indy_proof_request.dict(),
},
)
proof_id = (proof_req_res.json())["proof_id"]
response = await acme_client.delete(BASE_PATH + f"/proofs/{proof_id}", )
assert response.json() == None
async def test_get_proof_single(acme_and_alice_connection: AcmeAliceConnect,
acme_client: AsyncClient):
# V1
proof_req_res = await acme_client.post(
f"{BASE_PATH}/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
proof_id = proof_req_res.json()["proof_id"]
response = await acme_client.get(f"{BASE_PATH}/proofs/{proof_id}", )
result = response.json()
assert "connection_id" in result
assert "created_at" in result
assert "updated_at" in result
assert "presentation" in result
assert "presentation_request" in result
# V2
proof_req_res = await acme_client.post(
f"{BASE_PATH}/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v2",
"proof_request": indy_proof_request.dict(),
},
)
proof_id = proof_req_res.json()["proof_id"]
response = await acme_client.get(f"{BASE_PATH}/proofs/{proof_id}", )
result = response.json()
assert "connection_id" in result
assert "created_at" in result
assert "updated_at" in result
assert "presentation" in result
assert "v2-" in result["proof_id"]
assert "presentation_request" in result
async def test_reject_proof_request(
acme_and_alice_connection: AcmeAliceConnect,
alice_member_client: AsyncClient,
alice_tenant: Any,
acme_client: AsyncClient,
):
wait_for_event, _ = await start_listener(
topic="proofs", wallet_id=alice_tenant["tenant_id"])
# V1
response = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
response.raise_for_status()
# Wait for request received
alice_exchange = await wait_for_event(
filter_map={
"connection_id": acme_and_alice_connection["alice_connection_id"],
"state": "request-received",
"protocol_version": "v1",
})
reject_proof_request_v1 = RejectProofRequest(
proof_id=alice_exchange["proof_id"], problem_report=None)
response = await alice_member_client.post(
BASE_PATH + "/reject-request", json=reject_proof_request_v1.dict())
result = response.json()
response.raise_for_status()
assert result is None
async def test_get_credentials_for_request(
acme_and_alice_connection: AcmeAliceConnect,
acme_client: AsyncClient,
alice_tenant: Any,
alice_member_client: AsyncClient,
):
wait_for_event, _ = await start_listener(
topic="proofs", wallet_id=alice_tenant["tenant_id"])
# V1
await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
# Wait for request received
alice_exchange = await wait_for_event(
filter_map={
"connection_id": acme_and_alice_connection["alice_connection_id"],
"state": "request-received",
"protocol_version": "v1",
})
proof_id = alice_exchange["proof_id"]
response = await alice_member_client.get(
f"{BASE_PATH}/proofs/{proof_id}/credentials", )
result = response.json()[0]
assert "cred_info" in result.keys()
assert [
attr in [
"attrs", "cred_def_info", "referant", "interval",
"presentation_referents"
] for attr in result["cred_info"].keys()
]
# V2
wait_for_event, _ = await start_listener(
topic="proofs", wallet_id=alice_tenant["tenant_id"])
await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v2",
"proof_request": indy_proof_request.dict(),
},
)
# Wait for request received
alice_exchange = await wait_for_event(
filter_map={
"connection_id": acme_and_alice_connection["alice_connection_id"],
"state": "request-received",
"protocol_version": "v2",
})
proof_id = alice_exchange["proof_id"]
response = await alice_member_client.get(
f"{BASE_PATH}/proofs/{proof_id}/credentials", )
result = response.json()[0]
assert "cred_info" in result.keys()
assert [
attr in [
"attrs", "cred_def_info", "referant", "interval",
"presentation_referents"
] for attr in result["cred_info"].keys()
]
async def test_accept_proof_request_v1(
issue_credential_to_alice: CredentialExchange,
alice_member_client: AsyncClient,
acme_client: AsyncClient,
acme_and_alice_connection: AcmeAliceConnect,
):
response = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
response.raise_for_status()
acme_exchange = response.json()
acme_proof_id = acme_exchange["proof_id"]
assert check_webhook_state(
client=alice_member_client,
filter_map={"state": "request-received"},
topic="proofs",
max_duration=120,
)
proof_records_alice = await alice_member_client.get(BASE_PATH + "/proofs")
alice_proof_id = proof_records_alice.json()[0]["proof_id"]
requested_credentials = await alice_member_client.get(
f"/generic/verifier/proofs/{alice_proof_id}/credentials")
referent = requested_credentials.json()[0]["cred_info"]["referent"]
indy_request_attrs = IndyRequestedCredsRequestedAttr(cred_id=referent,
revealed=True)
proof_accept = AcceptProofRequest(
proof_id=alice_proof_id,
presentation_spec=IndyPresSpec(
requested_attributes={"0_speed_uuid": indy_request_attrs},
requested_predicates={},
self_attested_attributes={},
),
)
response = await alice_member_client.post(
BASE_PATH + "/accept-request",
json=proof_accept.dict(),
)
assert check_webhook_state(
client=alice_member_client,
filter_map={
"state": "done",
"proof_id": alice_proof_id
},
topic="proofs",
max_duration=120,
)
assert check_webhook_state(
client=acme_client,
filter_map={
"state": "done",
"proof_id": acme_proof_id
},
topic="proofs",
max_duration=120,
)
result = response.json()
pres_exchange_result = PresentationExchange(**result)
assert isinstance(pres_exchange_result, PresentationExchange)
assert response.status_code == 200
async def test_send_proof_request(
acme_and_alice_connection: AcmeAliceConnect,
alice_member_client: AsyncClient,
acme_client: AsyncClient,
alice_tenant: Any,
):
wait_for_event, _ = await start_listener(
topic="proofs", wallet_id=alice_tenant["tenant_id"])
response = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v1",
"proof_request": indy_proof_request.dict(),
},
)
result = response.json()
# assert result.keys() == ""
assert "presentation" in result.keys()
assert "presentation_request" in result.keys()
assert "created_at" in result.keys()
assert "proof_id" in result.keys()
assert result["role"] == "verifier"
assert result["state"]
# Wait for request received
await wait_for_event(
filter_map={
"connection_id": acme_and_alice_connection["alice_connection_id"],
"state": "request-received",
"protocol_version": "v1",
})
# V2
wait_for_event, _ = await start_listener(
topic="proofs", wallet_id=alice_tenant["tenant_id"])
response = await acme_client.post(
BASE_PATH + "/send-request",
json={
"connection_id": acme_and_alice_connection["acme_connection_id"],
"protocol_version": "v2",
"proof_request": indy_proof_request.dict(),
},
)
result = response.json()
assert "presentation" in result.keys()
assert "presentation_request" in result.keys()
assert "created_at" in result.keys()
assert "proof_id" in result.keys()
assert "v2-" in result["proof_id"]
assert result["role"] == "verifier"
assert result["state"]
# Wait for request received
await wait_for_event(
filter_map={
"connection_id": acme_and_alice_connection["alice_connection_id"],
"state": "request-received",
"protocol_version": "v2",
})