am-wd/cloudflare-api
1
0
Fork 0
Code Issues Actions Activity

Reorganize Zone Extension

Browse Source
This commit is contained in:
Andreas Müller
2025-06-24 10:48:40 +02:00
parent 135e1a11f3
commit 6f27dd3ff8
75 changed files with 0 additions and 10129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByHostTest.cs
View File

@@ -1,120 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Cache
{
[TestClass]
public class PurgeCachedContentByHostTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private readonly DateTime DateTime = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, InternalPurgeCacheRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId,
}
};
}
[TestMethod]
public async Task ShouldPurgeCachedContent()
{
// Arrange
var list = new List<string>
{
"www.example.com",
"example.org",
};
var client = GetClient();
// Act
var response = await client.PurgeCachedContentByHost(ZoneId, list);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.PurgeEverything);
Assert.IsNull(callback.Request.Urls);
Assert.IsNull(callback.Request.UrlsWithHeaders);
Assert.IsNull(callback.Request.Tags);
Assert.IsNotNull(callback.Request.Hostnames);
Assert.AreEqual(2, callback.Request.Hostnames.Count);
Assert.AreEqual("www.example.com", callback.Request.Hostnames[0]);
Assert.AreEqual("example.org", callback.Request.Hostnames[1]);
Assert.IsNull(callback.Request.Prefixes);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumenNullExceptionIfListIsNull()
{
// Arrange
var client = GetClient();
// Act
await client.PurgeCachedContentByHost(ZoneId, null);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>(It.IsAny<string>(), It.IsAny<InternalPurgeCacheRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalPurgeCacheRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

123
UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByPrefixTest.cs
View File

@@ -1,123 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Cache
{
[TestClass]
public class PurgeCachedContentByPrefixTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private readonly DateTime DateTime = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, InternalPurgeCacheRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId,
}
};
}
[TestMethod]
public async Task ShouldPurgeCachedContent()
{
// Arrange
var list = new List<string>
{
null,
"example.com/foo",
"example.com/bar",
"example.org/hello/world",
};
var client = GetClient();
// Act
var response = await client.PurgeCachedContentByPrefix(ZoneId, list);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.PurgeEverything);
Assert.IsNull(callback.Request.Urls);
Assert.IsNull(callback.Request.UrlsWithHeaders);
Assert.IsNull(callback.Request.Tags);
Assert.IsNull(callback.Request.Hostnames);
Assert.IsNotNull(callback.Request.Prefixes);
Assert.AreEqual(3, callback.Request.Prefixes.Count);
Assert.AreEqual("example.com/foo", callback.Request.Prefixes[0]);
Assert.AreEqual("example.com/bar", callback.Request.Prefixes[1]);
Assert.AreEqual("example.org/hello/world", callback.Request.Prefixes[2]);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumenNullExceptionIfListIsNull()
{
// Arrange
var client = GetClient();
// Act
await client.PurgeCachedContentByPrefix(ZoneId, null);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>(It.IsAny<string>(), It.IsAny<InternalPurgeCacheRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalPurgeCacheRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

121
UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByTagTest.cs
View File

@@ -1,121 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Cache
{
[TestClass]
public class PurgeCachedContentByTagTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private readonly DateTime DateTime = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, InternalPurgeCacheRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId,
}
};
}
[TestMethod]
public async Task ShouldPurgeCachedContent()
{
// Arrange
var list = new List<string>
{
"Tag-1",
"",
"Tag-2",
};
var client = GetClient();
// Act
var response = await client.PurgeCachedContentByTag(ZoneId, list);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.PurgeEverything);
Assert.IsNull(callback.Request.Urls);
Assert.IsNull(callback.Request.UrlsWithHeaders);
Assert.IsNotNull(callback.Request.Tags);
Assert.AreEqual(2, callback.Request.Tags.Count);
Assert.AreEqual("Tag-1", callback.Request.Tags[0]);
Assert.AreEqual("Tag-2", callback.Request.Tags[1]);
Assert.IsNull(callback.Request.Hostnames);
Assert.IsNull(callback.Request.Prefixes);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumenNullExceptionIfListIsNull()
{
// Arrange
var client = GetClient();
// Act
await client.PurgeCachedContentByTag(ZoneId, null);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>(It.IsAny<string>(), It.IsAny<InternalPurgeCacheRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalPurgeCacheRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

164
UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByUrlTest.cs
View File

@@ -1,164 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Cache
{
[TestClass]
public class PurgeCachedContentByUrlTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private readonly DateTime DateTime = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, InternalPurgeCacheRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId,
}
};
}
[TestMethod]
public async Task ShouldPurgeCachedContentByUrl()
{
// Arrange
var list = new List<ZonePurgeCachedUrlRequest>
{
new("https://example.com/foo.txt"),
new("https://example.com/bar.baz"),
};
var client = GetClient();
// Act
var response = await client.PurgeCachedContentByUrl(ZoneId, list);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.PurgeEverything);
Assert.IsNotNull(callback.Request.Urls);
Assert.AreEqual(2, callback.Request.Urls.Count);
Assert.AreEqual("https://example.com/foo.txt", callback.Request.Urls[0]);
Assert.AreEqual("https://example.com/bar.baz", callback.Request.Urls[1]);
Assert.IsNull(callback.Request.UrlsWithHeaders);
Assert.IsNull(callback.Request.Tags);
Assert.IsNull(callback.Request.Hostnames);
Assert.IsNull(callback.Request.Prefixes);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPurgeCachedContentByUrlWithHeader()
{
// Arrange
var list = new List<ZonePurgeCachedUrlRequest>
{
new("https://example.com/foo.txt") { Headers = new Dictionary<string, string> { { "X-Test1", "Test" } } },
new("https://example.com/bar.baz") { Headers = new Dictionary<string, string> { { "X-Test2", "Test" } } },
};
var client = GetClient();
// Act
var response = await client.PurgeCachedContentByUrl(ZoneId, list);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.PurgeEverything);
Assert.IsNull(callback.Request.Urls);
Assert.IsNotNull(callback.Request.UrlsWithHeaders);
Assert.AreEqual(2, callback.Request.UrlsWithHeaders.Count);
Assert.AreEqual("https://example.com/foo.txt", callback.Request.UrlsWithHeaders[0].Url);
Assert.AreEqual("Test", callback.Request.UrlsWithHeaders[0].Headers["X-Test1"]);
Assert.AreEqual("https://example.com/bar.baz", callback.Request.UrlsWithHeaders[1].Url);
Assert.AreEqual("Test", callback.Request.UrlsWithHeaders[1].Headers["X-Test2"]);
Assert.IsNull(callback.Request.Tags);
Assert.IsNull(callback.Request.Hostnames);
Assert.IsNull(callback.Request.Prefixes);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumenNullExceptionIfListIsNull()
{
// Arrange
var client = GetClient();
// Act
await client.PurgeCachedContentByUrl(ZoneId, null);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>(It.IsAny<string>(), It.IsAny<InternalPurgeCacheRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalPurgeCacheRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

99
UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentTest.cs
View File

@@ -1,99 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Cache
{
[TestClass]
public class PurgeCachedContentTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private readonly DateTime DateTime = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, InternalPurgeCacheRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId,
}
};
}
[TestMethod]
public async Task ShouldPurgeCachedContent()
{
// Arrange
var client = GetClient();
// Act
var response = await client.PurgeCachedContent(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/purge_cache", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNotNull(callback.Request.PurgeEverything);
Assert.IsTrue(callback.Request.PurgeEverything.Value);
Assert.IsNull(callback.Request.Urls);
Assert.IsNull(callback.Request.UrlsWithHeaders);
Assert.IsNull(callback.Request.Tags);
Assert.IsNull(callback.Request.Hostnames);
Assert.IsNull(callback.Request.Prefixes);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<InternalPurgeCacheRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<IdResponse, InternalPurgeCacheRequest>(It.IsAny<string>(), It.IsAny<InternalPurgeCacheRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalPurgeCacheRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

160
UnitTests/Cloudflare.Zones.Tests/DnsRecords/BatchDnsRecordsTest.cs
View File

@@ -1,160 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class BatchDnsRecordsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
private Mock<ICloudflareClient> _clientMock;
private List<(string RequestPath, InternalBatchRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
private CloudflareResponse<BatchDnsRecordsResult> _response;
private BatchDnsRecordsRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<BatchDnsRecordsResult>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new BatchDnsRecordsResult
{
DeletedRecords = [new DnsRecord { Id = RecordId, ZoneId = ZoneId, ZoneName = "example.com", Name = "example.com", Type = DnsRecordType.A, Content = "198.51.100.4" }],
UpdatedRecords = [new DnsRecord { Id = RecordId, ZoneId = ZoneId, ZoneName = "example.com", Name = "example.com", Type = DnsRecordType.A, Content = "198.51.100.4" }],
OverwrittenRecords = [new DnsRecord { Id = RecordId, ZoneId = ZoneId, ZoneName = "example.com", Name = "example.com", Type = DnsRecordType.A, Content = "198.51.100.4" }],
CreatedRecords = [new DnsRecord { Id = RecordId, ZoneId = ZoneId, ZoneName = "example.com", Name = "example.com", Type = DnsRecordType.A, Content = "198.51.100.4" }],
}
};
_request = new BatchDnsRecordsRequest(ZoneId)
{
DnsRecordIdsToDelete = [RecordId],
DnsRecordsToUpdate = [new UpdateDnsRecordRequest(RecordId, ZoneId, "example.com", DnsRecordType.A) { Content = "198.51.100.4" }],
DnsRecordsToOverwrite = [new OverwriteDnsRecordRequest(RecordId, ZoneId, "example.com", DnsRecordType.A) { Content = "198.51.100.4" }],
DnsRecordsToCreate = [new CreateDnsRecordRequest(ZoneId, "example.com", DnsRecordType.A) { Content = "198.51.100.4" }],
};
}
[TestMethod]
public async Task ShouldExecuteBatchDnsRecords()
{
// Arrange
var client = GetClient();
// Act
var response = await client.BatchDnsRecords(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/batch", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(1, callback.Request.Deletes.Count);
Assert.AreEqual(RecordId, callback.Request.Deletes.First().Id);
Assert.AreEqual(1, callback.Request.Patches.Count);
var patch = callback.Request.Patches.First();
Assert.AreEqual(RecordId, patch.Id);
Assert.AreEqual("example.com", patch.Name);
Assert.AreEqual(DnsRecordType.A, patch.Type);
Assert.AreEqual("198.51.100.4", patch.Content);
Assert.AreEqual(1, callback.Request.Puts.Count);
var put = callback.Request.Puts.First();
Assert.AreEqual(RecordId, put.Id);
Assert.AreEqual("example.com", put.Name);
Assert.AreEqual(DnsRecordType.A, put.Type);
Assert.AreEqual("198.51.100.4", put.Content);
Assert.AreEqual(1, callback.Request.Posts.Count);
var post = callback.Request.Posts.First();
Assert.AreEqual("example.com", post.Name);
Assert.AreEqual(DnsRecordType.A, post.Type);
Assert.AreEqual("198.51.100.4", post.Content);
_clientMock.Verify(m => m.PostAsync<BatchDnsRecordsResult, InternalBatchRequest>(It.IsAny<string>(), It.IsAny<InternalBatchRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[DataRow("023e105f4ecef8ad9ca31a8372d0c354")]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentExceptionForDifferentZoneIdOnUpdateRecord(string str)
{
// Arrange
_request.DnsRecordsToUpdate.First().ZoneId = str;
var client = GetClient();
// Act
await client.BatchDnsRecords(_request);
// Assert - ArgumentException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[DataRow("023e105f4ecef8ad9ca31a8372d0c354")]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentExceptionForDifferentZoneIdOnOverwriteRecord(string str)
{
// Arrange
_request.DnsRecordsToOverwrite.First().ZoneId = str;
var client = GetClient();
// Act
await client.BatchDnsRecords(_request);
// Assert - ArgumentException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<BatchDnsRecordsResult, InternalBatchRequest>(It.IsAny<string>(), It.IsAny<InternalBatchRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalBatchRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

1368
UnitTests/Cloudflare.Zones.Tests/DnsRecords/CreateDnsRecordTest.cs
View File

File diff suppressed because it is too large Load Diff

85
UnitTests/Cloudflare.Zones.Tests/DnsRecords/DeleteDnsRecordTest.cs
View File

@@ -1,85 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class DeleteDnsRecordTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = RecordId,
}
};
}
[TestMethod]
public async Task ShouldDeleteDnsRecord()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DeleteDnsRecord(ZoneId, RecordId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.DeleteAsync<IdResponse>($"zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.DeleteAsync<IdResponse>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

107
UnitTests/Cloudflare.Zones.Tests/DnsRecords/DnsRecordDetailsTest.cs
View File

@@ -1,107 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class DnsRecordDetailsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<DnsRecord> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<DnsRecord>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new DnsRecord
{
Id = RecordId,
ZoneId = ZoneId,
ZoneName = "example.com",
Name = "*.example.com",
Type = DnsRecordType.A,
Content = "198.51.100.4",
Proxiable = true,
Proxied = true,
Ttl = 1,
Settings = new(),
Meta = new DnsRecordMeta
{
AutoAdded = false,
ManagedByApps = false,
ManagedByArgoTunnel = false
},
Comment = "Domain verification record",
Tags = [],
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
CommentModifiedOn = DateTime.Parse("2024-01-01T05:20:00.12345Z"),
TagsModifiedOn = DateTime.Parse("2025-01-01T05:20:00.12345Z"),
}
};
}
[TestMethod]
public async Task ShouldDeleteDnsRecord()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DnsRecordDetails(ZoneId, RecordId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<DnsRecord>($"zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<DnsRecord>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

67
UnitTests/Cloudflare.Zones.Tests/DnsRecords/ExportDnsRecordsTest.cs
View File

@@ -1,67 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class ExportDnsRecordsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<string> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<string>
{
Success = true,
Result = "This is my BIND export file."
};
}
[TestMethod]
public async Task ShouldExportZoneDnsRecords()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ExportDnsRecords(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/export", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<string>($"zones/{ZoneId}/dns_records/export", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<string>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

246
UnitTests/Cloudflare.Zones.Tests/DnsRecords/ImportDnsRecordsTest.cs
View File

@@ -1,246 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class ImportDnsRecordsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string BindConfigContent = "www.example.com. 300 IN A 127.0.0.1";
private Mock<ICloudflareClient> _clientMock;
private List<(string RequestPath, MultipartFormDataContent Request, IQueryParameterFilter QueryFilter)> _callbacks;
private CloudflareResponse<ImportDnsRecordsResult> _response;
private ImportDnsRecordsRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ImportDnsRecordsResult>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ImportDnsRecordsResult
{
RecordsAdded = 5,
TotalRecordsParsed = 6,
}
};
_request = new ImportDnsRecordsRequest(ZoneId, BindConfigContent);
}
[TestMethod]
public async Task ShouldImportDnsRecordsFromString()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ImportDnsRecords(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/import", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(1, callback.Request.Count());
var part = callback.Request.First();
Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<ByteArrayContent>(part);
Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
_clientMock.Verify(m => m.PostAsync<ImportDnsRecordsResult, MultipartFormDataContent>($"zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldImportDnsRecordsFromFile()
{
// Arrange
string file = Path.GetTempFileName();
try
{
File.WriteAllText(file, BindConfigContent);
_request.File = file;
var client = GetClient();
// Act
var response = await client.ImportDnsRecords(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/import", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(1, callback.Request.Count());
var part = callback.Request.First();
Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<ByteArrayContent>(part);
Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
_clientMock.Verify(m => m.PostAsync<ImportDnsRecordsResult, MultipartFormDataContent>($"zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
finally
{
File.Delete(file);
}
}
[DataTestMethod]
[DataRow(true)]
[DataRow(false)]
public async Task ShouldImportDnsRecordsFromStringWithProxied(bool proxied)
{
// Arrange
_request.Proxied = proxied;
var client = GetClient();
// Act
var response = await client.ImportDnsRecords(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/import", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(2, callback.Request.Count());
var part = callback.Request.First();
Assert.AreEqual("proxied", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<StringContent>(part);
Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync());
part = callback.Request.Last();
Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<ByteArrayContent>(part);
Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
_clientMock.Verify(m => m.PostAsync<ImportDnsRecordsResult, MultipartFormDataContent>($"zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(true)]
[DataRow(false)]
public async Task ShouldImportDnsRecordsFromFileWithProxied(bool proxied)
{
// Arrange
string file = Path.GetTempFileName();
try
{
File.WriteAllText(file, BindConfigContent);
_request.File = file;
_request.Proxied = proxied;
var client = GetClient();
// Act
var response = await client.ImportDnsRecords(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/import", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(2, callback.Request.Count());
var part = callback.Request.First();
Assert.AreEqual("proxied", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<StringContent>(part);
Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync());
part = callback.Request.Last();
Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
Assert.IsInstanceOfType<ByteArrayContent>(part);
Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
_clientMock.Verify(m => m.PostAsync<ImportDnsRecordsResult, MultipartFormDataContent>($"zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
finally
{
File.Delete(file);
}
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForFile(string file)
{
// Arrange
_request.File = file;
var client = GetClient();
// Act
await client.ImportDnsRecords(_request);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<ImportDnsRecordsResult, MultipartFormDataContent>(It.IsAny<string>(), It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, MultipartFormDataContent, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

843
UnitTests/Cloudflare.Zones.Tests/DnsRecords/ListDnsRecordsTest.cs
View File

@@ -1,843 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class ListDnsRecordsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IReadOnlyList<DnsRecord>> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IReadOnlyList<DnsRecord>>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
ResultInfo = new PaginationInfo
{
Count = 1,
Page = 1,
PerPage = 20,
TotalCount = 2000,
TotalPages = 100,
},
Result = [
new DnsRecord
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
ZoneId = "023e105f4ecef8ad9ca31a8372d0c354",
ZoneName = "example.com",
Name = "*.example.com",
Type = DnsRecordType.A,
Content = "198.51.100.4",
Proxiable = true,
Proxied = true,
Ttl = 1,
Settings = new(),
Meta = new DnsRecordMeta
{
AutoAdded = false,
ManagedByApps = false,
ManagedByArgoTunnel = false
},
Comment = "Domain verification record",
Tags = [],
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
CommentModifiedOn = DateTime.Parse("2024-01-01T05:20:00.12345Z"),
TagsModifiedOn = DateTime.Parse("2025-01-01T05:20:00.12345Z"),
},
new DnsRecord
{
Id = "023e105f4ecef8ad9ca31a8372d0c355",
ZoneId = "023e105f4ecef8ad9ca31a8372d0c356",
ZoneName = "example.com",
Name = "example.com",
Type = DnsRecordType.A,
Content = "198.51.100.4",
Proxiable = true,
Proxied = true,
Ttl = 1,
Settings = new(),
Meta = new DnsRecordMeta
{
AutoAdded = false,
ManagedByApps = false,
ManagedByArgoTunnel = false
},
Comment = "Domain verification record",
Tags = [],
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
CommentModifiedOn = DateTime.Parse("2024-01-01T05:20:00.12345Z"),
TagsModifiedOn = DateTime.Parse("2025-01-01T05:20:00.12345Z"),
}
]
};
}
[TestMethod]
public async Task ShouldListDnsRecords()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ListDnsRecords(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<IReadOnlyList<DnsRecord>>($"zones/{ZoneId}/dns_records", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldListDnsRecordsWithFilter()
{
// Arrange
var filter = new ListDnsRecordsFilter
{
Name = "example.com"
};
var client = GetClient();
// Act
var response = await client.ListDnsRecords(ZoneId, filter);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records", callback.RequestPath);
Assert.IsNotNull(callback.QueryFilter);
Assert.IsInstanceOfType<ListDnsRecordsFilter>(callback.QueryFilter);
Assert.AreEqual("example.com", ((ListDnsRecordsFilter)callback.QueryFilter).Name);
_clientMock.Verify(m => m.GetAsync<IReadOnlyList<DnsRecord>>($"zones/{ZoneId}/dns_records", filter, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldReturnEmptyParameterList()
{
// Arrange
var filter = new ListDnsRecordsFilter();
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldReturnFullParameterList()
{
// Arrange
var filter = new ListDnsRecordsFilter
{
Comment = "Hello World",
CommentAbsent = true,
CommentContains = "lo Wor",
CommentEndsWith = "ld",
CommentExact = "Hello World",
CommentPresent = true,
CommentStartsWith = "He",
Content = "127.0.0.1",
ContentContains = "7.0.0",
ContentEndsWith = "0.1",
ContentExact = "127.0.0.1",
ContentStartsWith = "127",
Direction = SortDirection.Descending,
Match = FilterMatchType.All,
Name = "example.com",
NameContains = "ample",
NameEndsWith = ".com",
NameExact = "example.com",
NameStartsWith = "ex",
OrderBy = DnsRecordsOrderBy.Name,
Page = 2,
PerPage = 5,
Proxied = true,
Search = "Some Search",
Tag = "team:DNS",
TagAbsent = "important",
TagContains = "greeting:ello",
TagEndsWith = "greeting:rld",
TagExact = "greeting:Hello World",
TagPresent = "important",
TagStartsWith = "greeting:Hel",
TagMatch = FilterMatchType.Any,
Type = DnsRecordType.A,
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(33, dict.Count);
Assert.IsTrue(dict.ContainsKey("comment"));
Assert.IsTrue(dict.ContainsKey("comment.absent"));
Assert.IsTrue(dict.ContainsKey("comment.contains"));
Assert.IsTrue(dict.ContainsKey("comment.endswith"));
Assert.IsTrue(dict.ContainsKey("comment.exact"));
Assert.IsTrue(dict.ContainsKey("comment.present"));
Assert.IsTrue(dict.ContainsKey("comment.startswith"));
Assert.IsTrue(dict.ContainsKey("content"));
Assert.IsTrue(dict.ContainsKey("content.contains"));
Assert.IsTrue(dict.ContainsKey("content.endswith"));
Assert.IsTrue(dict.ContainsKey("content.exact"));
Assert.IsTrue(dict.ContainsKey("content.startswith"));
Assert.IsTrue(dict.ContainsKey("direction"));
Assert.IsTrue(dict.ContainsKey("match"));
Assert.IsTrue(dict.ContainsKey("name"));
Assert.IsTrue(dict.ContainsKey("name.contains"));
Assert.IsTrue(dict.ContainsKey("name.endswith"));
Assert.IsTrue(dict.ContainsKey("name.exact"));
Assert.IsTrue(dict.ContainsKey("name.startswith"));
Assert.IsTrue(dict.ContainsKey("order"));
Assert.IsTrue(dict.ContainsKey("page"));
Assert.IsTrue(dict.ContainsKey("per_page"));
Assert.IsTrue(dict.ContainsKey("proxied"));
Assert.IsTrue(dict.ContainsKey("search"));
Assert.IsTrue(dict.ContainsKey("tag"));
Assert.IsTrue(dict.ContainsKey("tag.absent"));
Assert.IsTrue(dict.ContainsKey("tag.contains"));
Assert.IsTrue(dict.ContainsKey("tag.endswith"));
Assert.IsTrue(dict.ContainsKey("tag.exact"));
Assert.IsTrue(dict.ContainsKey("tag.present"));
Assert.IsTrue(dict.ContainsKey("tag.startswith"));
Assert.IsTrue(dict.ContainsKey("tag_match"));
Assert.IsTrue(dict.ContainsKey("type"));
Assert.AreEqual("Hello World", dict["comment"]);
Assert.AreEqual("true", dict["comment.absent"]);
Assert.AreEqual("lo Wor", dict["comment.contains"]);
Assert.AreEqual("ld", dict["comment.endswith"]);
Assert.AreEqual("Hello World", dict["comment.exact"]);
Assert.AreEqual("true", dict["comment.present"]);
Assert.AreEqual("He", dict["comment.startswith"]);
Assert.AreEqual("127.0.0.1", dict["content"]);
Assert.AreEqual("7.0.0", dict["content.contains"]);
Assert.AreEqual("0.1", dict["content.endswith"]);
Assert.AreEqual("127.0.0.1", dict["content.exact"]);
Assert.AreEqual("127", dict["content.startswith"]);
Assert.AreEqual("desc", dict["direction"]);
Assert.AreEqual("all", dict["match"]);
Assert.AreEqual("example.com", dict["name"]);
Assert.AreEqual("ample", dict["name.contains"]);
Assert.AreEqual(".com", dict["name.endswith"]);
Assert.AreEqual("example.com", dict["name.exact"]);
Assert.AreEqual("ex", dict["name.startswith"]);
Assert.AreEqual("name", dict["order"]);
Assert.AreEqual("2", dict["page"]);
Assert.AreEqual("5", dict["per_page"]);
Assert.AreEqual("true", dict["proxied"]);
Assert.AreEqual("Some Search", dict["search"]);
Assert.AreEqual("team:DNS", dict["tag"]);
Assert.AreEqual("important", dict["tag.absent"]);
Assert.AreEqual("greeting:ello", dict["tag.contains"]);
Assert.AreEqual("greeting:rld", dict["tag.endswith"]);
Assert.AreEqual("greeting:Hello World", dict["tag.exact"]);
Assert.AreEqual("important", dict["tag.present"]);
Assert.AreEqual("greeting:Hel", dict["tag.startswith"]);
Assert.AreEqual("any", dict["tag_match"]);
Assert.AreEqual("A", dict["type"]);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddComment(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { Comment = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow(false)]
public void ShouldNotAddCommentAbsent(bool? b)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentAbsent = b };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddCommentContains(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentContains = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddCommentEndsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentEndsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddCommentExact(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentExact = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow(false)]
public void ShouldNotAddCommentPresent(bool? b)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentPresent = b };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddCommentStartsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { CommentStartsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddContent(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { Content = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddContentContains(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { ContentContains = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddContentEndsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { ContentEndsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddContentExact(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { ContentExact = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddContentStartsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { ContentStartsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow((SortDirection)0)]
public void ShouldNotAddDirection(SortDirection? direction)
{
// Arrange
var filter = new ListDnsRecordsFilter { Direction = direction };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow((FilterMatchType)0)]
public void ShouldNotAddMatch(FilterMatchType? match)
{
// Arrange
var filter = new ListDnsRecordsFilter { Match = match };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddName(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { Name = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddNameContains(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { NameContains = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddNameEndsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { NameEndsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddNameExact(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { NameExact = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddNameStartsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { NameStartsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow((DnsRecordsOrderBy)0)]
public void ShouldNotAddOrder(DnsRecordsOrderBy? order)
{
// Arrange
var filter = new ListDnsRecordsFilter { OrderBy = order };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow(0)]
public void ShouldNotAddPage(int? page)
{
// Arrange
var filter = new ListDnsRecordsFilter { Page = page };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow(0)]
[DataRow(5_000_001)]
public void ShouldNotAddPerPage(int? perPage)
{
// Arrange
var filter = new ListDnsRecordsFilter { PerPage = perPage };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTag(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { Tag = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagAbsent(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagAbsent = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagContains(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagContains = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagEndsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagEndsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagExact(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagExact = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagPresent(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagPresent = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddTagStartsWith(string str)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagStartsWith = str };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow((FilterMatchType)0)]
public void ShouldNotAddTagMatch(FilterMatchType? tagMatch)
{
// Arrange
var filter = new ListDnsRecordsFilter { TagMatch = tagMatch };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow((DnsRecordType)0)]
public void ShouldNotAddType(DnsRecordType? type)
{
// Arrange
var filter = new ListDnsRecordsFilter { Type = type };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<IReadOnlyList<DnsRecord>>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

118
UnitTests/Cloudflare.Zones.Tests/DnsRecords/OverwriteDnsRecordTest.cs
View File

@@ -1,118 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class OverwriteDnsRecordTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<DnsRecord> _response;
private List<(string RequestPath, InternalDnsRecordRequest Request)> _callbacks;
private OverwriteDnsRecordRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<DnsRecord>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new DnsRecord
{
Id = RecordId,
ZoneId = ZoneId,
ZoneName = "example.com",
Name = "*.example.com",
Type = DnsRecordType.A,
Content = "198.51.100.4",
Proxiable = true,
Proxied = true,
Ttl = 1,
Settings = new(),
Meta = new DnsRecordMeta
{
AutoAdded = false,
ManagedByApps = false,
ManagedByArgoTunnel = false
},
Comment = "Domain verification record",
Tags = [],
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
CommentModifiedOn = DateTime.Parse("2024-01-01T05:20:00.12345Z"),
TagsModifiedOn = DateTime.Parse("2025-01-01T05:20:00.12345Z"),
}
};
_request = new OverwriteDnsRecordRequest(RecordId, ZoneId, "example.com", DnsRecordType.A)
{
Content = "127.0.1.22"
};
}
[TestMethod]
public async Task ShouldOverwriteDnsRecord()
{
// Arrange
var client = GetClient();
// Act
var response = await client.OverwriteDnsRecord(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual("example.com", callback.Request.Name);
Assert.AreEqual(DnsRecordType.A, callback.Request.Type);
Assert.AreEqual("127.0.1.22", callback.Request.Content);
_clientMock.Verify(m => m.PutAsync<DnsRecord, InternalDnsRecordRequest>($"zones/{ZoneId}/dns_records/{RecordId}", It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PutAsync<DnsRecord, InternalDnsRecordRequest>(It.IsAny<string>(), It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalDnsRecordRequest, CancellationToken>((requestPath, request, _) => _callbacks.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

84
UnitTests/Cloudflare.Zones.Tests/DnsRecords/ScanDnsRecordsTest.cs
View File

@@ -1,84 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class ScanDnsRecordsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ImportDnsRecordsResult> _response;
private List<string> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ImportDnsRecordsResult>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ImportDnsRecordsResult
{
RecordsAdded = 5,
TotalRecordsParsed = 6,
}
};
}
[TestMethod]
public async Task ShouldScanDnsRecords()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ScanDnsRecords(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
Assert.AreEqual($"zones/{ZoneId}/dns_records/scan", _callbacks.First());
_clientMock.Verify(m => m.PostAsync<ImportDnsRecordsResult, object>($"zones/{ZoneId}/dns_records/scan", null, null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<ImportDnsRecordsResult, object>(It.IsAny<string>(), It.IsAny<object>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, object, IQueryParameterFilter, CancellationToken>((requestPath, _, _, _) => _callbacks.Add(requestPath))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

118
UnitTests/Cloudflare.Zones.Tests/DnsRecords/UpdateDnsRecordTest.cs
View File

@@ -1,118 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.DnsRecords
{
[TestClass]
public class UpdateDnsRecordTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<DnsRecord> _response;
private List<(string RequestPath, InternalDnsRecordRequest Request)> _callbacks;
private UpdateDnsRecordRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<DnsRecord>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new DnsRecord
{
Id = RecordId,
ZoneId = ZoneId,
ZoneName = "example.com",
Name = "*.example.com",
Type = DnsRecordType.A,
Content = "198.51.100.4",
Proxiable = true,
Proxied = true,
Ttl = 1,
Settings = new(),
Meta = new DnsRecordMeta
{
AutoAdded = false,
ManagedByApps = false,
ManagedByArgoTunnel = false
},
Comment = "Domain verification record",
Tags = [],
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
CommentModifiedOn = DateTime.Parse("2024-01-01T05:20:00.12345Z"),
TagsModifiedOn = DateTime.Parse("2025-01-01T05:20:00.12345Z"),
}
};
_request = new UpdateDnsRecordRequest(RecordId, ZoneId, "example.com", DnsRecordType.A)
{
Content = "127.0.1.22"
};
}
[TestMethod]
public async Task ShouldUpdateDnsRecord()
{
// Arrange
var client = GetClient();
// Act
var response = await client.UpdateDnsRecord(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual("example.com", callback.Request.Name);
Assert.AreEqual(DnsRecordType.A, callback.Request.Type);
Assert.AreEqual("127.0.1.22", callback.Request.Content);
_clientMock.Verify(m => m.PatchAsync<DnsRecord, InternalDnsRecordRequest>($"zones/{ZoneId}/dns_records/{RecordId}", It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PatchAsync<DnsRecord, InternalDnsRecordRequest>(It.IsAny<string>(), It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalDnsRecordRequest, CancellationToken>((requestPath, request, _) => _callbacks.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

109
UnitTests/Cloudflare.Zones.Tests/DnsSettings/ShowDnsSettingsTest.cs
View File

@@ -1,109 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.DnsSettings
{
[TestClass]
public class ShowDnsSettingsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ZoneDnsSetting> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ZoneDnsSetting>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ZoneDnsSetting
{
FlattenAllCnames = false,
FoundationDns = false,
MultiProvider = false,
Nameservers = new Nameserver
{
Type = NameserverType.CloudflareStandard,
},
NameserverTtl = 86400,
SecondaryOverrides = false,
SOA = new StartOfAuthority
(
expire: 604800,
minimumTtl: 1800,
primaryNameserver: "kristina.ns.cloudflare.com",
refresh: 10000,
retry: 2400,
zoneAdministrator: "admin.example.com",
ttl: 3600
),
Mode = ZoneMode.DnsOnly
}
};
}
[TestMethod]
public async Task ShouldGetDnsSetting()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ShowZoneDnsSettings(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response?.Result, response.Result);
Assert.AreEqual(1, _callbacks?.Count);
var callback = _callbacks?.First();
Assert.AreEqual($"zones/{ZoneId}/dns_settings", callback?.RequestPath);
Assert.IsNull(callback?.QueryFilter);
_clientMock?.Verify(m => m.GetAsync<ZoneDnsSetting>($"zones/{ZoneId}/dns_settings", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock?.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
if (_response == null) throw new InvalidOperationException();
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<ZoneDnsSetting>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks?.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

355
UnitTests/Cloudflare.Zones.Tests/DnsSettings/UpdateDnsSettingsTest.cs
View File

@@ -1,355 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.DnsSettings
{
[TestClass]
public class UpdateDnsSettingsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ZoneDnsSetting> _response;
private List<(string RequestPath, InternalUpdateDnsSettingsRequest Request)> _callbacks;
private UpdateDnsSettingsRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ZoneDnsSetting>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ZoneDnsSetting
{
FlattenAllCnames = false,
FoundationDns = false,
MultiProvider = false,
Nameservers = new Nameserver
{
Type = NameserverType.CloudflareStandard,
},
NameserverTtl = 86400,
SecondaryOverrides = false,
SOA = new StartOfAuthority
(
expire: 604800,
minimumTtl: 1800,
primaryNameserver: "kristina.ns.cloudflare.com",
refresh: 10000,
retry: 2400,
zoneAdministrator: "admin.example.com",
ttl: 3600
),
Mode = ZoneMode.DnsOnly
}
};
_request = new UpdateDnsSettingsRequest(ZoneId)
{
FlattenAllCnames = true,
FoundationDns = false,
MultiProvider = false,
Nameservers = new Nameserver
{
Type = NameserverType.CloudflareRandom
},
NameserverTtl = 86400,
SecondaryOverrides = false,
SOA = new StartOfAuthority
(
expire: 604800,
minimumTtl: 1800,
primaryNameserver: "ns1.example.org",
refresh: 28800,
retry: 3600,
ttl: 43200,
zoneAdministrator: "admin.example.org"
),
Mode = ZoneMode.Standard
};
}
[TestMethod]
public async Task ShouldUpdateDnsSettingsFull()
{
// Arrange
if (_request == null) throw new InvalidOperationException();
var client = GetClient();
// Act
var response = await client.UpdateZoneDnsSettings(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response?.Result, response.Result);
Assert.AreEqual(1, _callbacks?.Count);
var callback = _callbacks?.First();
Assert.AreEqual($"zones/{ZoneId}/dns_settings", callback?.RequestPath);
Assert.IsNotNull(callback?.Request);
Assert.IsTrue(callback?.Request.FlattenAllCnames);
Assert.IsFalse(callback?.Request.FoundationDns);
Assert.IsFalse(callback?.Request.MultiProvider);
Assert.IsNotNull(callback?.Request.Nameservers);
Assert.AreEqual(NameserverType.CloudflareRandom, callback?.Request.Nameservers.Type);
Assert.AreEqual(86400, callback?.Request.NameserverTtl);
Assert.IsFalse(callback?.Request.SecondaryOverrides);
Assert.IsNotNull(callback?.Request.Soa);
Assert.AreEqual(604800, callback?.Request.Soa.Expire);
Assert.AreEqual(1800, callback?.Request.Soa.MinimumTtl);
Assert.AreEqual("ns1.example.org", callback?.Request.Soa.PrimaryNameserver);
Assert.AreEqual(28800, callback?.Request.Soa.Refresh);
Assert.AreEqual(3600, callback?.Request.Soa.Retry);
Assert.AreEqual(43200, callback?.Request.Soa.Ttl);
Assert.AreEqual("admin.example.org", callback?.Request.Soa.ZoneAdministrator);
Assert.AreEqual(ZoneMode.Standard, callback?.Request.Mode);
_clientMock?.Verify(m => m.PatchAsync<ZoneDnsSetting, InternalUpdateDnsSettingsRequest>($"zones/{ZoneId}/dns_settings", It.IsAny<InternalUpdateDnsSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock?.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldUpdateDnsSettingsNone()
{
// Arrange
var request = new UpdateDnsSettingsRequest(ZoneId);
var client = GetClient();
// Act
var response = await client.UpdateZoneDnsSettings(request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response?.Result, response.Result);
Assert.AreEqual(1, _callbacks?.Count);
var callback = _callbacks?.First();
Assert.AreEqual($"zones/{ZoneId}/dns_settings", callback?.RequestPath);
Assert.IsNotNull(callback?.Request);
Assert.IsNull(callback?.Request.FlattenAllCnames);
Assert.IsNull(callback?.Request.FoundationDns);
Assert.IsNull(callback?.Request.MultiProvider);
Assert.IsNull(callback?.Request.Nameservers);
Assert.IsNull(callback?.Request.NameserverTtl);
Assert.IsNull(callback?.Request.SecondaryOverrides);
Assert.IsNull(callback?.Request.Soa);
Assert.IsNull(callback?.Request.Mode);
_clientMock?.Verify(m => m.PatchAsync<ZoneDnsSetting, InternalUpdateDnsSettingsRequest>($"zones/{ZoneId}/dns_settings", It.IsAny<InternalUpdateDnsSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock?.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidMode()
{
// Arrange
if (_request == null) throw new InvalidOperationException();
_request.Mode = 0;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverType()
{
// Arrange
if (_request == null || _request.Nameservers == null) throw new InvalidOperationException();
_request.Nameservers.Type = 0;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(29)]
[DataRow(86401)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverTtl(int ttl)
{
// Arrange
if (_request == null) throw new InvalidOperationException();
_request.NameserverTtl = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(86399)]
[DataRow(2419201)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaExpire(int ttl)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.Expire = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(59)]
[DataRow(86401)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaMinimumTtl(int ttl)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.MinimumTtl = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingSoaNameserver(string nameserver)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.PrimaryNameserver = nameserver;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentNullException
}
[DataTestMethod]
[DataRow(599)]
[DataRow(86401)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRefresh(int ttl)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.Refresh = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(599)]
[DataRow(86401)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRetry(int ttl)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.Retry = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(299)]
[DataRow(86401)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaTtl(int ttl)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.Ttl = ttl;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionForMissingSoaAdministrator(string admin)
{
// Arrange
if (_request == null || _request.SOA == null) throw new InvalidOperationException();
_request.SOA.ZoneAdministrator = admin;
var client = GetClient();
// Act
await client.UpdateZoneDnsSettings(_request);
// Assert - ArgumentNullException
}
private ICloudflareClient GetClient()
{
if (_response == null) throw new InvalidOperationException();
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PatchAsync<ZoneDnsSetting, InternalUpdateDnsSettingsRequest>(It.IsAny<string>(), It.IsAny<InternalUpdateDnsSettingsRequest>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalUpdateDnsSettingsRequest, CancellationToken>((requestPath, request, _) => _callbacks?.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

151
UnitTests/Cloudflare.Zones.Tests/Hold/CreateZoneHoldTest.cs
View File

@@ -1,151 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Filters;
using Moq;
namespace Cloudflare.Zones.Tests.Hold
{
[TestClass]
public class CreateZoneHoldTest
{
private readonly DateTime _date = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ZoneHold> _response;
private List<(string RequestPath, object Request, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ZoneHold>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ZoneHold
{
Hold = true,
HoldAfter = _date,
IncludeSubdomains = "true"
}
};
}
[TestMethod]
public async Task ShouldCreateZoneHold()
{
// Arrange
var client = GetClient();
// Act
var response = await client.CreateZoneHold(ZoneId, includeSubdomains: false);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/hold", callback.RequestPath);
Assert.IsNotNull(callback.QueryFilter);
Assert.IsInstanceOfType<CreateZoneHoldFilter>(callback.QueryFilter);
Assert.IsFalse(((CreateZoneHoldFilter)callback.QueryFilter).IncludeSubdomains);
_clientMock.Verify(m => m.PostAsync<ZoneHold, object>($"zones/{ZoneId}/hold", null, It.IsAny<CreateZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldCreateZoneHoldWithSubdomains()
{
// Arrange
var client = GetClient();
// Act
var response = await client.CreateZoneHold(ZoneId, includeSubdomains: true);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/hold", callback.RequestPath);
Assert.IsNotNull(callback.QueryFilter);
Assert.IsInstanceOfType<CreateZoneHoldFilter>(callback.QueryFilter);
Assert.IsTrue(((CreateZoneHoldFilter)callback.QueryFilter).IncludeSubdomains);
_clientMock.Verify(m => m.PostAsync<ZoneHold, object>($"zones/{ZoneId}/hold", null, It.IsAny<CreateZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldReturnEmptyDictionary()
{
// Arrange
var filter = new CreateZoneHoldFilter();
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldReturnQueryParameter()
{
// Arrange
var filter = new CreateZoneHoldFilter { IncludeSubdomains = true };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(1, dict.Count);
Assert.IsTrue(dict.ContainsKey("include_subdomains"));
Assert.AreEqual("true", dict["include_subdomains"]);
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<ZoneHold, object>(It.IsAny<string>(), It.IsAny<object>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, object, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

151
UnitTests/Cloudflare.Zones.Tests/Hold/DeleteZoneHoldTest.cs
View File

@@ -1,151 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Filters;
using Moq;
namespace Cloudflare.Zones.Tests.Hold
{
[TestClass]
public class DeleteZoneHoldTest
{
private readonly DateTime _date = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ZoneHold> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ZoneHold>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ZoneHold
{
Hold = true,
HoldAfter = _date,
IncludeSubdomains = "true"
}
};
}
[TestMethod]
public async Task ShouldDeleteZoneHold()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DeleteZoneHold(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/hold", callback.RequestPath);
Assert.IsNotNull(callback.QueryFilter);
Assert.IsInstanceOfType<DeleteZoneHoldFilter>(callback.QueryFilter);
Assert.IsNull(((DeleteZoneHoldFilter)callback.QueryFilter).HoldAfter);
_clientMock.Verify(m => m.DeleteAsync<ZoneHold>($"zones/{ZoneId}/hold", It.IsAny<DeleteZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldDeleteZoneHoldTemporarily()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DeleteZoneHold(ZoneId, holdAfter: _date);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/hold", callback.RequestPath);
Assert.IsNotNull(callback.QueryFilter);
Assert.IsInstanceOfType<DeleteZoneHoldFilter>(callback.QueryFilter);
Assert.AreEqual(_date, ((DeleteZoneHoldFilter)callback.QueryFilter).HoldAfter);
_clientMock.Verify(m => m.DeleteAsync<ZoneHold>($"zones/{ZoneId}/hold", It.IsAny<DeleteZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldReturnEmptyDictionary()
{
// Arrange
var filter = new DeleteZoneHoldFilter();
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldReturnQueryParameter()
{
// Arrange
var filter = new DeleteZoneHoldFilter { HoldAfter = _date };
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(1, dict.Count);
Assert.IsTrue(dict.ContainsKey("hold_after"));
Assert.AreEqual("2024-10-10T20:30:40Z", dict["hold_after"]);
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.DeleteAsync<ZoneHold>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

90
UnitTests/Cloudflare.Zones.Tests/Hold/GetZoneHoldTest.cs
View File

@@ -1,90 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.Hold
{
[TestClass]
public class GetZoneHoldTest
{
private readonly DateTime _date = new DateTime(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<ZoneHold> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<ZoneHold>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new ZoneHold
{
Hold = true,
HoldAfter = _date,
IncludeSubdomains = "false"
}
};
}
[TestMethod]
public async Task ShouldGetZoneHold()
{
// Arrange
var client = GetClient();
// Act
var response = await client.GetZoneHold(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/hold", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<ZoneHold>($"zones/{ZoneId}/hold", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<ZoneHold>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

181
UnitTests/Cloudflare.Zones.Tests/SecurityCenterTests.cs
View File

@@ -1,181 +0,0 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests
{
[TestClass]
public class SecurityCenterTests
{
private CultureInfo _currentCulture;
private CultureInfo _currentUICulture;
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<SecurityTxt> _getResponse;
private CloudflareResponse<object> _updateResponse;
private CloudflareResponse<object> _deleteResponse;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _getCallbacks;
private List<(string RequestPath, InternalUpdateSecurityTxtRequest Request)> _updateCallbacks;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _deleteCallbacks;
private UpdateSecurityTxtRequest _request;
[TestInitialize]
public void Initialize()
{
_getCallbacks = [];
_updateCallbacks = [];
_deleteCallbacks = [];
_getResponse = new CloudflareResponse<SecurityTxt>
{
Success = true,
Result = new SecurityTxt
{
Acknowledgements = ["https://example.com/hall-of-fame.html"],
Canonical = ["https://www.example.com/.well-known/security.txt"],
Contact = ["mailto:security@example.com"],
Enabled = true,
Encryption = ["https://example.com/pgp-key.txt"],
Expires = DateTime.Parse("2019-08-24T14:15:22Z"),
Hiring = ["https://example.com/jobs.html"],
Policy = ["https://example.com/disclosure-policy.html"],
PreferredLanguages = "de, en"
}
};
_updateResponse = new CloudflareResponse<object> { Success = true };
_deleteResponse = new CloudflareResponse<object> { Success = true };
_request = new UpdateSecurityTxtRequest(ZoneId)
{
Acknowledgements = ["https://example.com/hall-of-fame.html"],
Canonical = ["https://www.example.com/.well-known/security.txt"],
Contact = ["mailto:security@example.com"],
Enabled = true,
Encryption = ["https://example.com/pgp-key.txt"],
Expires = new DateTime(2024, 8, 1, 10, 20, 30, DateTimeKind.Unspecified),
Hiring = ["https://example.com/jobs.html"],
Policy = ["https://example.com/disclosure-policy.html"],
PreferredLanguages = ["de", "en", ""]
};
_currentCulture = Thread.CurrentThread.CurrentCulture;
_currentUICulture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture = new CultureInfo("de-DE");
}
[TestCleanup]
public void Cleanup()
{
Thread.CurrentThread.CurrentCulture = _currentCulture;
Thread.CurrentThread.CurrentUICulture = _currentUICulture;
}
[TestMethod]
public async Task ShouldGetSecurityTxt()
{
// Arrange
var client = GetClient();
// Act
var response = await client.GetSecurityTxt(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_getResponse.Result, response.Result);
Assert.AreEqual(1, _getCallbacks.Count);
var callback = _getCallbacks.First();
Assert.AreEqual($"zones/{ZoneId}/security-center/securitytxt", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<SecurityTxt>($"zones/{ZoneId}/security-center/securitytxt", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldUpdateSecurityTxt()
{
// Arrange
var client = GetClient();
// Act
var response = await client.UpdateSecurityTxt(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(1, _updateCallbacks.Count);
var callback = _updateCallbacks.First();
Assert.AreEqual($"zones/{ZoneId}/security-center/securitytxt", callback.RequestPath);
Assert.IsNotNull(callback.Request);
CollectionAssert.AreEqual(_request.Acknowledgements.ToArray(), callback.Request.Acknowledgements.ToArray());
CollectionAssert.AreEqual(_request.Canonical.ToArray(), callback.Request.Canonical.ToArray());
CollectionAssert.AreEqual(_request.Contact.ToArray(), callback.Request.Contact.ToArray());
Assert.AreEqual(_request.Enabled, callback.Request.Enabled);
CollectionAssert.AreEqual(_request.Encryption.ToArray(), callback.Request.Encryption.ToArray());
Assert.AreEqual("01.08.2024 08:20:30 +0", callback.Request.Expires?.ToString("dd.MM.yyyy HH:mm:ss z"));
CollectionAssert.AreEqual(_request.Hiring.ToArray(), callback.Request.Hiring.ToArray());
CollectionAssert.AreEqual(_request.Policy.ToArray(), callback.Request.Policy.ToArray());
Assert.AreEqual("de, en", callback.Request.PreferredLanguages);
}
[TestMethod]
public async Task ShouldDeleteSecurityTxt()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DeleteSecurityTxt(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(1, _deleteCallbacks.Count);
var callback = _deleteCallbacks.First();
Assert.AreEqual($"zones/{ZoneId}/security-center/securitytxt", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.DeleteAsync<object>($"zones/{ZoneId}/security-center/securitytxt", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<SecurityTxt>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _getCallbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _getResponse);
_clientMock
.Setup(m => m.PutAsync<object, InternalUpdateSecurityTxtRequest>(It.IsAny<string>(), It.IsAny<InternalUpdateSecurityTxtRequest>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalUpdateSecurityTxtRequest, CancellationToken>((requestPath, queryFilter, _) => _updateCallbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _updateResponse);
_clientMock
.Setup(m => m.DeleteAsync<object>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _deleteCallbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _deleteResponse);
return _clientMock.Object;
}
}
}

190
UnitTests/Cloudflare.Zones.Tests/Zones/CreateZoneTest.cs
View File

@@ -1,190 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class CreateZoneTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<Zone> _response;
private List<(string RequestPath, InternalCreateZoneRequest Request)> _callbacks;
private CreateZoneRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<Zone>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new Zone
{
Id = ZoneId,
Account = new AccountBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Account Name"
},
ActivatedOn = DateTime.Parse("2014-01-02T00:01:00.12345Z"),
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
DevelopmentMode = 7200,
Meta = new ZoneMetaData
{
CdnOnly = true,
CustomCertificateQuota = 1,
DnsOnly = true,
FoundationDns = true,
PageRuleQuota = 100,
PhishingDetected = false,
Step = 2
},
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
Name = "example.com",
NameServers =
[
"bob.ns.cloudflare.com",
"lola.ns.cloudflare.com"
],
OriginalDnshost = "NameCheap",
OriginalNameServers =
[
"ns1.originaldnshost.com",
"ns2.originaldnshost.com"
],
OriginalRegistrar = "GoDaddy",
Owner = new OwnerBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Org",
Type = "organization"
},
Paused = true,
Status = ZoneStatus.Initializing,
Type = ZoneType.Full,
VanityNameServers =
[
"ns1.example.com",
"ns2.example.com"
]
}
};
_request = new CreateZoneRequest("023e105f4ecef8ad9ca31a8372d0c353", "example.com");
}
[DataTestMethod]
[DataRow(null)]
[DataRow(ZoneType.Full)]
public async Task ShouldReturnCreatedZone(ZoneType? type)
{
// Arrange
_request.Type = type;
var client = GetClient();
// Act
var response = await client.CreateZone(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual("zones", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(_request.AccountId, callback.Request.Account.Id);
Assert.AreEqual(_request.Name, callback.Request.Name);
Assert.AreEqual(_request.Type, callback.Request.Type);
_clientMock.Verify(m => m.PostAsync<Zone, InternalCreateZoneRequest>("zones", It.IsAny<InternalCreateZoneRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionWhenRequestIsNull()
{
// Arrange
var client = GetClient();
// Act
await client.CreateZone(null);
// Assert - ArgumentNullException
}
[DataTestMethod]
[DataRow(".internal")]
[DataRow("test@example")]
[DataRow("test@example.com")]
[DataRow("häppi.example.com")]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentExceptionForInvalidName(string name)
{
// Arrange
_request.Name = name;
var client = GetClient();
// Act
await client.CreateZone(_request);
// Assert - ArgumentException
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidType()
{
// Arrange
_request.Type = 0;
var client = GetClient();
// Act
await client.CreateZone(_request);
// Assert - ArgumentOutOfRangeException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PostAsync<Zone, InternalCreateZoneRequest>(It.IsAny<string>(), It.IsAny<InternalCreateZoneRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalCreateZoneRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, _, _) => _callbacks.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

86
UnitTests/Cloudflare.Zones.Tests/Zones/DeleteZoneTest.cs
View File

@@ -1,86 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class DeleteZoneTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId
}
};
}
[TestMethod]
public async Task ShouldDeleteZone()
{
// Arrange
var client = GetClient();
// Act
var response = await client.DeleteZone(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.DeleteAsync<IdResponse>($"zones/{ZoneId}", It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.DeleteAsync<IdResponse>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

205
UnitTests/Cloudflare.Zones.Tests/Zones/EditZoneTest.cs
View File

@@ -1,205 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using AMWD.Net.Api.Cloudflare.Zones.Internals.Requests;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class EditZoneTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<Zone> _response;
private List<(string RequestPath, InternalEditZoneRequest Request)> _callbacks;
private EditZoneRequest _request;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<Zone>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new Zone
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Account = new AccountBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Account Name"
},
ActivatedOn = DateTime.Parse("2014-01-02T00:01:00.12345Z"),
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
DevelopmentMode = 7200,
Meta = new ZoneMetaData
{
CdnOnly = true,
CustomCertificateQuota = 1,
DnsOnly = true,
FoundationDns = true,
PageRuleQuota = 100,
PhishingDetected = false,
Step = 2
},
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
Name = "example.com",
NameServers =
[
"bob.ns.cloudflare.com",
"lola.ns.cloudflare.com"
],
OriginalDnshost = "NameCheap",
OriginalNameServers =
[
"ns1.originaldnshost.com",
"ns2.originaldnshost.com"
],
OriginalRegistrar = "GoDaddy",
Owner = new OwnerBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Org",
Type = "organization"
},
Paused = true,
Status = ZoneStatus.Initializing,
Type = ZoneType.Full,
VanityNameServers =
[
"ns1.example.com",
"ns2.example.com"
]
}
};
_request = new EditZoneRequest(ZoneId)
{
Type = ZoneType.Full,
VanityNameServers = ["ns1.example.org", "ns2.example.org"]
};
}
[TestMethod]
public async Task ShouldReturnModifiedZoneForType()
{
// Arrange
_request.VanityNameServers = null;
var client = GetClient();
// Act
var response = await client.EditZone(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.AreEqual(_request.Type.Value, callback.Request.Type.Value);
Assert.IsNull(callback.Request.VanityNameServers);
_clientMock.Verify(m => m.PatchAsync<Zone, InternalEditZoneRequest>($"zones/{ZoneId}", It.IsAny<InternalEditZoneRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldReturnModifiedZoneForVanityNameServers()
{
// Arrange
_request.Type = null;
_request.VanityNameServers.Add("");
var client = GetClient();
// Act
var response = await client.EditZone(_request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}", callback.RequestPath);
Assert.IsNotNull(callback.Request);
Assert.IsNull(callback.Request.Type);
Assert.AreEqual(2, callback.Request.VanityNameServers.Count);
Assert.IsTrue(callback.Request.VanityNameServers.Contains("ns1.example.org"));
Assert.IsTrue(callback.Request.VanityNameServers.Contains("ns2.example.org"));
_clientMock.Verify(m => m.PatchAsync<Zone, InternalEditZoneRequest>($"zones/{ZoneId}", It.IsAny<InternalEditZoneRequest>(), It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(CloudflareException))]
public async Task ShouldThrowCloudflareExceptionOnMultiplePropertiesSet()
{
// Arrange
var client = GetClient();
// Act
await client.EditZone(_request);
// Assert - CloudflareException
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidType()
{
// Arrange
_request.Type = 0;
_request.VanityNameServers = null;
var client = GetClient();
// Act
await client.EditZone(_request);
// Assert - ArgumentOutOfRangeException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PatchAsync<Zone, InternalEditZoneRequest>(It.IsAny<string>(), It.IsAny<InternalEditZoneRequest>(), It.IsAny<CancellationToken>()))
.Callback<string, InternalEditZoneRequest, CancellationToken>((requestPath, request, _) => _callbacks.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

393
UnitTests/Cloudflare.Zones.Tests/Zones/ListZonesTest.cs
View File

@@ -1,393 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class ListZonesTest
{
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IReadOnlyList<Zone>> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IReadOnlyList<Zone>>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
ResultInfo = new PaginationInfo
{
Count = 1,
Page = 1,
PerPage = 20,
TotalCount = 2000
},
Result =
[
new Zone
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Account = new AccountBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Account Name"
},
ActivatedOn = DateTime.Parse("2014-01-02T00:01:00.12345Z"),
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
DevelopmentMode = 7200,
Meta = new ZoneMetaData
{
CdnOnly = true,
CustomCertificateQuota = 1,
DnsOnly = true,
FoundationDns = true,
PageRuleQuota = 100,
PhishingDetected = false,
Step = 2
},
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
Name = "example.com",
NameServers =
[
"bob.ns.cloudflare.com",
"lola.ns.cloudflare.com"
],
OriginalDnshost = "NameCheap",
OriginalNameServers =
[
"ns1.originaldnshost.com",
"ns2.originaldnshost.com"
],
OriginalRegistrar = "GoDaddy",
Owner = new OwnerBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Org",
Type = "organization"
},
Paused = true,
Status = ZoneStatus.Initializing,
Type = ZoneType.Full,
VanityNameServers =
[
"ns1.example.com",
"ns2.example.com"
]
}
]
};
}
[TestMethod]
public async Task ShouldReturnListOfZones()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ListZones();
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual("zones", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<IReadOnlyList<Zone>>("zones", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldReturnListOfZonesWithFilter()
{
// Arrange
var filter = new ListZonesFilter
{
AccountId = "023e105f4ecef8ad9ca31a8372d0c353"
};
var client = GetClient();
// Act
var response = await client.ListZones(filter);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual("zones", callback.RequestPath);
Assert.AreEqual(filter, callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<IReadOnlyList<Zone>>("zones", filter, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldReturnEmptyParameterList()
{
// Arrange
var filter = new ListZonesFilter();
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldReturnFullParameterList()
{
// Arrange
var filter = new ListZonesFilter
{
AccountId = "023e105f4ecef8ad9ca31a8372d0c353",
AccountName = "Example Account Name",
Match = FilterMatchType.Any,
Name = "example.com",
PerPage = 13,
Page = 5,
OrderBy = ZonesOrderBy.AccountName,
Direction = SortDirection.Descending,
Status = ZoneStatus.Active
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(9, dict.Count);
Assert.IsTrue(dict.ContainsKey("account.id"));
Assert.IsTrue(dict.ContainsKey("account.name"));
Assert.IsTrue(dict.ContainsKey("direction"));
Assert.IsTrue(dict.ContainsKey("match"));
Assert.IsTrue(dict.ContainsKey("name"));
Assert.IsTrue(dict.ContainsKey("order"));
Assert.IsTrue(dict.ContainsKey("page"));
Assert.IsTrue(dict.ContainsKey("per_page"));
Assert.IsTrue(dict.ContainsKey("status"));
Assert.AreEqual("023e105f4ecef8ad9ca31a8372d0c353", dict["account.id"]);
Assert.AreEqual("Example Account Name", dict["account.name"]);
Assert.AreEqual("desc", dict["direction"]);
Assert.AreEqual("any", dict["match"]);
Assert.AreEqual("example.com", dict["name"]);
Assert.AreEqual("account.name", dict["order"]);
Assert.AreEqual("5", dict["page"]);
Assert.AreEqual("13", dict["per_page"]);
Assert.AreEqual("active", dict["status"]);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddAccountId(string id)
{
// Arrange
var filter = new ListZonesFilter
{
AccountId = id
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddAccountName(string name)
{
// Arrange
var filter = new ListZonesFilter
{
AccountName = name
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldNotAddDirection()
{
// Arrange
var filter = new ListZonesFilter
{
Direction = 0
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldNotAddMatch()
{
// Arrange
var filter = new ListZonesFilter
{
Match = 0
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
public void ShouldNotAddName(string name)
{
// Arrange
var filter = new ListZonesFilter
{
Name = name
};
// Act
var dict = new Dictionary<string, object>();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldNotAddOrder()
{
// Arrange
var filter = new ListZonesFilter
{
OrderBy = 0
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldNotAddPage()
{
// Arrange
var filter = new ListZonesFilter
{
Page = 0
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[DataTestMethod]
[DataRow(4)]
[DataRow(51)]
public void ShouldNotAddPerPage(int perPage)
{
// Arrange
var filter = new ListZonesFilter
{
PerPage = perPage
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
[TestMethod]
public void ShouldNotAddStatus()
{
// Arrange
var filter = new ListZonesFilter
{
Status = 0
};
// Act
var dict = filter.GetQueryParameters();
// Assert
Assert.IsNotNull(dict);
Assert.AreEqual(0, dict.Count);
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<IReadOnlyList<Zone>>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

86
UnitTests/Cloudflare.Zones.Tests/Zones/RerunActivationCheckTest.cs
View File

@@ -1,86 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class RerunActivationCheckTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<IdResponse> _response;
private List<(string RequestPath, object Request)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<IdResponse>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new IdResponse
{
Id = ZoneId
}
};
}
[TestMethod]
public async Task ShouldRerunActivationCheck()
{
// Arrange
var client = GetClient();
// Act
var response = await client.RerunActivationCheck(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}/activation_check", callback.RequestPath);
Assert.IsNull(callback.Request);
_clientMock.Verify(m => m.PutAsync<IdResponse, object>($"zones/{ZoneId}/activation_check", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.PutAsync<IdResponse, object>(It.IsAny<string>(), It.IsAny<object>(), It.IsAny<CancellationToken>()))
.Callback<string, object, CancellationToken>((requestPath, request, _) => _callbacks.Add((requestPath, request)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}

163
UnitTests/Cloudflare.Zones.Tests/Zones/ZoneDetailsTest.cs
View File

@@ -1,163 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using AMWD.Net.Api.Cloudflare.Zones;
using Moq;
namespace Cloudflare.Zones.Tests.Zones
{
[TestClass]
public class ZoneDetailsTest
{
private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
private Mock<ICloudflareClient> _clientMock;
private CloudflareResponse<Zone> _response;
private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
[TestInitialize]
public void Initialize()
{
_callbacks = [];
_response = new CloudflareResponse<Zone>
{
Success = true,
Messages = [
new ResponseInfo
{
Code = 1000,
Message = "Message 1",
}
],
Errors = [
new ResponseInfo
{
Code = 1000,
Message = "Error 1",
}
],
Result = new Zone
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Account = new AccountBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Account Name"
},
ActivatedOn = DateTime.Parse("2014-01-02T00:01:00.12345Z"),
CreatedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
DevelopmentMode = 7200,
Meta = new ZoneMetaData
{
CdnOnly = true,
CustomCertificateQuota = 1,
DnsOnly = true,
FoundationDns = true,
PageRuleQuota = 100,
PhishingDetected = false,
Step = 2
},
ModifiedOn = DateTime.Parse("2014-01-01T05:20:00.12345Z"),
Name = "example.com",
NameServers =
[
"bob.ns.cloudflare.com",
"lola.ns.cloudflare.com"
],
OriginalDnshost = "NameCheap",
OriginalNameServers =
[
"ns1.originaldnshost.com",
"ns2.originaldnshost.com"
],
OriginalRegistrar = "GoDaddy",
Owner = new OwnerBase
{
Id = "023e105f4ecef8ad9ca31a8372d0c353",
Name = "Example Org",
Type = "organization"
},
Paused = true,
Status = ZoneStatus.Initializing,
Type = ZoneType.Full,
VanityNameServers =
[
"ns1.example.com",
"ns2.example.com"
]
}
};
}
[TestMethod]
public async Task ShouldReturnZoneDetails()
{
// Arrange
var client = GetClient();
// Act
var response = await client.ZoneDetails(ZoneId);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.AreEqual(_response.Result, response.Result);
Assert.AreEqual(1, _callbacks.Count);
var callback = _callbacks.First();
Assert.AreEqual($"zones/{ZoneId}", callback.RequestPath);
Assert.IsNull(callback.QueryFilter);
_clientMock.Verify(m => m.GetAsync<Zone>($"zones/{ZoneId}", null, It.IsAny<CancellationToken>()), Times.Once);
_clientMock.VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullExceptionWhenZoneIdIsNull(string id)
{
// Arrange
var client = GetClient();
// Act
await client.ZoneDetails(id);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public async Task ShouldThrowArgumentOutOfRangeExceptionWhenZoneIdTooLong()
{
// Arrange
string id = new('a', 33);
var client = GetClient();
// Act
await client.ZoneDetails(id);
// Assert - ArgumentOutOfRangeException
}
private ICloudflareClient GetClient()
{
_clientMock = new Mock<ICloudflareClient>();
_clientMock
.Setup(m => m.GetAsync<Zone>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
.ReturnsAsync(() => _response);
return _clientMock.Object;
}
}
}