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

Moving folder structure

Browse Source
This commit is contained in:
Andreas Müller
2025-07-10 10:12:50 +02:00
parent 450aa5f1c9
commit 29f6c4ae81
172 changed files with 109 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
test/Cloudflare.Tests/Auth/ApiKeyAuthenticationTest.cs Normal file
View File

@@ -0,0 +1,79 @@
using System.Linq;
using System.Net.Http;
using AMWD.Net.Api.Cloudflare;
namespace Cloudflare.Core.Tests.Auth
{
[TestClass]
public class ApiKeyAuthenticationTest
{
[TestMethod]
public void ShouldAddHeaders()
{
// Arrange
string emailAddress = "test@example.com";
string apiKey = "some-api-key";
var auth = new ApiKeyAuthentication(emailAddress, apiKey);
using var clt = new HttpClient();
// Act
auth.AddHeader(clt);
// Assert
Assert.IsTrue(clt.DefaultRequestHeaders.Contains("X-Auth-Email"));
Assert.IsTrue(clt.DefaultRequestHeaders.Contains("X-Auth-Key"));
Assert.AreEqual(emailAddress, clt.DefaultRequestHeaders.GetValues("X-Auth-Email").First());
Assert.AreEqual(apiKey, clt.DefaultRequestHeaders.GetValues("X-Auth-Key").First());
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldArgumentNullExceptionForEmailAddress(string emailAddress)
{
// Arrange
string apiKey = "some-api-key";
// Act
new ApiKeyAuthentication(emailAddress, apiKey);
// Assert - ArgumentNullException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldArgumentNullExceptionForApiKey(string apiKey)
{
// Arrange
string emailAddress = "test@example.com";
// Act
new ApiKeyAuthentication(emailAddress, apiKey);
// Assert - ArgumentNullException
}
[DataTestMethod]
[DataRow("test")]
[DataRow("test@example")]
[DataRow("example.com")]
[ExpectedException(typeof(ArgumentException))]
public void ShouldArgumentExceptionForInvalidEmailAddress(string emailAddress)
{
// Arrange
string apiKey = "some-api-key";
// Act
new ApiKeyAuthentication(emailAddress, apiKey);
// Assert - ArgumentException
}
}
}

43
test/Cloudflare.Tests/Auth/ApiTokenAuthenticationTest.cs Normal file
View File

@@ -0,0 +1,43 @@
using System.Net.Http;
using AMWD.Net.Api.Cloudflare;
namespace Cloudflare.Core.Tests.Auth
{
[TestClass]
public class ApiTokenAuthenticationTest
{
[TestMethod]
public void ShouldAddHeader()
{
// Arrange
string apiToken = "some-api-token";
var auth = new ApiTokenAuthentication(apiToken);
using var clt = new HttpClient();
// Act
auth.AddHeader(clt);
// Assert
Assert.IsTrue(clt.DefaultRequestHeaders.Contains("Authorization"));
Assert.AreEqual("Bearer", clt.DefaultRequestHeaders.Authorization.Scheme);
Assert.AreEqual(apiToken, clt.DefaultRequestHeaders.Authorization.Parameter);
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldArgumentNullExceptionForEmailAddress(string apiToken)
{
// Arrange
// Act
new ApiTokenAuthentication(apiToken);
// Assert - ArgumentNullException
}
}
}

7
test/Cloudflare.Tests/Cloudflare.Tests.csproj Normal file
View File

@@ -0,0 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
</Project>

248
test/Cloudflare.Tests/CloudflareClientTest.cs Normal file
View File

@@ -0,0 +1,248 @@
using System.Linq;
using System.Net.Http;
using System.Reflection;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests
{
[TestClass]
public class CloudflareClientTest
{
private Mock<HttpMessageHandler> _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new Mock<HttpMessageHandler>();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_clientOptionsMock.Setup(o => o.BaseUrl).Returns("http://localhost/api/v4/");
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
}
[TestMethod]
public void ShouldInitializeWithEmailAndKey()
{
// Arrange
string email = "test@example.com";
string apiKey = "some-api-key";
// Act
using var client = new CloudflareClient(email, apiKey);
// Assert
var httpClient = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(client) as HttpClient;
Assert.IsNotNull(httpClient);
Assert.AreEqual(email, httpClient.DefaultRequestHeaders.GetValues("X-Auth-Email").First());
Assert.AreEqual(apiKey, httpClient.DefaultRequestHeaders.GetValues("X-Auth-Key").First());
VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldInitializeWithApiToken()
{
// Arrange
string token = "some-special-api-token";
// Act
using var client = new CloudflareClient(token);
// Assert
var httpClient = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(client) as HttpClient;
Assert.IsNotNull(httpClient);
Assert.AreEqual($"Bearer {token}", httpClient.DefaultRequestHeaders.GetValues("Authorization").First());
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullOnMissingAuthentication()
{
// Arrange
// Act
using var client = new CloudflareClient((IAuthentication)null);
// Assert - ArgumentNullException
}
[TestMethod]
public void ShouldAddCustomDefaultHeaders()
{
// Arrange
var clientOptions = new ClientOptions();
clientOptions.DefaultHeaders.Add("SomeKey", "SomeValue");
// Act
using var client = new CloudflareClient("token", clientOptions);
// Assert
var httpClient = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(client) as HttpClient;
Assert.IsNotNull(httpClient);
Assert.IsTrue(httpClient.DefaultRequestHeaders.Contains("SomeKey"));
Assert.AreEqual("SomeValue", httpClient.DefaultRequestHeaders.GetValues("SomeKey").First());
VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldDisposeHttpClient()
{
// Arrange
var client = GetClient();
// Act
client.Dispose();
// Assert
_httpHandlerMock.Protected().Verify("Dispose", Times.Once(), exactParameterMatch: true, true);
VerifyDefault();
VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldAllowMultipleDispose()
{
// Arrange
var client = GetClient();
// Act
client.Dispose();
client.Dispose();
// Assert
_httpHandlerMock.Protected().Verify("Dispose", Times.Once(), exactParameterMatch: true, true);
VerifyDefault();
VerifyNoOtherCalls();
}
[TestMethod]
public void ShouldAssertClientOptions()
{
// Arrange + Act
var client = GetClient();
// Assert
VerifyDefault();
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullForBaseUrlOnAssertClientOptions()
{
// Arrange
_clientOptionsMock
.Setup(o => o.BaseUrl)
.Returns((string)null);
// Act
var client = GetClient();
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeForTimeoutOnAssertClientOptions()
{
// Arrange
_clientOptionsMock
.Setup(o => o.Timeout)
.Returns(TimeSpan.Zero);
// Act
var client = GetClient();
// Assert - ArgumentOutOfRangeException
}
[DataTestMethod]
[DataRow(-1)]
[DataRow(11)]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void ShouldThrowArgumentOutOfRangeForMaxRetriesOnAssertClientOptions(int maxRetries)
{
// Arrange
_clientOptionsMock
.Setup(o => o.MaxRetries)
.Returns(maxRetries);
// Act
var client = GetClient();
// Assert - ArgumentOutOfRangeException
}
[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullForUseProxyOnAssertClientOptions()
{
// Arrange
_clientOptionsMock
.Setup(o => o.UseProxy)
.Returns(true);
// Act
var client = GetClient();
// Assert - ArgumentNullException
}
private void VerifyDefault()
{
_clientOptionsMock.VerifyGet(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.VerifyGet(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.VerifyGet(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.VerifyGet(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.VerifyGet(o => o.Proxy, Times.Once);
_clientOptionsMock.VerifyGet(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.VerifyGet(o => o.UseProxy, Times.Exactly(2));
_authenticationMock.Verify(a => a.AddHeader(It.IsAny<HttpClient>()), Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
}
private CloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Object);
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
}
}

315
test/Cloudflare.Tests/CloudflareClientTests/DeleteAsyncTest.cs Normal file
View File

@@ -0,0 +1,315 @@
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Security.Authentication;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests.CloudflareClientTests
{
[TestClass]
public class DeleteAsyncTest
{
private const string BaseUrl = "http://localhost/api/v4/";
private HttpMessageHandlerMock _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new HttpMessageHandlerMock();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_authenticationMock
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Some-API-Token"));
_clientOptionsMock.Setup(o => o.BaseUrl).Returns(BaseUrl);
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposed()
{
// Arrange
var client = GetClient() as CloudflareClient;
client.Dispose();
// Act
await client.DeleteAsync<object>("test");
// Assert - ObjectDisposedException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
{
// Arrange
var client = GetClient();
// Act
await client.DeleteAsync<object>(path);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentOnRequestPath()
{
// Arrange
var client = GetClient();
// Act
await client.DeleteAsync<object>("foo?bar=baz");
// Assert - ArgumentException
}
[TestMethod]
public async Task ShouldDelete()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.DeleteAsync<TestClass>("test");
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent(@"{""success"": false, ""errors"": [{ ""code"": ""4711"", ""message"": ""foo & baz."" }, { ""code"": ""4712"", ""message"": ""Happy Error!"" }], ""messages"": []}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
try
{
// Act
await client.DeleteAsync<TestClass>("foo");
Assert.Fail();
}
catch (AuthenticationException ex)
{
// Assert
Assert.IsNull(ex.InnerException);
Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
}
}
[TestMethod]
public async Task ShouldReturnPlainText()
{
// Arrange
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string> { { "bar", "08/15" } });
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.DeleteAsync<string>("some-awesome-path");
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(JsonReaderException))]
public async Task ShouldThrowExceptionOnInvalidResponse()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is a bad text :p", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
await client.DeleteAsync<TestClass>("some-path");
}
private void VerifyDefaults()
{
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Once);
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.Mock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Mock.Object)
{
Timeout = _clientOptionsMock.Object.Timeout,
BaseAddress = new Uri(BaseUrl),
};
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AMWD.CloudflareClient", "1.0.0"));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (_clientOptionsMock.Object.DefaultHeaders.Count > 0)
{
foreach (var headerKvp in _clientOptionsMock.Object.DefaultHeaders)
httpClient.DefaultRequestHeaders.Add(headerKvp.Key, headerKvp.Value);
}
_authenticationMock.Object.AddHeader(httpClient);
_authenticationMock.Invocations.Clear();
_clientOptionsMock.Invocations.Clear();
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
private class TestClass
{
[JsonProperty("string")]
public string Str { get; set; }
[JsonProperty("integer")]
public int Int { get; set; }
}
private class TestFilter : IQueryParameterFilter
{
public IDictionary<string, string> GetQueryParameters()
{
return new Dictionary<string, string>
{
{ "test", "filter-text" }
};
}
}
}
}

355
test/Cloudflare.Tests/CloudflareClientTests/GetAsyncTest.cs Normal file
View File

@@ -0,0 +1,355 @@
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Security.Authentication;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests.CloudflareClientTests
{
[TestClass]
public class GetAsyncTest
{
private const string BaseUrl = "http://localhost/api/v4/";
private HttpMessageHandlerMock _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new HttpMessageHandlerMock();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_authenticationMock
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Some-API-Token"));
_clientOptionsMock.Setup(o => o.BaseUrl).Returns(BaseUrl);
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposed()
{
// Arrange
var client = GetClient() as CloudflareClient;
client.Dispose();
// Act
await client.GetAsync<object>("/test");
// Assert - ObjectDisposedException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
{
// Arrange
var client = GetClient();
// Act
await client.GetAsync<object>(path);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentOnRequestPath()
{
// Arrange
var client = GetClient();
// Act
await client.GetAsync<object>("/foo?bar=baz");
// Assert - ArgumentException
}
[TestMethod]
public async Task ShouldGet()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.GetAsync<TestClass>("test");
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent(@"{""success"": false, ""errors"": [{ ""code"": ""4711"", ""message"": ""foo & baz."" }, { ""code"": ""4712"", ""message"": ""Happy Error!"" }], ""messages"": []}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
try
{
// Act
await client.GetAsync<TestClass>("foo");
Assert.Fail();
}
catch (AuthenticationException ex)
{
// Assert
Assert.IsNull(ex.InnerException);
Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
}
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
[ExpectedException(typeof(CloudflareException))]
public async Task ShouldThrowCloudflareExceptionOnStatusCodeWhenDeserializeFails(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock?.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent("", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
await client.GetAsync<TestClass>("foo");
// Assert - CloudflareException
}
[TestMethod]
public async Task ShouldReturnPlainText()
{
// Arrange
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string> { { "bar", "08/15" } });
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.GetAsync<string>("some-awesome-path", new TestFilter());
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(JsonReaderException))]
public async Task ShouldThrowExceptionOnInvalidResponse()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is a bad text :p", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
await client.GetAsync<TestClass>("some-path");
}
[TestMethod]
[ExpectedException(typeof(CloudflareException))]
public async Task ShouldThrowCloudflareExceptionWhenDeserializeFails()
{
// Arrange
_httpHandlerMock?.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
await client.GetAsync<TestClass>("foo");
// Assert - CloudflareException
}
private void VerifyDefaults()
{
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Once);
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.Mock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Mock.Object)
{
Timeout = _clientOptionsMock.Object.Timeout,
BaseAddress = new Uri(BaseUrl),
};
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AMWD.CloudflareClient", "1.0.0"));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (_clientOptionsMock.Object.DefaultHeaders.Count > 0)
{
foreach (var headerKvp in _clientOptionsMock.Object.DefaultHeaders)
httpClient.DefaultRequestHeaders.Add(headerKvp.Key, headerKvp.Value);
}
_authenticationMock.Object.AddHeader(httpClient);
_authenticationMock.Invocations.Clear();
_clientOptionsMock.Invocations.Clear();
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
private class TestClass
{
[JsonProperty("string")]
public string Str { get; set; }
[JsonProperty("integer")]
public int Int { get; set; }
}
private class TestFilter : IQueryParameterFilter
{
public IDictionary<string, string> GetQueryParameters()
{
return new Dictionary<string, string>
{
{ "test", "filter-text" }
};
}
}
}
}

375
test/Cloudflare.Tests/CloudflareClientTests/PatchAsyncTest.cs Normal file
View File

@@ -0,0 +1,375 @@
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Security.Authentication;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests.CloudflareClientTests
{
[TestClass]
public class PatchAsyncTest
{
private const string BaseUrl = "https://localhost/api/v4/";
private HttpMessageHandlerMock _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
private TestClass _request;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new HttpMessageHandlerMock();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_authenticationMock
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Some-API-Token"));
_clientOptionsMock.Setup(o => o.BaseUrl).Returns(BaseUrl);
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
_request = new TestClass
{
Int = 54321,
Str = "Happy Testing!"
};
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposed()
{
// Arrange
var client = GetClient() as CloudflareClient;
client.Dispose();
// Act
await client.PatchAsync<object, object>("test", _request);
// Assert - ObjectDisposedException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
{
// Arrange
var client = GetClient();
// Act
await client.PatchAsync<object, object>(path, _request);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentOnRequestPath()
{
// Arrange
var client = GetClient();
// Act
await client.PatchAsync<object, object>("foo?bar=baz", _request);
// Assert - ArgumentException
}
[TestMethod]
public async Task ShouldPatch()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PatchAsync<TestClass, TestClass>("test", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPatchHttpContentDirectly()
{
// Arrange
var stringContent = new StringContent(@"{""test"":""HERE ?""}", Encoding.UTF8, "application/json");
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PatchAsync<TestClass, StringContent>("test", stringContent);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent(@"{""success"": false, ""errors"": [{ ""code"": ""4711"", ""message"": ""foo & baz."" }, { ""code"": ""4712"", ""message"": ""Happy Error!"" }], ""messages"": []}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
try
{
// Act
await client.PatchAsync<object, object>("foo", _request);
Assert.Fail();
}
catch (AuthenticationException ex)
{
// Assert
Assert.IsNull(ex.InnerException);
Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
}
}
[TestMethod]
public async Task ShouldReturnPlainText()
{
// Arrange
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string> { { "bar", "08/15" } });
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.PatchAsync<string, TestClass>("some-awesome-path", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(JsonReaderException))]
public async Task ShouldThrowExceptionOnInvalidResponse()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is a bad text :p", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
await client.PatchAsync<TestClass, TestClass>("some-path", _request);
}
private void VerifyDefaults()
{
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Once);
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.Mock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Mock.Object)
{
Timeout = _clientOptionsMock.Object.Timeout,
BaseAddress = new Uri(BaseUrl),
};
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AMWD.CloudflareClient", "1.0.0"));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (_clientOptionsMock.Object.DefaultHeaders.Count > 0)
{
foreach (var headerKvp in _clientOptionsMock.Object.DefaultHeaders)
httpClient.DefaultRequestHeaders.Add(headerKvp.Key, headerKvp.Value);
}
_authenticationMock.Object.AddHeader(httpClient);
_authenticationMock.Invocations.Clear();
_clientOptionsMock.Invocations.Clear();
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
private class TestClass
{
[JsonProperty("string")]
public string Str { get; set; }
[JsonProperty("integer")]
public int Int { get; set; }
}
private class TestFilter : IQueryParameterFilter
{
public IDictionary<string, string> GetQueryParameters()
{
return new Dictionary<string, string>
{
{ "test", "filter-text" }
};
}
}
}
}

472
test/Cloudflare.Tests/CloudflareClientTests/PostAsyncTest.cs Normal file
View File

@@ -0,0 +1,472 @@
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Security.Authentication;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests.CloudflareClientTests
{
[TestClass]
public class PostAsyncTest
{
private const string BaseUrl = "https://localhost/api/v4/";
private HttpMessageHandlerMock _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
private TestClass _request;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new HttpMessageHandlerMock();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_authenticationMock
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Some-API-Token"));
_clientOptionsMock.Setup(o => o.BaseUrl).Returns(BaseUrl);
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
_request = new TestClass
{
Int = 54321,
Str = "Happy Testing!"
};
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposed()
{
// Arrange
var client = GetClient() as CloudflareClient;
client.Dispose();
// Act
await client.PostAsync<object, object>("test", _request);
// Assert - ObjectDisposedException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
{
// Arrange
var client = GetClient();
// Act
await client.PostAsync<object, object>(path, _request);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentOnRequestPath()
{
// Arrange
var client = GetClient();
// Act
await client.PostAsync<object, object>("foo?bar=baz", _request);
// Assert - ArgumentException
}
[TestMethod]
public async Task ShouldPost()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PostAsync<TestClass, TestClass>("test", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPostHttpContentDirectly()
{
// Arrange
var stringContent = new StringContent(@"{""test"":""HERE ?""}", Encoding.UTF8, "application/json");
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PostAsync<TestClass, StringContent>("test", stringContent);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPostWithoutContent()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PostAsync<TestClass, object>("posting", null);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent(@"{""success"": false, ""errors"": [{ ""code"": ""4711"", ""message"": ""foo & baz."" }, { ""code"": ""4712"", ""message"": ""Happy Error!"" }], ""messages"": []}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
try
{
// Act
await client.PostAsync<object, object>("foo", _request);
Assert.Fail();
}
catch (AuthenticationException ex)
{
// Assert
Assert.IsNull(ex.InnerException);
Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
}
}
[TestMethod]
public async Task ShouldReturnPlainText()
{
// Arrange
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string> { { "bar", "08/15" } });
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.PostAsync<string, TestClass>("some-awesome-path", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(JsonReaderException))]
public async Task ShouldThrowExceptionOnInvalidResponse()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is a bad text :p", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
await client.PostAsync<TestClass, TestClass>("some-path", _request);
}
[TestMethod]
public async Task ShouldOnlySerializeNonNullValues()
{
// Arrange
_request.Str = null;
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.PostAsync<string, TestClass>("path", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
VerifyDefaults();
VerifyNoOtherCalls();
}
private void VerifyDefaults()
{
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Once);
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.Mock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Mock.Object)
{
Timeout = _clientOptionsMock.Object.Timeout,
BaseAddress = new Uri(BaseUrl),
};
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AMWD.CloudflareClient", "1.0.0"));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (_clientOptionsMock.Object.DefaultHeaders.Count > 0)
{
foreach (var headerKvp in _clientOptionsMock.Object.DefaultHeaders)
httpClient.DefaultRequestHeaders.Add(headerKvp.Key, headerKvp.Value);
}
_authenticationMock.Object.AddHeader(httpClient);
_authenticationMock.Invocations.Clear();
_clientOptionsMock.Invocations.Clear();
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
private class TestClass
{
[JsonProperty("string")]
public string Str { get; set; }
[JsonProperty("integer")]
public int Int { get; set; }
}
private class TestFilter : IQueryParameterFilter
{
public IDictionary<string, string> GetQueryParameters()
{
return new Dictionary<string, string>
{
{ "test", "filter-text" }
};
}
}
}
}

423
test/Cloudflare.Tests/CloudflareClientTests/PutAsyncTest.cs Normal file
View File

@@ -0,0 +1,423 @@
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Reflection;
using System.Security.Authentication;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AMWD.Net.Api.Cloudflare;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests.CloudflareClientTests
{
[TestClass]
public class PutAsyncTest
{
private const string BaseUrl = "https://localhost/api/v4/";
private HttpMessageHandlerMock _httpHandlerMock;
private Mock<ClientOptions> _clientOptionsMock;
private Mock<IAuthentication> _authenticationMock;
private TestClass _request;
[TestInitialize]
public void Initialize()
{
_httpHandlerMock = new HttpMessageHandlerMock();
_authenticationMock = new Mock<IAuthentication>();
_clientOptionsMock = new Mock<ClientOptions>();
_authenticationMock
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Some-API-Token"));
_clientOptionsMock.Setup(o => o.BaseUrl).Returns(BaseUrl);
_clientOptionsMock.Setup(o => o.Timeout).Returns(TimeSpan.FromSeconds(60));
_clientOptionsMock.Setup(o => o.MaxRetries).Returns(2);
_clientOptionsMock.Setup(o => o.DefaultHeaders).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string>());
_clientOptionsMock.Setup(o => o.AllowRedirects).Returns(false);
_clientOptionsMock.Setup(o => o.UseProxy).Returns(false);
_request = new TestClass
{
Int = 54321,
Str = "Happy Testing!"
};
}
[TestMethod]
[ExpectedException(typeof(ObjectDisposedException))]
public async Task ShouldThrowDisposed()
{
// Arrange
var client = GetClient() as CloudflareClient;
client.Dispose();
// Act
await client.PutAsync<object, object>("test", _request);
// Assert - ObjectDisposedException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
{
// Arrange
var client = GetClient();
// Act
await client.PutAsync<object, object>(path, _request);
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public async Task ShouldThrowArgumentOnRequestPath()
{
// Arrange
var client = GetClient();
// Act
await client.PutAsync<object, object>("foo?bar=baz", _request);
// Assert - ArgumentException
}
[TestMethod]
public async Task ShouldPut()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PutAsync<TestClass, TestClass>("test", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPutHttpContentDirectly()
{
// Arrange
var stringContent = new StringContent(@"{""test"":""HERE ?""}", Encoding.UTF8, "application/json");
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PutAsync<TestClass, StringContent>("test", stringContent);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
VerifyDefaults();
VerifyNoOtherCalls();
}
[TestMethod]
public async Task ShouldPutWithoutContent()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{""success"": true, ""errors"": [], ""messages"": [], ""result"": { ""string"": ""some-string"", ""integer"": 123 }}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
// Act
var response = await client.PutAsync<TestClass, object>("putput", null);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Errors);
Assert.IsNotNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual(0, response.Errors.Count);
Assert.AreEqual(0, response.Messages.Count);
Assert.IsNotNull(response.Result);
Assert.AreEqual("some-string", response.Result.Str);
Assert.AreEqual(123, response.Result.Int);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
}
[DataTestMethod]
[DataRow(HttpStatusCode.Unauthorized)]
[DataRow(HttpStatusCode.Forbidden)]
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = statusCode,
Content = new StringContent(@"{""success"": false, ""errors"": [{ ""code"": ""4711"", ""message"": ""foo & baz."" }, { ""code"": ""4712"", ""message"": ""Happy Error!"" }], ""messages"": []}", Encoding.UTF8, MediaTypeNames.Application.Json),
});
var client = GetClient();
try
{
// Act
await client.PutAsync<object, object>("foo", _request);
Assert.Fail();
}
catch (AuthenticationException ex)
{
// Assert
Assert.IsNull(ex.InnerException);
Assert.AreEqual($"4711: foo & baz.{Environment.NewLine}4712: Happy Error!", ex.Message);
}
}
[TestMethod]
public async Task ShouldReturnPlainText()
{
// Arrange
_clientOptionsMock.Setup(o => o.DefaultQueryParams).Returns(new Dictionary<string, string> { { "bar", "08/15" } });
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is an awesome text ;-)", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
var response = await client.PutAsync<string, TestClass>("some-awesome-path", _request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsNull(response.Errors);
Assert.IsNull(response.Messages);
Assert.IsNull(response.ResultInfo);
Assert.AreEqual("This is an awesome text ;-)", response.Result);
Assert.AreEqual(1, _httpHandlerMock.Callbacks.Count);
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.IsTrue(callback.Headers.ContainsKey("Accept"));
Assert.IsTrue(callback.Headers.ContainsKey("Authorization"));
Assert.IsTrue(callback.Headers.ContainsKey("User-Agent"));
Assert.AreEqual("application/json", callback.Headers["Accept"]);
Assert.AreEqual("Bearer Some-API-Token", callback.Headers["Authorization"]);
Assert.AreEqual("AMWD.CloudflareClient/1.0.0", callback.Headers["User-Agent"]);
_httpHandlerMock.Mock.Protected().Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
VerifyNoOtherCalls();
}
[TestMethod]
[ExpectedException(typeof(JsonReaderException))]
public async Task ShouldThrowExceptionOnInvalidResponse()
{
// Arrange
_httpHandlerMock.Responses.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("This is a bad text :p", Encoding.UTF8, MediaTypeNames.Text.Plain),
});
var client = GetClient();
// Act
await client.PutAsync<TestClass, TestClass>("some-path", _request);
}
private void VerifyDefaults()
{
_authenticationMock.Verify(m => m.AddHeader(It.IsAny<HttpClient>()), Times.Once);
_clientOptionsMock.Verify(o => o.BaseUrl, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Timeout, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.MaxRetries, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.DefaultHeaders, Times.Once);
_clientOptionsMock.Verify(o => o.DefaultQueryParams, Times.Once);
_clientOptionsMock.Verify(o => o.AllowRedirects, Times.Once);
_clientOptionsMock.Verify(o => o.UseProxy, Times.Exactly(2));
_clientOptionsMock.Verify(o => o.Proxy, Times.Once);
}
private void VerifyNoOtherCalls()
{
_httpHandlerMock.Mock.VerifyNoOtherCalls();
_authenticationMock.VerifyNoOtherCalls();
_clientOptionsMock.VerifyNoOtherCalls();
}
private ICloudflareClient GetClient()
{
var httpClient = new HttpClient(_httpHandlerMock.Mock.Object)
{
Timeout = _clientOptionsMock.Object.Timeout,
BaseAddress = new Uri(BaseUrl),
};
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("AMWD.CloudflareClient", "1.0.0"));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (_clientOptionsMock.Object.DefaultHeaders.Count > 0)
{
foreach (var headerKvp in _clientOptionsMock.Object.DefaultHeaders)
httpClient.DefaultRequestHeaders.Add(headerKvp.Key, headerKvp.Value);
}
_authenticationMock.Object.AddHeader(httpClient);
_authenticationMock.Invocations.Clear();
_clientOptionsMock.Invocations.Clear();
var client = new CloudflareClient(_authenticationMock.Object, _clientOptionsMock.Object);
var httpClientField = client.GetType()
.GetField("_httpClient", BindingFlags.NonPublic | BindingFlags.Instance);
(httpClientField.GetValue(client) as HttpClient).Dispose();
httpClientField.SetValue(client, httpClient);
return client;
}
private class TestClass
{
[JsonProperty("string")]
public string Str { get; set; }
[JsonProperty("integer")]
public int Int { get; set; }
}
private class TestFilter : IQueryParameterFilter
{
public IDictionary<string, string> GetQueryParameters()
{
return new Dictionary<string, string>
{
{ "test", "filter-text" }
};
}
}
}
}

64
test/Cloudflare.Tests/Extensions/EnumExtensionsTest.cs Normal file
View File

@@ -0,0 +1,64 @@
using System.Runtime.Serialization;
using AMWD.Net.Api.Cloudflare;
namespace Cloudflare.Core.Tests.Extensions
{
[TestClass]
public class EnumExtensionsTest
{
[TestMethod]
public void ShouldReturnEnumMemberValue()
{
// Arrange
var enumValue = EnumWithAttribute.One;
// Act
string val = enumValue.GetEnumMemberValue();
// Assert
Assert.AreEqual("eins", val);
}
[TestMethod]
public void ShouldReturnStringMissingAttribute()
{
// Arrange
var enumValue = EnumWithoutAttribute.Two;
// Act
string val = enumValue.GetEnumMemberValue();
// Assert
Assert.AreEqual("Two", val);
}
[TestMethod]
public void ShouldReturnString()
{
// Arrange
EnumWithAttribute enumValue = 0;
// Act
string val = enumValue.GetEnumMemberValue();
// Assert
Assert.AreEqual("0", val);
}
public enum EnumWithAttribute
{
[EnumMember(Value = "eins")]
One = 1,
[EnumMember(Value = "zwei")]
Two = 2,
}
public enum EnumWithoutAttribute
{
One = 1,
Two = 2,
}
}
}

172
test/Cloudflare.Tests/Extensions/StringExtensionsTest.cs Normal file
View File

@@ -0,0 +1,172 @@
using System;
using AMWD.Net.Api.Cloudflare;
namespace Cloudflare.Tests.Extensions
{
[TestClass]
public class StringExtensionsTest
{
[TestMethod]
public void ShouldValidateId()
{
// Arrange
string id = "023e105f4ecef8ad9ca31a8372d0c353";
// Act
id.ValidateCloudflareId();
// Assert - no exception thrown
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForValidateId(string name)
{
// Arrange
// Act
name.ValidateCloudflareId();
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOutOfRangeExceptionForValidateId()
{
// Arrange
string id = new('a', 33);
// Act
id.ValidateCloudflareId();
// Assert - ArgumentException
}
[DataTestMethod]
[DataRow("023e105f4ecef8ad9ca31a8372d0c35")]
[DataRow("023e105f4ecef8ad9ca31a8372d0C353")]
[DataRow("023e105f4ecef8ad9ca31a8372d0y353")]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForValidateId(string id)
{
// Arrange
// Act
id.ValidateCloudflareId();
// Assert - ArgumentException
}
[TestMethod]
public void ShouldValidateName()
{
// Arrange
string name = "Example Account Name";
// Act
name.ValidateCloudflareName();
// Assert - no exception thrown
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForValidateName(string name)
{
// Arrange
// Act
name.ValidateCloudflareName();
// Assert - ArgumentNullException
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentOutOfRangeExceptionForValidateName()
{
// Arrange
string name = new('a', 254);
// Act
name.ValidateCloudflareName();
// Assert - ArgumentException
}
[TestMethod]
public void ShouldValidateEmail()
{
// Arrange
string email = "test@example.com";
// Act
email.ValidateCloudflareEmailAddress();
// Assert - no exception thrown
}
[DataTestMethod]
[DataRow(null)]
[DataRow("")]
[DataRow(" ")]
[ExpectedException(typeof(ArgumentNullException))]
public void ShouldThrowArgumentNullExceptionForValidateEmail(string email)
{
// Arrange
// Act
email.ValidateCloudflareEmailAddress();
// Assert - ArgumentNullException
}
[DataTestMethod]
[DataRow("test")]
[DataRow("test@example")]
[DataRow("example.com")]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForValidateEmail(string email)
{
// Arrange
// Act
email.ValidateCloudflareEmailAddress();
// Assert - ArgumentException
}
[DataTestMethod]
[DataRow(null)]
[DataRow("SomeExampleString")]
public void ShouldValidateLength(string str)
{
// Arrange
// Act
str.ValidateLength(30, nameof(str));
// Assert - no exception thrown
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void ShouldThrowArgumentExceptionForValidateLength()
{
// Arrange
string str = "SomeExampleString";
// Act
str.ValidateLength(10, nameof(str));
// Assert - ArgumentException
}
}
}

52
test/Cloudflare.Tests/MessageHandlerMock.cs Normal file
View File

@@ -0,0 +1,52 @@
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Moq;
using Moq.Protected;
namespace Cloudflare.Core.Tests
{
internal class HttpMessageHandlerMock
{
public HttpMessageHandlerMock()
{
Mock = new();
Mock.Protected()
.Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
.Callback<HttpRequestMessage, CancellationToken>(async (request, ct) =>
{
var callback = new HttpMessageRequestCallback
{
Method = request.Method,
Url = request.RequestUri.ToString(),
Headers = request.Headers.ToDictionary(h => h.Key, h => h.Value.First()),
};
if (request.Content != null)
callback.Content = await request.Content.ReadAsStringAsync();
Callbacks.Add(callback);
})
.ReturnsAsync(() => Responses.Dequeue());
}
public List<HttpMessageRequestCallback> Callbacks { get; } = [];
public Queue<HttpResponseMessage> Responses { get; } = new();
public Mock<HttpClientHandler> Mock { get; }
}
internal class HttpMessageRequestCallback
{
public HttpMethod Method { get; set; }
public string Url { get; set; }
public Dictionary<string, string> Headers { get; set; }
public string Content { get; set; }
}
}