@commercetools/checkout-payments-processor-sdk 0.0.6

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

@@ -0,0 +1,1616 @@
+import { randomUUID } from 'node:crypto';
+import type {
+  Cart,
+  CartPagedQueryResponse,
+  Order,
+  Payment,
+} from '@commercetools/platform-sdk';
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { RequestContextProvider } from '@/api/index.js';
+import { DefaultCommercetoolsAPI } from '@/commercetools/api/root-api.js';
+import { DefaultCartService } from '@/commercetools/services/ct-cart.service.js';
+import { CommercetoolsLogger } from '@/logger/commercetools-logger.js';
+import { authToken } from '@/mocks/auth.mock.js';
+import type { SessionPrincipal } from '@/security/authn/types/authn.type.js';
+import { SessionAuthentication } from '@/security/index.js';
+
+const mockServer = setupServer();
+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,
+  httpClient: (input: string | URL | Request, init?: RequestInit) => {
+    return fetch(input, init);
+  },
+});
+// TODO finalise the test
+const ctCartService = new DefaultCartService({
+  ctAPI,
+  logger,
+  contextProvider,
+});
+
+describe('commercetools cart service', () => {
+  beforeAll(() =>
+    mockServer.listen({
+      onUnhandledRequest: 'error',
+    }),
+  );
+  afterAll(() => mockServer.close());
+
+  describe('getPaymentAmount', () => {
+    test('should return the total net amount if no taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 100,
+      });
+    });
+
+    test('should return the total gross amount if taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 120,
+      });
+    });
+
+    test('should discount the existent payment approved from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const rejectedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Failure',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(rejectedPayment.id, 200, rejectedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 20,
+      });
+    });
+
+    test('should not discount the existent payment reverted from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const revertedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+          {
+            type: 'CancelAuthorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(revertedPayment.id, 200, revertedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 120,
+      });
+    });
+
+    test('should return an error when the cart is full paid', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const anotherApprovedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 20,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 20,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(
+          anotherApprovedPayment.id,
+          200,
+          anotherApprovedPayment,
+        ),
+      );
+
+      //When
+      const resultPromise = ctCartService.getPaymentAmount({ cart });
+
+      //Then
+      await expect(resultPromise).rejects.toThrow(
+        'The cart has already been paid in full',
+      );
+    });
+  });
+
+  describe('getPlannedPaymentAmount', () => {
+    test('should return the total net amount if no taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 100,
+      });
+    });
+
+    test('should return the total gross amount if taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 120,
+      });
+    });
+
+    test('should discount the existent payment approved from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const rejectedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Failure',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(rejectedPayment.id, 200, rejectedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 20,
+      });
+    });
+
+    test('should not discount the existent payment reverted from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const revertedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+          {
+            type: 'CancelAuthorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(revertedPayment.id, 200, revertedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 120,
+      });
+    });
+
+    test('should return an error when the cart is full paid', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const anotherApprovedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 20,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 20,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(
+          anotherApprovedPayment.id,
+          200,
+          anotherApprovedPayment,
+        ),
+      );
+
+      //When
+      const resultPromise = ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      await expect(resultPromise).rejects.toThrow(
+        'The cart has already been paid in full',
+      );
+    });
+  });
+
+  describe('getPlannedPaymentAmount with giftCardPlannedAmount set in context', () => {
+    const contextProvider = new RequestContextProvider({
+      getContextFn: () => ({
+        correlationId: 'correlation-id',
+        requestId: 'request-id',
+        authentication: new SessionAuthentication('some-id', {
+          giftCardPlannedAmount: {
+            centAmount: 10,
+            currencyCode: 'EUR',
+          },
+        } as SessionPrincipal),
+      }),
+      updateContextFn: () => {},
+    });
+
+    const ctCartService = new DefaultCartService({
+      ctAPI,
+      logger,
+      contextProvider,
+    });
+
+    test('should return the total net amount if no taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 90,
+      });
+    });
+
+    test('should return the total gross amount if taxed price and does not exist any payment approved', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 110,
+      });
+    });
+
+    test('should discount the existent payment approved from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const rejectedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Failure',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(rejectedPayment.id, 200, rejectedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 10,
+      });
+    });
+
+    test('should not discount the existent payment reverted from the cart gross price', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const revertedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+          {
+            type: 'CancelAuthorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(revertedPayment.id, 200, revertedPayment),
+      );
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 110,
+      });
+    });
+
+    test('should return an error when the cart is full paid', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        taxedPrice: {
+          totalGross: {
+            currencyCode: 'EUR',
+            centAmount: 120,
+          },
+        },
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        paymentInfo: {
+          payments: [
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+            {
+              typeId: 'payment',
+              id: randomUUID(),
+            },
+          ],
+        },
+      } as Cart;
+
+      const approvedPayment = {
+        id: cart.paymentInfo?.payments[0].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 100,
+            },
+          },
+        ],
+      } as Payment;
+
+      const anotherApprovedPayment = {
+        id: cart.paymentInfo?.payments[1].id,
+        version: 1,
+        amountPlanned: {
+          currencyCode: 'EUR',
+          centAmount: 20,
+        },
+        transactions: [
+          {
+            type: 'Authorization',
+            state: 'Success',
+            amount: {
+              currencyCode: 'EUR',
+              centAmount: 20,
+            },
+          },
+        ],
+      } as Payment;
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetPaymentById(approvedPayment.id, 200, approvedPayment),
+        mockGetPaymentById(
+          anotherApprovedPayment.id,
+          200,
+          anotherApprovedPayment,
+        ),
+      );
+
+      //When
+      const resultPromise = ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      await expect(resultPromise).rejects.toThrow(
+        'The cart has already been paid in full',
+      );
+    });
+
+    test('should return cart amount when giftCardPlannedAmount currency does not match with cart currency', async () => {
+      const contextProvider = new RequestContextProvider({
+        getContextFn: () => ({
+          correlationId: 'correlation-id',
+          requestId: 'request-id',
+          authentication: new SessionAuthentication('some-id', {
+            giftCardPlannedAmount: {
+              centAmount: 10,
+              currencyCode: 'USD',
+            },
+          } as SessionPrincipal),
+        }),
+        updateContextFn: () => {},
+      });
+
+      const ctCartService = new DefaultCartService({
+        ctAPI,
+        logger,
+        contextProvider,
+      });
+
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        totalPrice: {
+          currencyCode: 'EUR',
+          centAmount: 100,
+        },
+      } as Cart;
+
+      //When
+      const result = await ctCartService.getPlannedPaymentAmount({ cart });
+
+      //Then
+      expect(result).toEqual({
+        currencyCode: 'EUR',
+        centAmount: 100,
+      });
+    });
+  });
+
+  describe('getOneShippingAddress', () => {
+    test('should return undefined if Single and no shippingAddress', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        shippingMode: 'Single',
+      } as Cart;
+
+      //When
+      const result = ctCartService.getOneShippingAddress({ cart });
+
+      //Then
+      expect(result).toBeUndefined();
+    });
+
+    test('should return undefined if Multiple and shipping empty', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        shippingMode: 'Multiple',
+        shipping: [],
+      } as unknown as Cart;
+
+      //When
+      const result = ctCartService.getOneShippingAddress({ cart });
+
+      //Then
+      expect(result).toBeUndefined();
+    });
+
+    test('should return undefined if Multiple and no shipping', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        shippingMode: 'Multiple',
+      } as unknown as Cart;
+
+      //When
+      const result = ctCartService.getOneShippingAddress({ cart });
+
+      //Then
+      expect(result).toBeUndefined();
+    });
+
+    test('should return the shipping address in case of single shipping address', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        shippingAddress: {
+          id: randomUUID(),
+          country: 'US',
+          state: 'NY',
+          city: 'New York',
+          streetName: '5th Avenue',
+          postalCode: '10001',
+        },
+        shippingMode: 'Single',
+      } as Cart;
+
+      //When
+      const result = ctCartService.getOneShippingAddress({ cart });
+
+      //Then
+      expect(result).toEqual(cart.shippingAddress);
+    });
+
+    test('should return the first shipping address in case of multiple shipping addresses', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        shippingMode: 'Multiple',
+        shipping: [
+          {
+            shippingKey: 'id0',
+            shippingAddress: {
+              id: randomUUID(),
+              country: 'US',
+              state: 'NY',
+              city: 'New York',
+              streetName: '5th Avenue',
+              postalCode: '10001',
+            },
+          },
+          {
+            shippingKey: 'id1',
+            shippingAddress: {
+              id: randomUUID(),
+              country: 'US',
+              state: 'CA',
+              city: 'Los Angeles',
+              streetName: 'Hollywood Blvd',
+              postalCode: '90028',
+            },
+          },
+        ],
+      } as Cart;
+
+      //When
+      const result = ctCartService.getOneShippingAddress({ cart });
+
+      //Then
+      expect(result).toEqual(cart.shipping[0].shippingAddress);
+    });
+  });
+
+  describe('getNormalizedShipping', () => {
+    test('should return the empty array info in case of mode Single with no shippingInfo/shippingAddress', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        shippingMode: 'Single',
+        version: 1,
+      } as Cart;
+
+      //When
+      const result = ctCartService.getNormalizedShipping({ cart });
+
+      //Then
+      expect(result).toEqual([]);
+    });
+
+    test('should return the empty array info in case of mode Multiple with no shipping', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        shippingMode: 'Multiple',
+        version: 1,
+        shippingAddress: {
+          id: randomUUID(),
+          country: 'US',
+          state: 'NY',
+          city: 'New York',
+          streetName: '5th Avenue',
+          postalCode: '10001',
+        },
+      } as Cart;
+
+      //When
+      const result = ctCartService.getNormalizedShipping({ cart });
+
+      //Then
+      expect(result).toEqual([]);
+    });
+
+    test('should return the empty array info in case of mode Multiple with empty shipping', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        shippingMode: 'Multiple',
+        version: 1,
+        shipping: [],
+      } as unknown as Cart;
+
+      //When
+      const result = ctCartService.getNormalizedShipping({ cart });
+
+      //Then
+      expect(result).toEqual([]);
+    });
+
+    test('should return the shipping info in case of single shipping info', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        shippingMode: 'Single',
+        version: 1,
+        shippingAddress: {
+          id: randomUUID(),
+          country: 'US',
+          state: 'NY',
+          city: 'New York',
+          streetName: '5th Avenue',
+          postalCode: '10001',
+        },
+        shippingInfo: {
+          shippingMethodName: 'Standard Delivery',
+          price: {
+            currencyCode: 'EUR',
+            centAmount: 0,
+          },
+          shippingRate: {
+            price: {
+              currencyCode: 'EUR',
+              centAmount: 0,
+            },
+          },
+          shippingMethod: {
+            typeId: 'shipping-method',
+            id: '23ac9884-6d83-498a-86b8-62d778ca494b',
+          },
+          taxedPrice: {
+            totalNet: {
+              type: 'centPrecision',
+              currencyCode: 'EUR',
+              centAmount: 0,
+              fractionDigits: 2,
+            },
+            totalGross: {
+              type: 'centPrecision',
+              currencyCode: 'EUR',
+              centAmount: 0,
+              fractionDigits: 2,
+            },
+            totalTax: {
+              type: 'centPrecision',
+              currencyCode: 'EUR',
+              centAmount: 0,
+              fractionDigits: 2,
+            },
+          },
+          shippingMethodState: 'MatchesCart',
+        },
+      } as Cart;
+
+      //When
+      const result = ctCartService.getNormalizedShipping({ cart });
+
+      //Then
+      expect(result).toEqual([
+        {
+          shippingAddress: cart.shippingAddress,
+          shippingInfo: cart.shippingInfo,
+        },
+      ]);
+    });
+
+    test('should return the shipping info in case of multiple shipping infos', async () => {
+      //Given
+      const cart = {
+        id: randomUUID(),
+        shippingMode: 'Multiple',
+        version: 1,
+        shipping: [
+          {
+            shippingKey: 'id0',
+            shippingAddress: {
+              id: randomUUID(),
+              country: 'US',
+              state: 'NY',
+              city: 'New York',
+              streetName: '5th Avenue',
+              postalCode: '10001',
+            },
+            shippingInfo: {
+              shippingMethodName: 'Standard Delivery',
+              price: {
+                currencyCode: 'EUR',
+                centAmount: 0,
+              },
+              shippingRate: {
+                price: {
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                },
+              },
+              shippingMethod: {
+                typeId: 'shipping-method',
+                id: '23ac9884-6d83-498a-86b8-62d778ca494b',
+              },
+              taxedPrice: {
+                totalNet: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+                totalGross: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+                totalTax: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+              },
+              shippingMethodState: 'MatchesCart',
+            },
+          },
+          {
+            shippingKey: 'id1',
+            shippingAddress: {
+              id: randomUUID(),
+              country: 'US',
+              state: 'CA',
+              city: 'Los Angeles',
+              streetName: 'Hollywood Blvd',
+              postalCode: '90028',
+            },
+            shippingInfo: {
+              shippingMethodName: 'Standard Delivery',
+              price: {
+                currencyCode: 'EUR',
+                centAmount: 0,
+              },
+              shippingRate: {
+                price: {
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                },
+              },
+              shippingMethod: {
+                typeId: 'shipping-method',
+                id: '23ac9884-6d83-498a-86b8-62d778ca494b',
+              },
+              taxedPrice: {
+                totalNet: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+                totalGross: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+                totalTax: {
+                  type: 'centPrecision',
+                  currencyCode: 'EUR',
+                  centAmount: 0,
+                  fractionDigits: 2,
+                },
+              },
+              shippingMethodState: 'MatchesCart',
+            },
+          },
+        ],
+      } as Cart;
+
+      //When
+      const result = ctCartService.getNormalizedShipping({ cart });
+
+      //Then
+      expect(result).toEqual([
+        {
+          shippingAddress: cart.shipping[0].shippingAddress,
+          shippingInfo: cart.shipping[0].shippingInfo,
+        },
+        {
+          shippingAddress: cart.shipping[1].shippingAddress,
+          shippingInfo: cart.shipping[1].shippingInfo,
+        },
+      ]);
+    });
+  });
+
+  describe('getCartByPaymentId', () => {
+    test('should return a cart', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const cart: CartPagedQueryResponse = {
+        count: 1,
+        limit: 100,
+        offset: 0,
+        results: [
+          {
+            id: 'order-id',
+            version: 1,
+            paymentInfo: {
+              payments: [
+                {
+                  id: paymentId,
+                  typeId: 'payment',
+                },
+              ],
+            },
+          } as Cart,
+        ],
+      };
+
+      mockServer.use(mockGetAuthToken(200, authToken), mockFindCart(200, cart));
+
+      // Actual
+      const actual = await ctCartService.getCartByPaymentId({ paymentId });
+
+      // Expected
+      const expected: Order = {
+        id: 'order-id',
+        version: 1,
+        paymentInfo: {
+          payments: [
+            {
+              id: paymentId,
+              typeId: 'payment',
+            },
+          ],
+        },
+      } as Order;
+
+      expect(actual).toEqual(expected);
+    });
+
+    test('should return ErrorResourceNotFound if no cart by the given paymentId could be found', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const order: CartPagedQueryResponse = {
+        count: 0,
+        limit: 100,
+        offset: 0,
+        results: [],
+      };
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockFindCart(200, order),
+      );
+
+      // Actual
+      const actual = ctCartService.getCartByPaymentId({ paymentId });
+
+      // Expected
+      await expect(actual).rejects.toThrow(
+        `The referenced object of type cart paymentInfo(payments(id = "${paymentId}")) was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+      );
+    });
+  });
+
+  describe('isRecurringCart', () => {
+    test('should return false when cart has no customerId', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        origin: 'Customer',
+        lineItems: [],
+        customLineItems: [],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(false);
+    });
+
+    test('should return true when cart origin is RecurringOrder', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'RecurringOrder',
+        lineItems: [],
+        customLineItems: [],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return true when at least one line item has recurrenceInfo', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'Customer',
+        lineItems: [
+          {
+            id: randomUUID(),
+            recurrenceInfo: {
+              interval: 'month',
+              count: 1,
+            },
+          },
+        ],
+        customLineItems: [],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return true when at least one custom line item has recurrenceInfo', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'Customer',
+        lineItems: [],
+        customLineItems: [
+          {
+            id: randomUUID(),
+            recurrenceInfo: {
+              interval: 'week',
+              count: 2,
+            },
+          },
+        ],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return false when cart has customerId but no recurring indicators', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'Customer',
+        lineItems: [
+          {
+            id: randomUUID(),
+          },
+        ],
+        customLineItems: [],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(false);
+    });
+
+    test('should return true when cart has multiple recurring conditions', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'RecurringOrder',
+        lineItems: [
+          {
+            id: randomUUID(),
+            recurrenceInfo: {
+              interval: 'month',
+              count: 1,
+            },
+          },
+        ],
+        customLineItems: [
+          {
+            id: randomUUID(),
+            recurrenceInfo: {
+              interval: 'week',
+              count: 1,
+            },
+          },
+        ],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return true when at least one line item has recurrenceInfo among multiple items', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'Customer',
+        lineItems: [
+          {
+            id: randomUUID(),
+          },
+          {
+            id: randomUUID(),
+            recurrenceInfo: {
+              interval: 'day',
+              count: 7,
+            },
+          },
+          {
+            id: randomUUID(),
+          },
+        ],
+        customLineItems: [],
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(true);
+    });
+
+    test('should return false when lineItems and customLineItems are undefined', () => {
+      // Given
+      const cart = {
+        id: randomUUID(),
+        version: 1,
+        customerId: randomUUID(),
+        origin: 'Customer',
+      } as unknown as Cart;
+
+      // When
+      const result = ctCartService.isRecurringCart(cart);
+
+      // Then
+      expect(result).toBe(false);
+    });
+  });
+});
+
+const mockGetAuthToken = (respCode: number, data?: object) =>
+  http.post('http://auth.test.com/oauth/token', async () => {
+    return HttpResponse.json(data, {
+      status: respCode,
+    });
+  });
+
+const mockGetPaymentById = (id: string, respCode: number, data?: object) =>
+  http.get(`http://api.test.com/test/payments/${id}`, async () => {
+    return HttpResponse.json(data, {
+      status: respCode,
+    });
+  });
+
+const mockFindCart = (respCode: number, data?: object) =>
+  http.get(`http://api.test.com/test/carts`, async () => {
+    return HttpResponse.json(data, {
+      status: respCode,
+    });
+  });