OpenAPIGenerator upgrade to v7.16.0 - [1] Added /Core classes and tests

Adyen.IntegrationTest/Adyen.IntegrationTest.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net8.0;net6.0</TargetFrameworks>
+        <TargetFramework>net8.0</TargetFramework>
         <LangVersion>12</LangVersion>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>disable</Nullable>

Adyen.Test/Adyen.Test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net6.0</TargetFrameworks>
+    <TargetFramework>net8.0</TargetFramework>
     <LangVersion>12</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>disable</Nullable>

Adyen.Test/Core/Auth/TokenProviderTest.cs

@@ -0,0 +1,49 @@
+using Adyen.Core.Auth;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Adyen.Test.Core.Auth
+{
+    [TestClass]
+    public class TokenProviderTest
+    {
+        internal sealed class TestToken : TokenBase
+        {
+            public string Value { get; }
+
+            internal TestToken(string value)
+            {
+                Value = value;
+            }
+        }
+
+        [TestMethod]
+        public async Task Given_TokenProviderWithToken_When_GetCalled_Then_SameInstanceAndValueAreReturned()
+        {
+            // Arrange
+            var token = new TestToken("apikey");
+            var provider = new TokenProvider<TestToken>(token);
+
+            // Act
+            var result = provider.Get();
+
+            // Assert
+            Assert.AreSame(token, result);
+            Assert.AreEqual("apikey", result.Value);
+        }
+
+        [TestMethod]
+        public async Task Given_TokenProvider_When_GetCalledMultipleTimes_Then_SameInstanceReturnedEachTime()
+        {
+            // Arrange
+            var token = new TestToken("apikey");
+            var provider = new TokenProvider<TestToken>(token);
+
+            // Act
+            var first = provider.Get();
+            var second = provider.Get();
+
+            // Assert
+            Assert.AreSame(first, second);
+        }
+    }
+}

Adyen.Test/Core/Client/ApiResponseTest.cs

@@ -0,0 +1,173 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Adyen.Core.Client;
+
+namespace Adyen.Test.Core.Client
+{
+    [TestClass]
+    public class ApiResponseTests
+    {
+        private HttpRequestMessage CreateRequest(string? uri = "https://adyen.com")
+            => new HttpRequestMessage(HttpMethod.Get, uri);
+
+        private HttpResponseMessage CreateResponse(HttpStatusCode statusCode, string reasonPhrase = "")
+            => new HttpResponseMessage(statusCode)
+            {
+                ReasonPhrase = reasonPhrase
+            };
+
+        [TestMethod]
+        [DataRow(HttpStatusCode.OK, true)]
+        [DataRow(HttpStatusCode.Created, true)]
+        [DataRow(HttpStatusCode.Accepted, true)]
+        [DataRow(HttpStatusCode.BadRequest, false)]
+        [DataRow(HttpStatusCode.Unauthorized, false)]
+        [DataRow(HttpStatusCode.Forbidden, false)]
+        [DataRow(HttpStatusCode.NotFound, false)]
+        [DataRow(HttpStatusCode.TooManyRequests, false)]
+        [DataRow(HttpStatusCode.UnprocessableEntity, false)]
+        [DataRow(HttpStatusCode.InternalServerError, false)]
+        public async Task Given_ApiResponse_When_SuccessStatusCode_Then_Result_ShouldMatchHttpResponseMessage(HttpStatusCode code, bool expected)
+        {
+            // Arrange
+            // Act
+            var response = new ApiResponse(CreateRequest(), CreateResponse(code), "", "/", DateTime.UtcNow, new JsonSerializerOptions());
+            // Assert
+            Assert.AreEqual(expected, response.IsSuccessStatusCode);
+        }
+
+        [TestMethod]
+        public async Task Given_ApiResponse_When_Properties_Are_Set_Then_Object_Should_Return_Correct_Values()
+        {
+            // Arrange
+            var request = CreateRequest("https://adyen.com/");
+
+            // Act
+            var responseMessage = CreateResponse(HttpStatusCode.Accepted, "Accepted");
+            var apiResponse = new ApiResponse(request, responseMessage, "{\"key\":\"value\"}", "/path", DateTime.UtcNow, new JsonSerializerOptions());
+
+            // Assert
+            Assert.AreEqual(responseMessage.StatusCode, apiResponse.StatusCode);
+            Assert.AreEqual(responseMessage.ReasonPhrase, apiResponse.ReasonPhrase);
+            Assert.AreEqual(request.RequestUri, apiResponse.RequestUri);
+            Assert.AreEqual("/path", apiResponse.Path);
+            Assert.IsNotNull(apiResponse.Headers);
+            Assert.AreEqual("{\"key\":\"value\"}", apiResponse.RawContent);
+            Assert.IsNull(apiResponse.ContentStream);
+        }
+
+        [TestMethod]
+        public async Task Given_ApiResponse_When_ContentStream_Is_Set_Then_Return_ContentStream_And_Empty_RawContent()
+        {
+            // Arrange
+            var request = CreateRequest();
+            var responseMessage = CreateResponse(HttpStatusCode.OK);
+
+            // Act
+            var stream = new MemoryStream(new byte[] { 1, 2, 3 });
+            var apiResponse = new ApiResponse(request, responseMessage, stream, "/stream", DateTime.UtcNow, new JsonSerializerOptions());
+
+            // Assert
+            Assert.AreEqual(stream, apiResponse.ContentStream);
+            Assert.AreEqual(string.Empty, apiResponse.RawContent);
+        }
+
+        private class TestApiResponse<T> : ApiResponse,
+            IOk<T>, ICreated<T>, IAccepted<T>,
+            IBadRequest<T>, IUnauthorized<T>, IForbidden<T>, ITooManyRequests<T>, INotFound<T>, IUnprocessableContent<T>, IInternalServerError<T>
+        {
+            public TestApiResponse(HttpRequestMessage message, HttpResponseMessage response, string raw, string path, DateTime requested, JsonSerializerOptions opts)
+                : base(message, response, raw, path, requested, opts) { }
+
+            private T DeserializeRaw() => JsonSerializer.Deserialize<T>(RawContent, _jsonSerializerOptions)!;
+
+            public T Ok() => DeserializeRaw();
+            public bool TryDeserializeOkResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T Created() => DeserializeRaw();
+            public bool TryDeserializeCreatedResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T Accepted() => DeserializeRaw();
+            public bool TryDeserializeAcceptedResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T BadRequest() => DeserializeRaw();
+            public bool TryDeserializeBadRequestResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T Unauthorized() => DeserializeRaw();
+            public bool TryDeserializeUnauthorizedResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T Forbidden() => DeserializeRaw();
+            public bool TryDeserializeForbiddenResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T TooManyRequests() => DeserializeRaw();
+            public bool TryDeserializeTooManyRequestsResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T NotFound() => DeserializeRaw();
+            public bool TryDeserializeNotFoundResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T UnprocessableContent() => DeserializeRaw();
+            public bool TryDeserializeUnprocessableContentResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+
+            public T InternalServerError() => DeserializeRaw();
+            public bool TryDeserializeInternalServerErrorResponse(out T? result) { result = string.IsNullOrEmpty(RawContent) ? default : DeserializeRaw(); return result != null; }
+        }
+
+        private record TestModel(string Foo);
+
+        [TestMethod]
+        public async Task Given_ApiResponse_When_TypedResponses_Then_Deserialize_Correctly()
+        {
+            // Arrange
+            var model = new TestModel("adyen");
+
+            // Act
+            string json = JsonSerializer.Serialize(model, new JsonSerializerOptions());
+            var response = new TestApiResponse<TestModel>(CreateRequest(), CreateResponse(HttpStatusCode.OK), json, "/path", DateTime.UtcNow, new JsonSerializerOptions());
+
+            // Assert
+            Assert.AreEqual(model, response.Ok());
+            Assert.IsTrue(response.TryDeserializeOkResponse(out var okResult));
+            Assert.AreEqual(model, okResult);
+
+            Assert.AreEqual(model, response.Created());
+            Assert.IsTrue(response.TryDeserializeCreatedResponse(out var createdResult));
+            Assert.AreEqual(model, createdResult);
+
+            Assert.AreEqual(model, response.Accepted());
+            Assert.IsTrue(response.TryDeserializeAcceptedResponse(out var acceptedResult));
+            Assert.AreEqual(model, acceptedResult);
+
+            Assert.AreEqual(model, response.BadRequest());
+            Assert.IsTrue(response.TryDeserializeBadRequestResponse(out var badResult));
+            Assert.AreEqual(model, badResult);
+
+            Assert.AreEqual(model, response.Unauthorized());
+            Assert.IsTrue(response.TryDeserializeUnauthorizedResponse(out var unAuthResult));
+            Assert.AreEqual(model, unAuthResult);
+
+            Assert.AreEqual(model, response.Forbidden());
+            Assert.IsTrue(response.TryDeserializeForbiddenResponse(out var forbiddenResult));
+            Assert.AreEqual(model, forbiddenResult);
+
+            Assert.AreEqual(model, response.TooManyRequests());
+            Assert.IsTrue(response.TryDeserializeTooManyRequestsResponse(out var tooManyResult));
+            Assert.AreEqual(model, tooManyResult);
+
+            Assert.AreEqual(model, response.NotFound());
+            Assert.IsTrue(response.TryDeserializeNotFoundResponse(out var notFoundResult));
+            Assert.AreEqual(model, notFoundResult);
+
+            Assert.AreEqual(model, response.UnprocessableContent());
+            Assert.IsTrue(response.TryDeserializeUnprocessableContentResponse(out var unprocessableResult));
+            Assert.AreEqual(model, unprocessableResult);
+
+            Assert.AreEqual(model, response.InternalServerError());
+            Assert.IsTrue(response.TryDeserializeInternalServerErrorResponse(out var internalResult));
+            Assert.AreEqual(model, internalResult);
+        }
+    }
+}

Adyen.Test/Core/Client/HttpRequestMessageExtensions.cs

@@ -0,0 +1,95 @@
+using Adyen.Core.Client.Extensions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Adyen.Test.Core.Client
+{
+    [TestClass]
+    public class HttpRequestMessageExtensionsTest
+    {
+        [TestMethod]
+        public void Given_AddUserAgentToHeaders_When_ApplicationName_Is_Null_Returns_adyen_dotnet_api_library_And_AdyenLibraryVersion()
+        {
+            // Arrange
+            HttpRequestMessageExtensions.ApplicationName = null;
+            var request = new HttpRequestMessage();
+
+            // Act
+            request.AddUserAgentToHeaders();
+
+            // Assert
+            string target = request.Headers.GetValues("UserAgent").First();
+            Assert.AreEqual($"adyen-dotnet-api-library/{HttpRequestMessageExtensions.AdyenLibraryVersion}", target);
+        }
+
+        [TestMethod]
+        public void Given_AddUserAgentToHeaders_When_ApplicationName_Is_Set_Returns_MyApp_adyen_dotnet_api_library_And_AdyenLibraryVersion()
+        {
+            // Arrange
+            var request = new HttpRequestMessage();
+            HttpRequestMessageExtensions.ApplicationName = "MyApp";
+
+            // Act
+            request.AddUserAgentToHeaders();
+
+            // Assert
+            string target = request.Headers.GetValues("UserAgent").First();
+            Assert.AreEqual($"MyApp adyen-dotnet-api-library/{HttpRequestMessageExtensions.AdyenLibraryVersion}", target);
+        }
+
+        [TestMethod]
+        public void Given_AddLibraryNameToHeader_When_Provided_Returns_adyen_dotnet_api_library()
+        {
+            // Arrange
+            HttpRequestMessageExtensions.ApplicationName = null;
+            var request = new HttpRequestMessage();
+
+            // Act
+            request.AddLibraryNameToHeader();
+
+            // Assert
+            string target = request.Headers.GetValues("adyen-library-name").First();
+            Assert.AreEqual("adyen-dotnet-api-library", target);
+        }
+
+        [TestMethod]
+        public void Given_AddLibraryNameToHeader_When_Provided_Returns_AdyenLibraryVersion()
+        {
+            // Arrange
+            HttpRequestMessageExtensions.ApplicationName = null;
+            var request = new HttpRequestMessage();
+
+            // Act
+            request.AddLibraryVersionToHeader();
+
+            // Assert
+            string target = request.Headers.GetValues("adyen-library-version").First();
+            Assert.AreEqual(HttpRequestMessageExtensions.AdyenLibraryVersion, target);
+        }
+
+        [TestMethod]
+        public void Given_AddUserAgentToHeaders_When_Called_MultipleTimes_Should_Not_Throw_Any_Exceptions()
+        {
+            // Arrange
+            HttpRequestMessageExtensions.ApplicationName = null;
+            var request = new HttpRequestMessage();
+
+            // Act
+            // Assert
+            try
+            {
+                request.AddUserAgentToHeaders();
+                request.AddUserAgentToHeaders();
+
+                request.AddLibraryNameToHeader();
+                request.AddLibraryNameToHeader();
+
+                request.AddLibraryVersionToHeader();
+                request.AddLibraryVersionToHeader();
+            }
+            catch (Exception e)
+            {
+                Assert.Fail();
+            }
+        }
+    }
+}