public async Task LoadTestAddUsers()
{
string token = await GenerateManagementApiToken();
var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
var connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest
{
Name = "Temp-Int-Test-" + MakeRandomName(),
Strategy = "auth0",
EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") }
});
// Add a new user
for (int i = 1; i <= 200; i++)
{
_outputHelper.WriteLine($"Adding user {i}");
var newUserRequest = new UserCreateRequest
{
Connection = connection.Name,
Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
EmailVerified = true,
Password = Password
};
await apiClient.Users.CreateAsync(newUserRequest);
}
await apiClient.Connections.DeleteAsync(connection.Id);
}
public async Task Active_Users_Returns_Values()
{
string token = await GenerateManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")))
{
var activeUsers = await apiClient.Stats.GetActiveUsersAsync();
activeUsers.Should().BeGreaterThan(0);
}
}
public async Task Can_request_device_credentials_using_pagination()
{
var mockHandler = new Mock <HttpMessageHandler>(MockBehavior.Strict);
var response = new PagedList <DeviceCredential> {
new DeviceCredential {
DeviceName = "Test"
}
};
var token = "AUTH0_TOKEN_DEVICE_CREDENTIALS";
var domain = GetVariable("AUTH0_MANAGEMENT_API_URL");
var request = new GetDeviceCredentialsRequest
{
ClientId = GetVariable("AUTH0_CLIENT_ID"),
Type = "rotating_refresh_token",
UserId = "google-oauth2|109627300720782495235",
Fields = "name,email",
};
var paginationInfo = new PaginationInfo(0, 25, true);
var expectedParams = new Dictionary <string, string>
{
{ "fields", request.Fields },
{ "include_fields", request.IncludeFields.ToString().ToLower() },
{ "user_id", request.UserId },
{ "client_id", request.ClientId },
{ "type", request.Type },
{ "page", paginationInfo.PageNo.ToString() },
{ "per_page", paginationInfo.PerPage.ToString() },
{ "include_totals", paginationInfo.IncludeTotals.ToString().ToLower() }
};
mockHandler.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.Is <HttpRequestMessage>(req => req.RequestUri.ToString().StartsWith($"https://{domain}/api/v2/device-credentials") && ValidateRequestContent(req, expectedParams)),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(response), Encoding.UTF8, "application/json"),
});
var httpClient = new HttpClient(mockHandler.Object);
var managementApiClient = new TestManagementApiClient(token, new Uri($"https://{domain}/api/v2"), new TestHttpClientManagementConnection(httpClient));
var deviceCredentials = await managementApiClient.DeviceCredentials.GetAllAsync(request, paginationInfo);
response.Should().NotBeNull();
response[0].DeviceName.Should().Equals("Test");
}
public async Task Daily_Stats_Returns_Values()
{
string token = await GenerateManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")))
{
var dailyStats = await apiClient.Stats.GetDailyStatsAsync(DateTime.Now.AddDays(-100), DateTime.Now);
dailyStats.Should().NotBeNull();
dailyStats.Count.Should().BeGreaterOrEqualTo(1);
dailyStats.Max(d => d.Logins).Should().BeGreaterThan(0);
}
}
public async Task Test_email_templates_crud_sequence()
{
var emailTemplateNames = Enum.GetValues(typeof(EmailTemplateName)).Cast <EmailTemplateName>();
string token = await GenerateManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")))
{
// Create each template
foreach (var emailTemplateName in emailTemplateNames)
{
EmailTemplate emailTemplate;
try
{
// Try and create the template. If it already exisits, we'll just update it
emailTemplate = await apiClient.EmailTemplates.CreateAsync(new EmailTemplateCreateRequest
{
Template = emailTemplateName,
Body = "<html>",
Enabled = true,
Subject = emailTemplateName.ToString(),
From = "*****@*****.**",
Syntax = EmailTemplateSyntax.Liquid
});
}
catch (ApiException)
{
emailTemplate = await apiClient.EmailTemplates.UpdateAsync(emailTemplateName, new EmailTemplateUpdateRequest
{
Template = emailTemplateName,
Body = "<html>",
Enabled = true,
Subject = emailTemplateName.ToString(),
From = "*****@*****.**",
Syntax = EmailTemplateSyntax.Liquid
});
}
}
// Patch each template
foreach (var emailTemplateName in emailTemplateNames)
{
// Try and create the template. If it already exisits, we'll just update it
var emailTemplate = await apiClient.EmailTemplates.PatchAsync(emailTemplateName, new EmailTemplatePatchRequest
{
Enabled = false,
From = "*****@*****.**"
});
}
}
}
public async Task Test_custom_domains()
{
string token = await GenerateBruckeManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("BRUCKE_MANAGEMENT_API_URL")))
{
// Test getting all custom domains
var domains = await apiClient.CustomDomains.GetAllAsync();
domains.Should().HaveCount(1); // There is only one custom domain currently registered on this tenant
string id = domains[0].CustomDomainId;
// Test getting a single custom domain
var domain = await apiClient.CustomDomains.GetAsync(id);
domain.Should().NotBeNull();
domain.CustomDomainId.Should().Be(id);
string non_existent_id = "cd_XXw4P8C04x1Aa9e5";
// Test deleting a non-existent domain
// (this does not throw for a non-existent domain?)
await apiClient.CustomDomains.DeleteAsync(non_existent_id);
// Test verifying a non-existing id. This will give 404
Func <Task <CustomDomainVerificationResponse> > verifyFunc = async() => await apiClient.CustomDomains.VerifyAsync(non_existent_id);
verifyFunc.Should().Throw <ApiException>()
.WithMessage($"The custom domain {non_existent_id} does not exist");
// Test adding a new domain. The BRUCKE tenant only allows one, so this should throw
Func <Task <CustomDomain> > createFunc = async() => await apiClient.CustomDomains.CreateAsync(new CustomDomainCreateRequest
{
Domain = "test.brucke.club",
Type = CustomDomainCertificateProvisioning.Auth0ManagedCertificate,
VerificationMethod = "txt"
});
createFunc.Should().Throw <ApiException>()
.WithMessage("You reached the maximum number of custom domains for your account (MAX ALLOWED: 1)");
}
}
public async Task Test_tenant_settings_sequence()
{
string token = await GenerateManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")))
{
// Get the current settings
var settings = apiClient.TenantSettings.GetAsync();
settings.Should().NotBeNull();
// Update the tenant settings - do not set some properties as the tenant is pre-configured
// to allow all the right logout urls etc.
var settingsUpdateRequest = new TenantSettingsUpdateRequest
{
ChangePassword = new TenantChangePassword
{
Enabled = true,
Html = "<b>hi</b>",
},
ErrorPage = new TenantErrorPage
{
Html = null,
ShowLogLink = false,
Url = $"www.{Guid.NewGuid():N}.aaa/error",
},
GuardianMfaPage = new TenantGuardianMfaPage
{
Html = "<b>hi</b>",
Enabled = true,
},
FriendlyName = Guid.NewGuid().ToString("N"),
PictureUrl = $"www.{Guid.NewGuid():N}.aaa/picture.png",
SupportEmail = $"support@{Guid.NewGuid():N}.aaa",
SupportUrl = $"www.{Guid.NewGuid():N}.aaa/support",
DefaultAudience = "",
DefaultDirectory = "Username-Password-Authentication",
EnabledLocales = new[] { "en" },
Flags = new TenantFlags()
{
ChangePwdFlowV1 = false,
DisableClickjackProtectionHeaders = true,
EnableAPIsSection = true,
EnableClientConnections = false,
EnablePipeline2 = true
},
DeviceFlow = new TenantDeviceFlow()
{
Charset = TenantDeviceFlowCharset.Base20,
Mask = "***-***-***"
}
};
var settingsUpdateResponse = await apiClient.TenantSettings.UpdateAsync(settingsUpdateRequest);
settingsUpdateResponse.Should().BeEquivalentTo(settingsUpdateRequest, options => options
.Excluding(p => p.Flags)
.Excluding(p => p.SandboxVersion)
.Excluding(p => p.SandboxVersionsAvailable)
);
settingsUpdateResponse.Flags.ChangePwdFlowV1.Should().BeFalse();
settingsUpdateResponse.Flags.DisableClickjackProtectionHeaders.Should().BeTrue();
settingsUpdateResponse.Flags.EnableAPIsSection.Should().BeTrue();
settingsUpdateResponse.Flags.EnableClientConnections.Should().BeFalse();
settingsUpdateResponse.Flags.EnablePipeline2.Should().BeTrue();
var resetUpdateRequest = new TenantSettingsUpdateRequest
{
ChangePassword = new TenantChangePassword
{
Html = null,
Enabled = false,
},
ErrorPage = new TenantErrorPage
{
Html = null,
Url = "",
},
GuardianMfaPage = new TenantGuardianMfaPage
{
Html = null,
Enabled = false,
},
FriendlyName = "Auth0.NET SDK integration test",
PictureUrl = "",
SupportEmail = "*****@*****.**",
SupportUrl = "",
};
await apiClient.TenantSettings.UpdateAsync(resetUpdateRequest);
}
}
public async Task Test_smtp_email_provider_crud_sequence()
{
string token = await GenerateManagementApiToken();
using (var apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")))
{
// Delete the email provider to ensure we start on a clean slate
await apiClient.EmailProvider.DeleteAsync();
// Getting the email provider now should throw, since none is configured
Func <Task> getFunc = async() => await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
getFunc.Should().Throw <ErrorApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_email_provider");
// Configure the email provider
var configureRequest = new EmailProviderConfigureRequest
{
Name = "smtp",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
SmtpHost = "smtp1.test.com",
SmtpPort = 25,
SmtpUsername = "******",
SmtpPassword = "******"
}
};
var configureResponse = await apiClient.EmailProvider.ConfigureAsync(configureRequest);
configureResponse.Name.Should().Be(configureRequest.Name);
configureResponse.IsEnabled.Should().Be(configureRequest.IsEnabled);
configureResponse.Credentials.SmtpHost.Should().Be(configureRequest.Credentials.SmtpHost);
configureResponse.Credentials.SmtpPort.Should().Be(configureRequest.Credentials.SmtpPort);
configureResponse.Credentials.SmtpUsername.Should().Be(configureRequest.Credentials.SmtpUsername);
configureResponse.Credentials.SmtpPassword.Should().BeNull(); // API no longer returns creds
// Check that we can get the email provider details
var provider = await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
provider.Name.Should().Be(configureRequest.Name);
provider.IsEnabled.Should().Be(configureRequest.IsEnabled);
provider.Credentials.ApiKey.Should().BeNull(); // API no longer returns creds
// Update the email provider
var updateRequest = new EmailProviderUpdateRequest
{
Name = "smtp",
IsEnabled = true,
Credentials = new EmailProviderCredentials
{
SmtpHost = "smtp2.test.com",
SmtpPort = 587,
SmtpUsername = "******",
SmtpPassword = "******"
}
};
var updateResponse = await apiClient.EmailProvider.UpdateAsync(updateRequest);
updateResponse.Name.Should().Be(updateRequest.Name);
updateResponse.IsEnabled.Should().Be(updateRequest.IsEnabled);
updateResponse.Credentials.SmtpHost.Should().Be(updateRequest.Credentials.SmtpHost);
updateResponse.Credentials.SmtpPort.Should().Be(updateRequest.Credentials.SmtpPort);
updateResponse.Credentials.SmtpUsername.Should().Be(updateRequest.Credentials.SmtpUsername);
updateResponse.Credentials.SmtpPassword.Should().BeNull(); // API no longer returns creds
// Delete the email provider again
await apiClient.EmailProvider.DeleteAsync();
// Check than once again the email provider should throw, since none is configured
getFunc = async() => await apiClient.EmailProvider.GetAsync("name,enabled,credentials,settings");
getFunc.Should().Throw <ErrorApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_email_provider");
}
}
