Andreas Müller
79567c730c
All checks were successful
Branch Build / build-test-deploy (push) Successful in 44s
654 lines
21 KiB
C#
654 lines
21 KiB
C#
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Security.Authentication;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using AMWD.Net.Api.LinkMobility;
|
|
using LinkMobility.Tests.Helpers;
|
|
using Moq.Protected;
|
|
|
|
namespace LinkMobility.Tests
|
|
{
|
|
[TestClass]
|
|
public class LinkMobilityClientTest
|
|
{
|
|
public TestContext TestContext { get; set; }
|
|
|
|
private const string BASE_URL = "https://localhost/rest/";
|
|
|
|
private Mock<IAuthentication> _authenticationMock;
|
|
private Mock<ClientOptions> _clientOptionsMock;
|
|
private HttpMessageHandlerMock _httpMessageHandlerMock;
|
|
|
|
private TestClass _request;
|
|
|
|
[TestInitialize]
|
|
public void Initialize()
|
|
{
|
|
_authenticationMock = new Mock<IAuthentication>();
|
|
_clientOptionsMock = new Mock<ClientOptions>();
|
|
_httpMessageHandlerMock = new HttpMessageHandlerMock();
|
|
|
|
_authenticationMock
|
|
.Setup(a => a.AddHeader(It.IsAny<HttpClient>()))
|
|
.Callback<HttpClient>(c => c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Scheme", "Parameter"));
|
|
|
|
_clientOptionsMock.Setup(c => c.BaseUrl).Returns(BASE_URL);
|
|
_clientOptionsMock.Setup(c => c.Timeout).Returns(TimeSpan.FromSeconds(30));
|
|
_clientOptionsMock.Setup(c => c.DefaultHeaders).Returns(new Dictionary<string, string>());
|
|
_clientOptionsMock.Setup(c => c.DefaultQueryParams).Returns(new Dictionary<string, string>());
|
|
_clientOptionsMock.Setup(c => c.AllowRedirects).Returns(true);
|
|
_clientOptionsMock.Setup(c => c.UseProxy).Returns(false);
|
|
|
|
_request = new()
|
|
{
|
|
Str = "Happy Testing",
|
|
Int = 54321
|
|
};
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldInitializeWithBasicAuth()
|
|
{
|
|
// Arrange
|
|
string username = "user";
|
|
string password = "pass";
|
|
string expectedParameter = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{username}:{password}"));
|
|
|
|
// Act
|
|
using var client = new LinkMobilityClient(username, password);
|
|
|
|
// Assert
|
|
var httpClient = ReflectionHelper.GetPrivateField<HttpClient>(client, "_httpClient");
|
|
|
|
Assert.IsNotNull(httpClient);
|
|
Assert.IsNotNull(httpClient.DefaultRequestHeaders.Authorization);
|
|
Assert.AreEqual("Basic", httpClient.DefaultRequestHeaders.Authorization.Scheme);
|
|
Assert.AreEqual(expectedParameter, httpClient.DefaultRequestHeaders.Authorization.Parameter);
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldInitializeWithBearerAuth()
|
|
{
|
|
// Arrange
|
|
string token = "test_token";
|
|
|
|
// Act
|
|
using var client = new LinkMobilityClient(token);
|
|
|
|
// Assert
|
|
var httpClient = ReflectionHelper.GetPrivateField<HttpClient>(client, "_httpClient");
|
|
|
|
Assert.IsNotNull(httpClient);
|
|
Assert.IsNotNull(httpClient.DefaultRequestHeaders.Authorization);
|
|
Assert.AreEqual("Bearer", httpClient.DefaultRequestHeaders.Authorization.Scheme);
|
|
Assert.AreEqual(token, httpClient.DefaultRequestHeaders.Authorization.Parameter);
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldThrowOnNullAuthentication()
|
|
{
|
|
// Arrange
|
|
|
|
// Act & Assert
|
|
var ex = Assert.ThrowsExactly<ArgumentNullException>(() => new LinkMobilityClient((IAuthentication)null));
|
|
|
|
Assert.AreEqual("authentication", ex.ParamName);
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldAddCustomDefaultHeaders()
|
|
{
|
|
// Arrange
|
|
var clientOptions = new ClientOptions();
|
|
clientOptions.DefaultHeaders.Add("SomeKey", "SomeValue");
|
|
|
|
// Act
|
|
using var client = new LinkMobilityClient("token", clientOptions);
|
|
|
|
// Assert
|
|
var httpClient = ReflectionHelper.GetPrivateField<HttpClient>(client, "_httpClient");
|
|
|
|
Assert.IsNotNull(httpClient);
|
|
Assert.IsTrue(httpClient.DefaultRequestHeaders.Contains("SomeKey"));
|
|
Assert.AreEqual("SomeValue", httpClient.DefaultRequestHeaders.GetValues("SomeKey").First());
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldAddDefaultQueryParameters()
|
|
{
|
|
// Arrange
|
|
_clientOptionsMock
|
|
.Setup(o => o.DefaultQueryParams)
|
|
.Returns(new Dictionary<string, string>
|
|
{
|
|
{ "SomeKey", "Some Value" },
|
|
{ "key2", "param2" }
|
|
});
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent(@"{ ""string"": ""some-string"", ""integer"": 123 }", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
var response = await client.PostAsync<TestClass, TestClass>("test", _request, null, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/test?SomeKey=Some+Value&key2=param2", callback.Url);
|
|
Assert.AreEqual(@"{""string"":""Happy Testing"",""integer"":54321}", callback.Content);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
|
|
_clientOptionsMock.VerifyGet(o => o.DefaultQueryParams, Times.Exactly(2));
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldAddCustomQueryParameters()
|
|
{
|
|
// Arrange
|
|
var queryParams = new TestParams();
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent(@"{ ""string"": ""some-string"", ""integer"": 123 }", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
var response = await client.PostAsync<TestClass, TestClass>("params/path", _request, queryParams, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/params/path?test=query+text", callback.Url);
|
|
Assert.AreEqual(@"{""string"":""Happy Testing"",""integer"":54321}", callback.Content);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
|
|
_clientOptionsMock.VerifyGet(o => o.DefaultQueryParams, Times.Once);
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldDisposeHttpClient()
|
|
{
|
|
// Arrange
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
client.Dispose();
|
|
|
|
// Assert
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("Dispose", Times.Once(), exactParameterMatch: true, true);
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldAllowMultipleDispose()
|
|
{
|
|
// Arrange
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
client.Dispose();
|
|
client.Dispose();
|
|
|
|
// Assert
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("Dispose", Times.Once(), exactParameterMatch: true, true);
|
|
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldAssertClientOptions()
|
|
{
|
|
// Arrange + Act
|
|
_ = GetClient();
|
|
|
|
// Assert
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(null)]
|
|
[DataRow("")]
|
|
[DataRow(" ")]
|
|
public void ShouldThrowArgumentNullForBaseUrlOnAssertClientOptions(string baseUrl)
|
|
{
|
|
// Arrange
|
|
_clientOptionsMock
|
|
.Setup(o => o.BaseUrl)
|
|
.Returns(baseUrl);
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsExactly<ArgumentNullException>(() =>
|
|
{
|
|
var client = GetClient();
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldThrowArgumentOutOfRangeForTimeoutOnAssertClientOptions()
|
|
{
|
|
// Arrange
|
|
_clientOptionsMock
|
|
.Setup(o => o.Timeout)
|
|
.Returns(TimeSpan.Zero);
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsExactly<ArgumentOutOfRangeException>(() =>
|
|
{
|
|
var client = GetClient();
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ShouldThrowArgumentNullForUseProxyOnAssertClientOptions()
|
|
{
|
|
// Arrange
|
|
_clientOptionsMock
|
|
.Setup(o => o.UseProxy)
|
|
.Returns(true);
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsExactly<ArgumentNullException>(() =>
|
|
{
|
|
var client = GetClient();
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldThrowDisposed()
|
|
{
|
|
// Arrange
|
|
var client = GetClient();
|
|
client.Dispose();
|
|
|
|
// Act & Assert
|
|
await Assert.ThrowsExactlyAsync<ObjectDisposedException>(async () =>
|
|
{
|
|
await client.PostAsync<object, TestClass>("/request/path", _request, null, TestContext.CancellationToken);
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(null)]
|
|
[DataRow("")]
|
|
[DataRow(" ")]
|
|
public async Task ShouldThrowArgumentNullOnRequestPath(string path)
|
|
{
|
|
// Arrange
|
|
var client = GetClient();
|
|
|
|
// Act & Assert
|
|
await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () =>
|
|
{
|
|
await client.PostAsync<object, TestClass>(path, _request, null, TestContext.CancellationToken);
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldThrowArgumentOnRequestPath()
|
|
{
|
|
// Arrange
|
|
var client = GetClient();
|
|
|
|
// Act & Assert
|
|
await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
|
|
{
|
|
await client.PostAsync<object, TestClass>("foo?bar=baz", _request, null, TestContext.CancellationToken);
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldPost()
|
|
{
|
|
// Arrange
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent(@"{ ""string"": ""some-string"", ""integer"": 123 }", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
var response = await client.PostAsync<TestClass, TestClass>("/request/path", _request, null, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
Assert.AreEqual("some-string", response.Str);
|
|
Assert.AreEqual(123, response.Int);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/request/path", callback.Url);
|
|
Assert.AreEqual(@"{""string"":""Happy Testing"",""integer"":54321}", callback.Content);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
|
|
_clientOptionsMock.VerifyGet(o => o.DefaultQueryParams, Times.Once);
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldPostHttpContentDirectly()
|
|
{
|
|
// Arrange
|
|
var stringContent = new StringContent(@"{""test"":""HERE ?""}", Encoding.UTF8, "application/json");
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent(@"{ ""string"": ""some-string"", ""integer"": 123 }", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
var response = await client.PostAsync<TestClass, HttpContent>("/request/path", stringContent, null, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
Assert.AreEqual("some-string", response.Str);
|
|
Assert.AreEqual(123, response.Int);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/request/path", callback.Url);
|
|
Assert.AreEqual(@"{""test"":""HERE ?""}", callback.Content);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
|
|
_clientOptionsMock.VerifyGet(o => o.DefaultQueryParams, Times.Once);
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldPostWithoutContent()
|
|
{
|
|
// Arrange
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent(@"{ ""string"": ""some-string"", ""integer"": 123 }", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
var response = await client.PostAsync<TestClass, object>("posting", null, null, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
Assert.AreEqual("some-string", response.Str);
|
|
Assert.AreEqual(123, response.Int);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/posting", callback.Url);
|
|
Assert.IsNull(callback.Content);
|
|
Assert.IsNull(callback.ContentRaw);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(HttpStatusCode.Unauthorized)]
|
|
[DataRow(HttpStatusCode.Forbidden)]
|
|
public async Task ShouldThrowAuthenticationExceptionOnStatusCode(HttpStatusCode statusCode)
|
|
{
|
|
// Arrange
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = statusCode,
|
|
Content = new StringContent(@"", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act & Assert
|
|
var ex = await Assert.ThrowsExactlyAsync<AuthenticationException>(async () =>
|
|
{
|
|
await client.PostAsync<object, TestClass>("foo", _request, null, TestContext.CancellationToken);
|
|
});
|
|
Assert.IsNull(ex.InnerException);
|
|
Assert.AreEqual($"HTTP auth missing: {statusCode}", ex.Message);
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow(HttpStatusCode.NotFound)]
|
|
[DataRow(HttpStatusCode.InternalServerError)]
|
|
public async Task ShouldThrowApplicationExceptionOnStatusCode(HttpStatusCode statusCode)
|
|
{
|
|
// Arrange
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = statusCode,
|
|
Content = new StringContent(@"", Encoding.UTF8, "application/json"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act & Assert
|
|
var ex = await Assert.ThrowsExactlyAsync<ApplicationException>(async () =>
|
|
{
|
|
await client.PostAsync<object, TestClass>("foo", _request, null, TestContext.CancellationToken);
|
|
});
|
|
Assert.IsNull(ex.InnerException);
|
|
Assert.AreEqual($"Unknown HTTP response: {statusCode}", ex.Message);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldThrowExceptionOnInvalidResponse()
|
|
{
|
|
// Arrange
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent("This is a bad text :p", Encoding.UTF8, "text/plain"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act & Assert
|
|
await Assert.ThrowsExactlyAsync<JsonReaderException>(async () =>
|
|
{
|
|
await client.PostAsync<TestClass, TestClass>("some-path", _request, null, TestContext.CancellationToken);
|
|
});
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ShouldOnlySerializeNonNullValues()
|
|
{
|
|
// Arrange
|
|
_request.Str = null;
|
|
_httpMessageHandlerMock.Responses.Enqueue(new HttpResponseMessage
|
|
{
|
|
StatusCode = HttpStatusCode.OK,
|
|
Content = new StringContent("\"This is an awesome text ;-)\"", Encoding.UTF8, "text/plain"),
|
|
});
|
|
|
|
var client = GetClient();
|
|
|
|
// Act
|
|
string response = await client.PostAsync<string, TestClass>("path", _request, null, TestContext.CancellationToken);
|
|
|
|
// Assert
|
|
Assert.IsNotNull(response);
|
|
|
|
Assert.AreEqual("This is an awesome text ;-)", response);
|
|
|
|
Assert.HasCount(1, _httpMessageHandlerMock.RequestCallbacks);
|
|
|
|
var callback = _httpMessageHandlerMock.RequestCallbacks.First();
|
|
Assert.AreEqual(HttpMethod.Post, callback.HttpMethod);
|
|
Assert.AreEqual("https://localhost/rest/path", callback.Url);
|
|
Assert.AreEqual(@"{""integer"":54321}", callback.Content);
|
|
|
|
Assert.HasCount(3, callback.Headers);
|
|
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("Scheme Parameter", callback.Headers["Authorization"]);
|
|
Assert.AreEqual("LinkMobilityClient/1.0.0", callback.Headers["User-Agent"]);
|
|
|
|
_httpMessageHandlerMock.Mock
|
|
.Protected()
|
|
.Verify("SendAsync", Times.Once(), ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>());
|
|
|
|
_clientOptionsMock.VerifyGet(o => o.DefaultQueryParams, Times.Once);
|
|
VerifyNoOtherCalls();
|
|
}
|
|
|
|
private void VerifyNoOtherCalls()
|
|
{
|
|
_authenticationMock.VerifyNoOtherCalls();
|
|
_clientOptionsMock.VerifyNoOtherCalls();
|
|
_httpMessageHandlerMock.Mock.VerifyNoOtherCalls();
|
|
}
|
|
|
|
private LinkMobilityClient GetClient()
|
|
{
|
|
var client = new LinkMobilityClient(_authenticationMock.Object, _clientOptionsMock.Object);
|
|
|
|
var httpClient = new HttpClient(_httpMessageHandlerMock.Mock.Object)
|
|
{
|
|
Timeout = _clientOptionsMock.Object.Timeout,
|
|
BaseAddress = new Uri(_clientOptionsMock.Object.BaseUrl)
|
|
};
|
|
|
|
httpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("LinkMobilityClient", "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();
|
|
|
|
ReflectionHelper.GetPrivateField<HttpClient>(client, "_httpClient")?.Dispose();
|
|
ReflectionHelper.SetPrivateField(client, "_httpClient", httpClient);
|
|
|
|
return client;
|
|
}
|
|
|
|
private class TestClass
|
|
{
|
|
[JsonProperty("string")]
|
|
public string Str { get; set; }
|
|
|
|
[JsonProperty("integer")]
|
|
public int Int { get; set; }
|
|
}
|
|
|
|
private class TestParams : IQueryParameter
|
|
{
|
|
public IReadOnlyDictionary<string, string> GetQueryParameters()
|
|
{
|
|
return new Dictionary<string, string>
|
|
{
|
|
{ "test", "query text" }
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|