@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/commercetools/services/ct-payment.service.test.ts

@@ -0,0 +1,1123 @@
+import { randomUUID } from 'node:crypto';
+import { RequestContextProvider } from '@api';
+import type { Payment, Transaction } from '@commercetools/platform-sdk';
+import { CommercetoolsLogger } from '@logger';
+import { CommercetoolsPaymentAPI } from '@/commercetools/api/payment-api.js';
+import { DefaultCommercetoolsAPI } from '@/commercetools/api/root-api.js';
+import { CommercetoolsAPIError } from '@/commercetools/errors/ct-api.error.js';
+import { DefaultPaymentService } from '@/commercetools/services/ct-payment.service.js';
+
+const projectKey = 'test';
+const contextProvider = new RequestContextProvider({
+  getContextFn: () => ({
+    correlationId: 'correlation-id',
+    requestId: 'request-id',
+  }),
+  updateContextFn: () => {},
+});
+const logger = new CommercetoolsLogger({ contextProvider, projectKey });
+
+const ctAPI = new DefaultCommercetoolsAPI({
+  apiUrl: 'http://api.test.com',
+  authUrl: 'http://auth.test.com',
+  clientId: 'clientId',
+  clientSecret: 'clientSecret',
+  projectKey,
+  contextProvider,
+  logger,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  httpClient: (input: string | URL | Request, init?: RequestInit) => {
+    return fetch(input, init);
+  },
+});
+
+const paymentAPI = new CommercetoolsPaymentAPI({ client: ctAPI.client });
+ctAPI.payment = paymentAPI;
+
+const ctPaymentService = new DefaultPaymentService({ ctAPI, logger });
+
+describe('commercetools payment service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getPaymentById', () => {
+    test('should return a payment', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const txId = randomUUID();
+      const payment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(payment);
+
+      //When
+      const result = await ctPaymentService.getPayment({
+        id: paymentId,
+      });
+
+      //Then
+      expect(result).toEqual(payment);
+    });
+  });
+
+  describe('findPaymentsByInterfaceId', () => {
+    test('should return a payment given the interface id', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const interfaceId = randomUUID();
+      const txId = randomUUID();
+      const payment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'find').mockResolvedValueOnce({
+        results: [payment],
+        count: 1,
+        total: 1,
+        offset: 0,
+        limit: 10,
+      });
+
+      //When
+      const result = await ctPaymentService.findPaymentsByInterfaceId({
+        interfaceId: interfaceId,
+      });
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject(payment);
+    });
+  });
+
+  describe('updatePayment', () => {
+    test('should update the payment in the first attempt', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const txId = randomUUID();
+      const interfaceId = randomUUID();
+      const initialPayment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const updatedPayment = {
+        id: paymentId,
+        version: 2,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+            interactionId: interfaceId,
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        initialPayment,
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockResolvedValueOnce(
+        updatedPayment,
+      );
+
+      //When
+      const result = await ctPaymentService.updatePayment({
+        id: paymentId,
+        pspReference: interfaceId,
+        transaction: {
+          type: 'Authorization',
+          amount: {
+            currencyCode: 'EUR',
+            centAmount: 10000,
+          },
+          state: 'Success',
+          interactionId: interfaceId,
+        },
+      });
+
+      //Then
+      expect(result).toEqual(updatedPayment);
+    });
+
+    test('should update the payment in the second attempt, after resolving a conflict due to invalid interfaceId', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const txId = randomUUID();
+      const interfaceId = randomUUID();
+      const initialPayment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const secondAttemptPayment = {
+        id: paymentId,
+        version: 2,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const updatedPayment = {
+        id: paymentId,
+        version: 3,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+            interactionId: interfaceId,
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        initialPayment,
+      );
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        secondAttemptPayment,
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockRejectedValueOnce(
+        new CommercetoolsAPIError({
+          body: {
+            message: `The interface id '${interfaceId}' was already used without setting a payment interface.`,
+            errors: [
+              {
+                code: 'InvalidInput',
+                message: `The interface id '${interfaceId}' was already used without setting a payment interface.`,
+                action: {
+                  action: 'setInterfaceId',
+                  interfaceId,
+                },
+              },
+            ],
+          },
+          statusCode: 400,
+          message: `The interface id '${interfaceId}' was already used without setting a payment interface.`,
+        }),
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockResolvedValueOnce(
+        updatedPayment,
+      );
+
+      //When
+      const result = await ctPaymentService.updatePayment({
+        id: paymentId,
+        pspReference: interfaceId,
+        transaction: {
+          type: 'Authorization',
+          amount: {
+            currencyCode: 'EUR',
+            centAmount: 10000,
+          },
+          state: 'Success',
+          interactionId: interfaceId,
+        },
+      });
+
+      //Then
+      expect(result).toEqual(updatedPayment);
+      expect(paymentAPI.getPaymentById).toHaveBeenCalledTimes(2);
+      expect(paymentAPI.updatePayment).toHaveBeenCalledTimes(2);
+    });
+
+    test('should update the payment in the second attempt, after resolving a concurrent modification conflict', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const txId = randomUUID();
+      const interfaceId = randomUUID();
+      const initialPayment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const secondAttemptPayment = {
+        id: paymentId,
+        version: 2,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const updatedPayment = {
+        id: paymentId,
+        version: 3,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        interfaceId,
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+            interactionId: interfaceId,
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        initialPayment,
+      );
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        secondAttemptPayment,
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockRejectedValueOnce(
+        new CommercetoolsAPIError({
+          body: {
+            message: `Object ${paymentId} has a different version than expected. Expected: 3 - Actual: 2`,
+            errors: [
+              {
+                code: 'ConcurrentModification',
+                message: `Object ${paymentId} has a different version than expected. Expected: 3 - Actual: 2`,
+              },
+            ],
+          },
+          statusCode: 409,
+          message: `Object ${paymentId} has a different version than expected. Expected: 3 - Actual: 2`,
+        }),
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockResolvedValueOnce(
+        updatedPayment,
+      );
+
+      //When
+      const result = await ctPaymentService.updatePayment({
+        id: paymentId,
+        pspReference: interfaceId,
+        transaction: {
+          type: 'Authorization',
+          amount: {
+            currencyCode: 'EUR',
+            centAmount: 10000,
+          },
+          state: 'Success',
+          interactionId: interfaceId,
+        },
+      });
+
+      //Then
+      expect(result).toEqual(updatedPayment);
+      expect(paymentAPI.getPaymentById).toHaveBeenCalledTimes(2);
+      expect(paymentAPI.updatePayment).toHaveBeenCalledTimes(2);
+    });
+
+    test('should not update the payment when there is an unexpected error', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const txId = randomUUID();
+      const interfaceId = randomUUID();
+      const initialPayment = {
+        id: paymentId,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      vi.spyOn(paymentAPI, 'getPaymentById').mockResolvedValueOnce(
+        initialPayment,
+      );
+      vi.spyOn(paymentAPI, 'updatePayment').mockRejectedValueOnce(
+        new CommercetoolsAPIError({
+          body: {
+            message: `General error`,
+          },
+          statusCode: 500,
+          message: `General error`,
+        }),
+      );
+
+      //When
+      const resultPromise = ctPaymentService.updatePayment({
+        id: paymentId,
+        pspReference: interfaceId,
+        transaction: {
+          type: 'Authorization',
+          amount: {
+            currencyCode: 'EUR',
+            centAmount: 10000,
+          },
+          state: 'Success',
+          interactionId: interfaceId,
+        },
+      });
+
+      //Then
+      await expect(resultPromise).rejects.toThrow('General error');
+      expect(paymentAPI.getPaymentById).toHaveBeenCalledTimes(1);
+      expect(paymentAPI.updatePayment).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('findMatchingTransactions', () => {
+    test('should find a match when an initial tx without interaction id exists ', () => {
+      //Given
+      const expectedTxId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: expectedTxId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: 'interactionId',
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.findMatchingTransactions(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toEqual(expectedTxId);
+    });
+
+    test('should find a match when the type and interaction id is the same', () => {
+      //Given
+      const expectedTxId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Failure',
+            interactionId: 'interactionId1',
+          },
+          {
+            id: expectedTxId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId: 'interactionId2',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: 'interactionId2',
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.findMatchingTransactions(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toEqual(expectedTxId);
+    });
+
+    test('should not find any match when the type and interaction id is different', () => {
+      //Given
+      const payment = {
+        id: randomUUID(),
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Failure',
+            interactionId: 'interactionId1',
+          },
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId: 'interactionId2',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: 'interactionId3',
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.findMatchingTransactions(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('findTransaction', () => {
+    test('should return true if a transaction with specified filters exists', () => {
+      const payment = {
+        id: randomUUID(),
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+          },
+        ],
+      } as Payment;
+
+      // When
+      const result = ctPaymentService.hasTransactionInState({
+        payment,
+        transactionType: 'Authorization',
+        states: ['Success', 'Pending'],
+      });
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return false because transaction with condition does not exist', () => {
+      const payment = {
+        id: randomUUID(),
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+          {
+            id: randomUUID(),
+            type: 'Charge',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+          },
+        ],
+      } as Payment;
+
+      // When
+      const result = ctPaymentService.hasTransactionInState({
+        payment,
+        transactionType: 'Authorization',
+        states: ['Success'],
+      });
+
+      // Then
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('consolidateTransactionChanges', () => {
+    test('should return an empty array when the transaction is in initial state without interactionId', () => {
+      //Given
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Initial',
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(0);
+    });
+
+    test('should return an add transaction action when there is no matching transaction', () => {
+      //Given
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: randomUUID(),
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Failure',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: randomUUID(),
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        action: 'addTransaction',
+        transaction,
+      });
+    });
+
+    test('should return a change state and change interaction id actions when an initial transaction to reuse already exists', () => {
+      //Given
+      const txId = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Initial',
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: interactionId,
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(2);
+      expect(result).toMatchObject([
+        {
+          action: 'changeTransactionState',
+          state: 'Success',
+          transactionId: txId,
+        },
+        {
+          action: 'changeTransactionInteractionId',
+          interactionId,
+          transactionId: txId,
+        },
+      ]);
+    });
+
+    test('should return a change state when the transaction was pending and now it is success', () => {
+      //Given
+      const txId = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId,
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: interactionId,
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result).toMatchObject([
+        {
+          action: 'changeTransactionState',
+          state: 'Success',
+          transactionId: txId,
+        },
+      ]);
+    });
+
+    test('should return a change state when the transaction was failure and now it is success', () => {
+      //Given
+      const txId = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Failure',
+            interactionId,
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId: interactionId,
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result).toMatchObject([
+        {
+          action: 'changeTransactionState',
+          state: 'Success',
+          transactionId: txId,
+        },
+      ]);
+    });
+
+    test('should return a change state when the transaction was success and now it is failure', () => {
+      //Given
+      const txId = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Success',
+            interactionId,
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Failure',
+        interactionId: interactionId,
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result).toMatchObject([
+        {
+          action: 'changeTransactionState',
+          state: 'Failure',
+          transactionId: txId,
+        },
+      ]);
+    });
+
+    test('should return a change state when the transaction was pending and now it is failure', () => {
+      //Given
+      const txId = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId,
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Failure',
+        interactionId: interactionId,
+      } as Transaction;
+
+      //When
+      const result = ctPaymentService.consolidateTransactionChanges(
+        payment,
+        transaction,
+      );
+
+      //Then
+      expect(result).toHaveLength(1);
+      expect(result).toMatchObject([
+        {
+          action: 'changeTransactionState',
+          state: 'Failure',
+          transactionId: txId,
+        },
+      ]);
+    });
+
+    test('should return an error when more than one transaction matches the criteria', () => {
+      //Given
+      const txId1 = randomUUID();
+      const txId2 = randomUUID();
+      const interactionId = randomUUID();
+      const payment = {
+        id: randomUUID(),
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        transactions: [
+          {
+            id: txId1,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId,
+          },
+          {
+            id: txId2,
+            type: 'Authorization',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 10000,
+            },
+            state: 'Pending',
+            interactionId,
+          },
+        ],
+      } as Payment;
+
+      const transaction = {
+        type: 'Authorization',
+        amount: {
+          currencyCode: 'EUR',
+          centAmount: 10000,
+        },
+        state: 'Success',
+        interactionId,
+      } as Transaction;
+
+      //When
+      const result = () =>
+        ctPaymentService.consolidateTransactionChanges(payment, transaction);
+
+      //Then
+      expect(result).toThrow(/Multiple matching transactions found/);
+    });
+  });
+});