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()); }