public static void TestGetAccountMembersAsync(int?page, int?perPage, OrderType?order)
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var accounts = client.GetAccountsAsync().Result;
var accountMembers = client.GetAccountMembersAsync(accounts.Result.First().Id, page, perPage, order).Result;
Assert.NotNull(accountMembers);
Assert.Empty(accountMembers.Errors);
Assert.True(accountMembers.Success);
}
}
public static void TestGetRolesAsync()
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var accounts = client.GetAccountsAsync().Result;
var roles = client.GetRolesAsync(accounts.Result.First().Id).Result;
Assert.NotNull(roles);
Assert.Empty(roles.Errors);
Assert.True(roles.Success);
}
}
public static void TestEditUserAsync()
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var userDetails = client.GetUserDetailsAsync().Result;
var editedUser = client.EditUserAsync(userDetails.Result).Result;
Assert.NotNull(editedUser);
Assert.Empty(editedUser.Errors);
Assert.True(editedUser.Success);
}
}
public static void TestDeleteMembershipAsync()
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var userMembership = client.GetMembershipsAsync().Result;
var deletedMembership = client.DeleteMembershipAsync(userMembership.Result.First().Id).Result;
Assert.NotNull(deletedMembership);
Assert.True(deletedMembership.Success);
if (deletedMembership.Errors != null)
{
Assert.Empty(deletedMembership.Errors);
}
}
public static void TestGetAccountDetailsAsync()
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var accounts = client.GetAccountsAsync().Result;
var accountDetails = client.GetAccountDetailsAsync(accounts.Result.First().Id).Result;
Assert.NotNull(accountDetails);
Assert.True(accountDetails.Success);
if (accountDetails.Errors != null)
{
Assert.Empty(accountDetails.Errors);
}
}
public static void UpdateAccountAsync()
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var accounts = client.GetAccountsAsync().Result;
var updatedAccount = client.UpdateAccountAsync(accounts.Result.First().Id, accounts.Result.First().Name).Result;
Assert.NotNull(updatedAccount);
Assert.True(updatedAccount.Success);
if (updatedAccount.Errors != null)
{
Assert.Empty(updatedAccount.Errors);
}
}
public static void TestGetCustomHostnamesAsync(string hostname, int?page, int?perPage,
CustomHostnameOrderType?type, OrderType?order, bool?ssl)
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var zoneId = client.GetZonesAsync().Result.Result.First().Id;
var customHostnames = client.GetCustomHostnamesAsync(zoneId, hostname, page, perPage, type, order, ssl).Result;
Assert.NotNull(customHostnames);
Assert.Empty(customHostnames.Errors);
Assert.True(customHostnames.Success);
}
}
public static void TestGetCustomHostnameDetailsAsync()
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var zoneId = client.GetZonesAsync().Result.Result.First().Id;
var customHostnameId = client.GetCustomHostnamesAsync(zoneId).Result.Result.First().Id;
var customHostnameDetails = client.GetCustomHostnameDetailsAsync(zoneId, customHostnameId).Result;
Assert.NotNull(customHostnameDetails);
Assert.Empty(customHostnameDetails.Errors);
Assert.True(customHostnameDetails.Success);
}
}
public static void TestDeleteCustomHostnameAsync()
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var zoneId = client.GetZonesAsync().Result.Result.First().Id;
var customHostname = client.GetCustomHostnamesAsync(zoneId).Result.Result.First();
var deleteCustomHostname = client.DeleteCustomHostnameAsync(zoneId, customHostname.Hostname).Result;
Assert.NotNull(deleteCustomHostname);
Assert.Empty(deleteCustomHostname.Errors);
Assert.True(deleteCustomHostname.Success);
}
}
public async Task TestVerifyUserAsync()
{
var token = TokenTestData.Tokens.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{UserEndpoints.Base}/{TokenEndpoints.Base}/{TokenEndpoints.Verify}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(token)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var verification = await client.Users.VerifyAsync();
verification.Result.Should().BeEquivalentTo(token);
}
public async Task TestGetMembershipsAsync(MembershipStatus?status, string accountName, int?page,
int?perPage,
MembershipOrder?membershipOrder, OrderType?order)
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var userMembership = await client.GetMembershipsAsync(status, accountName, page, perPage, membershipOrder, order);
Assert.NotNull(userMembership);
Assert.True(userMembership.Success);
if (userMembership.Errors != null)
{
Assert.Empty(userMembership.Errors);
}
}
public static void TestGetMembershipsAsync(MembershipStatus?status, string accountName, int?page,
int?perPage,
MembershipOrder?membershipOrder, OrderType?order)
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var userMembership = client
.GetMembershipsAsync(status, accountName, page, perPage, membershipOrder, order).Result;
Assert.NotNull(userMembership);
Assert.Empty(userMembership.Errors);
Assert.True(userMembership.Success);
}
}
public static void TestUpdateMembershipStatusAsync(SetMembershipStatus status)
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var userMembership = client.GetMembershipsAsync().Result;
if (userMembership.Result.First().Status == MembershipStatus.Accepted)
{
var updateUserMembershipStatus = client.UpdateMembershipStatusAsync(userMembership.Result.First().Id, status).Result;
Assert.NotNull(updateUserMembershipStatus);
Assert.Contains(1001, updateUserMembershipStatus.Errors.Select(x => x.Code));
Assert.False(updateUserMembershipStatus.Success);
}
}
public async Task TestGetRolesAsync()
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var accounts = await client.GetAccountsAsync();
var subscriptions = await client.GetAccountSubscriptionsAsync(accounts.Result.First().Id);
Assert.NotNull(subscriptions);
Assert.True(subscriptions.Success);
if (subscriptions.Errors != null)
{
Assert.Empty(subscriptions.Errors);
}
}
public async Task TestGetAccountSubscriptionsAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Subscriptions}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(SubscriptionTestData.Subscriptions)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var subscriptions = await client.Accounts.Subscriptions.GetAsync(accountId);
subscriptions.Result.Should().BeEquivalentTo(SubscriptionTestData.Subscriptions);
}
public async Task TestGetUserMembershipDetailsAsync()
{
var membership = UserMembershipTestsData.Memberships.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{MembershipEndpoints.Base}/{membership.Id}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(UserMembershipTestsData.Memberships.First())));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var userMembershipDetails = await client.Users.Memberships.GetDetailsAsync(membership.Id);
userMembershipDetails.Result.Should().BeEquivalentTo(membership);
}
public async Task TestScanDnsRecordsAsync()
{
var zone = ZoneTestData.Zones.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}/{DnsRecordEndpoints.Scan}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(DnsRecordTestData.DnsRecordScans.First())));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var scanZone = await client.Zones.DnsRecords.ScanAsync(zone.Id);
scanZone.Result.Should().BeEquivalentTo(DnsRecordTestData.DnsRecordScans.First());
}
public async Task TestGetZoneDetailsAsync()
{
var zone = ZoneTestData.Zones.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(zone)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var zoneDetails = await client.Zones.GetDetailsAsync(zone.Id);
zoneDetails.Result.Should().BeEquivalentTo(zone);
}
public async Task TestGetAccountMembersAsync(int?page, int?perPage, OrderType?order)
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var accounts = await client.GetAccountsAsync();
var accountMembers = await client.GetAccountMembersAsync(accounts.Result.First().Id, page, perPage, order);
Assert.NotNull(accountMembers);
Assert.True(accountMembers.Success);
if (accountMembers.Errors != null)
{
Assert.Empty(accountMembers.Errors);
}
}
public async Task TestGetRoleDetailsAsync()
{
using var client = new CloudFlareClient(Credentials.Credentials.Authentication);
var accounts = await client.GetAccountsAsync();
var roles = await client.GetRolesAsync(accounts.Result.First().Id);
var roleDetails = client.GetRoleDetailsAsync(accounts.Result.First().Id, roles.Result.First().Id).Result;
Assert.NotNull(roleDetails);
Assert.True(roleDetails.Success);
if (roleDetails.Errors != null)
{
Assert.Empty(roleDetails.Errors);
}
}
public async Task TestGetAccountDetailsOnEnterpriseAsync()
{
var account = AccountTestData.Accounts.Last();
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{account.Id}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(account)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var accountDetails = await client.Accounts.GetDetailsAsync(account.Id);
accountDetails.Result.Should().BeEquivalentTo(account);
accountDetails.Result.Type.Should().Be(AccountType.Enterprise);
}
public async Task TestGetRoleDetailsAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
var role = RoleTestData.Roles.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Roles}/{role.Id}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(role)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var roleDetails = await client.Accounts.Roles.GetDetailsAsync(accountId, role.Id);
roleDetails.Result.Should().BeEquivalentTo(role);
}
public static void TestGetMembershipDetailsAsync()
{
using (var client = new CloudFlareClient(Credentials.Credentials.Authentication))
{
var userMembership = client.GetMembershipsAsync().Result;
Assert.NotNull(userMembership);
Assert.Empty(userMembership.Errors);
Assert.True(userMembership.Success);
var userMembershipDetails = client.GetMembershipDetailsAsync(userMembership.Result.First().Id).Result;
Assert.NotNull(userMembershipDetails);
Assert.Empty(userMembershipDetails.Errors);
Assert.True(userMembershipDetails.Success);
}
}
public async Task TestPurgeAllFilesAsync()
{
var zone = ZoneTestData.Zones.First();
var expected = new Zone {
Id = zone.Id
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{ZoneEndpoints.PurgeCache}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(expected)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var purge = await client.Zones.PurgeAllFilesAsync(zone.Id, true);
purge.Result.Should().BeEquivalentTo(expected);
}
public async Task TestDeleteUserMembershipAsync()
{
var membership = UserMembershipTestsData.Memberships.First();
var expected = new Membership {
Id = membership.Id
};
_wireMockServer
.Given(Request.Create().WithPath($"/{MembershipEndpoints.Base}/{membership.Id}").UsingDelete())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(expected)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var deletedMembership = await client.Users.Memberships.DeleteAsync(membership.Id);
deletedMembership.Result.Should().BeEquivalentTo(expected);
}
public async Task TestCreateDataDnsRecordAsync()
{
var zone = ZoneTestData.Zones.First();
var newRecord = new NewDnsRecord <Srv>
{
Type = DnsRecordType.Srv,
Data = new()
{
Name = "@",
Port = 1234,
Priority = 5,
Protocol = Protocol.Tcp,
Service = "_servicename",
Target = "servicename.tothnet.hu",
Weight = 5
},
Proxied = true,
Ttl = 12,
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var dnsRecord = DnsRecordTestData.DnsRecords.First().DeepClone();
dnsRecord.Type = newRecord.Type;
dnsRecord.Priority = newRecord.Data.Priority;
dnsRecord.Data = newRecord.Data;
return(WireMockResponseHelper.CreateTestResponse(dnsRecord));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var created = await client.Zones.DnsRecords.AddAsync(zone.Id, newRecord);
created.Result.Should().BeEquivalentTo(DnsRecordTestData.DnsRecords.First(),
c => c.Excluding(p => p.Data)
.Excluding(p => p.Type)
.Excluding(p => p.Priority));
JsonConvert.DeserializeObject <Srv>(created.Result.Data.ToString()).Should().BeEquivalentTo(newRecord.Data);
created.Result.Type.Should().Be(newRecord.Type);
created.Result.Priority.Should().Be(newRecord.Data.Priority);
}
public async Task TestDeleteCustomHostnameAsync()
{
var zone = ZoneTestData.Zones.First();
var customHostname = CustomHostnameTestData.CustomHostnames.First();
var expected = new CustomHostname {
Id = customHostname.Id
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{CustomHostnameEndpoints.Base}/{customHostname.Id}").UsingDelete())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(expected)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var deleteCustomHostname = await client.Zones.CustomHostnames.DeleteAsync(zone.Id, customHostname.Id);
deleteCustomHostname.Result.Should().BeEquivalentTo(expected);
}
public async Task TestDeleteAccountSubscriptionsAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
var subscription = SubscriptionTestData.Subscriptions.First();
var expected = new DeletedSubscription {
SubscriptionId = subscription.Id
};
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Subscriptions}/{subscription.Id}").UsingDelete())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(expected)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var deletedSubscription = await client.Accounts.Subscriptions.DeleteAsync(accountId, subscription.Id);
deletedSubscription.Result.Should().BeEquivalentTo(expected);
}
public async Task TestAddCustomHostnameAsync()
{
var zone = ZoneTestData.Zones.First();
var customHostname = CustomHostnameTestData.CustomHostnames.First();
var newCustomHostname = new NewCustomHostname {
Hostname = customHostname.Hostname, Ssl = SslTestData.Ssls.First()
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{CustomHostnameEndpoints.Base}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(customHostname)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var addCustomHostname = await client.Zones.CustomHostnames.AddAsync(zone.Id, newCustomHostname);
addCustomHostname.Result.Should().BeEquivalentTo(customHostname);
}
public async Task TestImportDnsRecordAsync()
{
var zone = ZoneTestData.Zones.First();
var record = DnsRecordTestData.DnsRecords.First();
var file = FileHelper.CreateTempFile("test.txt");
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}/{DnsRecordEndpoints.Import}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(DnsRecordTestData.DnsRecordImports.First())));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var deleteCustomHostname = await client.Zones.DnsRecords.ImportAsync(zone.Id, file, false);
file.Delete();
deleteCustomHostname.Result.Should().BeEquivalentTo(DnsRecordTestData.DnsRecordImports.First());
}
