public async Task TestGetUserMembershipsAsync()
{
var displayOptions = new DisplayOptions {
Page = 1, PerPage = 20, Order = OrderType.Asc
};
var membershipFilter = new MembershipFilter {
AccountName = "tothnet", MembershipOrder = MembershipOrder.Status, Status = Status.Accepted
};
_wireMockServer
.Given(Request.Create()
.WithPath($"/{MembershipEndpoints.Base}/")
.WithParam(Filtering.Page)
.WithParam(Filtering.PerPage)
.WithParam(Filtering.Order)
.WithParam(Filtering.Status)
.WithParam(Filtering.AccountName)
.WithParam(Filtering.Direction)
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(UserMembershipTestsData.Memberships)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var userMembership = await client.Users.Memberships.GetAsync(membershipFilter, displayOptions);
userMembership.Result.Should().BeEquivalentTo(UserMembershipTestsData.Memberships);
}
public async Task TestUpdateAccountMemberAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
var membership = AccountMembershipTestData.Members.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Members}/{membership.Id}").UsingPut())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <Member>(x.Body);
var response = AccountMembershipTestData.Members.First(y => y.Id == x.PathSegments[3]).DeepClone();
response.Code = body.Code;
response.Status = body.Status;
return(WireMockResponseHelper.CreateTestResponse(response));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var updatedMember = await client.Accounts.Members.UpdateAsync(accountId, membership);
updatedMember.Result.Code.Should().Be(membership.Code);
updatedMember.Result.Status.Should().Be(membership.Status);
updatedMember.Result.Should().BeEquivalentTo(membership, opt => opt.Excluding(x => x.Code).Excluding(x => x.Status));
}
public async Task TestGetCustomHostnamesAsync()
{
var displayOptions = new DisplayOptions {
Page = 1, PerPage = 20, Order = OrderType.Asc
};
var filtering = new CustomHostnameFilter {
CustomHostnameId = CustomHostnameTestData.CustomHostnames.First().Id
};
var zone = ZoneTestData.Zones.First();
_wireMockServer
.Given(Request.Create()
.WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{CustomHostnameEndpoints.Base}/")
.WithParam(Filtering.Page)
.WithParam(Filtering.PerPage)
.WithParam(Filtering.Direction)
.WithParam(Filtering.Id)
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(CustomHostnameTestData.CustomHostnames)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var customHostnames = await client.Zones.CustomHostnames.GetAsync(zone.Id, filtering, displayOptions);
customHostnames.Result.Should().BeEquivalentTo(CustomHostnameTestData.CustomHostnames);
}
public async Task TestGetDnsRecordsAsync()
{
var displayOptions = new DisplayOptions {
Page = 1, PerPage = 20, Order = OrderType.Asc
};
var dnsRecordFilter = new DnsRecordFilter {
Content = "127.0.0.1", Match = false, Name = "tothnet.hu", Type = DnsRecordType.A
};
var zone = ZoneTestData.Zones.First();
_wireMockServer
.Given(Request.Create()
.WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}/")
.WithParam(Filtering.Page)
.WithParam(Filtering.PerPage)
.WithParam(Filtering.Order)
.WithParam(Filtering.Name)
.WithParam(Filtering.Content)
.WithParam(Filtering.DnsRecordType)
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(DnsRecordTestData.DnsRecords)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var records = await client.Zones.DnsRecords.GetAsync(zone.Id, dnsRecordFilter, displayOptions);
records.Result.Should().BeEquivalentTo(DnsRecordTestData.DnsRecords);
}
public async Task TestCreateDnsRecordAsync()
{
var zone = ZoneTestData.Zones.First();
var dnsRecord = DnsRecordTestData.DnsRecords.First();
var newRecord = new NewDnsRecord
{
Name = dnsRecord.Name,
Content = dnsRecord.Content,
Priority = dnsRecord.Priority,
Proxied = dnsRecord.Proxied,
Ttl = dnsRecord.Ttl,
Type = dnsRecord.Type
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(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(dnsRecord);
}
public async Task TestUpdateDnsRecordAsync()
{
var zone = ZoneTestData.Zones.First();
var record = DnsRecordTestData.DnsRecords.First();
var modified = new ModifiedDnsRecord
{
Name = "new.tothnet.hu",
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{DnsRecordEndpoints.Base}/{record.Id}").UsingPut())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <ModifiedDnsRecord>(x.Body);
var response = DnsRecordTestData.DnsRecords.First(y => y.Id == x.PathSegments[3]).DeepClone();
response.Name = body.Name;
return(WireMockResponseHelper.CreateTestResponse(response));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var update = await client.Zones.DnsRecords.UpdateAsync(zone.Id, record.Id, modified);
update.Result.Should().BeEquivalentTo(record, opt => opt.Excluding(x => x.Name));
update.Result.Name.Should().BeEquivalentTo("new.tothnet.hu");
}
public async Task TestClientAuthenticationWithApiKey()
{
var user = UserTestData.Users.First();
using var client = new CloudFlareClient(WireMockConnection.EmailAddress, WireMockConnection.Key, _connectionInfo);
IDictionary <string, WireMockList <string> > headers = null;
_wireMockServer
.Given(Request.Create().WithPath($"/{UserEndpoints.Base}").UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
headers = x.Headers;
return(WireMockResponseHelper.CreateTestResponse(user));
}));
await client.Users.GetDetailsAsync();
headers.Should().ContainKey("X-Auth-Email");
headers.First(x => x.Key == "X-Auth-Email").Value.Should().BeEquivalentTo(WireMockConnection.EmailAddress);
headers.Should().ContainKey("X-Auth-Key");
headers.First(x => x.Key == "X-Auth-Key").Value.Should().BeEquivalentTo(WireMockConnection.Key);
}
public async Task TestEditCustomHostnameAsync()
{
var zone = ZoneTestData.Zones.First();
var customHostname = CustomHostnameTestData.CustomHostnames.First();
var modified = new ModifiedCustomHostname
{
Ssl = SslTestData.Ssls.First().DeepClone()
};
modified.Ssl.Settings.Tls13 = FeatureStatus.Off;
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}/{CustomHostnameEndpoints.Base}/{customHostname.Id}").UsingPatch())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <NewCustomHostname>(x.Body);
var response = CustomHostnameTestData.CustomHostnames.First(y => y.Id == x.PathSegments[3]).DeepClone();
response.Ssl = body.Ssl;
return(WireMockResponseHelper.CreateTestResponse(response));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var editCustomHostname = await client.Zones.CustomHostnames.UpdateAsync(zone.Id, customHostname.Id, modified);
editCustomHostname.Result.Should().BeEquivalentTo(customHostname, opt => opt.Excluding(y => y.Ssl.Settings.Tls13));
editCustomHostname.Result.Ssl.Settings.Tls13.Should().BeEquivalentTo(FeatureStatus.Off);
}
public async Task TestModifyAccountSubscriptionsAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
var subscription = SubscriptionTestData.Subscriptions.First().DeepClone();
subscription.Price = long.MaxValue;
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Subscriptions}/{subscription.Id}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <Subscription>(x.Body);
var response = SubscriptionTestData.Subscriptions.First().DeepClone();
response.Price = body.Price;
return(WireMockResponseHelper.CreateTestResponse(response));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var modifiedSubscription = await client.Accounts.Subscriptions.UpdateAsync(accountId, subscription);
modifiedSubscription.Result.Should().BeEquivalentTo(SubscriptionTestData.Subscriptions.First(), opt => opt.Excluding(x => x.Price));
modifiedSubscription.Result.Price.Should().Be(long.MaxValue);
}
public async Task TestEditZoneAsync()
{
var zone = ZoneTestData.Zones.First();
var modified = new ModifiedZone {
Paused = true
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}/{zone.Id}").UsingPatch())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <ModifiedZone>(x.Body);
var response = ZoneTestData.Zones.First(y => y.Id == x.PathSegments[1]).DeepClone();
if (body.Paused != null)
{
response.Paused = body.Paused.Value;
}
return(WireMockResponseHelper.CreateTestResponse(response));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var editZone = await client.Zones.UpdateAsync(zone.Id, modified);
editZone.Result.Should().BeEquivalentTo(zone, opt => opt.Excluding(y => y.Paused));
editZone.Result.Paused.Should().BeTrue();
}
public async Task TestGetZonesAsync()
{
var displayOptions = new DisplayOptions {
Page = 1, PerPage = 20, Order = OrderType.Asc
};
var zoneFilter = new ZoneFilter {
Match = false, Status = ZoneStatus.Active, Name = "tothnet.hu"
};
_wireMockServer
.Given(Request.Create()
.WithPath($"/{ZoneEndpoints.Base}/")
.WithParam(Filtering.Page)
.WithParam(Filtering.PerPage)
.WithParam(Filtering.Order)
.WithParam(Filtering.Name)
.WithParam(Filtering.Status)
.WithParam(Filtering.Match)
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(ZoneTestData.Zones)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var zones = await client.Zones.GetAsync(zoneFilter, displayOptions);
zones.Result.Should().BeEquivalentTo(ZoneTestData.Zones);
}
public async Task UpdateAccountAsync()
{
var expectedAccount = AccountTestData.Accounts.First();
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{expectedAccount.Id}").UsingPut())
.RespondWith(Response.Create().WithStatusCode(200).WithBody(x =>
{
var body = JsonConvert.DeserializeObject <Account>(x.Body);
var account = AccountTestData.Accounts.First(y => y.Id == body.Id).DeepClone();
account.Id = body.Id;
account.Name = body.Name;
account.Settings = body.Settings;
return(WireMockResponseHelper.CreateTestResponse(account));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var updatedAccount = await client.Accounts.UpdateAsync(expectedAccount.Id, "New Name", new AdditionalAccountSettings
{
EnforceTwoFactorAuthentication = true
});
updatedAccount.Result.Name.Should().Be("New Name");
updatedAccount.Result.Settings.EnforceTwoFactorAuthentication.Should().BeTrue();
updatedAccount.Result.Should().BeEquivalentTo(expectedAccount, opt => opt.Excluding(x => x.Name).Excluding(x => x.Settings.EnforceTwoFactorAuthentication));
}
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 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 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 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 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 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 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 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 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());
}
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 TestUpdateUserDetailsAsync()
{
var expected = UserTestData.Users.First().DeepClone();
expected.Email = "*****@*****.**";
_wireMockServer
.Given(Request.Create().WithPath($"/{UserEndpoints.Base}").UsingPatch())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(x =>
{
var body = JsonConvert.DeserializeObject <User>(x.Body);
return(WireMockResponseHelper.CreateTestResponse(body));
}));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var updatedUser = await client.Users.UpdateAsync(expected);
updatedUser.Result.Should().BeEquivalentTo(expected);
}
public async Task TestCreateZoneAsync()
{
var zone = ZoneTestData.Zones.First();
var newZone = new NewZone
{
Name = zone.Name,
Type = zone.Type,
Account = zone.Account,
};
_wireMockServer
.Given(Request.Create().WithPath($"/{ZoneEndpoints.Base}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(zone)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var addZone = await client.Zones.AddAsync(newZone);
addZone.Result.Should().BeEquivalentTo(zone);
}
public async Task TestGetAccountsAsync()
{
var displayOptions = new DisplayOptions {
Page = 1, PerPage = 20, Order = OrderType.Asc
};
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/")
.WithParam(Filtering.Page)
.WithParam(Filtering.PerPage)
.WithParam(Filtering.Direction)
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(AccountTestData.Accounts)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var accounts = await client.Accounts.GetAsync(displayOptions);
accounts.Result.Should().BeEquivalentTo(AccountTestData.Accounts);
}
public async Task TestAddAccountMemberAsync()
{
var accountId = AccountTestData.Accounts.First().Id;
var membership = AccountMembershipTestData.Members.First();
var newMember = new NewMember
{
EmailAddress = membership.User.Email,
Roles = membership.Roles,
Status = membership.Status
};
_wireMockServer
.Given(Request.Create().WithPath($"/{AccountEndpoints.Base}/{accountId}/{AccountEndpoints.Members}").UsingPost())
.RespondWith(Response.Create().WithStatusCode(200)
.WithBody(WireMockResponseHelper.CreateTestResponse(membership)));
using var client = new CloudFlareClient(WireMockConnection.ApiKeyAuthentication, _connectionInfo);
var addedAccountMember = await client.Accounts.Members.AddAsync(accountId, newMember);
addedAccountMember.Result.Should().BeEquivalentTo(membership);
}
