[capital] Code generation: update services and models

Adyen.Test/Capital/DynamicOffersServiceTests.cs

@@ -0,0 +1,168 @@
+using System.Net;
+using System.Text;
+using Adyen.Core.Options;
+using Adyen.Capital.Extensions;
+using Adyen.Capital.Models;
+using Adyen.Capital.Services;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Adyen.Test.Capital
+{
+    [TestClass]
+    public class DynamicOffersServiceTests
+    {
+        [TestMethod]
+        public async Task GetAllDynamicOffersAsync_Returns200Ok_WithCorrectVerbAndPath()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offers-success.json");
+            var accountHolderId = "AH00000000000000000000001";
+
+            HttpRequestMessage? capturedRequest = null;
+            var mockHandler = new MockDelegatingHandler(request =>
+            {
+                capturedRequest = request;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(json, Encoding.UTF8, "application/json")
+                };
+            });
+
+            IHost testHost = Host.CreateDefaultBuilder()
+                .ConfigureCapital((context, services, config) =>
+                {
+                    config.ConfigureAdyenOptions(options => { options.Environment = AdyenEnvironment.Test; });
+                    services.AddDynamicOffersService(httpClientBuilderOptions: builder =>
+                    {
+                        builder.AddHttpMessageHandler(() => mockHandler);
+                    });
+                })
+                .Build();
+
+            var dynamicOffersService = testHost.Services.GetRequiredService<IDynamicOffersService>();
+
+            // Act
+            var response = await dynamicOffersService.GetAllDynamicOffersAsync(accountHolderId);
+
+            // Assert - response
+            Assert.IsTrue(response.TryDeserializeOkResponse(out var result));
+            Assert.IsNotNull(result);
+            Assert.AreEqual(1, result.DynamicOffers.Count);
+            Assert.AreEqual("DO00000000000000000000001", result.DynamicOffers[0].Id);
+            Assert.AreEqual("AH00000000000000000000001", result.DynamicOffers[0].AccountHolderId);
+            Assert.AreEqual("EUR", result.DynamicOffers[0].MinimumAmount.Currency);
+            Assert.AreEqual(5000, result.DynamicOffers[0].MinimumAmount.Value);
+            Assert.AreEqual("EUR", result.DynamicOffers[0].MaximumAmount.Currency);
+            Assert.AreEqual(25000, result.DynamicOffers[0].MaximumAmount.Value);
+
+            // Assert - HTTP verb and path
+            Assert.IsNotNull(capturedRequest);
+            Assert.AreEqual(HttpMethod.Get, capturedRequest.Method);
+            Assert.IsNotNull(capturedRequest.RequestUri);
+            Assert.AreEqual("/capital/v1/dynamicOffers", capturedRequest.RequestUri.AbsolutePath);
+            StringAssert.Contains(capturedRequest.RequestUri.Query, $"accountHolderId={accountHolderId}");
+        }
+
+        [TestMethod]
+        public async Task CalculatePreliminaryOfferFromDynamicOfferAsync_Returns200Ok_WithCorrectVerbAndPath()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offer-calculate-preliminary.json");
+            var dynamicOfferId = "DO00000000000000000000001";
+            var request = new CalculateGrantOfferRequest { Amount = new Amount { Currency = "EUR", Value = 10000 } };
+
+            HttpRequestMessage? capturedRequest = null;
+            var mockHandler = new MockDelegatingHandler(req =>
+            {
+                capturedRequest = req;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(json, Encoding.UTF8, "application/json")
+                };
+            });
+
+            IHost testHost = Host.CreateDefaultBuilder()
+                .ConfigureCapital((context, services, config) =>
+                {
+                    config.ConfigureAdyenOptions(options => { options.Environment = AdyenEnvironment.Test; });
+                    services.AddDynamicOffersService(httpClientBuilderOptions: builder =>
+                    {
+                        builder.AddHttpMessageHandler(() => mockHandler);
+                    });
+                })
+                .Build();
+
+            var dynamicOffersService = testHost.Services.GetRequiredService<IDynamicOffersService>();
+
+            // Act
+            var response = await dynamicOffersService.CalculatePreliminaryOfferFromDynamicOfferAsync(dynamicOfferId, request);
+
+            // Assert - response
+            Assert.IsTrue(response.TryDeserializeOkResponse(out var result));
+            Assert.IsNotNull(result);
+            Assert.AreEqual("EUR", result.Amount.Currency);
+            Assert.AreEqual(10000, result.Amount.Value);
+            Assert.AreEqual("EUR", result.Fee.Amount.Currency);
+            Assert.AreEqual(1000, result.Fee.Amount.Value);
+            Assert.AreEqual(1000, result.Repayment.BasisPoints);
+
+            // Assert - HTTP verb and path
+            Assert.IsNotNull(capturedRequest);
+            Assert.AreEqual(HttpMethod.Post, capturedRequest.Method);
+            Assert.IsNotNull(capturedRequest.RequestUri);
+            Assert.AreEqual($"/capital/v1/dynamicOffers/{dynamicOfferId}/calculate", capturedRequest.RequestUri.AbsolutePath);
+        }
+
+        [TestMethod]
+        public async Task CreateStaticOfferFromDynamicOfferAsync_Returns200Ok_WithCorrectVerbAndPath()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offer-create-static-offer.json");
+            var dynamicOfferId = "DO00000000000000000000001";
+            var request = new CreateGrantOfferRequest { Amount = new Amount { Currency = "EUR", Value = 10000 } };
+
+            HttpRequestMessage? capturedRequest = null;
+            var mockHandler = new MockDelegatingHandler(req =>
+            {
+                capturedRequest = req;
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent(json, Encoding.UTF8, "application/json")
+                };
+            });
+
+            IHost testHost = Host.CreateDefaultBuilder()
+                .ConfigureCapital((context, services, config) =>
+                {
+                    config.ConfigureAdyenOptions(options => { options.Environment = AdyenEnvironment.Test; });
+                    services.AddDynamicOffersService(httpClientBuilderOptions: builder =>
+                    {
+                        builder.AddHttpMessageHandler(() => mockHandler);
+                    });
+                })
+                .Build();
+
+            var dynamicOffersService = testHost.Services.GetRequiredService<IDynamicOffersService>();
+
+            // Act
+            var response = await dynamicOffersService.CreateStaticOfferFromDynamicOfferAsync(dynamicOfferId, request);
+
+            // Assert - response
+            Assert.IsTrue(response.TryDeserializeOkResponse(out var result));
+            Assert.IsNotNull(result);
+            Assert.AreEqual("GO00000000000000000000002", result.Id);
+            Assert.AreEqual("AH00000000000000000000001", result.AccountHolderId);
+            Assert.AreEqual(GrantOffer.ContractTypeEnum.CashAdvance, result.ContractType);
+            Assert.AreEqual("EUR", result.Amount.Currency);
+            Assert.AreEqual(10000, result.Amount.Value);
+
+            // Assert - HTTP verb and path
+            Assert.IsNotNull(capturedRequest);
+            Assert.AreEqual(HttpMethod.Post, capturedRequest.Method);
+            Assert.IsNotNull(capturedRequest.RequestUri);
+            Assert.AreEqual($"/capital/v1/dynamicOffers/{dynamicOfferId}/grantOffer", capturedRequest.RequestUri.AbsolutePath);
+        }
+    }
+}

Adyen.Test/Capital/DynamicOffersTest.cs

@@ -0,0 +1,96 @@
+using Adyen.Capital.Client;
+using Adyen.Capital.Extensions;
+using Adyen.Capital.Models;
+using Adyen.Core.Options;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Text.Json;
+
+namespace Adyen.Test.Capital
+{
+    [TestClass]
+    public class DynamicOffersTest
+    {
+        private static IHost _host;
+        private static JsonSerializerOptionsProvider _jsonSerializerOptionsProvider;
+
+        [ClassInitialize]
+        public static void ClassInitialize(TestContext context)
+        {
+            _host = Host.CreateDefaultBuilder()
+                .ConfigureCapital((ctx, services, config) =>
+                {
+                    config.ConfigureAdyenOptions(options =>
+                    {
+                        options.Environment = AdyenEnvironment.Test;
+                    });
+                })
+                .Build();
+
+            _jsonSerializerOptionsProvider = _host.Services.GetRequiredService<JsonSerializerOptionsProvider>();
+        }
+
+        [ClassCleanup]
+        public static void ClassCleanup()
+        {
+            _host?.Dispose();
+        }
+
+        [TestMethod]
+        public void Given_Deserialize_When_GetDynamicOffersResponse_Returns_Not_Null()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offers-success.json");
+
+            // Act
+            var response = JsonSerializer.Deserialize<GetDynamicOffersResponse>(json, _jsonSerializerOptionsProvider.Options);
+
+            // Assert
+            Assert.IsNotNull(response);
+            Assert.AreEqual(1, response.DynamicOffers.Count);
+            Assert.AreEqual("DO00000000000000000000001", response.DynamicOffers[0].Id);
+            Assert.AreEqual("AH00000000000000000000001", response.DynamicOffers[0].AccountHolderId);
+            Assert.AreEqual("EUR", response.DynamicOffers[0].MinimumAmount.Currency);
+            Assert.AreEqual(5000, response.DynamicOffers[0].MinimumAmount.Value);
+            Assert.AreEqual("EUR", response.DynamicOffers[0].MaximumAmount.Currency);
+            Assert.AreEqual(25000, response.DynamicOffers[0].MaximumAmount.Value);
+        }
+
+        [TestMethod]
+        public void Given_Deserialize_When_CalculatedGrantOffer_Returns_Not_Null()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offer-calculate-preliminary.json");
+
+            // Act
+            var response = JsonSerializer.Deserialize<CalculatedGrantOffer>(json, _jsonSerializerOptionsProvider.Options);
+
+            // Assert
+            Assert.IsNotNull(response);
+            Assert.AreEqual("EUR", response.Amount.Currency);
+            Assert.AreEqual(10000, response.Amount.Value);
+            Assert.AreEqual("EUR", response.Fee.Amount.Currency);
+            Assert.AreEqual(1000, response.Fee.Amount.Value);
+            Assert.AreEqual(1000, response.Repayment.BasisPoints);
+        }
+
+        [TestMethod]
+        public void Given_Deserialize_When_GrantOffer_From_DynamicOffer_Returns_Not_Null()
+        {
+            // Arrange
+            string json = TestUtilities.GetTestFileContent("mocks/capital/dynamic-offer-create-static-offer.json");
+
+            // Act
+            var response = JsonSerializer.Deserialize<GrantOffer>(json, _jsonSerializerOptionsProvider.Options);
+
+            // Assert
+            Assert.IsNotNull(response);
+            Assert.AreEqual("GO00000000000000000000002", response.Id);
+            Assert.AreEqual("AH00000000000000000000001", response.AccountHolderId);
+            Assert.AreEqual(GrantOffer.ContractTypeEnum.CashAdvance, response.ContractType);
+            Assert.AreEqual("EUR", response.Amount.Currency);
+            Assert.AreEqual(10000, response.Amount.Value);
+        }
+    }
+}

Adyen.Test/Capital/GrantsOffersServiceTests.cs

@@ -43,7 +43,7 @@ public async Task GetAllGrantOffersAsync_Success()
             var accountHolderId = "AH00000000000001";
 
             _grantsOffersService.GetAllGrantOffersAsync(
-                    Arg.Any<Option<string>>(),
+                    Arg.Any<string>(),
                     Arg.Any<RequestOptions?>(), 
                     Arg.Any<CancellationToken>())
                 .Returns(

Adyen.Test/mocks/capital/dynamic-offer-calculate-preliminary.json

@@ -0,0 +1,20 @@
+{
+  "id": "DO00000000000000000000001",
+  "accountHolderId": "AH00000000000000000000001",
+  "contractType": "cashAdvance",
+  "amount": {
+    "currency": "EUR",
+    "value": 10000
+  },
+  "fee": {
+    "amount": {
+      "currency": "EUR",
+      "value": 1000
+    }
+  },
+  "repayment": {
+    "basisPoints": 1000
+  },
+  "startsAt": "2024-01-01T00:00:00.0000000Z",
+  "expiresAt": "2024-12-31T00:00:00.0000000Z"
+}

Adyen.Test/mocks/capital/dynamic-offer-create-static-offer.json

@@ -0,0 +1,9 @@
+{
+  "id": "GO00000000000000000000002",
+  "accountHolderId": "AH00000000000000000000001",
+  "contractType": "cashAdvance",
+  "amount": {
+    "currency": "EUR",
+    "value": 10000
+  }
+}

Adyen.Test/mocks/capital/dynamic-offers-success.json

@@ -0,0 +1,25 @@
+{
+  "dynamicOffers": [
+    {
+      "id": "DO00000000000000000000001",
+      "accountHolderId": "AH00000000000000000000001",
+      "contractType": "cashAdvance",
+      "financingType": "businessFinancing",
+      "minimumAmount": {
+        "currency": "EUR",
+        "value": 5000
+      },
+      "maximumAmount": {
+        "currency": "EUR",
+        "value": 25000
+      },
+      "repayment": {
+        "term": {
+          "estimatedDays": 90
+        }
+      },
+      "startsAt": "2024-01-01T00:00:00.0000000Z",
+      "expiresAt": "2024-12-31T00:00:00.0000000Z"
+    }
+  ]
+}