def test_should_return_an_error_when_the_sandbox_token_is_not_configured():
config = Config()
sandbox = Sandbox.from_config(config)
result = sandbox.create_user()
assert_failure(result)
def test_should_return_an_error_when_the_api_key_is_not_configured():
config = Config()
auth = Auth.from_config(config)
result = auth.create_backend_token()
assert_failure(result)
def test_should_create_a_valid_backend_token_with_user(given_valid_api_key):
config = Config(api_key=given_valid_api_key)
auth = Auth.from_config(config)
backend_token_with_user = auth.create_backend_token(user_id="user_id")
assert backend_token_with_user is not None
def test_should_create_a_valid_user_token(given_valid_api_key):
config = Config(api_key=given_valid_api_key)
auth = Auth.from_config(config)
user_token = auth.create_user_token(user_id="user_id")
assert user_token is not None
def test_should_return_an_error_when_the_api_key_is_not_configured():
config = Config()
onboarding = Onboarding.from_config(config)
result = onboarding.create_user()
assert_failure(result)
def test_should_create_a_valid_backend_token(given_valid_api_key):
config = Config(api_key=given_valid_api_key)
auth = Auth.from_config(config)
backend_token = auth.create_backend_token()
assert backend_token is not None
def certified_onboarding(api_key: str, verbose: bool = False):
config = Config(api_key=api_key)
onboarding = Onboarding.from_config(config)
selfie_media_data = given_any_selfie_image_media_data()
document_front_media_data = given_any_document_front_media_data()
document_back_media_data = given_any_document_back_media_data()
user_id = onboarding.create_user(verbose=verbose).unwrap_or_return()
# Upload a selfie (Recommended 1-second video)
onboarding.add_selfie(user_id=user_id,
media_data=selfie_media_data,
verbose=verbose).unwrap_or_return()
# Create and upload front and back side from a document
document_id = onboarding.create_document(
user_id=user_id, type="idcard", issuing_country="ESP",
verbose=verbose).unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=document_front_media_data,
side="front",
manual=True,
verbose=verbose,
).unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=document_back_media_data,
side="back",
manual=True,
verbose=verbose,
).unwrap_or_return()
# Create Certificate
certificate_id = onboarding.create_certificate(
user_id=user_id, verbose=verbose).unwrap_or_return()
# Retrieved Certificate from certificate_id
certificate = onboarding.retrieve_certificate(
user_id=user_id, certificate_id=certificate_id,
verbose=verbose).unwrap_or_return()
# Save PdfReport data to a file
with open(f"certificate_{certificate_id}.pdf", "wb") as outfile:
outfile.write(certificate)
certificates = onboarding.retrieve_certificates(
user_id=user_id, verbose=verbose).unwrap_or_return()
assert len(certificates) >= 1
return isSuccess
def auth_example(api_key: str, user_id: str, verbose: bool = False):
config = Config(api_key=api_key)
auth = Auth.from_config(config)
backend_token = auth.create_backend_token(verbose=verbose).unwrap_or_return()
backend_token_with_user = auth.create_backend_token(
user_id=user_id
).unwrap_or_return()
user_token = auth.create_user_token(user_id=user_id).unwrap_or_return()
return isSuccess
def test_should_create_a_user_and_get_user_token_and_delete_it(
given_valid_sandbox_token, given_any_valid_mail):
config = Config(sandbox_token=given_valid_sandbox_token)
sandbox = Sandbox.from_config(config)
result_create_user = sandbox.create_user(user_info=UserInfo(
email=given_any_valid_mail))
assert_success(result_create_user)
result_user_token = sandbox.get_user_token(email=given_any_valid_mail)
assert_success(result_user_token)
result_delete_user = sandbox.delete_user(email=given_any_valid_mail)
assert_success(result_delete_user)
def sandbox_example(sandbox_token: str, email: str, verbose: bool = False):
config = Config(sandbox_token=sandbox_token)
sandbox = Sandbox.from_config(config)
user_id = sandbox.create_user(user_info=UserInfo(email=email),
verbose=verbose).unwrap_or_return()
user_token = sandbox.get_user_token(email=email,
verbose=verbose).unwrap_or_return()
user = sandbox.get_user(email=email, verbose=verbose).unwrap_or_return()
sandbox.delete_user(email=email, verbose=verbose).unwrap_or_return()
if verbose:
print(f"user_id: {user_id}")
print(f"user_token: {user_token}")
print(f"user: {user}")
return isSuccess
def do_complete_onboarding() -> Result[dict, Error]:
config = Config(api_key=given_valid_api_key)
onboarding = Onboarding.from_config(config)
user_id = onboarding.create_user().unwrap_or_return()
onboarding.add_selfie(
user_id=user_id,
media_data=given_any_selfie_image_media_data).unwrap_or_return()
document_id = onboarding.create_document(
user_id=user_id, type="idcard",
issuing_country="ESP").unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=given_any_document_front_media_data,
side="front",
manual=True,
).unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=given_any_document_back_media_data,
side="back",
manual=True,
).handle()
onboarding.document_properties(
user_id=user_id, document_id=document_id).unwrap_or_return()
report = onboarding.create_report(user_id=user_id).unwrap_or_return()
certificate_id = onboarding.create_certificate(
user_id=user_id).unwrap_or_return()
_ = onboarding.retrieve_certificate(
user_id=user_id, certificate_id=certificate_id).unwrap_or_return()
_ = onboarding.retrieve_certificates(
user_id=user_id).unwrap_or_return()
onboarding.delete_user(user_id).unwrap_or_return()
return Success(report)
def get_user_id_from_onboarding(api_key, verbose: bool = False) -> Result[str, Error]:
config = Config(api_key=api_key)
onboarding = Onboarding.from_config(config)
return onboarding.create_user(verbose=verbose)