public async Task DeleteAuthorizationServer()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
createdAuthorizationServer.Should().NotBeNull();
var retrievedAuthorizationServer = await testClient.AuthorizationServers.GetAuthorizationServerAsync(createdAuthorizationServer.Id);
retrievedAuthorizationServer.Should().NotBeNull();
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() => testClient.AuthorizationServers.GetAuthorizationServerAsync(createdAuthorizationServer.Id));
ex.StatusCode.Should().Be(404);
}
public async Task CreateOAuth2Scope()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthScope = new OAuth2Scope
{
Name = $"{SdkPrefix}:{nameof(CreateOAuth2Scope)}:TestOAuth2Scope({TestClient.RandomString(4)})",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthScope = await createdAuthorizationServer.CreateOAuth2ScopeAsync(testOAuthScope);
try
{
createdOAuthScope.Should().NotBeNull();
createdOAuthScope.Name.Should().Be(testOAuthScope.Name);
}
finally
{
await createdAuthorizationServer.DeleteOAuth2ScopeAsync(createdOAuthScope.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ActivateAuthorizationServer()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
try
{
createdAuthorizationServer.Should().NotBeNull();
createdAuthorizationServer.Status.Should().Be("ACTIVE");
await testClient.AuthorizationServers.DeactivateAuthorizationServerAsync(createdAuthorizationServer.Id);
await testClient.AuthorizationServers.ActivateAuthorizationServerAsync(createdAuthorizationServer.Id);
var retrievedDeactivatedAuthorizationServer = await testClient.AuthorizationServers.GetAuthorizationServerAsync(createdAuthorizationServer.Id);
retrievedDeactivatedAuthorizationServer.Status.Should().Be("ACTIVE");
}
finally
{
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ListAuthorizationServerKeys()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
try
{
var authorizationServerKeys = await createdAuthorizationServer.ListKeys().ToListAsync();
authorizationServerKeys.Should().NotBeNull();
authorizationServerKeys.Count.Should().BeGreaterThan(0);
}
finally
{
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ListCreatedAuthorizationServer()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
try
{
var authorizationServerIds = await testClient.AuthorizationServers.ListAuthorizationServers().Select(server => server.Id).ToHashSetAsync();
authorizationServerIds.Should().Contain(createdAuthorizationServer.Id);
}
finally
{
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task GetAuthorizationServerPolicy()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testPolicy = new Policy
{
Type = PolicyType.OAuthAuthorizationPolicy,
Status = "ACTIVE",
Name = "Test Policy",
Description = "Test policy",
Priority = 1,
Conditions = new PolicyRuleConditions
{
Clients = new ClientPolicyCondition
{
Include = new List <string> {
"ALL_CLIENTS"
},
},
},
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdPolicy = await createdAuthorizationServer.CreatePolicyAsync(testPolicy);
try
{
createdAuthorizationServer.Should().NotBeNull();
createdPolicy.Should().NotBeNull();
var retrievedPolicy = await createdAuthorizationServer.GetPolicyAsync(createdPolicy.Id);
retrievedPolicy.Should().NotBeNull();
retrievedPolicy.Id.Should().Be(createdPolicy.Id);
retrievedPolicy.Name.Should().Be(createdPolicy.Name);
retrievedPolicy.Description.Should().Be(createdPolicy.Description);
}
finally
{
await createdAuthorizationServer.DeletePolicyAsync(createdPolicy.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task UpdateOAuth2Claim()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthClaim = new OAuth2Claim
{
Name = $"{SdkPrefix}_{nameof(UpdateOAuth2Claim)}_TestOAuth2Claim_{TestClient.RandomString(4)}",
Status = "INACTIVE",
ClaimType = "RESOURCE",
ValueType = "EXPRESSION",
Value = "\"driving!\"",
};
var testUpdatedOAuthClaim = new OAuth2Claim
{
Name = $"{SdkPrefix}_{nameof(UpdateOAuth2Claim)}_TestOAuth2Claim_Updated_{TestClient.RandomString(4)}",
Status = "INACTIVE",
ClaimType = "RESOURCE",
ValueType = "EXPRESSION",
Value = "\"driving!\"",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthClaim = await createdAuthorizationServer.CreateOAuth2ClaimAsync(testOAuthClaim);
try
{
createdAuthorizationServer.Should().NotBeNull();
createdOAuthClaim.Should().NotBeNull();
createdOAuthClaim.Name.Should().Be(testOAuthClaim.Name);
var updatedOAuthScope = await createdAuthorizationServer.UpdateOAuth2ClaimAsync(testUpdatedOAuthClaim, createdOAuthClaim.Id);
updatedOAuthScope.Should().NotBeNull();
updatedOAuthScope.Name.Should().Be(testUpdatedOAuthClaim.Name);
}
finally
{
await createdAuthorizationServer.DeleteOAuth2ClaimAsync(createdOAuthClaim.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ListAuthorizationServerPolicies()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testPolicy = new Policy
{
Type = PolicyType.OAuthAuthorizationPolicy,
Status = "ACTIVE",
Name = "Test Policy",
Description = "Test policy",
Priority = 1,
Conditions = new PolicyRuleConditions
{
Clients = new ClientPolicyCondition
{
Include = new List <string> {
"ALL_CLIENTS"
},
},
},
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdPolicy = await createdAuthorizationServer.CreatePolicyAsync(testPolicy);
try
{
var policies = await createdAuthorizationServer.ListPolicies().ToListAsync();
policies.Should().NotBeNull();
policies.Count.Should().BeGreaterThan(0);
policies.Select(p => p.Id).ToHashSet().Should().Contain(createdPolicy.Id);
}
finally
{
await createdAuthorizationServer.DeletePolicyAsync(createdPolicy.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task DeleteOAuth2Claim()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthClaim = new OAuth2Claim
{
Name = $"{SdkPrefix}_{nameof(DeleteOAuth2Claim)}_TestOAuth2Claim{TestClient.RandomString(4)}",
Status = "INACTIVE",
ClaimType = "RESOURCE",
ValueType = "EXPRESSION",
Value = "\"driving!\"",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthClaim = await createdAuthorizationServer.CreateOAuth2ClaimAsync(testOAuthClaim);
try
{
createdAuthorizationServer.Should().NotBeNull();
createdOAuthClaim.Should().NotBeNull();
var retrievedOAuthScope = await createdAuthorizationServer.GetOAuth2ClaimAsync(createdOAuthClaim.Id);
retrievedOAuthScope.Should().NotBeNull();
await createdAuthorizationServer.DeleteOAuth2ClaimAsync(createdOAuthClaim.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() => testClient.AuthorizationServers.GetOAuth2ClaimAsync(createdAuthorizationServer.Id, createdOAuthClaim.Id));
ex.StatusCode.Should().Be(404);
}
finally
{
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task GetLinkedObjectDefinitionByPrimaryName()
{
var testClient = TestClient.Create();
var randomString = TestClient.RandomString(6);
var testPrimaryName = $"{SdkPrefix}_{nameof(GetLinkedObjectDefinitionByPrimaryName)}_primary_{randomString}";
var testAssociatedName = $"{SdkPrefix}_{nameof(GetLinkedObjectDefinitionByPrimaryName)}_associated_{randomString}";
var createdLinkedObjectDefinition = await testClient.LinkedObjects.AddLinkedObjectDefinitionAsync(
new LinkedObject
{
Primary = new LinkedObjectDetails
{
Name = testPrimaryName,
Title = "Primary",
Description = "Primary link property",
Type = "USER",
},
Associated = new LinkedObjectDetails
{
Name = testAssociatedName,
Title = "Associated",
Description = "Associated link property",
Type = "USER",
},
});
var retrievedLinkedObjectDefinition = await testClient.LinkedObjects.GetLinkedObjectDefinitionAsync(testPrimaryName);
try
{
retrievedLinkedObjectDefinition.Should().NotBeNull();
retrievedLinkedObjectDefinition.Primary.Should().NotBeNull();
retrievedLinkedObjectDefinition.Primary.Name.Should().Be(testPrimaryName);
retrievedLinkedObjectDefinition.Primary.Title.Should().Be("Primary");
retrievedLinkedObjectDefinition.Primary.Type.Value.Should().Be("USER");
retrievedLinkedObjectDefinition.Associated.Should().NotBeNull();
retrievedLinkedObjectDefinition.Associated.Name.Should().Be(testAssociatedName);
retrievedLinkedObjectDefinition.Associated.Title.Should().Be("Associated");
retrievedLinkedObjectDefinition.Associated.Type.Value.Should().Be("USER");
}
finally
{
await testClient.LinkedObjects.DeleteLinkedObjectDefinitionAsync(testPrimaryName);
}
}
public async Task DeleteOAuth2Scope()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthScope = new OAuth2Scope
{
Name = $"{SdkPrefix}:{nameof(DeleteOAuth2Scope)}:TestOAuth2Scope({TestClient.RandomString(4)})",
Consent = "REQUIRED",
MetadataPublish = "ALL_CLIENTS",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthScope = await createdAuthorizationServer.CreateOAuth2ScopeAsync(testOAuthScope);
try
{
createdAuthorizationServer.Should().NotBeNull();
createdOAuthScope.Should().NotBeNull();
var retrievedOAuthScope = await testClient.AuthorizationServers.GetOAuth2ScopeAsync(createdAuthorizationServer.Id, createdOAuthScope.Id);
retrievedOAuthScope.Should().NotBeNull();
await testClient.AuthorizationServers.DeleteOAuth2ScopeAsync(createdAuthorizationServer.Id, createdOAuthScope.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() => testClient.AuthorizationServers.GetOAuth2ScopeAsync(createdAuthorizationServer.Id, createdOAuthScope.Id));
ex.StatusCode.Should().Be(404);
}
finally
{
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ListOAuth2Claims()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthClaim = new OAuth2Claim
{
Name = $"{SdkPrefix}_{nameof(ListOAuth2Claims)}_TestOAuth2Claim_{TestClient.RandomString(4)}",
Status = "INACTIVE",
ClaimType = "RESOURCE",
ValueType = "EXPRESSION",
Value = "\"driving!\"",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthClaim = await createdAuthorizationServer.CreateOAuth2ClaimAsync(testOAuthClaim);
try
{
var allAuthorizationServerClaims = await testClient.AuthorizationServers.ListOAuth2Claims(createdAuthorizationServer.Id).ToListAsync();
allAuthorizationServerClaims.Should().NotBeNull();
allAuthorizationServerClaims.Count.Should().BeGreaterThan(0);
allAuthorizationServerClaims.Select(claim => claim.Id).ToHashSet().Should().Contain(createdOAuthClaim.Id);
}
finally
{
await createdAuthorizationServer.DeleteOAuth2ClaimAsync(createdOAuthClaim.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task ListAllUserTypes()
{
var testClient = TestClient.Create();
var existingUserTypeIds = await testClient.UserTypes.ListUserTypes().Select(ut => ut.Id).ToHashSetAsync();
var createdUserType1 = await testClient.UserTypes.CreateUserTypeAsync(new UserType()
{
Description = $"{nameof(ListAllUserTypes)} Test Description (1)",
DisplayName = $"{nameof(ListAllUserTypes)} Test DisplayName (1)",
Name = $"{nameof(ListAllUserTypes)}_TestUserType_1_{TestClient.RandomString(6)}",
});
var createdUserType2 = await testClient.UserTypes.CreateUserTypeAsync(new UserType()
{
Description = $"{nameof(ListAllUserTypes)} Test Description (2)",
DisplayName = $"{nameof(ListAllUserTypes)} Test DisplayName (2)",
Name = $"{nameof(ListAllUserTypes)}_TestUserType_2_{TestClient.RandomString(6)}",
});
Thread.Sleep(3000); // allow for user replication prior to read attempt
try
{
var allUserTypes = await testClient.UserTypes.ListUserTypes().ToListAsync();
var allUserTypesCount = allUserTypes.Count;
allUserTypesCount.Should().BeGreaterThan(0);
allUserTypesCount.Should().Be(existingUserTypeIds.Count + 2);
var allUserTypeIds = allUserTypes.Select(ut => ut.Id).ToHashSet();
Assert.Contains(createdUserType1.Id, allUserTypeIds);
Assert.Contains(createdUserType2.Id, allUserTypeIds);
}
finally
{
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType1.Id);
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType2.Id);
}
}
public async Task ListOAuth2Scopes()
{
var testClient = TestClient.Create();
var testAuthorizationServerName = $"{SdkPrefix}:Test AuthZ Server ({TestClient.RandomString(4)})";
var testAuthorizationServer = new AuthorizationServer
{
Name = testAuthorizationServerName,
Description = "Test Authorization Server",
Audiences = new string[] { "api://default" },
};
var testOAuthScope = new OAuth2Scope
{
Name = $"{SdkPrefix}:{nameof(ListOAuth2Scopes)}:TestOAuth2Scope({TestClient.RandomString(4)})",
};
var createdAuthorizationServer = await testClient.AuthorizationServers.CreateAuthorizationServerAsync(testAuthorizationServer);
var createdOAuthScope = await createdAuthorizationServer.CreateOAuth2ScopeAsync(testOAuthScope);
try
{
var allAuthorizationServerScopes = await createdAuthorizationServer.ListOAuth2Scopes().ToListAsync();
allAuthorizationServerScopes.Should().NotBeNull();
allAuthorizationServerScopes.Count.Should().BeGreaterThan(0);
allAuthorizationServerScopes.Select(scope => scope.Id).ToHashSet().Should().Contain(createdOAuthScope.Id);
}
finally
{
await createdAuthorizationServer.DeleteOAuth2ScopeAsync(createdOAuthScope.Id);
await createdAuthorizationServer.DeactivateAsync();
await testClient.AuthorizationServers.DeleteAuthorizationServerAsync(createdAuthorizationServer.Id);
}
}
public async Task GetLinkedObjectForUser()
{
var client = TestClient.Create();
var randomString = TestClient.RandomString(6); // use of guid results in field values that are too long
var primaryRelationshipName = $"dotnet_sdk_{nameof(GetLinkedObjectForUser)}_primary_{randomString}";
var associatedRelationshipName = $"dotnet_sdk_{nameof(GetLinkedObjectForUser)}_associated_{randomString}";
var createdPrimaryUser = await client.Users.CreateUserAsync(
new CreateUserWithPasswordOptions
{
Profile = new UserProfile
{
FirstName = "John-Primary",
LastName = $"{nameof(GetLinkedObjectForUser)}",
Email = $"{nameof(GetLinkedObjectForUser)}-primary-dotnet-sdk-{randomString}@example.com",
Login = $"{nameof(GetLinkedObjectForUser)}-primary-dotnet-sdk-{randomString}@example.com",
},
RecoveryQuestion = "Answer to life, the universe, & everything",
RecoveryAnswer = "42 of course",
Password = "******",
Activate = true,
});
var createdAssociatedUser = await client.Users.CreateUserAsync(
new CreateUserWithPasswordOptions
{
Profile = new UserProfile
{
FirstName = "David-Associated",
LastName = $"{nameof(GetLinkedObjectForUser)}",
Email = $"{nameof(GetLinkedObjectForUser)}-associated-dotnet-sdk-{randomString}@example.com",
Login = $"{nameof(GetLinkedObjectForUser)}-associated-dotnet-sdk-{randomString}@example.com",
},
RecoveryQuestion = "Answer to life, the universe, & everything",
RecoveryAnswer = "42 of course",
Password = "******",
Activate = true,
});
var createdLinkedObjectDefinition = await client.LinkedObjects.AddLinkedObjectDefinitionAsync(
new LinkedObject
{
Primary = new LinkedObjectDetails
{
Name = primaryRelationshipName,
Title = "Primary",
Description = "Primary link property",
Type = "USER",
},
Associated = new LinkedObjectDetails
{
Name = associatedRelationshipName,
Title = "Associated",
Description = "Associated link property",
Type = "USER",
},
});
Thread.Sleep(3000); // allow for user replication prior to read attempt
try
{
await createdAssociatedUser.SetLinkedObjectAsync(primaryRelationshipName, createdPrimaryUser.Id);
var links = await createdAssociatedUser.GetLinkedObjects(primaryRelationshipName).ToListAsync();
links.Should().NotBeNull();
links.Count.Should().Be(1);
}
finally
{
await createdPrimaryUser.DeactivateAsync();
await createdPrimaryUser.DeactivateOrDeleteAsync();
await createdAssociatedUser.DeactivateAsync();
await createdAssociatedUser.DeactivateOrDeleteAsync();
await client.LinkedObjects.DeleteLinkedObjectDefinitionAsync(primaryRelationshipName);
}
}
public async Task DeleteEventHook()
{
var testClient = TestClient.Create();
var testEventHookName = $"{SdkPrefix}:{nameof(DeleteEventHook)} Test Event Hook Name ({TestClient.RandomString(6)})";
var createdEventHook = await testClient.EventHooks.CreateEventHookAsync(
new EventHook
{
Name = testEventHookName,
Events = new EventSubscriptions
{
Type = EventType,
Items = new string[]
{
"user.lifecycle.create",
"user.lifecycle.activate",
},
},
Channel = new EventHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new EventHookChannelConfig
{
Uri = "https://www.example.com/eventHooks",
Headers = new List <IEventHookChannelConfigHeader>
{
new EventHookChannelConfigHeader
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new EventHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
createdEventHook.Id.Should().NotBeNullOrEmpty();
var retrievedEventHook = await testClient.EventHooks.GetEventHookAsync(createdEventHook.Id);
retrievedEventHook.Id.Should().Be(createdEventHook.Id);
await testClient.EventHooks.DeactivateEventHookAsync(createdEventHook.Id);
await testClient.EventHooks.DeleteEventHookAsync(createdEventHook.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() =>
testClient.EventHooks.GetEventHookAsync(createdEventHook.Id));
ex.StatusCode.Should().Be(404);
}
public async Task GetAllLinkedObjectDefinitions()
{
var testClient = TestClient.Create();
var randomString = TestClient.RandomString(6);
var testPrimaryName = $"{SdkPrefix}_{nameof(GetAllLinkedObjectDefinitions)}_primary_{randomString}";
var testAssociatedName = $"{SdkPrefix}_{nameof(GetAllLinkedObjectDefinitions)}_associated_{randomString}";
var createdLinkedObjectDefinition1 = await testClient.LinkedObjects.AddLinkedObjectDefinitionAsync(
new LinkedObject
{
Primary = new LinkedObjectDetails
{
Name = $"{testPrimaryName}_1",
Title = "Primary",
Description = "Primary link property",
Type = "USER",
},
Associated = new LinkedObjectDetails
{
Name = $"{testAssociatedName}_1",
Title = "Associated",
Description = "Associated link property",
Type = "USER",
},
});
var createdLinkedObjectDefinition2 = await testClient.LinkedObjects.AddLinkedObjectDefinitionAsync(
new LinkedObject
{
Primary = new LinkedObjectDetails
{
Name = $"{testPrimaryName}_2",
Title = "Primary",
Description = "Primary link property",
Type = "USER",
},
Associated = new LinkedObjectDetails
{
Name = $"{testAssociatedName}_2",
Title = "Associated",
Description = "Associated link property",
Type = "USER",
},
});
try
{
var allLinkedObjectDefinitions = testClient.LinkedObjects.ListLinkedObjectDefinitions();
var allLinkedObjectPrimaryNames =
await allLinkedObjectDefinitions.Select(lod => lod.Primary.Name).ToHashSetAsync();
var allLinkedObjectAssociatedNames =
await allLinkedObjectDefinitions.Select(lod => lod.Associated.Name).ToHashSetAsync();
Assert.Contains(createdLinkedObjectDefinition1.Primary.Name, allLinkedObjectPrimaryNames);
Assert.Contains(createdLinkedObjectDefinition2.Primary.Name, allLinkedObjectPrimaryNames);
Assert.Contains(createdLinkedObjectDefinition1.Associated.Name, allLinkedObjectAssociatedNames);
Assert.Contains(createdLinkedObjectDefinition2.Associated.Name, allLinkedObjectAssociatedNames);
}
finally
{
await testClient.LinkedObjects.DeleteLinkedObjectDefinitionAsync(
createdLinkedObjectDefinition1.Primary.Name);
await testClient.LinkedObjects.DeleteLinkedObjectDefinitionAsync(
createdLinkedObjectDefinition2.Primary.Name);
}
}
public async Task RetrieveInlineHook()
{
var testClient = TestClient.Create();
var testInlineHookName = $"{SdkPrefix}:{nameof(RetrieveInlineHook)} Test Inline Hook Name ({TestClient.RandomString(6)})";
var createdInlineHook = await testClient.InlineHooks.CreateInlineHookAsync(
new InlineHook
{
Name = testInlineHookName,
Version = "1.0.0",
Type = "com.okta.oauth2.tokens.transform",
Channel = new InlineHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new InlineHookChannelConfig
{
Uri = "https://www.example.com/inlineHook",
Headers = new List <IInlineHookChannelConfigHeaders>
{
new InlineHookChannelConfigHeaders
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new InlineHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
try
{
createdInlineHook.Id.Should().NotBeNullOrEmpty();
var retrievedInlineHook = await testClient.InlineHooks.GetInlineHookAsync(createdInlineHook.Id);
retrievedInlineHook.Id.Should().NotBeNullOrEmpty();
retrievedInlineHook.Id.Should().Be(createdInlineHook.Id);
retrievedInlineHook.Name.Should().Be(testInlineHookName);
retrievedInlineHook.Version.Should().Be("1.0.0");
retrievedInlineHook.Type.Should().Be(InlineHookType.ComOktaOauth2TokensTransform);
retrievedInlineHook.Channel.Should().NotBeNull();
retrievedInlineHook.Channel.Config.Should().NotBeNull();
retrievedInlineHook.Channel.Config.Uri.Should().Be("https://www.example.com/inlineHook");
}
finally
{
await testClient.InlineHooks.DeactivateInlineHookAsync(createdInlineHook.Id);
await testClient.InlineHooks.DeleteInlineHookAsync(createdInlineHook.Id);
}
}
public async Task DeleteUserTypeById()
{
var testClient = TestClient.Create();
var testDescription = $"{SdkPrefix}:{nameof(DeleteUserTypeById)} Test Description";
var testDisplayName = $"{SdkPrefix}:{nameof(DeleteUserTypeById)} Test DisplayName";
var testName = $"{SdkPrefix}_{nameof(DeleteUserTypeById)}_TestUserType_{TestClient.RandomString(6)}";
var createdUserType = await testClient.UserTypes.CreateUserTypeAsync(new UserType
{
Description = testDescription,
DisplayName = testDisplayName,
Name = testName,
});
createdUserType.Id.Should().NotBeNullOrEmpty();
var retrievedUserType = await testClient.UserTypes.GetUserTypeAsync(createdUserType.Id);
retrievedUserType.Id.Should().Be(createdUserType.Id);
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() =>
testClient.UserTypes.GetUserTypeAsync(createdUserType.Id));
ex.StatusCode.Should().Be(404);
}
public async Task ReplaceUserType()
{
var testClient = TestClient.Create();
var testDescription = $"{SdkPrefix}:{nameof(ReplaceUserType)} Test Description";
var testDisplayName = $"{SdkPrefix}:{nameof(ReplaceUserType)} Test DisplayName";
var testName = $"{SdkPrefix}_{nameof(ReplaceUserType)}_TestUserType_{TestClient.RandomString(6)}";
var createdUserType = await testClient.UserTypes.CreateUserTypeAsync(new UserType()
{
Description = testDescription,
DisplayName = testDisplayName,
Name = testName,
});
try
{
createdUserType.Id.Should().NotBeNullOrEmpty();
var replacedDescription = $"{createdUserType.Description} Repl"; // maximum length is 50
var replacedDisplayName = $"{createdUserType.DisplayName} Repl";
var replacedUserType = await testClient.UserTypes.ReplaceUserTypeAsync(
new UserType()
{
Description = replacedDescription,
DisplayName = replacedDisplayName,
Name = testName,
}, createdUserType.Id);
replacedUserType.Id.Should().Be(createdUserType.Id);
replacedUserType.Description.Should().Be(replacedDescription);
replacedUserType.DisplayName.Should().Be(replacedDisplayName);
replacedUserType.Name.Should().Be(testName);
var retrievedUserTypeForValidation = await testClient.UserTypes.GetUserTypeAsync(createdUserType.Id);
retrievedUserTypeForValidation.Id.Should().Be(createdUserType.Id);
retrievedUserTypeForValidation.Description.Should().Be(replacedDescription);
retrievedUserTypeForValidation.DisplayName.Should().Be(replacedDisplayName);
}
finally
{
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType.Id);
}
}
public async Task RetrieveUserTypeById()
{
var testClient = TestClient.Create();
var testDescription = $"{SdkPrefix}:{nameof(RetrieveUserTypeById)} Test Description";
var testDisplayName = $"{SdkPrefix}:{nameof(RetrieveUserTypeById)} Test DisplayName";
var testName = $"{SdkPrefix}{nameof(RetrieveUserTypeById)}_TestUserType_{TestClient.RandomString(6)}";
var createdUserType = await testClient.UserTypes.CreateUserTypeAsync(new UserType
{
Description = testDescription,
DisplayName = testDisplayName,
Name = testName,
});
try
{
createdUserType.Id.Should().NotBeNullOrEmpty();
var retrievedUserType = await testClient.UserTypes.GetUserTypeAsync(createdUserType.Id);
retrievedUserType.Should().NotBeNull();
retrievedUserType.Id.Should().Be(createdUserType.Id);
retrievedUserType.Description.Should().Be(testDescription);
retrievedUserType.DisplayName.Should().Be(testDisplayName);
}
finally
{
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType.Id);
}
}
public async Task UpdateUserType()
{
var testClient = TestClient.Create();
var testDescription = $"{SdkPrefix}:{nameof(UpdateUserType)} Test Description";
var testDisplayName = $"{SdkPrefix}:{nameof(UpdateUserType)} Test DisplayName";
var testName = $"{SdkPrefix}_{nameof(UpdateUserType)}_TestUserType_{TestClient.RandomString(6)}";
var createdUserType = await testClient.UserTypes.CreateUserTypeAsync(new UserType
{
Description = testDescription,
DisplayName = testDisplayName,
Name = testName,
});
try
{
createdUserType.Id.Should().NotBeNullOrEmpty();
var updatedDescription = $"{createdUserType.Description} Updated";
var updatedDisplayName = $"{createdUserType.Description} Updated";
var updatesToUserType = new UserType
{
Description = updatedDescription,
DisplayName = updatedDisplayName,
};
var updatedUserType = await testClient.UserTypes.UpdateUserTypeAsync(updatesToUserType, createdUserType.Id);
updatedUserType.Id.Should().Be(createdUserType.Id);
updatedUserType.Description.Should().Be(updatedDescription);
updatedUserType.DisplayName.Should().Be(updatedDisplayName);
var retrievedUserTypeForValidation = await testClient.UserTypes.GetUserTypeAsync(createdUserType.Id);
retrievedUserTypeForValidation.Id.Should().Be(createdUserType.Id);
retrievedUserTypeForValidation.Description.Should().Be(updatedDescription);
retrievedUserTypeForValidation.DisplayName.Should().Be(updatedDisplayName);
}
finally
{
await testClient.UserTypes.DeleteUserTypeAsync(createdUserType.Id);
}
}
public async Task DeleteGroupRule()
{
var testClient = TestClient.Create();
var guid = Guid.NewGuid();
var testNickName = $"dotnet-sdk-{nameof(DeleteGroupRule)}";
var testUserName = $"{testNickName}-{guid}@example.com";
var profile = new UserProfile
{
FirstName = "John",
LastName = $"{nameof(DeleteGroupRule)}",
Email = testUserName,
Login = testUserName,
["nickName"] = testNickName,
};
var createdUser = await testClient.Users.CreateUserAsync(new CreateUserWithPasswordOptions
{
Profile = profile,
Password = "******",
});
var createdGroup = await testClient.Groups.CreateGroupAsync(new CreateGroupOptions
{
Name = $"dotnet-sdk:{nameof(DeleteGroupRule)}-{guid}",
Description = $"dotnet-sdk:{nameof(DeleteGroupRule)}-{guid}",
});
Thread.Sleep(3000); // allow user replication prior to read attempt
var groupRule = new GroupRule
{
Type = "group_rule",
Name = $"US group rule ({TestClient.RandomString(6)})", // guid would cause field to be too long
Conditions = new GroupRuleConditions
{
People = new GroupRulePeopleCondition
{
Users = new GroupRuleUserCondition
{
Exclude = new List <string> {
createdUser.Id
},
},
Groups = new GroupRuleGroupCondition
{
Exclude = new List <string>(),
},
},
Expression = new GroupRuleExpression
{
Value = "user.countryCode==\"US\"",
Type = "urn:okta:expression:1.0",
},
},
Actions = new GroupRuleAction
{
AssignUserToGroups = new GroupRuleGroupAssignment
{
GroupIds = new List <string> {
createdGroup.Id
},
},
},
};
var createdGroupRule = await testClient.Groups.CreateGroupRuleAsync(groupRule);
try
{
var retrievedGroupRule = await testClient.Groups.GetGroupRuleAsync(createdGroupRule.Id);
retrievedGroupRule.Should().NotBeNull();
await testClient.Groups.DeleteGroupRuleAsync(createdGroupRule.Id);
Thread.Sleep(3000);
var ex = await Assert.ThrowsAsync <OktaApiException>(() => testClient.Groups.GetGroupRuleAsync(createdGroup.Id));
ex.StatusCode.Should().Be(404);
}
finally
{
await createdUser.DeactivateAsync();
await createdUser.DeactivateOrDeleteAsync();
await createdGroup.DeleteAsync();
}
}
public async Task ListAllEventHooks()
{
var testClient = TestClient.Create();
var testEventHookName = $"{SdkPrefix}:{nameof(ListAllEventHooks)} Test Event Hook Name ({TestClient.RandomString(6)})";
var existingEventHookIds = new HashSet <string>();
await foreach (IEventHook existingEventHook in testClient.EventHooks.ListEventHooks())
{
existingEventHookIds.Add(existingEventHook.Id);
}
var testEventHookIds = new HashSet <string>();
for (int i = 0; i < 5; i++)
{
var createdEventHook = await testClient.EventHooks.CreateEventHookAsync(
new EventHook
{
Name = $"{testEventHookName} {i}",
Events = new EventSubscriptions
{
Type = EventType,
Items = new string[]
{
"user.lifecycle.create",
"user.lifecycle.activate",
},
},
Channel = new EventHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new EventHookChannelConfig
{
Uri = "https://www.example.com/eventHooks",
Headers = new List <IEventHookChannelConfigHeader>
{
new EventHookChannelConfigHeader
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new EventHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
testEventHookIds.Add(createdEventHook.Id);
}
try
{
var allEventHookIds = new HashSet <string>();
var allEventHooks = testClient.EventHooks.ListEventHooks();
var allEventHooksCount = await allEventHooks.CountAsync();
allEventHooksCount.Should().BeGreaterThan(0);
allEventHooksCount.Should().Be(existingEventHookIds.Count + testEventHookIds.Count);
await foreach (IEventHook eventHook in allEventHooks)
{
allEventHookIds.Add(eventHook.Id);
}
foreach (string testEventHookId in testEventHookIds)
{
Assert.Contains(testEventHookId, allEventHookIds);
}
}
finally
{
foreach (string testEventHookId in testEventHookIds)
{
await testClient.EventHooks.DeactivateEventHookAsync(testEventHookId);
await testClient.EventHooks.DeleteEventHookAsync(testEventHookId);
}
}
}
public async Task ListAllInlineHooks()
{
var testClient = TestClient.Create();
var testInlineHookName = $"{SdkPrefix}:{nameof(ListAllInlineHooks)} Test Inline Hook Name ({TestClient.RandomString(6)})";
var existingInlineHookIds = new HashSet <string>();
await foreach (IInlineHook existingInlineHook in testClient.InlineHooks.ListInlineHooks())
{
existingInlineHookIds.Add(existingInlineHook.Id);
}
var testInlineHookIds = new HashSet <string>();
for (int i = 0; i < 5; i++)
{
var createdInlineHook = await testClient.InlineHooks.CreateInlineHookAsync(new InlineHook
{
Name = $"{testInlineHookName} {i}",
Version = "1.0.0",
Type = "com.okta.oauth2.tokens.transform",
Channel = new InlineHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new InlineHookChannelConfig
{
Uri = "https://www.example.com/inlineHook",
Headers = new List <IInlineHookChannelConfigHeaders>
{
new InlineHookChannelConfigHeaders
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new InlineHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
testInlineHookIds.Add(createdInlineHook.Id);
}
try
{
var allInlineHookIds = new HashSet <string>();
var allInlineHooks = testClient.InlineHooks.ListInlineHooks();
int allInlineHooksCount = await allInlineHooks.CountAsync();
allInlineHooksCount.Should().BeGreaterThan(0);
allInlineHooksCount.Should().Be(existingInlineHookIds.Count + testInlineHookIds.Count);
await foreach (var inlineHook in allInlineHooks)
{
allInlineHookIds.Add(inlineHook.Id);
}
foreach (var testInlineHookId in testInlineHookIds)
{
Assert.Contains(testInlineHookId, allInlineHookIds);
}
}
finally
{
foreach (var testInlineHookId in testInlineHookIds)
{
await testClient.InlineHooks.DeactivateInlineHookAsync(testInlineHookId);
await testClient.InlineHooks.DeleteInlineHookAsync(testInlineHookId);
}
}
}
public async Task RetrieveEventHook()
{
var testClient = TestClient.Create();
var testEventHookName = $"{SdkPrefix}:{nameof(RetrieveEventHook)} Test Event Hook Name ({TestClient.RandomString(6)})";
var createdEventHook = await testClient.EventHooks.CreateEventHookAsync(
new EventHook
{
Name = testEventHookName,
Events = new EventSubscriptions
{
Type = EventType,
Items = new string[]
{
"user.lifecycle.create",
"user.lifecycle.activate",
},
},
Channel = new EventHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new EventHookChannelConfig
{
Uri = "https://www.example.com/eventHooks",
Headers = new List <IEventHookChannelConfigHeader>
{
new EventHookChannelConfigHeader
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new EventHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
try
{
createdEventHook.Id.Should().NotBeNullOrEmpty();
var retrievedEventHook = await testClient.EventHooks.GetEventHookAsync(createdEventHook.Id);
retrievedEventHook.Id.Should().NotBeNullOrEmpty();
retrievedEventHook.Name.Should().Be(testEventHookName);
retrievedEventHook.Events.Should().NotBeNull();
retrievedEventHook.Events.Items.Should().NotBeNull();
retrievedEventHook.Events.Items.Count.Should().Be(2);
retrievedEventHook.Channel.Should().NotBeNull();
retrievedEventHook.Channel.Config.Should().NotBeNull();
retrievedEventHook.Channel.Config.Uri.Should().Be("https://www.example.com/eventHooks");
}
finally
{
await testClient.EventHooks.DeactivateEventHookAsync(createdEventHook.Id);
await testClient.EventHooks.DeleteEventHookAsync(createdEventHook.Id);
}
}
public async Task DeleteInlineHook()
{
var testClient = TestClient.Create();
var testInlineHookName = $"{SdkPrefix}:{nameof(DeleteInlineHook)} Test Inline Hook Name ({TestClient.RandomString(6)})";
var createdInlineHook = await testClient.InlineHooks.CreateInlineHookAsync(new InlineHook
{
Name = testInlineHookName,
Version = "1.0.0",
Type = "com.okta.oauth2.tokens.transform",
Channel = new InlineHookChannel
{
Type = "HTTP",
Version = "1.0.0",
Config = new InlineHookChannelConfig
{
Uri = "https://www.example.com/inlineHook",
Headers = new List <IInlineHookChannelConfigHeaders>
{
new InlineHookChannelConfigHeaders
{
Key = "X-Test-Header",
Value = "Test header value",
},
},
AuthScheme = new InlineHookChannelConfigAuthScheme
{
Type = "HEADER",
Key = "Authorization",
Value = "Test-Api-Key",
},
},
},
});
createdInlineHook.Id.Should().NotBeNullOrEmpty();
var retrievedEventHook = await testClient.InlineHooks.GetInlineHookAsync(createdInlineHook.Id);
retrievedEventHook.Id.Should().Be(createdInlineHook.Id);
await testClient.InlineHooks.DeactivateInlineHookAsync(createdInlineHook.Id);
await testClient.InlineHooks.DeleteInlineHookAsync(createdInlineHook.Id);
var ex = await Assert.ThrowsAsync <OktaApiException>(() =>
testClient.EventHooks.GetEventHookAsync(createdInlineHook.Id));
ex.StatusCode.Should().Be(404);
}