Merge branch 'main' into docs

.editorconfig

@@ -91,6 +91,7 @@ dotnet_naming_style.prefix_underscore.required_prefix = _
 
 [*.cs]
 csharp_preferred_modifier_order = public, private, protected, internal, static, extern, new, virtual, abstract, sealed, override, readonly, unsafe, volatile, async:suggestion
+csharp_style_prefer_primary_constructors = false
 
 # Only use "var" when it's obvious what the variable type is
 csharp_style_var_for_built_in_types = false:warning
@@ -157,3 +158,6 @@ csharp_space_between_square_brackets = false
 [*.{xml,csproj,targets,props,json,yml}]
 indent_size = 2
 indent_style = space
+
+[*.{json,yml}]
+end_of_line = lf

test/Cloudflare.Tests/Auth/ApiKeyAuthenticationTest.cs

@@ -2,7 +2,7 @@
 using System.Net.Http;
 using AMWD.Net.Api.Cloudflare;
 
-namespace Cloudflare.Core.Tests.Auth
+namespace Cloudflare.Tests.Auth
 {
 	[TestClass]
 	public class ApiKeyAuthenticationTest
@@ -32,48 +32,39 @@ namespace Cloudflare.Core.Tests.Auth
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldArgumentNullExceptionForEmailAddress(string emailAddress)
 		{
 			// Arrange
 			string apiKey = "some-api-key";
 
-			// Act
+			// Act & Assert
-			new ApiKeyAuthentication(emailAddress, apiKey);
+			Assert.ThrowsExactly<ArgumentNullException>(() => new ApiKeyAuthentication(emailAddress, apiKey));
-
-			// Assert - ArgumentNullException
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldArgumentNullExceptionForApiKey(string apiKey)
 		{
 			// Arrange
 			string emailAddress = "test@example.com";
 
-			// Act
+			// Act & Assert
-			new ApiKeyAuthentication(emailAddress, apiKey);
+			Assert.ThrowsExactly<ArgumentNullException>(() => new ApiKeyAuthentication(emailAddress, apiKey));
-
-			// Assert - ArgumentNullException
 		}
 
 		[TestMethod]
 		[DataRow("test")]
 		[DataRow("test@example")]
 		[DataRow("example.com")]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldArgumentExceptionForInvalidEmailAddress(string emailAddress)
 		{
 			// Arrange
 			string apiKey = "some-api-key";
 
-			// Act
+			// Act & Assert
-			new ApiKeyAuthentication(emailAddress, apiKey);
+			Assert.ThrowsExactly<ArgumentException>(() => new ApiKeyAuthentication(emailAddress, apiKey));
-
-			// Assert - ArgumentException
 		}
 	}
 }

test/Cloudflare.Tests/Auth/ApiTokenAuthenticationTest.cs

@@ -1,7 +1,7 @@
 using System.Net.Http;
 using AMWD.Net.Api.Cloudflare;
 
-namespace Cloudflare.Core.Tests.Auth
+namespace Cloudflare.Tests.Auth
 {
 	[TestClass]
 	public class ApiTokenAuthenticationTest
@@ -29,15 +29,12 @@ namespace Cloudflare.Core.Tests.Auth
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldArgumentNullExceptionForEmailAddress(string apiToken)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			new ApiTokenAuthentication(apiToken);
+			Assert.ThrowsExactly<ArgumentNullException>(() => new ApiTokenAuthentication(apiToken));
-
-			// Assert - ArgumentNullException
 		}
 	}
 }

test/Cloudflare.Tests/CloudflareClientTest.cs

@@ -5,7 +5,7 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests
+namespace Cloudflare.Tests
 {
 	[TestClass]
 	public class CloudflareClientTest
@@ -72,15 +72,15 @@ namespace Cloudflare.Core.Tests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullOnMissingAuthentication()
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			using var client = new CloudflareClient((IAuthentication)null);
+			Assert.ThrowsExactly<ArgumentNullException>(() =>
-
+			{
-			// Assert - ArgumentNullException
+				using var client = new CloudflareClient((IAuthentication)null);
+			});
 		}
 
 		[TestMethod]
@@ -150,7 +150,6 @@ namespace Cloudflare.Core.Tests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullForBaseUrlOnAssertClientOptions()
 		{
 			// Arrange
@@ -158,14 +157,14 @@ namespace Cloudflare.Core.Tests
 				.Setup(o => o.BaseUrl)
 				.Returns((string)null);
 
-			// Act
+			// Act & Assert
-			var client = GetClient();
+			Assert.ThrowsExactly<ArgumentNullException>(() =>
-
+			{
-			// Assert - ArgumentNullException
+				var client = GetClient();
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public void ShouldThrowArgumentOutOfRangeForTimeoutOnAssertClientOptions()
 		{
 			// Arrange
@@ -173,16 +172,16 @@ namespace Cloudflare.Core.Tests
 				.Setup(o => o.Timeout)
 				.Returns(TimeSpan.Zero);
 
-			// Act
+			// Act & Assert
-			var client = GetClient();
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				var client = GetClient();
+			});
 		}
 
 		[TestMethod]
 		[DataRow(-1)]
 		[DataRow(11)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public void ShouldThrowArgumentOutOfRangeForMaxRetriesOnAssertClientOptions(int maxRetries)
 		{
 			// Arrange
@@ -190,14 +189,14 @@ namespace Cloudflare.Core.Tests
 				.Setup(o => o.MaxRetries)
 				.Returns(maxRetries);
 
-			// Act
+			// Act & Assert
-			var client = GetClient();
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				var client = GetClient();
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullForUseProxyOnAssertClientOptions()
 		{
 			// Arrange
@@ -205,10 +204,11 @@ namespace Cloudflare.Core.Tests
 				.Setup(o => o.UseProxy)
 				.Returns(true);
 
-			// Act
+			// Act & Assert
-			var client = GetClient();
+			Assert.ThrowsExactly<ArgumentNullException>(() =>
-
+			{
-			// Assert - ArgumentNullException
+				var client = GetClient();
+			});
 		}
 
 		private void VerifyDefault()

test/Cloudflare.Tests/CloudflareClientTests/DeleteAsyncTest.cs

@@ -12,11 +12,13 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests.CloudflareClientTests
+namespace Cloudflare.Tests.CloudflareClientTests
 {
 	[TestClass]
 	public class DeleteAsyncTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string BaseUrl = "http://localhost/api/v4/";
 
 		private HttpMessageHandlerMock _httpHandlerMock;
@@ -44,46 +46,46 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ObjectDisposedException))]
 		public async Task ShouldThrowDisposed()
 		{
 			// Arrange
 			var client = GetClient() as CloudflareClient;
 			client.Dispose();
 
-			// Act
+			// Act & Assert
-			await client.DeleteAsync<object>("test");
+			await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
-
+			{
-			// Assert - ObjectDisposedException
+				await client.DeleteAsync<object>("test", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullOnRequestPath(string path)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.DeleteAsync<object>(path);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.DeleteAsync<object>(path, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentOnRequestPath()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.DeleteAsync<object>("foo?bar=baz");
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
-
+			{
-			// Assert - ArgumentException
+				await client.DeleteAsync<object>("foo?bar=baz", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -99,7 +101,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteAsync<TestClass>("test");
+			var response = await client.DeleteAsync<TestClass>("test", cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -108,21 +110,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Delete, callback.Method);
 			Assert.AreEqual("http://localhost/api/v4/test", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -154,7 +156,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			try
 			{
 				// Act
-				await client.DeleteAsync<TestClass>("foo");
+				await client.DeleteAsync<TestClass>("foo", cancellationToken: TestContext.CancellationTokenSource.Token);
 				Assert.Fail();
 			}
 			catch (AuthenticationException ex)
@@ -179,7 +181,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteAsync<string>("some-awesome-path");
+			var response = await client.DeleteAsync<string>("some-awesome-path", cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -190,14 +192,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Delete, callback.Method);
 			Assert.AreEqual("http://localhost/api/v4/some-awesome-path?bar=08%2F15", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -223,7 +225,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(JsonReaderException))]
 		public async Task ShouldThrowExceptionOnInvalidResponse()
 		{
 			// Arrange
@@ -235,8 +236,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.DeleteAsync<TestClass>("some-path");
+			await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
+			{
+				await client.DeleteAsync<TestClass>("some-path", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private void VerifyDefaults()

test/Cloudflare.Tests/CloudflareClientTests/GetAsyncTest.cs

@@ -12,11 +12,13 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests.CloudflareClientTests
+namespace Cloudflare.Tests.CloudflareClientTests
 {
 	[TestClass]
 	public class GetAsyncTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string BaseUrl = "http://localhost/api/v4/";
 
 		private HttpMessageHandlerMock _httpHandlerMock;
@@ -44,46 +46,46 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ObjectDisposedException))]
 		public async Task ShouldThrowDisposed()
 		{
 			// Arrange
 			var client = GetClient() as CloudflareClient;
 			client.Dispose();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<object>("/test");
+			await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
-
+			{
-			// Assert - ObjectDisposedException
+				await client.GetAsync<object>("/test", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullOnRequestPath(string path)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<object>(path);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.GetAsync<object>(path, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentOnRequestPath()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<object>("/foo?bar=baz");
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
-
+			{
-			// Assert - ArgumentException
+				await client.GetAsync<object>("/foo?bar=baz", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -99,7 +101,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.GetAsync<TestClass>("test");
+			var response = await client.GetAsync<TestClass>("test", cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -108,21 +110,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Get, callback.Method);
 			Assert.AreEqual("http://localhost/api/v4/test", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -154,7 +156,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			try
 			{
 				// Act
-				await client.GetAsync<TestClass>("foo");
+				await client.GetAsync<TestClass>("foo", cancellationToken: TestContext.CancellationTokenSource.Token);
 				Assert.Fail();
 			}
 			catch (AuthenticationException ex)
@@ -182,7 +184,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			try
 			{
 				// Act
-				await client.GetAsync<TestClass>("foo");
+				await client.GetAsync<TestClass>("foo", cancellationToken: TestContext.CancellationTokenSource.Token);
 				Assert.Fail();
 			}
 			catch (AuthenticationException ex)
@@ -196,7 +198,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		[TestMethod]
 		[DataRow(HttpStatusCode.Unauthorized)]
 		[DataRow(HttpStatusCode.Forbidden)]
-		[ExpectedException(typeof(CloudflareException))]
 		public async Task ShouldThrowCloudflareExceptionOnStatusCodeWhenDeserializeFails(HttpStatusCode statusCode)
 		{
 			// Arrange
@@ -208,10 +209,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<TestClass>("foo");
+			await Assert.ThrowsExactlyAsync<CloudflareException>(async () =>
-
+			{
-			// Assert - CloudflareException
+				await client.GetAsync<TestClass>("foo", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -228,7 +230,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.GetAsync<string>("some-awesome-path", new TestFilter());
+			var response = await client.GetAsync<string>("some-awesome-path", new TestFilter(), TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -239,14 +241,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Get, callback.Method);
 			Assert.AreEqual("http://localhost/api/v4/some-awesome-path?bar=08%2F15&test=filter-text", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -272,7 +274,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(JsonReaderException))]
 		public async Task ShouldThrowExceptionOnInvalidResponse()
 		{
 			// Arrange
@@ -284,12 +285,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<TestClass>("some-path");
+			await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
+			{
+				await client.GetAsync<TestClass>("some-path", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(CloudflareException))]
 		public async Task ShouldThrowCloudflareExceptionWhenDeserializeFails()
 		{
 			// Arrange
@@ -301,10 +304,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.GetAsync<TestClass>("foo");
+			await Assert.ThrowsExactlyAsync<CloudflareException>(async () =>
-
+			{
-			// Assert - CloudflareException
+				await client.GetAsync<TestClass>("foo", cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private void VerifyDefaults()

test/Cloudflare.Tests/CloudflareClientTests/PatchAsyncTest.cs

@@ -12,11 +12,13 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests.CloudflareClientTests
+namespace Cloudflare.Tests.CloudflareClientTests
 {
 	[TestClass]
 	public class PatchAsyncTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string BaseUrl = "https://localhost/api/v4/";
 
 		private HttpMessageHandlerMock _httpHandlerMock;
@@ -52,46 +54,46 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ObjectDisposedException))]
 		public async Task ShouldThrowDisposed()
 		{
 			// Arrange
 			var client = GetClient() as CloudflareClient;
 			client.Dispose();
 
-			// Act
+			// Act & Assert
-			await client.PatchAsync<object, object>("test", _request);
+			await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
-
+			{
-			// Assert - ObjectDisposedException
+				await client.PatchAsync<object, object>("test", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullOnRequestPath(string path)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PatchAsync<object, object>(path, _request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.PatchAsync<object, object>(path, _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentOnRequestPath()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PatchAsync<object, object>("foo?bar=baz", _request);
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
-
+			{
-			// Assert - ArgumentException
+				await client.PatchAsync<object, object>("foo?bar=baz", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -107,7 +109,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PatchAsync<TestClass, TestClass>("test", _request);
+			var response = await client.PatchAsync<TestClass, TestClass>("test", _request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -116,21 +118,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Patch, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -159,7 +161,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PatchAsync<TestClass, StringContent>("test", stringContent);
+			var response = await client.PatchAsync<TestClass, StringContent>("test", stringContent, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -168,21 +170,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Patch, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""test"":""HERE ?""}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -211,18 +213,13 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			try
+			var ex = await Assert.ThrowsExactlyAsync<AuthenticationException>(async () =>
 			{
-				// Act
+				await client.PatchAsync<object, object>("foo", _request, TestContext.CancellationTokenSource.Token);
-				await client.PatchAsync<object, object>("foo", _request);
+			});
-				Assert.Fail();
+			// Assert
-			}
+			Assert.IsNull(ex.InnerException);
-			catch (AuthenticationException ex)
+			Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
-			{
-				// Assert
-				Assert.IsNull(ex.InnerException);
-				Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
-			}
 		}
 
 		[TestMethod]
@@ -239,7 +236,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PatchAsync<string, TestClass>("some-awesome-path", _request);
+			var response = await client.PatchAsync<string, TestClass>("some-awesome-path", _request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -250,14 +247,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Patch, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/some-awesome-path?bar=08%2F15", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -283,7 +280,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(JsonReaderException))]
 		public async Task ShouldThrowExceptionOnInvalidResponse()
 		{
 			// Arrange
@@ -295,8 +291,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PatchAsync<TestClass, TestClass>("some-path", _request);
+			await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
+			{
+				await client.PatchAsync<TestClass, TestClass>("some-path", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private void VerifyDefaults()

test/Cloudflare.Tests/CloudflareClientTests/PostAsyncTest.cs

@@ -12,11 +12,13 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests.CloudflareClientTests
+namespace Cloudflare.Tests.CloudflareClientTests
 {
 	[TestClass]
 	public class PostAsyncTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string BaseUrl = "https://localhost/api/v4/";
 
 		private HttpMessageHandlerMock _httpHandlerMock;
@@ -52,46 +54,46 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ObjectDisposedException))]
 		public async Task ShouldThrowDisposed()
 		{
 			// Arrange
 			var client = GetClient() as CloudflareClient;
 			client.Dispose();
 
-			// Act
+			// Act & Assert
-			await client.PostAsync<object, object>("test", _request);
+			await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
-
+			{
-			// Assert - ObjectDisposedException
+				await client.PostAsync<object, object>("test", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullOnRequestPath(string path)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PostAsync<object, object>(path, _request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.PostAsync<object, object>(path, _request, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentOnRequestPath()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PostAsync<object, object>("foo?bar=baz", _request);
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
-
+			{
-			// Assert - ArgumentException
+				await client.PostAsync<object, object>("foo?bar=baz", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -107,7 +109,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PostAsync<TestClass, TestClass>("test", _request);
+			var response = await client.PostAsync<TestClass, TestClass>("test", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -116,21 +118,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Post, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -159,7 +161,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PostAsync<TestClass, StringContent>("test", stringContent);
+			var response = await client.PostAsync<TestClass, StringContent>("test", stringContent, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -168,21 +170,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Post, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""test"":""HERE ?""}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -210,7 +212,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PostAsync<TestClass, object>("posting", null);
+			var response = await client.PostAsync<TestClass, object>("posting", null, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -219,21 +221,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Post, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/posting", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -259,18 +261,13 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			try
+			// Act & Assert
+			var ex = await Assert.ThrowsExactlyAsync<AuthenticationException>(async () =>
 			{
-				// Act
+				await client.PostAsync<object, object>("foo", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
-				await client.PostAsync<object, object>("foo", _request);
+			});
-				Assert.Fail();
+			Assert.IsNull(ex.InnerException);
-			}
+			Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
-			catch (AuthenticationException ex)
-			{
-				// Assert
-				Assert.IsNull(ex.InnerException);
-				Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
-			}
 		}
 
 		[TestMethod]
@@ -287,7 +284,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PostAsync<string, TestClass>("some-awesome-path", _request);
+			var response = await client.PostAsync<string, TestClass>("some-awesome-path", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -298,14 +295,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Post, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/some-awesome-path?bar=08%2F15", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -331,7 +328,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(JsonReaderException))]
 		public async Task ShouldThrowExceptionOnInvalidResponse()
 		{
 			// Arrange
@@ -343,8 +339,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PostAsync<TestClass, TestClass>("some-path", _request);
+			await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
+			{
+				await client.PostAsync<TestClass, TestClass>("some-path", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -361,7 +360,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PostAsync<string, TestClass>("path", _request);
+			var response = await client.PostAsync<string, TestClass>("path", _request, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -372,14 +371,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Post, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/path", callback.Url);
 			Assert.AreEqual(@"{""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));

test/Cloudflare.Tests/CloudflareClientTests/PutAsyncTest.cs

@@ -12,11 +12,13 @@ using AMWD.Net.Api.Cloudflare;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests.CloudflareClientTests
+namespace Cloudflare.Tests.CloudflareClientTests
 {
 	[TestClass]
 	public class PutAsyncTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string BaseUrl = "https://localhost/api/v4/";
 
 		private HttpMessageHandlerMock _httpHandlerMock;
@@ -52,46 +54,46 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ObjectDisposedException))]
 		public async Task ShouldThrowDisposed()
 		{
 			// Arrange
 			var client = GetClient() as CloudflareClient;
 			client.Dispose();
 
-			// Act
+			// Act & Assert
-			await client.PutAsync<object, object>("test", _request);
+			await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
-
+			{
-			// Assert - ObjectDisposedException
+				await client.PutAsync<object, object>("test", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullOnRequestPath(string path)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PutAsync<object, object>(path, _request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.PutAsync<object, object>(path, _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentOnRequestPath()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PutAsync<object, object>("foo?bar=baz", _request);
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
-
+			{
-			// Assert - ArgumentException
+				await client.PutAsync<object, object>("foo?bar=baz", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
@@ -107,7 +109,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PutAsync<TestClass, TestClass>("test", _request);
+			var response = await client.PutAsync<TestClass, TestClass>("test", _request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -116,21 +118,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Put, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -159,7 +161,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PutAsync<TestClass, StringContent>("test", stringContent);
+			var response = await client.PutAsync<TestClass, StringContent>("test", stringContent, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -168,21 +170,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Put, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/test", callback.Url);
 			Assert.AreEqual(@"{""test"":""HERE ?""}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -210,7 +212,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PutAsync<TestClass, object>("putput", null);
+			var response = await client.PutAsync<TestClass, object>("putput", null, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -219,21 +221,21 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			Assert.IsNotNull(response.Messages);
 			Assert.IsNull(response.ResultInfo);
 
-			Assert.AreEqual(0, response.Errors.Count);
+			Assert.IsEmpty(response.Errors);
-			Assert.AreEqual(0, response.Messages.Count);
+			Assert.IsEmpty(response.Messages);
 
 			Assert.IsNotNull(response.Result);
 			Assert.AreEqual("some-string", response.Result.Str);
 			Assert.AreEqual(123, response.Result.Int);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Put, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/putput", callback.Url);
 			Assert.IsNull(callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -262,7 +264,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			try
 			{
 				// Act
-				await client.PutAsync<object, object>("foo", _request);
+				await client.PutAsync<object, object>("foo", _request, TestContext.CancellationTokenSource.Token);
 				Assert.Fail();
 			}
 			catch (AuthenticationException ex)
@@ -287,7 +289,7 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 			var client = GetClient();
 
 			// Act
-			var response = await client.PutAsync<string, TestClass>("some-awesome-path", _request);
+			var response = await client.PutAsync<string, TestClass>("some-awesome-path", _request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -298,14 +300,14 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			Assert.AreEqual("This is an awesome text ;-)", response.Result);
 
-			Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
+			Assert.HasCount(1, _httpHandlerMock.Callbacks);
 
 			var callback = _httpHandlerMock.Callbacks.First();
 			Assert.AreEqual(HttpMethod.Put, callback.Method);
 			Assert.AreEqual("https://localhost/api/v4/some-awesome-path?bar=08%2F15", callback.Url);
 			Assert.AreEqual(@"{""string"":""Happy Testing!"",""integer"":54321}", callback.Content);
 
-			Assert.AreEqual(3, callback.Headers.Count);
+			Assert.HasCount(3, callback.Headers);
 			Assert.IsTrue(callback.Headers.ContainsKey("Accept"));
 			Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
 			Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
@@ -331,7 +333,6 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(JsonReaderException))]
 		public async Task ShouldThrowExceptionOnInvalidResponse()
 		{
 			// Arrange
@@ -343,8 +344,11 @@ namespace Cloudflare.Core.Tests.CloudflareClientTests
 
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.PutAsync<TestClass, TestClass>("some-path", _request);
+			await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
+			{
+				await client.PutAsync<TestClass, TestClass>("some-path", _request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private void VerifyDefaults()

test/Cloudflare.Tests/Extensions/EnumExtensionsTest.cs

@@ -1,7 +1,7 @@
 using System.Runtime.Serialization;
 using AMWD.Net.Api.Cloudflare;
 
-namespace Cloudflare.Core.Tests.Extensions
+namespace Cloudflare.Tests.Extensions
 {
 	[TestClass]
 	public class EnumExtensionsTest

test/Cloudflare.Tests/Extensions/StringExtensionsTest.cs

@@ -1,5 +1,4 @@
-using System;
+using AMWD.Net.Api.Cloudflare;
-using AMWD.Net.Api.Cloudflare;
 
 namespace Cloudflare.Tests.Extensions
 {
@@ -22,43 +21,34 @@ namespace Cloudflare.Tests.Extensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullExceptionForValidateId(string name)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			name.ValidateCloudflareId();
+			Assert.ThrowsExactly<ArgumentNullException>(() => name.ValidateCloudflareId());
-
-			// Assert - ArgumentNullException
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldThrowArgumentOutOfRangeExceptionForValidateId()
 		{
 			// Arrange
 			string id = new('a', 33);
 
-			// Act
+			// Act & Assert
-			id.ValidateCloudflareId();
+			Assert.ThrowsExactly<ArgumentException>(() => id.ValidateCloudflareId());
-
-			// Assert - ArgumentException
 		}
 
 		[TestMethod]
 		[DataRow("023e105f4ecef8ad9ca31a8372d0c35")]
 		[DataRow("023e105f4ecef8ad9ca31a8372d0C353")]
 		[DataRow("023e105f4ecef8ad9ca31a8372d0y353")]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldThrowArgumentExceptionForValidateId(string id)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			id.ValidateCloudflareId();
+			Assert.ThrowsExactly<ArgumentException>(() => id.ValidateCloudflareId());
-
-			// Assert - ArgumentException
 		}
 
 		[TestMethod]
@@ -77,28 +67,22 @@ namespace Cloudflare.Tests.Extensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullExceptionForValidateName(string name)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			name.ValidateCloudflareName();
+			Assert.ThrowsExactly<ArgumentNullException>(() => name.ValidateCloudflareName());
-
-			// Assert - ArgumentNullException
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldThrowArgumentOutOfRangeExceptionForValidateName()
 		{
 			// Arrange
 			string name = new('a', 254);
 
-			// Act
+			// Act & Assert
-			name.ValidateCloudflareName();
+			Assert.ThrowsExactly<ArgumentException>(() => name.ValidateCloudflareName());
-
-			// Assert - ArgumentException
 		}
 
 		[TestMethod]
@@ -117,30 +101,24 @@ namespace Cloudflare.Tests.Extensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void ShouldThrowArgumentNullExceptionForValidateEmail(string email)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			email.ValidateCloudflareEmailAddress();
+			Assert.ThrowsExactly<ArgumentNullException>(() => email.ValidateCloudflareEmailAddress());
-
-			// Assert - ArgumentNullException
 		}
 
 		[TestMethod]
 		[DataRow("test")]
 		[DataRow("test@example")]
 		[DataRow("example.com")]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldThrowArgumentExceptionForValidateEmail(string email)
 		{
 			// Arrange
 
-			// Act
+			// Act & Assert
-			email.ValidateCloudflareEmailAddress();
+			Assert.ThrowsExactly<ArgumentException>(() => email.ValidateCloudflareEmailAddress());
-
-			// Assert - ArgumentException
 		}
 
 		[TestMethod]
@@ -157,16 +135,13 @@ namespace Cloudflare.Tests.Extensions
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void ShouldThrowArgumentExceptionForValidateLength()
 		{
 			// Arrange
 			string str = "SomeExampleString";
 
-			// Act
+			// Act & Assert
-			str.ValidateLength(10, nameof(str));
+			Assert.ThrowsExactly<ArgumentException>(() => str.ValidateLength(10, nameof(str)));
-
-			// Assert - ArgumentException
 		}
 	}
 }

test/Cloudflare.Tests/MessageHandlerMock.cs

@@ -1,12 +1,11 @@
-using System.Collections.Generic;
+using System.Linq;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Moq;
 using Moq.Protected;
 
-namespace Cloudflare.Core.Tests
+namespace Cloudflare.Tests
 {
 	internal class HttpMessageHandlerMock
 	{
@@ -25,11 +24,11 @@ namespace Cloudflare.Core.Tests
 					};
 
 					if (request.Content != null)
-						callback.Content = await request.Content.ReadAsStringAsync();
+						callback.Content = await request.Content.ReadAsStringAsync(ct);
 
 					Callbacks.Add(callback);
 				})
-				.ReturnsAsync(() => Responses.Dequeue());
+				.ReturnsAsync(Responses.Dequeue);
 		}
 
 		public List<HttpMessageRequestCallback> Callbacks { get; } = [];

test/Extensions/Cloudflare.Dns.Tests/CustomNameserversExtensions/AddCustomNameserverTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 	[TestClass]
 	public class AddCustomNameserverTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private const string Nameserver = "ns1.example.com";
@@ -50,21 +52,21 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.AddCustomNameserver(_request);
+			var response = await client.AddCustomNameserver(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/custom_ns", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/custom_ns", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(_request.NameserverName, callback.Request.NameserverName);
+			Assert.AreEqual(_request.NameserverName, request.NameserverName);
-			Assert.IsNull(callback.Request.NameserverSet);
+			Assert.IsNull(request.NameserverSet);
 
 			_clientMock.Verify(m => m.PostAsync<CustomNameserver, InternalAddCustomNameserverRequest>($"/accounts/{AccountId}/custom_ns", It.IsAny<InternalAddCustomNameserverRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/CustomNameserversExtensions/DeleteCustomNameserverTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 	[TestClass]
 	public class DeleteCustomNameserverTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private const string Nameserver = "ns1.example.com";
@@ -45,18 +47,18 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteCustomNameserver(AccountId, Nameserver);
+			var response = await client.DeleteCustomNameserver(AccountId, Nameserver, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/custom_ns/{Nameserver}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/custom_ns/{Nameserver}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.DeleteAsync<IReadOnlyCollection<string>>($"/accounts/{AccountId}/custom_ns/{Nameserver}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -66,16 +68,13 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldDeleteCustomNameserver(string nameserver)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.DeleteCustomNameserver(AccountId, nameserver);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await client.DeleteCustomNameserver(AccountId, nameserver, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentNullException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Dns.Tests/CustomNameserversExtensions/ListCustomNameserverTest.cs

@@ -10,9 +10,9 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 	[TestClass]
 	public class ListCustomNameserverTest
 	{
-		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		public TestContext TestContext { get; set; }
 
-		private const string Nameserver = "ns1.example.com";
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
 
@@ -45,18 +45,18 @@ namespace Cloudflare.Dns.Tests.CustomNameserversExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListCustomNameserver(AccountId);
+			var response = await client.ListCustomNameserver(AccountId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/custom_ns", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/custom_ns", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<CustomNameserver>>($"/accounts/{AccountId}/custom_ns", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

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

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 	[TestClass]
 	public class ShowDnsAccountSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c354";
 
@@ -69,19 +71,19 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ShowDnsAccountSettings(AccountId);
+			var response = await client.ShowDnsAccountSettings(AccountId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", requestPath);
 
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<DnsAccountSettings>($"/accounts/{AccountId}/dns_settings", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

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

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 	[TestClass]
 	public class UpdateDnsAccountSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c354";
 
@@ -100,37 +102,37 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsAccountSettings(_request);
+			var response = await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.IsTrue(callback.Request.ZoneDefaults.FlattenAllCnames);
+			Assert.IsTrue(request.ZoneDefaults.FlattenAllCnames);
-			Assert.IsFalse(callback.Request.ZoneDefaults.FoundationDns);
+			Assert.IsFalse(request.ZoneDefaults.FoundationDns);
-			Assert.IsNotNull(callback.Request.ZoneDefaults.InternalDns);
+			Assert.IsNotNull(request.ZoneDefaults.InternalDns);
-			Assert.AreEqual(ZoneId, callback.Request.ZoneDefaults.InternalDns.ReferenceZoneId);
+			Assert.AreEqual(ZoneId, request.ZoneDefaults.InternalDns.ReferenceZoneId);
-			Assert.IsFalse(callback.Request.ZoneDefaults.MultiProvider);
+			Assert.IsFalse(request.ZoneDefaults.MultiProvider);
-			Assert.IsNotNull(callback.Request.ZoneDefaults.Nameservers);
+			Assert.IsNotNull(request.ZoneDefaults.Nameservers);
-			Assert.AreEqual(DnsAccountNameserversType.Random, callback.Request.ZoneDefaults.Nameservers.Type);
+			Assert.AreEqual(DnsAccountNameserversType.Random, request.ZoneDefaults.Nameservers.Type);
-			Assert.AreEqual(86400, callback.Request.ZoneDefaults.NameserverTtl);
+			Assert.AreEqual(86400, request.ZoneDefaults.NameserverTtl);
-			Assert.IsFalse(callback.Request.ZoneDefaults.SecondaryOverrides);
+			Assert.IsFalse(request.ZoneDefaults.SecondaryOverrides);
-			Assert.IsNotNull(callback.Request.ZoneDefaults.SOA);
+			Assert.IsNotNull(request.ZoneDefaults.SOA);
-			Assert.AreEqual(604800, callback.Request.ZoneDefaults.SOA.Expire);
+			Assert.AreEqual(604800, request.ZoneDefaults.SOA.Expire);
-			Assert.AreEqual(1800, callback.Request.ZoneDefaults.SOA.MinimumTtl);
+			Assert.AreEqual(1800, request.ZoneDefaults.SOA.MinimumTtl);
-			Assert.AreEqual("ns1.example.org", callback.Request.ZoneDefaults.SOA.PrimaryNameserver);
+			Assert.AreEqual("ns1.example.org", request.ZoneDefaults.SOA.PrimaryNameserver);
-			Assert.AreEqual(28800, callback.Request.ZoneDefaults.SOA.Refresh);
+			Assert.AreEqual(28800, request.ZoneDefaults.SOA.Refresh);
-			Assert.AreEqual(3600, callback.Request.ZoneDefaults.SOA.Retry);
+			Assert.AreEqual(3600, request.ZoneDefaults.SOA.Retry);
-			Assert.AreEqual(43200, callback.Request.ZoneDefaults.SOA.TimeToLive);
+			Assert.AreEqual(43200, request.ZoneDefaults.SOA.TimeToLive);
-			Assert.AreEqual("admin.example.org", callback.Request.ZoneDefaults.SOA.ZoneAdministrator);
+			Assert.AreEqual("admin.example.org", request.ZoneDefaults.SOA.ZoneAdministrator);
-			Assert.AreEqual(DnsZoneMode.Standard, callback.Request.ZoneDefaults.ZoneMode);
+			Assert.AreEqual(DnsZoneMode.Standard, request.ZoneDefaults.ZoneMode);
 
 			_clientMock.Verify(m => m.PatchAsync<DnsAccountSettings, InternalUpdateDnsAccountSettingsRequest>($"/accounts/{AccountId}/dns_settings", It.IsAny<InternalUpdateDnsAccountSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -140,24 +142,24 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 		public async Task ShouldUpdateDnsSettingsNone()
 		{
 			// Arrange
-			var request = new UpdateDnsAccountSettingsRequest(AccountId);
+			var req = new UpdateDnsAccountSettingsRequest(AccountId);
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsAccountSettings(request);
+			var response = await client.UpdateDnsAccountSettings(req, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.IsNull(callback.Request.ZoneDefaults);
+			Assert.IsNull(request.ZoneDefaults);
 
 			_clientMock.Verify(m => m.PatchAsync<DnsAccountSettings, InternalUpdateDnsAccountSettingsRequest>($"/accounts/{AccountId}/dns_settings", It.IsAny<InternalUpdateDnsAccountSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -167,196 +169,196 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions
 		public async Task ShouldUpdateDnsSettingsNoneDefaults()
 		{
 			// Arrange
-			var request = new UpdateDnsAccountSettingsRequest(AccountId)
+			var req = new UpdateDnsAccountSettingsRequest(AccountId)
 			{
 				ZoneDefaults = new DnsAccountZoneDefaults()
 			};
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsAccountSettings(request);
+			var response = await client.UpdateDnsAccountSettings(req, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.IsNotNull(callback.Request.ZoneDefaults);
+			Assert.IsNotNull(request.ZoneDefaults);
-			Assert.IsNull(callback.Request.ZoneDefaults.FlattenAllCnames);
+			Assert.IsNull(request.ZoneDefaults.FlattenAllCnames);
-			Assert.IsNull(callback.Request.ZoneDefaults.FoundationDns);
+			Assert.IsNull(request.ZoneDefaults.FoundationDns);
-			Assert.IsNull(callback.Request.ZoneDefaults.MultiProvider);
+			Assert.IsNull(request.ZoneDefaults.MultiProvider);
-			Assert.IsNull(callback.Request.ZoneDefaults.Nameservers);
+			Assert.IsNull(request.ZoneDefaults.Nameservers);
-			Assert.IsNull(callback.Request.ZoneDefaults.NameserverTtl);
+			Assert.IsNull(request.ZoneDefaults.NameserverTtl);
-			Assert.IsNull(callback.Request.ZoneDefaults.SecondaryOverrides);
+			Assert.IsNull(request.ZoneDefaults.SecondaryOverrides);
-			Assert.IsNull(callback.Request.ZoneDefaults.SOA);
+			Assert.IsNull(request.ZoneDefaults.SOA);
-			Assert.IsNull(callback.Request.ZoneDefaults.ZoneMode);
+			Assert.IsNull(request.ZoneDefaults.ZoneMode);
 
 			_clientMock.Verify(m => m.PatchAsync<DnsAccountSettings, InternalUpdateDnsAccountSettingsRequest>($"/accounts/{AccountId}/dns_settings", It.IsAny<InternalUpdateDnsAccountSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidMode()
 		{
 			// Arrange
 			_request.ZoneDefaults.ZoneMode = 0;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverType()
 		{
 			// Arrange
 			_request.ZoneDefaults.Nameservers.Type = 0;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(29)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverTtl(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.NameserverTtl = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(86399)]
 		[DataRow(2419201)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaExpire(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.Expire = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(59)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaMinimumTtl(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.MinimumTtl = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionForMissingSoaNameserver(string nameserver)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.PrimaryNameserver = nameserver;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(599)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRefresh(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.Refresh = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(599)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRetry(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.Retry = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(299)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaTtl(int ttl)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.TimeToLive = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionForMissingSoaAdministrator(string admin)
 		{
 			// Arrange
 			_request.ZoneDefaults.SOA.ZoneAdministrator = admin;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsAccountSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.UpdateDnsAccountSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private ICloudflareClient GetClient()

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

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 	[TestClass]
 	public class CreateInternalDnsViewTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
 		private const string ViewName = "InternalView";
@@ -50,21 +52,21 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			var client = GetClient();
 
 			// Act
-			var response = await client.CreateInternalDnsView(_request);
+			var response = await client.CreateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(ViewName, callback.Request.Name);
+			Assert.AreEqual(ViewName, request.Name);
-			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), callback.Request.Zones.ToList());
+			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), 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();
@@ -74,31 +76,31 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionWhenNameIsNull(string name)
 		{
 			// Arrange
 			_request.Name = name;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.CreateInternalDnsView(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				var response = await client.CreateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionWhenNameTooLong()
 		{
 			// Arrange
 			_request.Name = new string('a', 256);
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.CreateInternalDnsView(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				var response = await client.CreateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private ICloudflareClient GetClient()

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

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 	[TestClass]
 	public class DeleteInternalDnsViewTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
 
@@ -45,18 +47,18 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteInternalDnsView(AccountId, ViewId);
+			var response = await client.DeleteInternalDnsView(AccountId, ViewId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.DeleteAsync<Identifier>($"/accounts/{AccountId}/dns_settings/views/{ViewId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

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

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 	[TestClass]
 	public class InternalDnsViewDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
 		private const string ViewName = "InternalView";
@@ -43,18 +45,18 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			var client = GetClient();
 
 			// Act
-			var response = await client.InternalDnsViewDetails(AccountId, ViewId);
+			var response = await client.InternalDnsViewDetails(AccountId, ViewId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<InternalDnsView>(
 				$"/accounts/{AccountId}/dns_settings/views/{ViewId}",

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

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 	[TestClass]
 	public class ListInternalDnsViewsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -45,19 +47,19 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListInternalDnsViews(AccountId);
+			var response = await client.ListInternalDnsViews(AccountId, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.IsNotNull(response.Result);
-			Assert.AreEqual(2, response.Result.Count);
+			Assert.HasCount(2, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<InternalDnsView>>(
 				$"/accounts/{AccountId}/dns_settings/views",
@@ -77,18 +79,18 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			};
 
 			// Act
-			var response = await client.ListInternalDnsViews(AccountId, filter);
+			var response = await client.ListInternalDnsViews(AccountId, filter, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.IsNotNull(response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views", requestPath);
-			Assert.AreEqual(filter, callback.QueryFilter);
+			Assert.AreEqual(filter, queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<InternalDnsView>>(
 				$"/accounts/{AccountId}/dns_settings/views",
@@ -110,7 +112,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -137,7 +139,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(11, dict.Count);
+			Assert.HasCount(11, dict);
 
 			Assert.AreEqual("desc", dict["direction"]);
 			Assert.AreEqual("all", dict["match"]);
@@ -166,7 +168,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -183,7 +185,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -200,7 +202,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -217,7 +219,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -233,7 +235,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -249,7 +251,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -265,7 +267,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -281,7 +283,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -298,7 +300,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -315,7 +317,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -332,7 +334,7 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		#endregion QueryFilter

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

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 	[TestClass]
 	public class UpdateInternalDnsViewTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string ViewId = "023e105f4ecef8ad9ca31a8372d0c354";
 		private const string ViewName = "InternalView";
@@ -50,21 +52,21 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateInternalDnsView(_request);
+			var response = await client.UpdateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/dns_settings/views/{ViewId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(ViewName, callback.Request.Name);
+			Assert.AreEqual(ViewName, request.Name);
-			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), callback.Request.Zones.ToList());
+			CollectionAssert.AreEqual(_request.ZoneIds.ToList(), request.Zones.ToList());
 
 			_clientMock.Verify(m => m.PatchAsync<InternalDnsView, InternalModifyInternalDnsViewRequest>(
 				$"/accounts/{AccountId}/dns_settings/views/{ViewId}",
@@ -77,31 +79,31 @@ namespace Cloudflare.Dns.Tests.DnsAccountSettingsExtensions.Views
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionWhenNameIsNull(string name)
 		{
 			// Arrange
 			_request.Name = name;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.UpdateInternalDnsView(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				var response = await client.UpdateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionWhenNameTooLong()
 		{
 			// Arrange
 			_request.Name = new string('a', 256);
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.UpdateInternalDnsView(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				var response = await client.UpdateInternalDnsView(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Dns.Tests/DnsDnssecExtensions/DeleteDnssecRecordsTest.cs

@@ -10,13 +10,15 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 	[TestClass]
 	public class DeleteDnssecRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
 
 		private CloudflareResponse<string> _response;
 
-		private List<(string RequestPath, IQueryParameterFilter? QueryFilter)> _callbacks;
+		private List<(string RequestPath, IQueryParameterFilter QueryFilter)> _callbacks;
 
 		[TestInitialize]
 		public void Initialize()
@@ -45,18 +47,18 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteDnssecRecords(ZoneId);
+			var response = await client.DeleteDnssecRecords(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dnssec", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dnssec", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.DeleteAsync<string>(
 				$"/zones/{ZoneId}/dnssec",
@@ -71,9 +73,9 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 			_clientMock
 				.Setup(m => m.DeleteAsync<string>(
 					It.IsAny<string>(),
-					It.IsAny<IQueryParameterFilter?>(),
+					It.IsAny<IQueryParameterFilter>(),
 					It.IsAny<CancellationToken>()))
-				.Callback<string, IQueryParameterFilter?, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
+				.Callback<string, IQueryParameterFilter, CancellationToken>((requestPath, queryFilter, _) => _callbacks.Add((requestPath, queryFilter)))
 				.ReturnsAsync(() => _response);
 
 			return _clientMock.Object;

test/Extensions/Cloudflare.Dns.Tests/DnsDnssecExtensions/DnssecDetailsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 	[TestClass]
 	public class DnssecDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -61,18 +63,18 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnssecDetails(ZoneId);
+			var response = await client.DnssecDetails(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dnssec", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dnssec", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<DNSSEC>(
 				$"/zones/{ZoneId}/dnssec",

test/Extensions/Cloudflare.Dns.Tests/DnsDnssecExtensions/EditDnssecStatusTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 	[TestClass]
 	public class EditDnssecStatusTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -72,23 +74,23 @@ namespace Cloudflare.Dns.Tests.DnsDnssecExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditDnssecStatus(_request);
+			var response = await client.EditDnssecStatus(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dnssec", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dnssec", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual(_request.DnssecMultiSigner, callback.Request.DnssecMultiSigner);
+			Assert.AreEqual(_request.DnssecMultiSigner, request.DnssecMultiSigner);
-			Assert.AreEqual(_request.DnssecPresigned, callback.Request.DnssecPresigned);
+			Assert.AreEqual(_request.DnssecPresigned, request.DnssecPresigned);
-			Assert.AreEqual(_request.DnssecUseNsec3, callback.Request.DnssecUseNsec3);
+			Assert.AreEqual(_request.DnssecUseNsec3, request.DnssecUseNsec3);
-			Assert.AreEqual(_request.Status, callback.Request.Status);
+			Assert.AreEqual(_request.Status, request.Status);
 
 			_clientMock.Verify(m => m.PatchAsync<DNSSEC, InternalEditDnssecStatusRequest>(
 				$"/zones/{ZoneId}/dnssec",

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/BatchDnsRecordsTest.cs

@@ -12,6 +12,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class BatchDnsRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
 
@@ -63,7 +65,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.BatchDnsRecords(_request);
+			var response = await client.BatchDnsRecords(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -79,32 +81,32 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			Assert.AreEqual(RecordId, response.Result.Overwrites.Single().Id);
 			Assert.AreEqual(IpContent, response.Result.Overwrites.Single().Content);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/batch", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/batch", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(1, callback.Request.Deletes.Count);
+			Assert.HasCount(1, request.Deletes);
-			Assert.AreEqual(RecordId, callback.Request.Deletes.First().Id);
+			Assert.AreEqual(RecordId, request.Deletes.First().Id);
 
-			Assert.AreEqual(1, callback.Request.Patches.Count);
+			Assert.HasCount(1, request.Patches);
-			var patch = callback.Request.Patches.First();
+			var patch = request.Patches.First();
 			Assert.AreEqual(RecordId, patch.Id);
 			Assert.AreEqual(DomainName, patch.Name);
 			Assert.AreEqual(DnsRecordType.A, patch.Type);
 			Assert.AreEqual(IpContent, patch.Content);
 
-			Assert.AreEqual(1, callback.Request.Puts.Count);
+			Assert.HasCount(1, request.Puts);
-			var put = callback.Request.Puts.First();
+			var put = request.Puts.First();
 			Assert.AreEqual(RecordId, put.Id);
 			Assert.AreEqual(DomainName, put.Name);
 			Assert.AreEqual(DnsRecordType.A, put.Type);
 			Assert.AreEqual(IpContent, put.Content);
 
-			Assert.AreEqual(1, callback.Request.Posts.Count);
+			Assert.HasCount(1, request.Posts);
-			var post = callback.Request.Posts.First();
+			var post = request.Posts.First();
 			Assert.AreEqual(DomainName, post.Name);
 			Assert.AreEqual(DnsRecordType.A, post.Type);
 			Assert.AreEqual(IpContent, post.Content);

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/DeleteDnsRecordTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class DeleteDnsRecordTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
 
@@ -45,18 +47,18 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteDnsRecord(ZoneId, RecordId);
+			var response = await client.DeleteDnsRecord(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.DeleteAsync<Identifier>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/DnsRecordDetailsTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class DnsRecordDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
 
@@ -59,7 +61,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -67,11 +69,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -101,7 +103,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -109,11 +111,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -142,7 +144,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -150,11 +152,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -183,7 +185,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -191,11 +193,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -224,7 +226,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -232,11 +234,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -265,7 +267,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -273,11 +275,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -306,7 +308,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -314,11 +316,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -347,7 +349,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -355,11 +357,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -388,7 +390,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -396,11 +398,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -429,7 +431,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -437,11 +439,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -470,7 +472,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -478,11 +480,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -511,7 +513,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -519,11 +521,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -552,7 +554,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -560,11 +562,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -593,7 +595,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -601,11 +603,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -634,7 +636,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -642,11 +644,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -675,7 +677,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -683,11 +685,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -716,7 +718,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -724,11 +726,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -757,7 +759,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -765,11 +767,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -798,7 +800,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -806,11 +808,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -839,7 +841,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -847,11 +849,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -880,7 +882,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -888,11 +890,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			AssertRecord(result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -906,18 +908,18 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.IsNull(response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -933,18 +935,18 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DnsRecordDetails(ZoneId, RecordId);
+			var response = await client.DnsRecordDetails(ZoneId, RecordId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.IsNull(response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JObject>($"/zones/{ZoneId}/dns_records/{RecordId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/ExportDnsRecordsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class ExportDnsRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -35,18 +37,18 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ExportDnsRecords(ZoneId);
+			var response = await client.ExportDnsRecords(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/export", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/export", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<string>($"/zones/{ZoneId}/dns_records/export", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/ImportDnsRecordsTest.cs

@@ -12,6 +12,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class ImportDnsRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string BindConfigContent = "www.example.com.		300	IN	A	127.0.0.1";
 
@@ -55,25 +57,25 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ImportDnsRecords(_request);
+			var response = await client.ImportDnsRecords(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(1, callback.Request.Count());
+			Assert.AreEqual(1, request.Count());
 
-			var part = callback.Request.First();
+			var part = request.First();
 			Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
 			Assert.IsInstanceOfType<ByteArrayContent>(part);
-			Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
+			Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
 			_clientMock.Verify(m => m.PostAsync<RecordImportResponse, MultipartFormDataContent>($"/zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -91,25 +93,25 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 				var client = GetClient();
 
 				// Act
-				var response = await client.ImportDnsRecords(_request);
+				var response = await client.ImportDnsRecords(_request, TestContext.CancellationTokenSource.Token);
 
 				// Assert
 				Assert.IsNotNull(response);
 				Assert.IsTrue(response.Success);
 				Assert.AreEqual(_response.Result, response.Result);
 
-				Assert.AreEqual(1, _callbacks.Count);
+				Assert.HasCount(1, _callbacks);
 
-				var callback = _callbacks.First();
+				var (requestPath, request, queryFilter) = _callbacks.First();
-				Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", callback.RequestPath);
+				Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", requestPath);
-				Assert.IsNotNull(callback.Request);
+				Assert.IsNotNull(request);
 
-				Assert.AreEqual(1, callback.Request.Count());
+				Assert.AreEqual(1, request.Count());
 
-				var part = callback.Request.First();
+				var part = request.First();
 				Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
 				Assert.IsInstanceOfType<ByteArrayContent>(part);
-				Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
+				Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
 				_clientMock.Verify(m => m.PostAsync<RecordImportResponse, MultipartFormDataContent>($"/zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 				_clientMock.VerifyNoOtherCalls();
@@ -130,30 +132,30 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ImportDnsRecords(_request);
+			var response = await client.ImportDnsRecords(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(2, callback.Request.Count());
+			Assert.AreEqual(2, request.Count());
 
-			var part = callback.Request.First();
+			var part = request.First();
 			Assert.AreEqual("proxied", part.Headers.ContentDisposition.Name);
 			Assert.IsInstanceOfType<StringContent>(part);
-			Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync());
+			Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
-			part = callback.Request.Last();
+			part = request.Last();
 			Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
 			Assert.IsInstanceOfType<ByteArrayContent>(part);
-			Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
+			Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
 			_clientMock.Verify(m => m.PostAsync<RecordImportResponse, MultipartFormDataContent>($"/zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -174,30 +176,30 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 				var client = GetClient();
 
 				// Act
-				var response = await client.ImportDnsRecords(_request);
+				var response = await client.ImportDnsRecords(_request, TestContext.CancellationTokenSource.Token);
 
 				// Assert
 				Assert.IsNotNull(response);
 				Assert.IsTrue(response.Success);
 				Assert.AreEqual(_response.Result, response.Result);
 
-				Assert.AreEqual(1, _callbacks.Count);
+				Assert.HasCount(1, _callbacks);
 
-				var callback = _callbacks.First();
+				var (requestPath, request, queryFilter) = _callbacks.First();
-				Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", callback.RequestPath);
+				Assert.AreEqual($"/zones/{ZoneId}/dns_records/import", requestPath);
-				Assert.IsNotNull(callback.Request);
+				Assert.IsNotNull(request);
 
-				Assert.AreEqual(2, callback.Request.Count());
+				Assert.AreEqual(2, request.Count());
 
-				var part = callback.Request.First();
+				var part = request.First();
 				Assert.AreEqual("proxied", part.Headers.ContentDisposition.Name);
 				Assert.IsInstanceOfType<StringContent>(part);
-				Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync());
+				Assert.AreEqual(proxied.ToString().ToLower(), await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
-				part = callback.Request.Last();
+				part = request.Last();
 				Assert.AreEqual("file", part.Headers.ContentDisposition.Name);
 				Assert.IsInstanceOfType<ByteArrayContent>(part);
-				Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync());
+				Assert.AreEqual(BindConfigContent, await part.ReadAsStringAsync(TestContext.CancellationTokenSource.Token));
 
 				_clientMock.Verify(m => m.PostAsync<RecordImportResponse, MultipartFormDataContent>($"/zones/{ZoneId}/dns_records/import", It.IsAny<MultipartFormDataContent>(), It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 				_clientMock.VerifyNoOtherCalls();
@@ -212,17 +214,14 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionForFile(string file)
 		{
 			// Arrange
 			_request.File = file;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.ImportDnsRecords(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await client.ImportDnsRecords(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentNullException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/ListDnsRecordsTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class ListDnsRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -83,14 +85,14 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListDnsRecords(ZoneId);
+			var response = await client.ListDnsRecords(ZoneId, cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 
 			Assert.IsNotNull(response.Result);
-			Assert.AreEqual(2, response.Result.Count);
+			Assert.HasCount(2, response.Result);
 
 			Assert.IsInstanceOfType<ARecord>(response.Result.First());
 			Assert.AreEqual("023e105f4ecef8ad9ca31a8372d0c353", response.Result.First().Id);
@@ -98,11 +100,11 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			Assert.IsInstanceOfType<AAAARecord>(response.Result.Last());
 			Assert.AreEqual("023e105f4ecef8ad9ca31a8372d0c355", response.Result.Last().Id);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<JObject>>($"/zones/{ZoneId}/dns_records", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -120,14 +122,14 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListDnsRecords(ZoneId, filter);
+			var response = await client.ListDnsRecords(ZoneId, filter, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 
 			Assert.IsNotNull(response.Result);
-			Assert.AreEqual(2, response.Result.Count);
+			Assert.HasCount(2, response.Result);
 
 			Assert.IsInstanceOfType<ARecord>(response.Result.First());
 			Assert.AreEqual("023e105f4ecef8ad9ca31a8372d0c353", response.Result.First().Id);
@@ -135,14 +137,14 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			Assert.IsInstanceOfType<AAAARecord>(response.Result.Last());
 			Assert.AreEqual("023e105f4ecef8ad9ca31a8372d0c355", response.Result.Last().Id);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records", requestPath);
-			Assert.IsNotNull(callback.QueryFilter);
+			Assert.IsNotNull(queryFilter);
 
-			Assert.IsInstanceOfType<ListDnsRecordsFilter>(callback.QueryFilter);
+			Assert.IsInstanceOfType<ListDnsRecordsFilter>(queryFilter);
-			Assert.AreEqual("example.com", ((ListDnsRecordsFilter)callback.QueryFilter).Name);
+			Assert.AreEqual("example.com", ((ListDnsRecordsFilter)queryFilter).Name);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<JObject>>($"/zones/{ZoneId}/dns_records", filter, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -159,7 +161,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -214,7 +216,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(33, dict.Count);
+			Assert.HasCount(33, dict);
 
 			Assert.IsTrue(dict.ContainsKey("comment"));
 			Assert.IsTrue(dict.ContainsKey("comment.absent"));
@@ -311,7 +313,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -327,7 +329,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -344,7 +346,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -361,7 +363,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -378,7 +380,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -394,7 +396,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -411,7 +413,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -428,7 +430,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -445,7 +447,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -462,7 +464,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -479,7 +481,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -496,7 +498,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -512,7 +514,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -528,7 +530,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -545,7 +547,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -562,7 +564,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -579,7 +581,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -596,7 +598,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -613,7 +615,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -629,7 +631,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -645,7 +647,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -662,7 +664,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -679,7 +681,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -696,7 +698,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -713,7 +715,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -730,7 +732,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -747,7 +749,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -764,7 +766,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -781,7 +783,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -797,7 +799,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -813,7 +815,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/OverwriteDnsRecordTest.cs

@@ -12,6 +12,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class OverwriteDnsRecordTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
 
@@ -65,7 +67,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.OverwriteDnsRecord(_request);
+			var response = await client.OverwriteDnsRecord(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -88,15 +90,15 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			Assert.IsNotNull(response.Result.CommentModifiedOn);
 			Assert.IsNotNull(response.Result.TagsModifiedOn);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual("example.com", callback.Request.Name);
+			Assert.AreEqual("example.com", request.Name);
-			Assert.AreEqual(DnsRecordType.A, callback.Request.Type);
+			Assert.AreEqual(DnsRecordType.A, request.Type);
-			Assert.AreEqual("127.0.1.22", callback.Request.Content);
+			Assert.AreEqual("127.0.1.22", request.Content);
 
 			_clientMock.Verify(m => m.PutAsync<JObject, InternalDnsRecordRequest>($"/zones/{ZoneId}/dns_records/{RecordId}", It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/ScanDnsRecordsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class ScanDnsRecordsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -45,14 +47,14 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ScanDnsRecords(ZoneId);
+			var response = await client.ScanDnsRecords(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 			Assert.AreEqual($"/zones/{ZoneId}/dns_records/scan", _callbacks.First());
 
 			_clientMock.Verify(m => m.PostAsync<RecordScanResponse, object>($"/zones/{ZoneId}/dns_records/scan", null, null, It.IsAny<CancellationToken>()), Times.Once);

test/Extensions/Cloudflare.Dns.Tests/DnsRecordsExtensions/UpdateDnsRecordTest.cs

@@ -1,7 +1,4 @@
-using System;
+using System.Linq;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using AMWD.Net.Api.Cloudflare;
@@ -15,6 +12,8 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 	[TestClass]
 	public class UpdateDnsRecordTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string RecordId = "023e105f4ecef8ad9ca31a8372d0c355";
 
@@ -70,7 +69,7 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsRecord(_request);
+			var response = await client.UpdateDnsRecord(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
@@ -93,15 +92,15 @@ namespace Cloudflare.Dns.Tests.DnsRecordsExtensions
 			Assert.IsNotNull(response.Result.CommentModifiedOn);
 			Assert.IsNotNull(response.Result.TagsModifiedOn);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_records/{RecordId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual("example.com", callback.Request.Name);
+			Assert.AreEqual("example.com", request.Name);
-			Assert.AreEqual(DnsRecordType.A, callback.Request.Type);
+			Assert.AreEqual(DnsRecordType.A, request.Type);
-			Assert.AreEqual("127.0.1.22", callback.Request.Content);
+			Assert.AreEqual("127.0.1.22", request.Content);
 
 			_clientMock.Verify(m => m.PatchAsync<JObject, InternalDnsRecordRequest>($"/zones/{ZoneId}/dns_records/{RecordId}", It.IsAny<InternalDnsRecordRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsZoneSettingsExtensions/ShowDnsZoneSettingsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Dns.Tests.DnsZoneSettingsExtensions
 	[TestClass]
 	public class ShowDnsZoneSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -65,19 +67,19 @@ namespace Cloudflare.Dns.Tests.DnsZoneSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ShowDnsZoneSettings(ZoneId);
+			var response = await client.ShowDnsZoneSettings(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", requestPath);
 
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock?.Verify(m => m.GetAsync<DnsZoneSettings>($"/zones/{ZoneId}/dns_settings", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock?.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Dns.Tests/DnsZoneSettingsExtensions/UpdateDnsZoneSettingsTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Dns.Tests.DnsZoneSettingsExtensions
 	[TestClass]
 	public class UpdateDnsZoneSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -93,37 +95,37 @@ namespace Cloudflare.Dns.Tests.DnsZoneSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsZoneSettings(_request);
+			var response = await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.IsTrue(callback.Request.FlattenAllCnames);
+			Assert.IsTrue(request.FlattenAllCnames);
-			Assert.IsFalse(callback.Request.FoundationDns);
+			Assert.IsFalse(request.FoundationDns);
-			Assert.IsNotNull(callback.Request.InternalDns);
+			Assert.IsNotNull(request.InternalDns);
-			Assert.AreEqual(ZoneId, callback.Request.InternalDns.ReferenceZoneId);
+			Assert.AreEqual(ZoneId, request.InternalDns.ReferenceZoneId);
-			Assert.IsFalse(callback.Request.MultiProvider);
+			Assert.IsFalse(request.MultiProvider);
-			Assert.IsNotNull(callback.Request.Nameservers);
+			Assert.IsNotNull(request.Nameservers);
-			Assert.AreEqual(DnsZoneNameserversType.Standard, callback.Request.Nameservers.Type);
+			Assert.AreEqual(DnsZoneNameserversType.Standard, request.Nameservers.Type);
-			Assert.AreEqual(86400, callback.Request.NameserverTtl);
+			Assert.AreEqual(86400, request.NameserverTtl);
-			Assert.IsFalse(callback.Request.SecondaryOverrides);
+			Assert.IsFalse(request.SecondaryOverrides);
-			Assert.IsNotNull(callback.Request.SOA);
+			Assert.IsNotNull(request.SOA);
-			Assert.AreEqual(604800, callback.Request.SOA.Expire);
+			Assert.AreEqual(604800, request.SOA.Expire);
-			Assert.AreEqual(1800, callback.Request.SOA.MinimumTtl);
+			Assert.AreEqual(1800, request.SOA.MinimumTtl);
-			Assert.AreEqual("ns1.example.org", callback.Request.SOA.PrimaryNameserver);
+			Assert.AreEqual("ns1.example.org", request.SOA.PrimaryNameserver);
-			Assert.AreEqual(28800, callback.Request.SOA.Refresh);
+			Assert.AreEqual(28800, request.SOA.Refresh);
-			Assert.AreEqual(3600, callback.Request.SOA.Retry);
+			Assert.AreEqual(3600, request.SOA.Retry);
-			Assert.AreEqual(43200, callback.Request.SOA.TimeToLive);
+			Assert.AreEqual(43200, request.SOA.TimeToLive);
-			Assert.AreEqual("admin.example.org", callback.Request.SOA.ZoneAdministrator);
+			Assert.AreEqual("admin.example.org", request.SOA.ZoneAdministrator);
-			Assert.AreEqual(DnsZoneMode.Standard, callback.Request.ZoneMode);
+			Assert.AreEqual(DnsZoneMode.Standard, request.ZoneMode);
 
 			_clientMock.Verify(m => m.PatchAsync<DnsZoneSettings, InternalUpdateDnsZoneSettingsRequest>($"/zones/{ZoneId}/dns_settings", It.IsAny<InternalUpdateDnsZoneSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -133,192 +135,192 @@ namespace Cloudflare.Dns.Tests.DnsZoneSettingsExtensions
 		public async Task ShouldUpdateDnsSettingsNone()
 		{
 			// Arrange
-			var request = new UpdateDnsZoneSettingsRequest(ZoneId);
+			var req = new UpdateDnsZoneSettingsRequest(ZoneId);
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateDnsZoneSettings(request);
+			var response = await client.UpdateDnsZoneSettings(req, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/dns_settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.IsNull(callback.Request.FlattenAllCnames);
+			Assert.IsNull(request.FlattenAllCnames);
-			Assert.IsNull(callback.Request.FoundationDns);
+			Assert.IsNull(request.FoundationDns);
-			Assert.IsNull(callback.Request.MultiProvider);
+			Assert.IsNull(request.MultiProvider);
-			Assert.IsNull(callback.Request.Nameservers);
+			Assert.IsNull(request.Nameservers);
-			Assert.IsNull(callback.Request.NameserverTtl);
+			Assert.IsNull(request.NameserverTtl);
-			Assert.IsNull(callback.Request.SecondaryOverrides);
+			Assert.IsNull(request.SecondaryOverrides);
-			Assert.IsNull(callback.Request.SOA);
+			Assert.IsNull(request.SOA);
-			Assert.IsNull(callback.Request.ZoneMode);
+			Assert.IsNull(request.ZoneMode);
 
 			_clientMock.Verify(m => m.PatchAsync<DnsZoneSettings, InternalUpdateDnsZoneSettingsRequest>($"/zones/{ZoneId}/dns_settings", It.IsAny<InternalUpdateDnsZoneSettingsRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidMode()
 		{
 			// Arrange
 			_request.ZoneMode = 0;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverType()
 		{
 			// Arrange
 			_request.Nameservers.Type = 0;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(29)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidNameserverTtl(int ttl)
 		{
 			// Arrange
 			_request.NameserverTtl = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(86399)]
 		[DataRow(2419201)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaExpire(int ttl)
 		{
 			// Arrange
 			_request.SOA.Expire = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(59)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaMinimumTtl(int ttl)
 		{
 			// Arrange
 			_request.SOA.MinimumTtl = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionForMissingSoaNameserver(string nameserver)
 		{
 			// Arrange
 			_request.SOA.PrimaryNameserver = nameserver;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(599)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRefresh(int ttl)
 		{
 			// Arrange
 			_request.SOA.Refresh = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(599)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaRetry(int ttl)
 		{
 			// Arrange
 			_request.SOA.Retry = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(299)]
 		[DataRow(86401)]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidSoaTtl(int ttl)
 		{
 			// Arrange
 			_request.SOA.TimeToLive = ttl;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () =>
-
+			{
-			// Assert - ArgumentOutOfRangeException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		[TestMethod]
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("   ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionForMissingSoaAdministrator(string admin)
 		{
 			// Arrange
 			_request.SOA.ZoneAdministrator = admin;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.UpdateDnsZoneSettings(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
-
+			{
-			// Assert - ArgumentNullException
+				await client.UpdateDnsZoneSettings(_request, TestContext.CancellationTokenSource.Token);
+			});
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/RegistrarExtensions/GetDomainTest.cs

@@ -11,8 +11,9 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 	[TestClass]
 	public class GetDomainTest
 	{
-		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		public TestContext TestContext { get; set; }
 
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string DomainName = "example.com";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -36,16 +37,16 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 			var client = GetClient();
 
 			// Act
-			var result = await client.GetDomain(AccountId, DomainName);
+			var result = await client.GetDomain(AccountId, DomainName, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.AreEqual(_response, result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains/{DomainName}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains/{DomainName}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<JToken>($"/accounts/{AccountId}/registrar/domains/{DomainName}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -55,16 +56,13 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionOnDomainName(string domainName)
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var result = await client.GetDomain(AccountId, domainName);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await client.GetDomain(AccountId, domainName, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentNullException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/RegistrarExtensions/ListDomainsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 	[TestClass]
 	public class ListDomainsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -33,16 +35,16 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 			var client = GetClient();
 
 			// Act
-			var result = await client.ListDomains(AccountId);
+			var result = await client.ListDomains(AccountId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.AreEqual(_response, result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<Domain>>($"/accounts/{AccountId}/registrar/domains", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/RegistrarExtensions/UpdateDomainTest.cs

@@ -12,8 +12,9 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 	[TestClass]
 	public class UpdateDomainTest
 	{
-		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
+		public TestContext TestContext { get; set; }
 
+		private const string AccountId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string DomainName = "example.com";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -45,20 +46,20 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 			var client = GetClient();
 
 			// Act
-			var result = await client.UpdateDomain(_request);
+			var result = await client.UpdateDomain(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.AreEqual(_response, result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains/{DomainName}", callback.RequestPath);
+			Assert.AreEqual($"/accounts/{AccountId}/registrar/domains/{DomainName}", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual(_request.AutoRenew, callback.Request.AutoRenew);
+			Assert.AreEqual(_request.AutoRenew, request.AutoRenew);
-			Assert.AreEqual(_request.Locked, callback.Request.Locked);
+			Assert.AreEqual(_request.Locked, request.Locked);
-			Assert.AreEqual(_request.Privacy, callback.Request.Privacy);
+			Assert.AreEqual(_request.Privacy, request.Privacy);
 
 			_clientMock.Verify(m => m.PutAsync<JToken, InternalUpdateDomainRequest>($"/accounts/{AccountId}/registrar/domains/{DomainName}", It.IsAny<InternalUpdateDomainRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -68,17 +69,14 @@ namespace Cloudflare.Zones.Tests.RegistrarExtensions
 		[DataRow(null)]
 		[DataRow("")]
 		[DataRow("  ")]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public async Task ShouldThrowArgumentNullExceptionOnDomainName(string domainName)
 		{
 			// Arrange
 			_request.DomainName = domainName;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var result = await client.UpdateDomain(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await client.UpdateDomain(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentNullException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZoneHoldsExtensions/CreateZoneHoldTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 	[TestClass]
 	public class CreateZoneHoldTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private readonly DateTime _date = new(2025, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
@@ -54,21 +56,21 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.CreateZoneHold(_request);
+			var response = await client.CreateZoneHold(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
-			Assert.IsNotNull(callback.QueryFilter);
+			Assert.IsNotNull(queryFilter);
 
-			Assert.IsInstanceOfType<InternalCreateZoneHoldFilter>(callback.QueryFilter);
+			Assert.IsInstanceOfType<InternalCreateZoneHoldFilter>(queryFilter);
-			Assert.IsNull(((InternalCreateZoneHoldFilter)callback.QueryFilter).IncludeSubdomains);
+			Assert.IsNull(((InternalCreateZoneHoldFilter)queryFilter).IncludeSubdomains);
 
 			_clientMock.Verify(m => m.PostAsync<ZoneHold, object>($"/zones/{ZoneId}/hold", null, It.IsAny<InternalCreateZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -82,21 +84,21 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.CreateZoneHold(_request);
+			var response = await client.CreateZoneHold(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
-			Assert.IsNotNull(callback.QueryFilter);
+			Assert.IsNotNull(queryFilter);
 
-			Assert.IsInstanceOfType<InternalCreateZoneHoldFilter>(callback.QueryFilter);
+			Assert.IsInstanceOfType<InternalCreateZoneHoldFilter>(queryFilter);
-			Assert.IsTrue(((InternalCreateZoneHoldFilter)callback.QueryFilter).IncludeSubdomains);
+			Assert.IsTrue(((InternalCreateZoneHoldFilter)queryFilter).IncludeSubdomains);
 
 			_clientMock.Verify(m => m.PostAsync<ZoneHold, object>($"/zones/{ZoneId}/hold", null, It.IsAny<InternalCreateZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -113,7 +115,7 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -129,7 +131,7 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(1, dict.Count);
+			Assert.HasCount(1, dict);
 			Assert.IsTrue(dict.ContainsKey("include_subdomains"));
 			Assert.AreEqual(includeSubdomains.ToString().ToLower(), dict["include_subdomains"]);
 		}

test/Extensions/Cloudflare.Zones.Tests/ZoneHoldsExtensions/GetZoneHoldTest.cs

@@ -10,7 +10,9 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 	[TestClass]
 	public class GetZoneHoldTest
 	{
-		private readonly DateTime _date = new DateTime(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
+		public TestContext TestContext { get; set; }
+
+		private readonly DateTime _date = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -49,18 +51,18 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.GetZoneHold(ZoneId);
+			var response = await client.GetZoneHold(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<ZoneHold>($"/zones/{ZoneId}/hold", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZoneHoldsExtensions/RemoveZoneHoldTest.cs

@@ -11,8 +11,9 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 	[TestClass]
 	public class RemoveZoneHoldTest
 	{
-		// Local: Europe/Berlin (Germany) - [CEST +2] | CET +1
+		public TestContext TestContext { get; set; }
-		private readonly DateTime _date = new(2025, 10, 10, 20, 30, 40, 0, DateTimeKind.Unspecified);
+
+		private readonly DateTime _date = new(2025, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -55,21 +56,21 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.RemoveZoneHold(_request);
+			var response = await client.RemoveZoneHold(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
-			Assert.IsNotNull(callback.QueryFilter);
+			Assert.IsNotNull(queryFilter);
 
-			Assert.IsInstanceOfType<InternalRemoveZoneHoldFilter>(callback.QueryFilter);
+			Assert.IsInstanceOfType<InternalRemoveZoneHoldFilter>(queryFilter);
-			Assert.IsNull(((InternalRemoveZoneHoldFilter)callback.QueryFilter).HoldAfter);
+			Assert.IsNull(((InternalRemoveZoneHoldFilter)queryFilter).HoldAfter);
 
 			_clientMock.Verify(m => m.DeleteAsync<ZoneHold>($"/zones/{ZoneId}/hold", It.IsAny<InternalRemoveZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -83,21 +84,21 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.RemoveZoneHold(_request);
+			var response = await client.RemoveZoneHold(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
-			Assert.IsNotNull(callback.QueryFilter);
+			Assert.IsNotNull(queryFilter);
 
-			Assert.IsInstanceOfType<InternalRemoveZoneHoldFilter>(callback.QueryFilter);
+			Assert.IsInstanceOfType<InternalRemoveZoneHoldFilter>(queryFilter);
-			Assert.AreEqual(_date, ((InternalRemoveZoneHoldFilter)callback.QueryFilter).HoldAfter);
+			Assert.AreEqual(_date, ((InternalRemoveZoneHoldFilter)queryFilter).HoldAfter);
 
 			_clientMock.Verify(m => m.DeleteAsync<ZoneHold>($"/zones/{ZoneId}/hold", It.IsAny<InternalRemoveZoneHoldFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -114,7 +115,7 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -128,9 +129,9 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(1, dict.Count);
+			Assert.HasCount(1, dict);
 			Assert.IsTrue(dict.ContainsKey("hold_after"));
-			Assert.AreEqual("2025-10-10T18:30:40Z", dict["hold_after"]);
+			Assert.AreEqual("2025-10-10T20:30:40Z", dict["hold_after"]);
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZoneHoldsExtensions/UpdateZoneHoldTest.cs

@@ -11,7 +11,9 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 	[TestClass]
 	public class UpdateZoneHoldTest
 	{
-		private readonly DateTime _date = new DateTime(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
+		public TestContext TestContext { get; set; }
+
+		private readonly DateTime _date = new(2024, 10, 10, 20, 30, 40, 0, DateTimeKind.Utc);
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -58,21 +60,21 @@ namespace Cloudflare.Zones.Tests.ZoneHoldsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateZoneHold(_request);
+			var response = await client.UpdateZoneHold(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/hold", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/hold", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual(_date, callback.Request.HoldAfter);
+			Assert.AreEqual(_date, request.HoldAfter);
-			Assert.IsTrue(callback.Request.IncludeSubdomains);
+			Assert.IsTrue(request.IncludeSubdomains);
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZonePlansExtensions/AvailablePlanDetailsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 	[TestClass]
 	public class AvailablePlanDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 		private const string PlanId = "023e105f4ecef8ad9ca31a8372d0c354";
 
@@ -44,18 +46,18 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.AvailablePlanDetails(ZoneId, PlanId);
+			var response = await client.AvailablePlanDetails(ZoneId, PlanId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/available_plans/{PlanId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/available_plans/{PlanId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<AvailableRatePlan>($"/zones/{ZoneId}/available_plans/{PlanId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZonePlansExtensions/ListAvailablePlansTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 	[TestClass]
 	public class ListAvailablePlansTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -43,18 +45,18 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListAvailablePlans(ZoneId);
+			var response = await client.ListAvailablePlans(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/available_plans", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/available_plans", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<AvailableRatePlan>>($"/zones/{ZoneId}/available_plans", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZonePlansExtensions/ListAvailableRatePlansTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 	[TestClass]
 	public class ListAvailableRatePlansTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -43,18 +45,18 @@ namespace Cloudflare.Zones.Tests.ZonePlansExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListAvailableRatePlans(ZoneId);
+			var response = await client.ListAvailableRatePlans(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/available_rate_plans", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/available_rate_plans", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<RatePlanGetResponse>($"/zones/{ZoneId}/available_rate_plans", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZoneSettingsExtensions/EditMultipleZoneSettingsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 	[TestClass]
 	public class EditMultipleZoneSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -57,7 +59,7 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 
 			// Act
 #pragma warning disable CS0618
-			var response = await client.EditMultipleZoneSettings(_request);
+			var response = await client.EditMultipleZoneSettings(_request, TestContext.CancellationTokenSource.Token);
 #pragma warning restore CS0618
 
 			// Assert
@@ -65,16 +67,16 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/settings", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/settings", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual(2, callback.Request.Count);
+			Assert.HasCount(2, request);
 
-			Assert.IsInstanceOfType<SSL>(callback.Request.First());
+			Assert.IsInstanceOfType<SSL>(request.First());
-			Assert.IsInstanceOfType<WebP>(callback.Request.Last());
+			Assert.IsInstanceOfType<WebP>(request.Last());
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZoneSettingsExtensions/EditZoneSettingTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 	[TestClass]
 	public class EditZoneSettingTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -51,21 +53,21 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditZoneSetting(_request);
+			var response = await client.EditZoneSetting(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual("origin_pull", callback.Request["value"]);
+			Assert.AreEqual("origin_pull", request["value"]);
-			Assert.IsFalse(callback.Request.ContainsKey("enabled"));
+			Assert.IsFalse(request.ContainsKey("enabled"));
 		}
 
 		[TestMethod]
@@ -78,35 +80,32 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditZoneSetting(_request);
+			var response = await client.EditZoneSetting(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", requestPath);
 
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
-			Assert.AreEqual(enabled, callback.Request["enabled"]);
+			Assert.AreEqual(enabled, request["enabled"]);
-			Assert.IsFalse(callback.Request.ContainsKey("value"));
+			Assert.IsFalse(request.ContainsKey("value"));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentException()
 		{
 			// Arrange
 			var request = new EditZoneSettingRequest<TestSetting>(ZoneId, new TestSetting());
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.EditZoneSetting(request);
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () => await client.EditZoneSetting(request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZoneSettingsExtensions/GetAllZoneSettingsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 	[TestClass]
 	public class GetAllZoneSettingsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -47,7 +49,7 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 
 			// Act
 #pragma warning disable CS0618
-			var response = await client.GetAllZoneSettings(ZoneId);
+			var response = await client.GetAllZoneSettings(ZoneId, TestContext.CancellationTokenSource.Token);
 #pragma warning restore CS0618
 
 			// Assert
@@ -55,11 +57,11 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/settings", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/settings", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<ZoneSettingBase>>($"/zones/{ZoneId}/settings", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZoneSettingsExtensions/GetZoneSettingTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 	[TestClass]
 	public class GetZoneSettingTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -43,34 +45,31 @@ namespace Cloudflare.Zones.Tests.ZoneSettingsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.GetZoneSetting<SSL>(ZoneId);
+			var response = await client.GetZoneSetting<SSL>(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/settings/ssl", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<SSL>($"/zones/{ZoneId}/settings/ssl", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public async Task ShouldThrowArgumentException()
 		{
 			// Arrange
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			var response = await client.GetZoneSetting<TestSetting>(ZoneId);
+			await Assert.ThrowsExactlyAsync<ArgumentException>(async () => await client.GetZoneSetting<TestSetting>(ZoneId, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZoneSubscriptionsExtensions/CreateZoneSubscriptionTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 	[TestClass]
 	public class CreateZoneSubscriptionTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -56,21 +58,21 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.CreateZoneSubscription(_request);
+			var response = await client.CreateZoneSubscription(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/subscription", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/subscription", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(_request.Frequency, callback.Request.Frequency);
+			Assert.AreEqual(_request.Frequency, request.Frequency);
-			Assert.AreEqual(_request.RatePlan, callback.Request.RatePlan);
+			Assert.AreEqual(_request.RatePlan, request.RatePlan);
 
 			_clientMock.Verify(m => m.PostAsync<Subscription, InternalCreateZoneSubscriptionRequest>($"/zones/{ZoneId}/subscription", It.IsAny<InternalCreateZoneSubscriptionRequest>(), null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZoneSubscriptionsExtensions/UpdateZoneSubscriptionTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 	[TestClass]
 	public class UpdateZoneSubscriptionTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -56,21 +58,21 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.UpdateZoneSubscription(_request);
+			var response = await client.UpdateZoneSubscription(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/subscription", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/subscription", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(_request.Frequency, callback.Request.Frequency);
+			Assert.AreEqual(_request.Frequency, request.Frequency);
-			Assert.AreEqual(_request.RatePlan, callback.Request.RatePlan);
+			Assert.AreEqual(_request.RatePlan, request.RatePlan);
 
 			_clientMock.Verify(m => m.PutAsync<Subscription, InternalUpdateZoneSubscriptionRequest>($"/zones/{ZoneId}/subscription", It.IsAny<InternalUpdateZoneSubscriptionRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZoneSubscriptionsExtensions/ZoneSubscriptionDetailsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 	[TestClass]
 	public class ZoneSubscriptionDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -43,18 +45,18 @@ namespace Cloudflare.Zones.Tests.ZoneSubscriptionsExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ZoneSubscriptionDetails(ZoneId);
+			var response = await client.ZoneSubscriptionDetails(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/subscription", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/subscription", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<Subscription>($"/zones/{ZoneId}/subscription", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/CreateZoneTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class CreateZoneTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -105,39 +107,36 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.CreateZone(_request);
+			var response = await client.CreateZone(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual("/zones", callback.RequestPath);
+			Assert.AreEqual("/zones", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.AreEqual(_request.AccountId, callback.Request.Account.Id);
+			Assert.AreEqual(_request.AccountId, request.Account.Id);
-			Assert.AreEqual(_request.Name, callback.Request.Name);
+			Assert.AreEqual(_request.Name, request.Name);
-			Assert.AreEqual(_request.Type, callback.Request.Type);
+			Assert.AreEqual(_request.Type, 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(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionOnInvalidType()
 		{
 			// Arrange
 			_request.Type = 0;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.CreateZone(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () => await client.CreateZone(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentOutOfRangeException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/DeleteZoneTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class DeleteZoneTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -46,18 +48,18 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.DeleteZone(ZoneId);
+			var response = await client.DeleteZone(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.DeleteAsync<Identifier>($"/zones/{ZoneId}", It.IsAny<IQueryParameterFilter>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/EditZoneTest.cs

@@ -11,6 +11,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class EditZoneTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -104,22 +106,22 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditZone(_request);
+			var response = await client.EditZone(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.IsTrue(callback.Request.Paused);
+			Assert.IsTrue(request.Paused);
-			Assert.IsNull(callback.Request.Type);
+			Assert.IsNull(request.Type);
-			Assert.IsNull(callback.Request.VanityNameServers);
+			Assert.IsNull(request.VanityNameServers);
 
 			_clientMock.Verify(m => m.PatchAsync<Zone, InternalEditZoneRequest>($"/zones/{ZoneId}", It.IsAny<InternalEditZoneRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -134,22 +136,22 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditZone(_request);
+			var response = await client.EditZone(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.IsNull(callback.Request.Paused);
+			Assert.IsNull(request.Paused);
-			Assert.AreEqual(_request.Type.Value, callback.Request.Type.Value);
+			Assert.AreEqual(_request.Type.Value, request.Type.Value);
-			Assert.IsNull(callback.Request.VanityNameServers);
+			Assert.IsNull(request.VanityNameServers);
 
 			_clientMock.Verify(m => m.PatchAsync<Zone, InternalEditZoneRequest>($"/zones/{ZoneId}", It.IsAny<InternalEditZoneRequest>(), It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -165,59 +167,52 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.EditZone(_request);
+			var response = await client.EditZone(_request, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}", requestPath);
-			Assert.IsNotNull(callback.Request);
+			Assert.IsNotNull(request);
 
-			Assert.IsNull(callback.Request.Paused);
+			Assert.IsNull(request.Paused);
-			Assert.IsNull(callback.Request.Type);
+			Assert.IsNull(request.Type);
-			Assert.AreEqual(2, callback.Request.VanityNameServers.Count);
+			Assert.HasCount(2, request.VanityNameServers);
-			Assert.IsTrue(callback.Request.VanityNameServers.Contains("ns1.example.org"));
+			Assert.IsTrue(request.VanityNameServers.Contains("ns1.example.org"));
-			Assert.IsTrue(callback.Request.VanityNameServers.Contains("ns2.example.org"));
+			Assert.IsTrue(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 ShouldThrowCloudflareExceptionOnMultiplePropertiesSet1()
 		{
 			// Arrange
 			_request.VanityNameServers = null;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.EditZone(_request);
+			await Assert.ThrowsExactlyAsync<CloudflareException>(async () => await client.EditZone(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - CloudflareException
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(CloudflareException))]
 		public async Task ShouldThrowCloudflareExceptionOnMultiplePropertiesSet2()
 		{
 			// Arrange
 			_request.Paused = null;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.EditZone(_request);
+			await Assert.ThrowsExactlyAsync<CloudflareException>(async () => await client.EditZone(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - CloudflareException
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public async Task ShouldThrowArgumentOutOfRangeExceptionForInvalidType()
 		{
 			// Arrange
@@ -226,10 +221,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			_request.VanityNameServers = null;
 			var client = GetClient();
 
-			// Act
+			// Act & Assert
-			await client.EditZone(_request);
+			await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () => await client.EditZone(_request, TestContext.CancellationTokenSource.Token));
-
-			// Assert - ArgumentOutOfRangeException
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/ListZonesTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class ListZonesTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -102,18 +104,18 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListZones();
+			var response = await client.ListZones(cancellationToken: TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual("/zones", callback.RequestPath);
+			Assert.AreEqual("/zones", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<Zone>>("/zones", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -131,18 +133,18 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ListZones(filter);
+			var response = await client.ListZones(filter, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual("/zones", callback.RequestPath);
+			Assert.AreEqual("/zones", requestPath);
-			Assert.AreEqual(filter, callback.QueryFilter);
+			Assert.AreEqual(filter, queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<IReadOnlyCollection<Zone>>("/zones", filter, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();
@@ -159,7 +161,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -184,7 +186,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(9, dict.Count);
+			Assert.HasCount(9, dict);
 
 			Assert.IsTrue(dict.ContainsKey("account.id"));
 			Assert.IsTrue(dict.ContainsKey("account.name"));
@@ -224,7 +226,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -244,7 +246,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -261,7 +263,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -278,7 +280,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -294,11 +296,11 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			};
 
 			// Act
-			var dict = new Dictionary<string, object>();
+			var dict = filter.GetQueryParameters();
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -315,7 +317,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -332,7 +334,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -351,7 +353,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		[TestMethod]
@@ -368,7 +370,7 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 
 			// Assert
 			Assert.IsNotNull(dict);
-			Assert.AreEqual(0, dict.Count);
+			Assert.IsEmpty(dict);
 		}
 
 		private ICloudflareClient GetClient()

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/RerunActivationCheckTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class RerunActivationCheckTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -46,18 +48,18 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.RerunActivationCheck(ZoneId);
+			var response = await client.RerunActivationCheck(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, request) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}/activation_check", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}/activation_check", requestPath);
-			Assert.IsNull(callback.Request);
+			Assert.IsNull(request);
 
 			_clientMock.Verify(m => m.PutAsync<Identifier, object>($"/zones/{ZoneId}/activation_check", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();

test/Extensions/Cloudflare.Zones.Tests/ZonesExtensions/ZoneDetailsTest.cs

@@ -10,6 +10,8 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 	[TestClass]
 	public class ZoneDetailsTest
 	{
+		public TestContext TestContext { get; set; }
+
 		private const string ZoneId = "023e105f4ecef8ad9ca31a8372d0c353";
 
 		private Mock<ICloudflareClient> _clientMock;
@@ -92,18 +94,18 @@ namespace Cloudflare.Zones.Tests.ZonesExtensions
 			var client = GetClient();
 
 			// Act
-			var response = await client.ZoneDetails(ZoneId);
+			var response = await client.ZoneDetails(ZoneId, TestContext.CancellationTokenSource.Token);
 
 			// Assert
 			Assert.IsNotNull(response);
 			Assert.IsTrue(response.Success);
 			Assert.AreEqual(_response.Result, response.Result);
 
-			Assert.AreEqual(1, _callbacks.Count);
+			Assert.HasCount(1, _callbacks);
 
-			var callback = _callbacks.First();
+			var (requestPath, queryFilter) = _callbacks.First();
-			Assert.AreEqual($"/zones/{ZoneId}", callback.RequestPath);
+			Assert.AreEqual($"/zones/{ZoneId}", requestPath);
-			Assert.IsNull(callback.QueryFilter);
+			Assert.IsNull(queryFilter);
 
 			_clientMock.Verify(m => m.GetAsync<Zone>($"/zones/{ZoneId}", null, It.IsAny<CancellationToken>()), Times.Once);
 			_clientMock.VerifyNoOtherCalls();