Added some Zone features

UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByHostTest.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare.Zones.Cache.InternalRequests;
+using AMWD.Net.Api.Cloudflare.Zones;
+using Moq;
+using AMWD.Net.Api.Cloudflare;
+
+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<ZoneIdResponse> _response;
+
+		private List<(string RequestPath, PurgeRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<ZoneIdResponse>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Message 1",
+					}
+				],
+				Errors = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Error 1",
+					}
+				],
+				Result = new ZoneIdResponse
+				{
+					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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), 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<ZoneIdResponse, PurgeRequest>(It.IsAny<string>(), It.IsAny<PurgeRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, PurgeRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByPrefixTest.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare.Zones.Cache.InternalRequests;
+using AMWD.Net.Api.Cloudflare.Zones;
+using Moq;
+using AMWD.Net.Api.Cloudflare;
+
+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<ZoneIdResponse> _response;
+
+		private List<(string RequestPath, PurgeRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<ZoneIdResponse>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Message 1",
+					}
+				],
+				Errors = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Error 1",
+					}
+				],
+				Result = new ZoneIdResponse
+				{
+					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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), 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<ZoneIdResponse, PurgeRequest>(It.IsAny<string>(), It.IsAny<PurgeRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, PurgeRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByTagTest.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare.Zones.Cache.InternalRequests;
+using AMWD.Net.Api.Cloudflare.Zones;
+using Moq;
+using AMWD.Net.Api.Cloudflare;
+
+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<ZoneIdResponse> _response;
+
+		private List<(string RequestPath, PurgeRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<ZoneIdResponse>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Message 1",
+					}
+				],
+				Errors = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Error 1",
+					}
+				],
+				Result = new ZoneIdResponse
+				{
+					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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), 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<ZoneIdResponse, PurgeRequest>(It.IsAny<string>(), It.IsAny<PurgeRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, PurgeRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentByUrlTest.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare.Zones.Cache.InternalRequests;
+using AMWD.Net.Api.Cloudflare.Zones;
+using Moq;
+using AMWD.Net.Api.Cloudflare;
+
+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<ZoneIdResponse> _response;
+
+		private List<(string RequestPath, PurgeRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<ZoneIdResponse>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Message 1",
+					}
+				],
+				Errors = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Error 1",
+					}
+				],
+				Result = new ZoneIdResponse
+				{
+					Id = ZoneId,
+				}
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldPurgeCachedContentByUrl()
+		{
+			// Arrange
+			var list = new List<ZonePurgeCachedUrlRequest>
+			{
+				new ZonePurgeCachedUrlRequest { Url = "https://example.com/foo.txt" },
+				new ZonePurgeCachedUrlRequest { Url = "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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public async Task ShouldPurgeCachedContentByUrlWithHeader()
+		{
+			// Arrange
+			var list = new List<ZonePurgeCachedUrlRequest>
+			{
+				new ZonePurgeCachedUrlRequest { Url = "https://example.com/foo.txt", Headers = new Dictionary<string, string> { { "X-Test1", "Test" } } },
+				new ZonePurgeCachedUrlRequest { Url = "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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), 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<ZoneIdResponse, PurgeRequest>(It.IsAny<string>(), It.IsAny<PurgeRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, PurgeRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

UnitTests/Cloudflare.Zones.Tests/Cache/PurgeCachedContentTest.cs

@@ -0,0 +1,99 @@
+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.Cache.InternalRequests;
+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<ZoneIdResponse> _response;
+
+		private List<(string RequestPath, PurgeRequest Request, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<ZoneIdResponse>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Message 1",
+					}
+				],
+				Errors = [
+					new ResponseInfo
+					{
+						Code = 1000,
+						Message = "Error 1",
+					}
+				],
+				Result = new ZoneIdResponse
+				{
+					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<ZoneIdResponse, PurgeRequest>($"zones/{ZoneId}/purge_cache", It.IsAny<PurgeRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.PostAsync<ZoneIdResponse, PurgeRequest>(It.IsAny<string>(), It.IsAny<PurgeRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, PurgeRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, queryFilter, _) => _callbacks.Add((requestPath, request, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}