adyen-ruby-api-library 11.0.0 → 11.2.0

data/spec/client_spec.rb

@@ -32,8 +32,8 @@ RSpec.describe Adyen do
       .to raise_error(Adyen::AuthenticationError)
   end
 
-  it "fails a checkout call without oauth token" do
-    expect{ @shared_values[:client].checkout.payments_api.payment_methods("{}") }.
+  it 'fails a checkout call without oauth token' do
+    expect { @shared_values[:client].checkout.payments_api.payment_methods('{}') }.
       to raise_error(Adyen::AuthenticationError)
   end
 
@@ -43,6 +43,40 @@ RSpec.describe Adyen do
     @shared_values[:client].api_key = 'api_key'
   end
 
+  describe 'service name resolution' do
+    let(:client) { Adyen::Client.new(env: :mock, mock_service_url_base: 'https://mock.test') }
+
+    it 'is Checkout service when using checkout.payments_api' do
+      expect(client.checkout.payments_api.service)
+        .to eq('Checkout')
+    end
+
+    it 'is Checkout service when using checkout.recurring_api' do
+      expect(client.checkout.recurring_api.service)
+        .to eq('Checkout')
+    end
+
+    it 'is Recurring service when using recurring.recurring_api' do
+      expect(client.recurring.recurring_api.service)
+        .to eq('Recurring')
+    end
+
+    it 'is Payment service when using payment.payments_api' do
+      expect(client.payment.payments_api.service)
+        .to eq('Payment')
+    end
+
+    it 'is Payment service when using payment.modifications_api' do
+      expect(client.payment.modifications_api.service)
+        .to eq('Payment')
+    end
+
+    it 'is Payout service when using payout.instant_payouts_api' do
+      expect(client.payout.instant_payouts_api.service)
+        .to eq('Payout')
+    end
+  end
+
   it 'uses the specified mock service URL' do
     client = Adyen::Client.new(env: :mock, mock_service_url_base: 'https://mock.test')
     expect(client.service_url_base('Account'))
@@ -115,11 +149,11 @@ RSpec.describe Adyen do
 
   # test with Ruby 3.2+ only (where Faraday requestOptions timeout is supported)
   it 'initiates a Faraday connection with the provided options' do
-    skip "Only runs on Ruby >= 3.2" unless RUBY_VERSION >= '3.2'
+    skip 'Only runs on Ruby >= 3.2' unless RUBY_VERSION >= '3.2'
     connection_options = Faraday::ConnectionOptions.new(
       request: {
-        open_timeout: 5,  
-        timeout: 10      
+        open_timeout: 5,
+        timeout: 10
       }
     )
     expect(Faraday::ConnectionOptions).not_to receive(:new)
@@ -142,63 +176,63 @@ RSpec.describe Adyen do
 
   # test with Ruby 3.2+ only (where Faraday requestOptions timeout is supported)
   it 'initiates a Faraday connection with the expected default timeouts' do
-    skip "Only runs on Ruby >= 3.2" unless RUBY_VERSION >= '3.2'
+    skip 'Only runs on Ruby >= 3.2' unless RUBY_VERSION >= '3.2'
     client = Adyen::Client.new(env: :test)
     expect(client.connection_options[:request][:open_timeout]).to eq(30)
     expect(client.connection_options[:request][:timeout]).to eq(60)
   end
 
-  it "checks the creation of checkout url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("Checkout", "paymentMethods", "71")).
-    to eq("https://checkout-test.adyen.com/v71/paymentMethods")
+  it 'checks the creation of checkout url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('Checkout', 'paymentMethods', '71')).
+      to eq('https://checkout-test.adyen.com/v71/paymentMethods')
   end
 
-  it "checks the creation of checkout url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :live, live_url_prefix: "YourLiveUrlPrefix")
-    expect(client.service_url("Checkout", "paymentMethods", "71")).
-    to eq("https://YourLiveUrlPrefix-checkout-live.adyenpayments.com/checkout/v71/paymentMethods")
+  it 'checks the creation of checkout url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :live, live_url_prefix: 'YourLiveUrlPrefix')
+    expect(client.service_url('Checkout', 'paymentMethods', '71')).
+      to eq('https://YourLiveUrlPrefix-checkout-live.adyenpayments.com/checkout/v71/paymentMethods')
   end
-  it "checks the creation of lem url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :live)
-    expect(client.service_url("LegalEntityManagement", "businessLines", "3")).
-    to eq("https://kyc-live.adyen.com/lem/v3/businessLines")
+  it 'checks the creation of lem url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :live)
+    expect(client.service_url('LegalEntityManagement', 'businessLines', '3')).
+      to eq('https://kyc-live.adyen.com/lem/v3/businessLines')
   end
 
-  it "checks the creation of balancePlatform url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :live)
-    expect(client.service_url("BalancePlatform", "legalEntities", "1")).
-    to eq("https://balanceplatform-api-live.adyen.com/bcl/v1/legalEntities")
+  it 'checks the creation of balancePlatform url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :live)
+    expect(client.service_url('BalancePlatform', 'legalEntities', '1')).
+      to eq('https://balanceplatform-api-live.adyen.com/bcl/v1/legalEntities')
   end
 
-  it "checks the creation of balancePlatform url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("BalancePlatform", "legalEntities", "1")).
-    to eq("https://balanceplatform-api-test.adyen.com/bcl/v1/legalEntities")
+  it 'checks the creation of balancePlatform url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('BalancePlatform', 'legalEntities', '1')).
+      to eq('https://balanceplatform-api-test.adyen.com/bcl/v1/legalEntities')
   end
 
-  it "checks the creation of transfers url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("Transfers", "transactions", "1")).
-    to eq("https://balanceplatform-api-test.adyen.com/btl/v1/transactions")
+  it 'checks the creation of transfers url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('Transfers', 'transactions', '1')).
+      to eq('https://balanceplatform-api-test.adyen.com/btl/v1/transactions')
   end
 
-  it "checks the creation of management url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("Management", "companies", "1")).
-    to eq("https://management-test.adyen.com/v1/companies")
+  it 'checks the creation of management url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('Management', 'companies', '1')).
+      to eq('https://management-test.adyen.com/v1/companies')
   end
 
-  it "checks the creation of binLookup url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("BinLookup", "getCostEstimate", "54")).
-    to eq("https://pal-test.adyen.com/pal/servlet/BinLookup/v54/getCostEstimate")
+  it 'checks the creation of binLookup url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('BinLookup', 'getCostEstimate', '54')).
+      to eq('https://pal-test.adyen.com/pal/servlet/BinLookup/v54/getCostEstimate')
   end
 
-  it "check the creation of storedValue url" do
-    client = Adyen::Client.new(api_key: "api_key", env: :test)
-    expect(client.service_url("StoredValue", "issue", "46")).
-    to eq("https://pal-test.adyen.com/pal/servlet/StoredValue/v46/issue")
+  it 'check the creation of storedValue url' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    expect(client.service_url('StoredValue', 'issue', '46')).
+      to eq('https://pal-test.adyen.com/pal/servlet/StoredValue/v46/issue')
   end
 
   it 'checks the creation of checkout url' do
@@ -206,6 +240,7 @@ RSpec.describe Adyen do
     expect(client.service_url('Checkout', 'paymentMethods', '70'))
       .to eq('https://YourLiveUrlPrefix-checkout-live.adyenpayments.com/checkout/v70/paymentMethods')
   end
+
   it 'checks the creation of lem url' do
     client = Adyen::Client.new(api_key: 'api_key', env: :live)
     expect(client.service_url('LegalEntityManagement', 'businessLines', '3'))
@@ -276,19 +311,18 @@ RSpec.describe Adyen do
     client = Adyen::Client.new(api_key: 'api_key', env: :test)
     expect(client.service_url('TerminalCloudAPI', 'connectedTerminals', nil))
       .to eq('https://terminal-api-test.adyen.com/connectedTerminals')
-
   end
-          
+
   it 'checks the initialization of the terminal region' do
     client = Adyen::Client.new(api_key: 'api_key', env: :test, terminal_region: 'eu')
     expect(client.service_url('TerminalCloudAPI', 'connectedTerminals', nil))
-    .to eq('https://terminal-api-test-eu.adyen.com/connectedTerminals')
+      .to eq('https://terminal-api-test-eu.adyen.com/connectedTerminals')
   end
 
   it 'checks the initialization of the terminal region set to nil per default' do
     client = Adyen::Client.new(api_key: 'api_key', env: :test)
     expect(client.service_url('TerminalCloudAPI', 'connectedTerminals', nil))
-    .to eq('https://terminal-api-test.adyen.com/connectedTerminals')
+      .to eq('https://terminal-api-test.adyen.com/connectedTerminals')
   end
 
   it 'checks the creation of PosMobile sessions url' do
@@ -300,17 +334,42 @@ RSpec.describe Adyen do
   it 'correctly maps Disputes to DisputesService and generates valid URL' do
     client = Adyen::Client.new(env: :test)
     expect(client.service_url_base('Disputes'))
-      .to eq('https://ca-test.adyen.com/ca/services/DisputesService')
-  end  
+      .to eq('https://ca-test.adyen.com/ca/services/DisputeService')
+  end
+
+  it 'checks the creation of DataProtection url' do
+    client = Adyen::Client.new(env: :test)
+    expect(client.service_url_base('DataProtection'))
+      .to eq('https://ca-test.adyen.com/ca/services/DataProtectionService')
+  end
+
+  it 'checks the creation of SessionAuthentication url for the test env' do
+    client = Adyen::Client.new(env: :test)
+    expect(client.service_url_base('SessionAuthentication'))
+      .to eq('https://test.adyen.com/authe/api')
+  end
+
+  it 'checks the creation of SessionAuthentication url for the live env' do
+    client = Adyen::Client.new(env: :live)
+    expect(client.service_url_base('SessionAuthentication'))
+      .to eq('https://authe-live.adyen.com/authe/api')
+  end
+
+   it 'checks the creation of Recurring API url for the test env' do
+    client = Adyen::Client.new(env: :test)
+    expect(client.service_url_base('Recurring'))
+      .to eq('https://pal-test.adyen.com/pal/servlet/Recurring')
+  end
+
 
   it 'raises FormatError on 400 response and checks content' do
     client = Adyen::Client.new(api_key: 'api_key', env: :test)
     mock_faraday_connection = double(Faraday::Connection)
     error_body = {
       status: 400,
-      errorCode: "702",
-      message: "Structure of CreateCheckoutSessionRequest contains the following unknown fields: [paymentMethod]",
-      errorType: "validation"
+      errorCode: '702',
+      message: 'Structure of CreateCheckoutSessionRequest contains the following unknown fields: [paymentMethod]',
+      errorType: 'validation'
     }
     mock_response = Faraday::Response.new(status: 400, body: error_body)
 
@@ -331,12 +390,12 @@ RSpec.describe Adyen do
     client = Adyen::Client.new(api_key: 'api_key', env: :test)
     mock_faraday_connection = double(Faraday::Connection)
     error_body = {
-      type: "https://docs.adyen.com/errors/validation",
-      title: "The request is missing required fields or contains invalid data.",
+      type: 'https://docs.adyen.com/errors/validation',
+      title: 'The request is missing required fields or contains invalid data.',
       status: 422,
-      detail: "It is mandatory to specify a legalEntityId when creating a new account holder.",
-      invalidFields: [{ "name" => "legalEntityId", "message" => "legalEntityId is not provided" }],
-      errorCode: "30_011"
+      detail: 'It is mandatory to specify a legalEntityId when creating a new account holder.',
+      invalidFields: [{ 'name' => 'legalEntityId', 'message' => 'legalEntityId is not provided' }],
+      errorCode: '30_011'
     }
     mock_response = Faraday::Response.new(status: 422, body: error_body)
 
@@ -359,11 +418,11 @@ RSpec.describe Adyen do
     mock_faraday_connection = double(Faraday::Connection)
     error_body = {
       status: 422,
-      errorCode: "14_030",
-      message: "Return URL is missing.",
-      errorType: "validation",
-      pspReference: "8816118280275544"
-    }  
+      errorCode: '14_030',
+      message: 'Return URL is missing.',
+      errorType: 'validation',
+      pspReference: '8816118280275544'
+    }
     mock_response = Faraday::Response.new(status: 422, body: error_body)
 
     allow(Faraday).to receive(:new).and_return(mock_faraday_connection)
@@ -384,9 +443,9 @@ RSpec.describe Adyen do
     mock_faraday_connection = double(Faraday::Connection)
     error_body = {
       status: 500,
-      errorCode: "999",
-      message: "Unexpected error.",
-      errorType: "server error"
+      errorCode: '999',
+      message: 'Unexpected error.',
+      errorType: 'server error'
     }
     mock_response = Faraday::Response.new(status: 500, body: error_body)
 
@@ -401,4 +460,116 @@ RSpec.describe Adyen do
       expect(error.msg).to eq('Unexpected error. ErrorCode: 999')
     end
   end
+
+  it 'raises NotFoundError on 404 response and checks content' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    mock_faraday_connection = double(Faraday::Connection)
+    error_body = '701 Version 71 is not supported, latest version: 68'
+    mock_response = Faraday::Response.new(status: 404, body: error_body)
+
+    allow(Faraday).to receive(:new).and_return(mock_faraday_connection)
+    allow(mock_faraday_connection).to receive_message_chain(:headers, :[]=)
+    allow(mock_faraday_connection).to receive(:post).and_return(mock_response)
+
+    expect {
+      client.checkout.payments_api.payments({})
+    }.to raise_error(Adyen::NotFoundError) do |error|
+      expect(error.code).to eq(404)
+      expect(error.msg).to eq('Not found error')
+    end
+  end
+
+  it 'raises NotFoundError on 404 response with an invalid JSON body' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    mock_faraday_connection = double(Faraday::Connection)
+    error_body = 'this is an error message'
+    mock_response = Faraday::Response.new(status: 404, body: error_body)
+
+    allow(Faraday).to receive(:new).and_return(mock_faraday_connection)
+    allow(mock_faraday_connection).to receive_message_chain(:headers, :[]=)
+    allow(mock_faraday_connection).to receive(:post).and_return(mock_response)
+
+    expect {
+      client.payment.payments_api.authorise({})
+    }.to raise_error(Adyen::NotFoundError) do |error|
+      expect(error.code).to eq(404)
+      expect(error.msg).to eq('Not found error')
+    end
+  end
+
+  it 'ensures User-Agent is present in request headers' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test)
+    mock_response = Faraday::Response.new(status: 200, body: '{}')
+
+    mock_conn = instance_double(Faraday::Connection)
+    expect(Faraday).to receive(:new).and_yield(mock_conn).and_return(mock_conn)
+    allow(mock_conn).to receive(:adapter)
+    connection_headers = {}
+    allow(mock_conn).to receive(:headers).and_return(connection_headers)
+
+    expect(mock_conn).to receive(:post) do |&block|
+      mock_req = double('Faraday::Request')
+      allow(mock_req).to receive(:body=)
+      block.call(mock_req) if block_given?
+      mock_response
+    end.and_return(mock_response)
+
+    client.checkout.payments_api.payments({})
+
+    expect(connection_headers['User-Agent']).to_not be_nil
+    expect(connection_headers['User-Agent']).to_not be_empty
+    expect(connection_headers['User-Agent']).to eq("#{Adyen::NAME}/#{Adyen::VERSION}")
+  end
+
+  it 'ensures User-Agent includes application_name when provided' do
+    client = Adyen::Client.new(api_key: 'api_key', env: :test, application_name: 'MyTestApp')
+    mock_response = Faraday::Response.new(status: 200, body: '{}')
+
+    mock_conn = instance_double(Faraday::Connection)
+    expect(Faraday).to receive(:new).and_yield(mock_conn).and_return(mock_conn)
+    allow(mock_conn).to receive(:adapter)
+    connection_headers = {}
+    allow(mock_conn).to receive(:headers).and_return(connection_headers)
+
+    expect(mock_conn).to receive(:post) do |&block|
+      mock_req = double('Faraday::Request')
+      allow(mock_req).to receive(:body=)
+      block.call(mock_req) if block_given?
+      mock_response
+    end.and_return(mock_response)
+
+    client.checkout.payments_api.payments({})
+
+    expect(connection_headers['User-Agent']).to_not be_nil
+    expect(connection_headers['User-Agent']).to_not be_empty
+    expect(connection_headers['User-Agent']).to eq("MyTestApp #{Adyen::NAME}/#{Adyen::VERSION}")
+  end
+
+  it 'ensures User-Agent includes application_name when set after initialization' do
+    client = Adyen::Client.new
+    client.api_key = 'api_key'
+    client.env = :test
+    client.application_name = 'MyTestAppAfterInit' # Set after initialization
+
+    mock_response = Faraday::Response.new(status: 200, body: '{}')
+
+    mock_conn = instance_double(Faraday::Connection)
+    expect(Faraday).to receive(:new).and_yield(mock_conn).and_return(mock_conn)
+    allow(mock_conn).to receive(:adapter)
+    connection_headers = {}
+    allow(mock_conn).to receive(:headers).and_return(connection_headers)
+
+    expect(mock_conn).to receive(:post) do |&block|
+      mock_req = double('Faraday::Request')
+      allow(mock_req).to receive(:body=)
+      block.call(mock_req) if block_given?
+      mock_response
+    end.and_return(mock_response)
+
+    client.checkout.payments_api.payments({})
+
+    expect(connection_headers['User-Agent']).to_not be_nil
+    expect(connection_headers['User-Agent']).to_not be_empty
+    expect(connection_headers['User-Agent']).to eq("MyTestAppAfterInit #{Adyen::NAME}/#{Adyen::VERSION}")
+  end
 end

data/spec/data_protection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Adyen::DataProtection, service: 'Data Protection Service' do
+RSpec.describe Adyen::DataProtection, service: 'DataProtection' do
   # client instance to be used in dynamically generated tests
   client = create_client(:basic)
 
@@ -10,5 +10,5 @@ RSpec.describe Adyen::DataProtection, service: 'Data Protection Service' do
     %w[request_subject_erasure result SUCCESS]
   ]
 
-  generate_tests(client, 'DataProtectionService', test_sets, client.data_protection.data_protection_api)
+  generate_tests(client, 'DataProtection', test_sets, client.data_protection.data_protection_api)
 end

data/spec/disputes_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Adyen::Disputes, service: 'disputes service' do
+RSpec.describe Adyen::Disputes, service: 'Disputes' do
   before(:all) do
     @shared_values = {
       client: create_client(:api_key),
@@ -11,9 +11,9 @@ RSpec.describe Adyen::Disputes, service: 'disputes service' do
   # methods / values to test for
   # format is defined in spec_helper
   it 'makes a retrieve_applicable_defense_reasons call' do
-    request_body = JSON.parse(json_from_file('mocks/requests/DisputesService/retrieve_applicable_defense_reasons.json'))
+    request_body = JSON.parse(json_from_file('mocks/requests/Disputes/retrieve_applicable_defense_reasons.json'))
 
-    response_body = json_from_file('mocks/responses/DisputesService/retrieve_applicable_defense_reasons.json')
+    response_body = json_from_file('mocks/responses/Disputes/retrieve_applicable_defense_reasons.json')
 
     url = @shared_values[:client].service_url(@shared_values[:service], 'retrieveApplicableDefenseReasons',
                                               @shared_values[:client].disputes.version)

data/spec/lem_spec.rb

@@ -60,4 +60,79 @@ RSpec.describe Adyen::LegalEntityManagement, service: 'LegalEntityManagement' do
     expect(result.status)
       .to eq(200)
   end
+
+  it 'makes a legal_entities GET call' do
+    legal_entity_id = 'LE322JV223222D5F4K62J7465'
+    response_body = json_from_file('mocks/responses/LegalEntityManagement/get_legal_entity.json')
+
+    url = @shared_values[:client].service_url(@shared_values[:service], "legalEntities/#{legal_entity_id}",
+                                              @shared_values[:client].legal_entity_management.version)
+    WebMock.stub_request(:get, url)
+           .with(
+             headers: {
+               'x-api-key' => @shared_values[:client].api_key
+             }
+           )
+           .to_return(
+             body: response_body
+           )
+
+    result = @shared_values[:client].legal_entity_management.legal_entities_api.get_legal_entity(legal_entity_id)
+    response_hash = result.response
+
+    expect(result.status)
+      .to eq(200)
+    expect(response_hash)
+      .to eq(JSON.parse(response_body))
+    expect(response_hash)
+      .to be_a Adyen::HashWithAccessors
+    expect(response_hash)
+      .to be_a_kind_of Hash
+  end
+
+  it 'raises an error when calling legal_entities GET call' do
+    invalid_legal_entity_id = 'NON_EXISTENT_ID'
+    error_response_body = { status: 404, errorCode: '100', message: 'Legal entity not found', errorType: 'validation' }.to_json 
+
+    url = @shared_values[:client].service_url(@shared_values[:service], "legalEntities/#{invalid_legal_entity_id}",
+                                              @shared_values[:client].legal_entity_management.version)
+    WebMock.stub_request(:get, url)
+           .with(
+             headers: {
+               'x-api-key' => @shared_values[:client].api_key
+             }
+           )
+           .to_return(
+             status: 404,
+             body: error_response_body
+           )
+
+    expect do
+      @shared_values[:client].legal_entity_management.legal_entities_api.get_legal_entity(invalid_legal_entity_id)
+    end.to raise_error(Adyen::NotFoundError) do |error|
+      expect(error.code).to eq(404)
+      expect(error.msg).to eq('Legal entity not found ErrorCode: 100')
+    end
+  end
+
+  it 'makes a LegaleEntity /requestPeriodicReview call' do
+    url = @shared_values[:client].service_url(@shared_values[:service], "legalEntities/LE123/requestPeriodicReview",
+                                              @shared_values[:client].legal_entity_management.version)
+    WebMock.stub_request(:post, url)
+           .with(
+             headers: {
+               'x-api-key' => @shared_values[:client].api_key
+             }
+           )
+           .to_return(
+             body: '{}'
+           )
+
+    result = @shared_values[:client].legal_entity_management.legal_entities_api.request_periodic_review('LE123')
+    result.response
+
+    expect(result.status)
+      .to eq(200)
+  end
+  
 end

data/spec/mocks/responses/Capital/get-grant-account-success.json

@@ -0,0 +1,20 @@
+{
+  "id": "CG00000000000000000000001",
+  "fundingBalanceAccountId": "BA00000000000000000000001",
+  "limits": [
+    {
+      "amount": {
+        "currency": "EUR",
+        "value": 100000
+      }
+    }
+  ],
+  "balances": [
+    {
+      "currency": "EUR",
+      "principal": 10000,
+      "fee": 1000,
+      "total": 11000
+    }
+  ]
+}

data/spec/mocks/responses/Capital/get-grant-disbursement-success.json

@@ -0,0 +1,26 @@
+{
+  "id": "DI00000000000000000000001",
+  "grantId": "GR00000000000000000000001",
+  "accountHolderId": "AH00000000000000000000001",
+  "balanceAccountId": "BA00000000000000000000001",
+  "amount": {
+    "currency": "EUR",
+    "value": 10000
+  },
+  "fee": {
+    "amount": {
+      "currency": "EUR",
+      "value": 1000
+    }
+  },
+  "balances": {
+    "currency": "EUR",
+    "principal": 10000,
+    "fee": 1000,
+    "total": 11000
+  },
+  "repayment": {
+    "basisPoints": 1000,
+    "updateDescription": "string"
+  }
+}

data/spec/mocks/responses/Capital/get-grant-disbursements-success.json

@@ -0,0 +1,30 @@
+{
+  "disbursements": [
+    {
+      "id": "DI00000000000000000000001",
+      "grantId": "GR00000000000000000000001",
+      "accountHolderId": "AH00000000000000000000001",
+      "balanceAccountId": "BA00000000000000000000001",
+      "amount": {
+        "currency": "EUR",
+        "value": 10000
+      },
+      "fee": {
+        "amount": {
+          "currency": "EUR",
+          "value": 1000
+        }
+      },
+      "balances": {
+        "currency": "EUR",
+        "principal": 10000,
+        "fee": 1000,
+        "total": 11000
+      },
+      "repayment": {
+        "basisPoints": 1000,
+        "updateDescription": "string"
+      }
+    }
+  ]
+}

data/spec/mocks/responses/Capital/get-grant-offer-success.json

@@ -0,0 +1,31 @@
+{
+  "id": "GO00000000000000000000001",
+  "accountHolderId": "AH00000000000000000000001",
+  "contractType": "cashAdvance",
+  "amount": {
+    "currency": "EUR",
+    "value": 10000
+  },
+  "fee": {
+    "amount": {
+      "currency": "EUR",
+      "value": 1000
+    },
+    "aprBasisPoints": 1200
+  },
+  "repayment": {
+    "basisPoints": 1000,
+    "term": {
+      "estimatedDays": 180,
+      "maximumDays": 365
+    },
+    "threshold": {
+      "amount": {
+        "currency": "EUR",
+        "value": 1000
+      }
+    }
+  },
+  "startsAt": "2024-01-01T00:00:00Z",
+  "expiresAt": "2024-01-31T23:59:59Z"
+}

data/spec/mocks/responses/Capital/get-grant-success.json

@@ -0,0 +1,22 @@
+{
+  "id": "GR00000000000000000000001",
+  "grantAccountId": "CG00000000000000000000001",
+  "grantOfferId": "GO00000000000000000000001",
+  "counterparty": {
+    "accountHolderId": "AH00000000000000000000001",
+    "balanceAccountId": "BA00000000000000000000001"
+  },
+  "amount": {
+    "currency": "EUR",
+    "value": 10000
+  },
+  "balances": {
+    "currency": "EUR",
+    "principal": 10000,
+    "fee": 1000,
+    "total": 11000
+  },
+  "status": {
+    "code": "Active"
+  }
+}