async def test_activate_user(self, fs):
# Instantiate Mock Client
test_client = MockOktaClient(fs)
# Create Password
password = models.PasswordCredential({"value": "Password150kta"})
# Create User Credentials
user_creds = models.UserCredentials({"password": password})
# Create User Profile and CreateUser Request
user_profile = models.UserProfile()
user_profile.first_name = "John"
user_profile.last_name = "Doe-Activate"
user_profile.email = "*****@*****.**"
user_profile.login = "******"
create_user_req = models.CreateUserRequest({
"credentials": user_creds,
"profile": user_profile
})
try:
# Create query parameters and Create User
query_params_create = {"activate": "False"}
user, resp, err = await test_client.create_user(
create_user_req, query_params_create)
assert err is None
# Create query parameters and Activate User
query_params_activate = {"sendEmail": "False"}
token, resp, err = await test_client.activate_user(
user.id, query_params_activate)
assert err is None
assert token is not None
# Ensure correct Object is returned
assert isinstance(token, models.UserActivationToken)
# Create query parameters and List Users
query_params_list = {"filter": "status eq \"ACTIVE\""}
users, resp, err = await test_client.list_users(query_params_list)
assert err is None
# Ensure user is in list
assert next((usr for usr in users if usr.id == user.id),
None) is not None
finally:
errors = []
# Deactivate, then delete created user
try:
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
except Exception as exc:
errors.append(exc)
try:
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
except Exception as exc:
errors.append(exc)
assert len(errors) == 0
async def test_upload_org_logo(self, fs):
client = MockOktaClient(fs)
fs.pause()
logo = open(f'tests/integration/data/logo.png', 'rb')
_, err = await client.update_org_logo(logo)
fs.resume()
assert err is None
async def test_create_get_sign_on_policy_with_group_conditions(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Group
GROUP_NAME = "Group-Target-Test"
group_obj = models.Group(
{"profile": models.GroupProfile({"name": GROUP_NAME})})
created_group, _, err = await client.create_group(group_obj)
assert err is None
assert isinstance(created_group, models.Group)
# Create Policy & Conditions
policy_model = models.OktaSignOnPolicy({
"name":
f"{TestPoliciesResource.SDK_PREFIX} Test-Sign-On",
"status":
"ACTIVE",
"description":
"Test policy applies for tests only"
})
policy_conditions = models.OktaSignOnPolicyConditions({
"people":
models.PolicyPeopleCondition({
"groups":
models.GroupCondition({"include": [created_group.id]})
})
})
policy_model.conditions = policy_conditions
created_policy, _, err = await client.create_policy(policy_model)
assert err is None
assert isinstance(created_policy, models.OktaSignOnPolicy)
assert created_policy.name == policy_model.name
assert created_policy.description == policy_model.description
assert created_policy.status == "ACTIVE"
assert created_policy.type == models.PolicyType.OKTA_SIGN_ON
assert len(created_policy.conditions.people.groups.include) == 1
assert created_group.id in \
created_policy.conditions.people.groups.include
# Retrieve
retrieved_policy, _, err = await client.get_policy(created_policy.id)
assert err is None
assert retrieved_policy.id == created_policy.id
assert retrieved_policy.name == created_policy.name
assert retrieved_policy.description == created_policy.description
assert retrieved_policy.status == created_policy.status
assert retrieved_policy.type == created_policy.type
assert len(retrieved_policy.conditions.people.groups.include) == 1
assert created_group.id in \
retrieved_policy.conditions.people.groups.include
# Delete Policy + Group
_, err = await client.delete_policy(created_policy.id)
assert err is None
_, err = await client.delete_group(created_group.id)
assert err is None
async def test_create_password_policy(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Policy
policy_model = models.PasswordPolicy({
"name":
f"{TestPoliciesResource.SDK_PREFIX} Test-Password",
"status":
"ACTIVE",
"description":
"Test policy applies for tests only"
})
created_policy, _, err = await client.create_policy(policy_model)
assert err is None
assert isinstance(created_policy, models.PasswordPolicy)
assert created_policy.name == policy_model.name
assert created_policy.description == policy_model.description
assert created_policy.status == "ACTIVE"
assert created_policy.type == models.PolicyType.PASSWORD
# Retrieve
retrieved_policy, _, err = await client.get_policy(created_policy.id)
assert err is None
assert retrieved_policy.id == created_policy.id
assert retrieved_policy.name == created_policy.name
assert retrieved_policy.description == created_policy.description
assert retrieved_policy.status == created_policy.status
assert retrieved_policy.type == created_policy.type
# Delete
_, err = await client.delete_policy(created_policy.id)
assert err is None
async def test_list_groups(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Group Object
GROUP_NAME = "Group-Target-Test"
group_profile = models.GroupProfile({
"name": GROUP_NAME
})
group_obj = models.Group({
"profile": group_profile
})
try:
# Create Group
group, _, err = await client.create_group(group_obj)
assert err is None
assert isinstance(group, models.Group)
groups_list, resp, err = await client.list_groups()
assert err is None
assert not resp.has_next()
assert next((grp for grp in groups_list if grp.id == group.id))
finally:
# Delete created group
_, err = await client.delete_group(group.id)
assert err is None
async def test_search_group(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Group Object
GROUP_NAME = "Group-Target-Test"
group_profile = models.GroupProfile({
"name": GROUP_NAME
})
group_obj = models.Group({
"profile": group_profile
})
try:
# Create Group
group, _, err = await client.create_group(group_obj)
assert err is None
assert isinstance(group, models.Group)
query_params_query = {"q": GROUP_NAME}
groups_list, _, err = await client.list_groups(query_params_query)
assert err is None
assert groups_list
assert len(groups_list) == 1
assert next((grp for grp in groups_list if grp.id == group.id))
finally:
# Delete created group
_, err = await client.delete_group(group.id)
assert err is None
async def test_update_group(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Group Object
GROUP_NAME = "Group-Target-Test"
group_profile = models.GroupProfile({"name": GROUP_NAME})
group_obj = models.Group({"profile": group_profile})
# Create Group
group, _, err = await client.create_group(group_obj)
assert err is None
assert isinstance(group, models.Group)
# Create Updated Group Object
# Create Group Object
NEW_GROUP_NAME = "Group-Target-Test NEW"
new_group_profile = models.GroupProfile({"name": NEW_GROUP_NAME})
new_group_obj = models.Group({"profile": new_group_profile})
_, _, err = await client.update_group(group.id, new_group_obj)
assert err is None
# Verify update worked
found_group, _, err = await client.get_group(group.id)
assert err is None
assert found_group.id == group.id
assert found_group.profile.name == NEW_GROUP_NAME
# Delete created group
_, err = await client.delete_group(group.id)
assert err is None
async def test_update_custom_attribute(self, fs):
client = MockOktaClient(fs)
# make random custom attribute name, because it takes some time for cleanup
random.seed(2021)
custom_attribute_name = ''.join([ascii_lowercase[random.randint(0, 25)] for i in range(20)])
definition = copy.deepcopy(ADD_CUSTOM_ATTRIBUTE_DEFINITION)
definition['custom']['properties'][custom_attribute_name] = CUSTOM_ATTRIBUTE_PROPERTIES
try:
resp, _, err = await client.update_group_schema({'definitions': definition})
assert err is None
assert custom_attribute_name in resp.definitions.custom.properties
assert resp.definitions.custom.properties[custom_attribute_name]['title'] == 'Test Custom Attribute'
# update custom attribute
resp.definitions.custom.properties[custom_attribute_name]['title'] = 'New Title'
resp, _, err = await client.update_group_schema(resp)
assert err is None
assert resp.definitions.custom.properties[custom_attribute_name]['title'] == 'New Title'
finally:
definition = copy.deepcopy(REMOVE_CUSTOM_ATTRIBUTE_DEFINITION)
definition['custom']['properties'][custom_attribute_name] = None
resp, _, err = await client.update_group_schema({'definitions': definition}, keep_empty_params=True)
assert err is None
assert custom_attribute_name not in resp.definitions.custom.properties
async def test_create_get_group(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Group Object
GROUP_NAME = "Group-Target-Test"
group_profile = models.GroupProfile({"name": GROUP_NAME})
group_obj = models.Group({"profile": group_profile})
# Create Group
group, _, err = await client.create_group(group_obj)
assert err is None
assert isinstance(group, models.Group)
# Get group using ID
found_group, _, err = await client.get_group(group.id)
assert err is None
assert found_group.id == group.id
# Delete created group
_, err = await client.delete_group(group.id)
assert err is None
# Ensure group cannot be found again
found_group, resp, err = await client.get_group(group.id)
assert err is not None
assert resp.get_status() == HTTPStatus.NOT_FOUND
assert found_group is None
async def test_list_origins(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Trusted Origin
TO_NAME = f"{TestTrustedOriginsResource.SDK_PREFIX}_test_TO"
TO_ORIGIN = "http://example.com"
trusted_origin_model = models.TrustedOrigin({
"name":
TO_NAME,
"origin":
TO_ORIGIN,
"scopes": [
models.Scope({"type": models.ScopeType.CORS}),
models.Scope({"type": models.ScopeType.REDIRECT}),
]
})
created_trusted_origin, _, err = await \
client.create_origin(trusted_origin_model)
assert err is None
assert isinstance(created_trusted_origin, models.TrustedOrigin)
# List
trusted_origins, _, err = await client.list_origins()
assert err is None
assert isinstance(trusted_origins, list)
assert len(trusted_origins) > 0
assert isinstance(trusted_origins[0], models.TrustedOrigin)
assert next((to for to in trusted_origins
if to.name == created_trusted_origin.name), None) \
is not None
# Delete
_, err = await client.delete_origin(created_trusted_origin.id)
async def test_create_get_origin(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Trusted Origin
TO_NAME = f"{TestTrustedOriginsResource.SDK_PREFIX}_test_TO"
TO_ORIGIN = "http://example.com"
trusted_origin_model = models.TrustedOrigin({
"name":
TO_NAME,
"origin":
TO_ORIGIN,
"scopes": [
models.Scope({"type": models.ScopeType.CORS}),
models.Scope({"type": models.ScopeType.REDIRECT}),
]
})
created_trusted_origin, _, err = await \
client.create_origin(trusted_origin_model)
assert err is None
assert isinstance(created_trusted_origin, models.TrustedOrigin)
# Retrieve
retrieved_origin, _, err = await \
client.get_origin(created_trusted_origin.id)
assert err is None
assert isinstance(retrieved_origin, models.TrustedOrigin)
assert retrieved_origin.name == created_trusted_origin.name
assert len(retrieved_origin.scopes) == 2
# Delete
_, err = await client.delete_origin(created_trusted_origin.id)
async def test_get_org_contact_types(self, fs):
client = MockOktaClient(fs)
org_contact_types, _, err = await client.get_org_contact_types()
assert err is None
for item in org_contact_types:
assert isinstance(item, OrgContactTypeObj)
assert isinstance(item.contact_type, OrgContactType)
async def test_list_brands(self, fs):
client = MockOktaClient(fs)
brands, _, err = await client.list_brands()
assert err is None
assert len(brands) > 0
for brand in brands:
assert isinstance(brand, models.Brand)
async def test_list_factors_new_user(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create User
user_profile = models.UserProfile()
user_profile.first_name = "John"
user_profile.last_name = "Doe-List-Factor"
user_profile.email = "*****@*****.**"
user_profile.login = "******"
create_user_req = models.CreateUserRequest({
"credentials":
models.UserCredentials({
"password":
models.PasswordCredential({"value": "Password150kta"})
}),
"profile":
user_profile
})
created_user, _, err = await client.create_user(create_user_req)
assert err is None
assert isinstance(created_user, models.User)
# List factor to validate
users_factors, _, err = await client.list_factors(created_user.id)
assert err is None
assert len(users_factors) == 0
# Deactivate + delete user
_, err = await client.deactivate_user(created_user.id)
assert err is None
_, err = await client.deactivate_or_delete_user(created_user.id)
assert err is None
async def test_subscribe_unsubscribe_user(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
users, _, err = await client.list_users()
assert err is None
user = users[0]
notification_type = models.NotificationType('OKTA_ISSUE')
_, err = await client.subscribe_user_subscription_by_notification_type(
user.id, notification_type)
assert err is None
resp, _, err = await client.get_user_subscription_by_notification_type(
user.id, notification_type)
assert resp.notification_type == models.NotificationType('OKTA_ISSUE')
assert resp.status == models.SubscriptionStatus('SUBSCRIBED')
_, err = await client.unsubscribe_user_subscription_by_notification_type(
user.id, notification_type)
assert err is None
resp, _, err = await client.get_user_subscription_by_notification_type(
user.id, notification_type)
assert resp.notification_type == models.NotificationType('OKTA_ISSUE')
assert resp.status == models.SubscriptionStatus('UNSUBSCRIBED')
async def test_get_user_type(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create object
TEST_DESC = F"{TestUserTypesResource.SDK_PREFIX} description"
TEST_DISPLAY_NAME = F"{TestUserTypesResource.SDK_PREFIX} display name"
TEST_NAME = F"{TestUserTypesResource.SDK_PREFIX}_akIKx"
# ^ without VCR testing, can generate random TEST_NAME suffixes
user_type_obj = models.UserType({
"description": TEST_DESC,
"displayName": TEST_DISPLAY_NAME,
"name": TEST_NAME
})
try:
created, _, err = await client.create_user_type(user_type_obj)
assert err is None
assert created.id is not None
# Retrieve
found, _, err = await client.get_user_type(created.id)
assert err is None
assert found.id == created.id
assert found.description == TEST_DESC
assert found.display_name == TEST_DISPLAY_NAME
assert found.name == TEST_NAME
finally:
_, err = await client.delete_user_type(created.id)
assert err is None
async def test_get_threat_insight_configuration(self, fs):
client = MockOktaClient(fs)
resp, _, err = await client.get_current_configuration()
assert isinstance(resp, ThreatInsightConfiguration)
assert '_links' in resp.as_dict().keys()
assert 'action' in resp.as_dict().keys()
assert 'excludeZones' in resp.as_dict().keys()
async def test_subscribe_unsubscribe_role_by_notification_type(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
notification_type = models.NotificationType('OKTA_ISSUE')
_, err = await client.subscribe_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert err is None
resp, _, err = await client.get_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert isinstance(resp, models.Subscription)
assert resp.notification_type == models.NotificationType('OKTA_ISSUE')
assert resp.status == models.SubscriptionStatus('SUBSCRIBED')
try:
_, err = await client.unsubscribe_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert err is None
resp, _, err = await client.get_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert isinstance(resp, models.Subscription)
assert resp.notification_type == models.NotificationType(
'OKTA_ISSUE')
assert resp.status == models.SubscriptionStatus('UNSUBSCRIBED')
finally:
# restore subscription
_, err = await client.subscribe_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert err is None
async def test_update_feature_lifecycle(self):
# Instantiate Mock Client
client = MockOktaClient(fs)
# List
features, _, err = await client.list_features()
assert err is None
assert len(features) > 0
assert isinstance(features[0], models.Feature)
first_feature = features[0]
# Update
first_feature_id = first_feature.id
original_status = first_feature.status
lifecycle = "enable" if original_status == "DISABLED"\
else "disable"
status_change, _, err = await \
client.update_feature_lifecycle(first_feature_id, lifecycle)
assert err is None
assert isinstance(status_change, models.Feature)
assert original_status != status_change.status
# Revert
lifecycle = "disable" if original_status == "DISABLED"\
else "enable"
updated_status_change, _, err = await \
client.update_feature_lifecycle(first_feature_id, lifecycle)
assert err is None
assert isinstance(updated_status_change, models.Feature)
assert original_status == updated_status_change.status
async def test_create_auth_server(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Auth Server
TEST_NAME = f"{TestAuthorizationServerResource.SDK_PREFIX}_test_aaPeZ"
TEST_DESC = "Test Auth Server"
TEST_AUDS = ["api://default"]
auth_server_model = models.AuthorizationServer({
"name": TEST_NAME,
"description": TEST_DESC,
"audiences": TEST_AUDS
})
created_auth_server, _, err = await \
client.create_authorization_server(auth_server_model)
assert err is None
assert isinstance(created_auth_server, models.AuthorizationServer)
assert created_auth_server.name == TEST_NAME
assert created_auth_server.description == TEST_DESC
assert created_auth_server.audiences == TEST_AUDS
assert created_auth_server.audiences[0] == TEST_AUDS[0]
# Clean up
_, err = await client.deactivate_authorization_server(
created_auth_server.id)
assert err is None
_, err = await client.delete_authorization_server(
created_auth_server.id)
assert err is None
async def test_update_brand(self, fs):
client = MockOktaClient(fs)
custom_privacy_policy_url = 'https://www.someHost.com/privacy-policy'
brands, _, err = await client.list_brands()
assert err is None
brand_id = brands[0].id
brand, _, err = await client.get_brand(brand_id)
assert err is None
assert brand.id == brand_id
assert brand.custom_privacy_policy_url != custom_privacy_policy_url
new_brand = copy.deepcopy(brand)
new_brand.agree_to_custom_privacy_policy = True
new_brand.custom_privacy_policy_url = 'https://www.someHost.com/privacy-policy'
try:
updated_brand, _, err = await client.update_brand(
brand_id, new_brand)
assert err is None
assert isinstance(updated_brand, models.Brand)
assert brand.id == updated_brand.id
assert updated_brand.custom_privacy_policy_url == custom_privacy_policy_url
finally:
# restore previous brand settings
_, _, err = await client.update_brand(brand_id, brand)
assert err is None
async def test_assign_user_to_role(self, fs):
# Instantiate Mock Client
test_client = MockOktaClient(fs)
# Create Password
password = models.PasswordCredential({"value": "Password150kta"})
# Create User Credentials
user_creds = models.UserCredentials({"password": password})
# Create User Profile and CreateUser Request
user_profile = models.UserProfile()
user_profile.first_name = "John"
user_profile.last_name = "Doe-Assign-User-Role"
user_profile.email = "*****@*****.**"
user_profile.login = "******"
create_user_req = models.CreateUserRequest({
"credentials": user_creds,
"profile": user_profile
})
# Create Query Parameters and Create User
query_params_create = {"activate": "True"}
user, _, err = await test_client.create_user(create_user_req,
query_params_create)
assert err is None
# Create Assign Role Request with Roletype Enum
USER_ADMIN = models.RoleType.USER_ADMIN
assign_role_req = models.AssignRoleRequest({"type": USER_ADMIN})
# Assign Role to User
_, _, err = await test_client.assign_role_to_user(
user.id, assign_role_req)
assert err is None
# Get Roles for user and ensure role assigned is found
roles, _, err = await test_client.list_assigned_roles_for_user(user.id)
found_role = next((role for role in roles if role.type == USER_ADMIN),
None)
assert found_role is not None
# Remove assigned role from user
_, err = await test_client.remove_role_from_user(
user.id, found_role.id)
assert err is None
# Get Roles for user and ensure role assigned is NOT found
roles, _, err = await test_client.list_assigned_roles_for_user(user.id)
found_role = next((role for role in roles if role.type == USER_ADMIN),
None)
assert found_role is None
# Deactivate, then delete created user
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
async def test_update_policy(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Policy
policy_model = models.OktaSignOnPolicy({
"name":
f"{TestPoliciesResource.SDK_PREFIX} Test-Sign-On",
"status":
"ACTIVE",
"description":
"Test policy applies for tests only"
})
try:
created_policy, _, err = await client.create_policy(policy_model)
assert err is None
assert isinstance(created_policy, models.OktaSignOnPolicy)
assert created_policy.name == policy_model.name
assert created_policy.description == policy_model.description
assert created_policy.status == "ACTIVE"
assert created_policy.type == models.PolicyType.OKTA_SIGN_ON
# Retrieve
retrieved_policy, _, err = await client.get_policy(
created_policy.id)
assert err is None
assert retrieved_policy.id == created_policy.id
assert retrieved_policy.name == created_policy.name
assert retrieved_policy.description == created_policy.description
assert retrieved_policy.status == created_policy.status
assert retrieved_policy.type == created_policy.type
# Update
NEW_NAME = policy_model.name + "UPDATED"
NEW_DESC = policy_model.description + "UPDATED"
created_policy.name = NEW_NAME
created_policy.description = NEW_DESC
updated_policy, _, err = await client.update_policy(
created_policy.id, created_policy)
assert err is None
assert updated_policy.id == created_policy.id
assert updated_policy.name == NEW_NAME
assert updated_policy.description == NEW_DESC
# Retrieve
retrieved_policy, _, err = await client.get_policy(
created_policy.id)
assert err is None
assert retrieved_policy.id == created_policy.id
assert retrieved_policy.name == NEW_NAME
assert retrieved_policy.description == NEW_DESC
assert retrieved_policy.status == created_policy.status
assert retrieved_policy.type == created_policy.type
finally:
# Delete
_, err = await client.delete_policy(created_policy.id)
assert err is None
async def test_change_user_password(self, fs):
# Instantiate Mock Client
test_client = MockOktaClient(fs)
# Create Password
password = models.PasswordCredential({"value": "Password150kta"})
# Create User Credentials
user_creds = models.UserCredentials({"password": password})
# Create User Profile and CreateUser Request
user_profile = models.UserProfile()
user_profile.first_name = "John"
user_profile.last_name = "Doe-Change-PW"
user_profile.email = "*****@*****.**"
user_profile.login = "******"
create_user_req = models.CreateUserRequest({
"credentials": user_creds,
"profile": user_profile
})
# Create Query Parameters and Create User
query_params_create = {"activate": "True"}
user, _, err = await test_client.create_user(create_user_req,
query_params_create)
assert err is None
# Give time before changing password
time.sleep(1)
# Create new Password
NEW_PASSWORD = "******"
new_password = models.PasswordCredential({"value": NEW_PASSWORD})
change_pw_req = models.ChangePasswordRequest({
"oldPassword":
password,
"newPassword":
new_password
})
# change password and retrieve user after
_, _, err = await test_client.change_password(user.id, change_pw_req)
assert err is None
got_user, resp, err = await test_client.get_user(user.id)
assert got_user.id == user.id
assert err is None
# Verify password in updated user obj, changed after original
DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
assert datetime.strptime(got_user.password_changed, DATETIME_FORMAT)\
> datetime.strptime(user.password_changed, DATETIME_FORMAT)
# Deactivate, then delete created user
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
_, err = await test_client.deactivate_or_delete_user(user.id)
assert err is None
async def test_delete_oauth2_scope(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create Auth Server
TEST_NAME = f"{TestAuthorizationServerResource.SDK_PREFIX}_test_abDfZ"
TEST_DESC = "Test Auth Server"
TEST_AUDS = ["api://default"]
auth_server_model = models.AuthorizationServer({
"name": TEST_NAME,
"description": TEST_DESC,
"audiences": TEST_AUDS
})
created_auth_server, _, err = await \
client.create_authorization_server(auth_server_model)
assert err is None
assert isinstance(created_auth_server, models.AuthorizationServer)
assert created_auth_server.name == TEST_NAME
assert created_auth_server.description == TEST_DESC
assert created_auth_server.audiences == TEST_AUDS
assert created_auth_server.audiences[0] == TEST_AUDS[0]
# Create Oauth Scope
SCOPE_NAME = f"{TestAuthorizationServerResource.SDK_PREFIX}:abDGz"
scope_obj = models.OAuth2Scope({"name": SCOPE_NAME})
oauth_scope, _, err = await client.create_o_auth_2_scope(
created_auth_server.id, scope_obj)
assert err is None
assert isinstance(oauth_scope, models.OAuth2Scope)
assert oauth_scope.name == scope_obj.name
# Get Oauth Scope
found_oauth_scope, _, err = await client.get_o_auth_2_scope(
created_auth_server.id, oauth_scope.id)
assert err is None
assert found_oauth_scope.name == oauth_scope.name
# Delete Oauth Scope
_, err = await client.delete_o_auth_2_scope(created_auth_server.id,
oauth_scope.id)
assert err is None
# Get Oauth Scope
found_oauth_scope, resp, err = await client.get_o_auth_2_scope(
created_auth_server.id, oauth_scope.id)
assert err is not None
assert isinstance(err, OktaAPIError)
assert resp.get_status() == HTTPStatus.NOT_FOUND
# DeActivate Auth server
_, err = await client.deactivate_authorization_server(
created_auth_server.id)
assert err is None
# Delete Auth server
_, err = await client.delete_authorization_server(
created_auth_server.id)
assert err is None
async def test_delete_sms_template(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
# Create SMS Template
sms_translations = models.SmsTemplateTranslations()
sms_translations.es = \
"${org.name}: el código de verificación es ${code}"
sms_translations.fr = \
"${org.name}: votre code de vérification est ${code}"
sms_translations.it = "${org.name}: il codice di verifica è ${code}"
sms_template_model = models.SmsTemplate({
"name":
f"{TestTemplatesResource.SDK_PREFIX}-test-template",
"type":
models.SmsTemplateType.SMS_VERIFY_CODE,
"template":
"${org.name}: your verification code is ${code}",
"translations":
sms_translations
})
try:
created_template, _, err = await client.\
create_sms_template(sms_template_model)
assert err is None
assert isinstance(created_template, models.SmsTemplate)
assert created_template.name == sms_template_model.name
assert created_template.type == sms_template_model.type
assert created_template.template == sms_template_model.template
# Retrieve
retrieved_template, _, err = await client.\
get_sms_template(created_template.id)
assert err is None
assert retrieved_template.id == created_template.id
assert retrieved_template.name == created_template.name
assert retrieved_template.template == created_template.template
assert retrieved_template.translations.es == sms_translations.es
assert retrieved_template.translations.it == sms_translations.it
assert retrieved_template.translations.fr == sms_translations.fr
# Delete
_, err = await client.delete_sms_template(created_template.id)
assert err is None
# Retrieve
retrieved_template, resp, err = await client.\
get_sms_template(created_template.id)
assert err is not None
assert isinstance(err, OktaAPIError)
assert resp.get_status() == HTTPStatus.NOT_FOUND
assert retrieved_template is None
finally:
try:
_, err = await client.delete_sms_template(created_template.id)
except Exception:
pass
async def test_list_authenticators(self, fs):
client = MockOktaClient(fs)
resp, _, err = await client.list_authenticators()
assert err is None
assert len(resp) > 0
assert all([isinstance(elem, models.Authenticator) for elem in resp])
assert all(
[isinstance(elem.type, models.AuthenticatorType) for elem in resp])
async def test_get_role_subscription_by_notification_type(self, fs):
# Instantiate Mock Client
client = MockOktaClient(fs)
notification_type = models.NotificationType('OKTA_ISSUE')
resp, _, err = await client.get_role_subscription_by_notification_type(
'SUPER_ADMIN', notification_type)
assert isinstance(resp, models.Subscription)
assert resp.notification_type == models.NotificationType('OKTA_ISSUE')
async def test_list_network_zones(self, fs):
client = MockOktaClient(fs)
resp, _, err = await client.list_network_zones()
for network_zone in resp:
assert isinstance(network_zone, NetworkZone)
assert isinstance(network_zone.type, NetworkZoneType)
assert isinstance(network_zone.status, NetworkZoneStatus)
assert isinstance(network_zone.usage, NetworkZoneUsage)
async def test_get_org_contact_user(self, fs):
client = MockOktaClient(fs)
contact_type = OrgContactType('BILLING')
org_contact_user, _, err = await client.get_org_contact_user(
contact_type)
assert err is None
assert isinstance(org_contact_user, OrgContactUser)
assert org_contact_user.user_id is not None
