Add 'DNS Account Settings > Internal Views'

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/ShowDnsAccountSettingsTest.cs

@@ -83,8 +83,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 
 			Assert.IsNull(callback.QueryFilter);
 
-			_clientMock?.Verify(m => m.GetAsync<DnsAccountSettings>($"/accounts/{AccountId}/dns_settings", null, It.IsAny<CancellationToken>()), Times.Once);
-			_clientMock?.VerifyNoOtherCalls();
+			_clientMock.Verify(m => m.GetAsync<DnsAccountSettings>($"/accounts/{AccountId}/dns_settings", null, It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/Views/CreateInternalDnsViewTest.cs

@@ -0,0 +1,115 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare;
+using AMWD.Net.Api.Cloudflare.Dns;
+using AMWD.Net.Api.Cloudflare.Dns.Internals;
+using Moq;
+
+namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
+{
+	[TestClass]
+	public class CreateInternalDnsViewTest
+	{
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
+		private const string ViewName = "InternalView";
+
+		private Mock<ICloudflareClient> _clientMock;
+		private CloudflareResponse<InternalDnsView> _response;
+		private List<(string RequestPath, InternalModifyInternalDnsViewRequest Request)> _callbacks;
+		private CreateInternalDnsViewRequest _request;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<InternalDnsView>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo(1000, "Message 1")
+				],
+				Errors = [
+					new ResponseInfo(1000, "Error 1")
+				],
+				Result = new InternalDnsView(ViewId, ViewName)
+			};
+
+			_request = new CreateInternalDnsViewRequest(AccountId, ViewName)
+			{
+				ZoneIds = ["zone1", "zone2"]
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldCreateInternalDnsView()
+		{
+			// Arrange
+			var client = GetClient();
+
+			// Act
+			var response = await client.CreateInternalDnsView(_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($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.IsNotNull(callback.Request);
+
+			Assert.AreEqual(ViewName, callback.Request.Name);
+			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), callback.Request.Zones.ToList());
+
+			_clientMock.Verify(m => m.PostAsync<InternalDnsView, InternalModifyInternalDnsViewRequest>($"/accounts/{AccountId}/dns_settings/views", It.IsAny<InternalModifyInternalDnsViewRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow("")]
+		[DataRow("   ")]
+		[ExpectedException(typeof(ArgumentNullException))]
+		public async Task ShouldThrowArgumentNullExceptionWhenNameIsNull(string name)
+		{
+			// Arrange
+			_request.Name = name;
+			var client = GetClient();
+
+			// Act
+			var response = await client.CreateInternalDnsView(_request);
+
+			// Assert - ArgumentNullException
+		}
+
+		[TestMethod]
+		[ExpectedException(typeof(ArgumentOutOfRangeException))]
+		public async Task ShouldThrowArgumentOutOfRangeExceptionWhenNameTooLong()
+		{
+			// Arrange
+			_request.Name = new string('a', 256);
+			var client = GetClient();
+
+			// Act
+			var response = await client.CreateInternalDnsView(_request);
+
+			// Assert - ArgumentOutOfRangeException
+		}
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.PostAsync<InternalDnsView, InternalModifyInternalDnsViewRequest>(It.IsAny<string>(), It.IsAny<InternalModifyInternalDnsViewRequest>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, InternalModifyInternalDnsViewRequest, IQueryParameterFilter, CancellationToken>((requestPath, request, _, __) => _callbacks.Add((requestPath, request)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/Views/DeleteInternalDnsViewTest.cs

@@ -0,0 +1,76 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare;
+using AMWD.Net.Api.Cloudflare.Dns;
+using Moq;
+
+namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
+{
+	[TestClass]
+	public class DeleteInternalDnsViewTest
+	{
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
+
+		private Mock<ICloudflareClient> _clientMock;
+		private CloudflareResponse<Identifier> _response;
+		private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<Identifier>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo(1000, "Message 1")
+				],
+				Errors = [
+					new ResponseInfo(1000, "Error 1")
+				],
+				Result = new Identifier
+				{
+					Id = ViewId
+				}
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldDeleteInternalDnsView()
+		{
+			// Arrange
+			var client = GetClient();
+
+			// Act
+			var response = await client.DeleteInternalDnsView(AccountId, ViewId);
+
+			// 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($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.IsNull(callback.QueryFilter);
+
+			_clientMock.Verify(m => m.DeleteAsync<Identifier>($"/accounts/{AccountId}/dns_settings/views/{ViewId}", null, It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.DeleteAsync<Identifier>(It.IsAny<string>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()))
+				.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/Views/InternalDnsViewDetailsTest.cs

@@ -0,0 +1,80 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare;
+using AMWD.Net.Api.Cloudflare.Dns;
+using Moq;
+
+namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
+{
+	[TestClass]
+	public class InternalDnsViewDetailsTest
+	{
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
+		private const string ViewName = "InternalView";
+
+		private Mock<ICloudflareClient> _clientMock;
+		private CloudflareResponse<InternalDnsView> _response;
+		private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<InternalDnsView>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo(1000, "Message 1")
+				],
+				Errors = [
+					new ResponseInfo(1000, "Error 1")
+				],
+				Result = new InternalDnsView(ViewId, ViewName)
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldGetInternalDnsViewDetails()
+		{
+			// Arrange
+			var client = GetClient();
+
+			// Act
+			var response = await client.InternalDnsViewDetails(AccountId, ViewId);
+
+			// 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($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.IsNull(callback.QueryFilter);
+
+			_clientMock.Verify(m => m.GetAsync<InternalDnsView>(
+				$"/accounts/{AccountId}/dns_settings/views/{ViewId}",
+				null,
+				It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.GetAsync<InternalDnsView>(
+					It.IsAny<string>(),
+					It.IsAny<IQueryParameterFilter>(),
+					It.IsAny<CancellationToken>()))
+				.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/Views/ListInternalDnsViewsTest.cs

@@ -0,0 +1,354 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare;
+using AMWD.Net.Api.Cloudflare.Dns;
+using Moq;
+
+namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
+{
+	[TestClass]
+	public class ListInternalDnsViewsTest
+	{
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+
+		private Mock<ICloudflareClient> _clientMock;
+		private CloudflareResponse<IReadOnlyCollection<InternalDnsView>> _response;
+		private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<IReadOnlyCollection<InternalDnsView>>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo(1000, "Message 1")
+				],
+				Errors = [
+					new ResponseInfo(1000, "Error 1")
+				],
+				Result =
+				[
+					new InternalDnsView("023e105f4ecef8ad9ca31a8372d0c354", "View1"),
+					new InternalDnsView("023e105f4ecef8ad9ca31a8372d0c355", "View2")
+				]
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldListInternalDnsViews()
+		{
+			// Arrange
+			var client = GetClient();
+
+			// Act
+			var response = await client.ListInternalDnsViews(AccountId);
+
+			// Assert
+			Assert.IsNotNull(response);
+			Assert.IsTrue(response.Success);
+			Assert.IsNotNull(response.Result);
+			Assert.AreEqual(2, response.Result.Count);
+
+			Assert.AreEqual(1, _callbacks.Count);
+
+			var callback = _callbacks.First();
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.IsNull(callback.QueryFilter);
+
+			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<InternalDnsView>>(
+				$"/accounts/{AccountId}/dns_settings/views",
+				null,
+				It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		[TestMethod]
+		public async Task ShouldListInternalDnsViewsWithFilter()
+		{
+			// Arrange
+			var client = GetClient();
+			var filter = new ListInternalDnsViewsFilter
+			{
+				NameContains = "View"
+			};
+
+			// Act
+			var response = await client.ListInternalDnsViews(AccountId, filter);
+
+			// Assert
+			Assert.IsNotNull(response);
+			Assert.IsTrue(response.Success);
+			Assert.IsNotNull(response.Result);
+
+			Assert.AreEqual(1, _callbacks.Count);
+
+			var callback = _callbacks.First();
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.AreEqual(filter, callback.QueryFilter);
+
+			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<InternalDnsView>>(
+				$"/accounts/{AccountId}/dns_settings/views",
+				filter,
+				It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		#region QueryFilter
+
+		[TestMethod]
+		public void ShouldReturnEmptyParameterList()
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter();
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(0, dict.Count);
+		}
+
+		[TestMethod]
+		public void ShouldReturnFullParameterList()
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter
+			{
+				Direction = SortDirection.Descending,
+				Match = FilterMatchType.All,
+				NameContains = "view",
+				NameEndsWith = "end",
+				NameExact = "exactView",
+				NameStartsWith = "start",
+				OrderBy = InternalDnsViewsOrderBy.ModifiedOn,
+				Page = 2,
+				PerPage = 100,
+				ZoneId = "zone123",
+				ZoneName = "zone.example.com",
+			};
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(11, dict.Count);
+
+			Assert.AreEqual("desc", dict["direction"]);
+			Assert.AreEqual("all", dict["match"]);
+			Assert.AreEqual("view", dict["name.contains"]);
+			Assert.AreEqual("end", dict["name.endswith"]);
+			Assert.AreEqual("exactView", dict["name.exact"]);
+			Assert.AreEqual("start", dict["name.startswith"]);
+			Assert.AreEqual("modified_on", dict["order"]);
+			Assert.AreEqual("2", dict["page"]);
+			Assert.AreEqual("100", dict["per_page"]);
+			Assert.AreEqual("zone123", dict["zone_id"]);
+			Assert.AreEqual("zone.example.com", dict["zone_name"]);
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow("")]
+		[DataRow("   ")]
+		public void ShouldNotAddNameContains(string str)
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { NameStartsWith = 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 ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { Match = match };
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(0, dict.Count);
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow((InternalDnsViewsOrderBy)0)]
+		public void ShouldNotAddOrder(InternalDnsViewsOrderBy? order)
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { 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 ListInternalDnsViewsFilter { PerPage = perPage };
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(0, dict.Count);
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow("")]
+		[DataRow("   ")]
+		public void ShouldNotAddZoneId(string str)
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter { ZoneId = str };
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(0, dict.Count);
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow("")]
+		[DataRow("   ")]
+		public void ShouldNotAddZoneName(string str)
+		{
+			// Arrange
+			var filter = new ListInternalDnsViewsFilter { ZoneName = str };
+
+			// Act
+			var dict = filter.GetQueryParameters();
+
+			// Assert
+			Assert.IsNotNull(dict);
+			Assert.AreEqual(0, dict.Count);
+		}
+
+		#endregion QueryFilter
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.GetAsync<IReadOnlyCollection<InternalDnsView>>(
+					It.IsAny<string>(),
+					It.IsAny<IQueryParameterFilter>(),
+					It.IsAny<CancellationToken>()))
+				.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}

test/Extensions/Cloudflare.Dns.Tests/DnsAccountSettingsExtensions/Views/UpdateInternalDnsViewTest.cs

@@ -0,0 +1,121 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AMWD.Net.Api.Cloudflare;
+using AMWD.Net.Api.Cloudflare.Dns;
+using AMWD.Net.Api.Cloudflare.Dns.Internals;
+using Moq;
+
+namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
+{
+	[TestClass]
+	public class UpdateInternalDnsViewTest
+	{
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
+		private const string ViewName = "InternalView";
+
+		private Mock<ICloudflareClient> _clientMock;
+		private CloudflareResponse<InternalDnsView> _response;
+		private List<(string RequestPath, InternalModifyInternalDnsViewRequest Request)> _callbacks;
+		private UpdateInternalDnsViewRequest _request;
+
+		[TestInitialize]
+		public void Initialize()
+		{
+			_callbacks = [];
+
+			_response = new CloudflareResponse<InternalDnsView>
+			{
+				Success = true,
+				Messages = [
+					new ResponseInfo(1000, "Message 1")
+				],
+				Errors = [
+					new ResponseInfo(1000, "Error 1")
+				],
+				Result = new InternalDnsView(ViewId, ViewName)
+			};
+
+			_request = new UpdateInternalDnsViewRequest(AccountId, ViewId, ViewName)
+			{
+				ZoneIds = ["zone1", "zone2"]
+			};
+		}
+
+		[TestMethod]
+		public async Task ShouldUpdateInternalDnsView()
+		{
+			// Arrange
+			var client = GetClient();
+
+			// Act
+			var response = await client.UpdateInternalDnsView(_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($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.IsNotNull(callback.Request);
+
+			Assert.AreEqual(ViewName, callback.Request.Name);
+			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), callback.Request.Zones.ToList());
+
+			_clientMock.Verify(m => m.PatchAsync<InternalDnsView, InternalModifyInternalDnsViewRequest>(
+				$"/accounts/{AccountId}/dns_settings/views/{ViewId}",
+				It.IsAny<InternalModifyInternalDnsViewRequest>(),
+				It.IsAny<CancellationToken>()), Times.Once);
+			_clientMock.VerifyNoOtherCalls();
+		}
+
+		[DataTestMethod]
+		[DataRow(null)]
+		[DataRow("")]
+		[DataRow("   ")]
+		[ExpectedException(typeof(ArgumentNullException))]
+		public async Task ShouldThrowArgumentNullExceptionWhenNameIsNull(string name)
+		{
+			// Arrange
+			_request.Name = name;
+			var client = GetClient();
+
+			// Act
+			var response = await client.UpdateInternalDnsView(_request);
+
+			// Assert - ArgumentNullException
+		}
+
+		[TestMethod]
+		[ExpectedException(typeof(ArgumentOutOfRangeException))]
+		public async Task ShouldThrowArgumentOutOfRangeExceptionWhenNameTooLong()
+		{
+			// Arrange
+			_request.Name = new string('a', 256);
+			var client = GetClient();
+
+			// Act
+			var response = await client.UpdateInternalDnsView(_request);
+
+			// Assert - ArgumentOutOfRangeException
+		}
+
+		private ICloudflareClient GetClient()
+		{
+			_clientMock = new Mock<ICloudflareClient>();
+			_clientMock
+				.Setup(m => m.PatchAsync<InternalDnsView, InternalModifyInternalDnsViewRequest>(
+					It.IsAny<string>(),
+					It.IsAny<InternalModifyInternalDnsViewRequest>(),
+					It.IsAny<CancellationToken>()))
+				.Callback<string, InternalModifyInternalDnsViewRequest, CancellationToken>((requestPath, request, _) => _callbacks.Add((requestPath, request)))
+				.ReturnsAsync(() => _response);
+
+			return _clientMock.Object;
+		}
+	}
+}