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