@commercetools/checkout-payments-processor-sdk 0.0.6

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

@@ -0,0 +1,878 @@
+import { randomUUID } from 'node:crypto';
+import { RequestContextProvider } from '@api';
+import type {
+  PaymentMethod,
+  PaymentMethodPagedQueryResponse,
+  PaymentMethodUpdateAction,
+} from '@commercetools/platform-sdk';
+import {
+  ErrorInternalConstraintViolated,
+  ErrorResourceNotFound,
+} from '@errorx';
+import { CommercetoolsLogger } from '@logger';
+import { CommercetoolsPaymentMethodAPI } from '@/commercetools/api/payment-method-api.js';
+import { DefaultCommercetoolsAPI } from '@/commercetools/api/root-api.js';
+import { DefaultPaymentMethodService } from '@/commercetools/services/ct-payment-method.service.js';
+import type { SavePaymentMethodDraft } from '@/commercetools/types/payment-method.type.js';
+
+const projectKey = 'test-payment-methods';
+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 paymentMethodAPI = new CommercetoolsPaymentMethodAPI({
+  client: ctAPI.client,
+});
+ctAPI.paymentMethod = paymentMethodAPI;
+
+const ctPaymentMethodService = new DefaultPaymentMethodService({
+  ctAPI,
+  logger,
+});
+
+describe('commercetools payment-method service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('get', () => {
+    test('should return a payment method', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterface = 'psp-interface';
+      const paymentMethod: PaymentMethod = {
+        id: paymentId,
+        version: 1,
+        default: false,
+        paymentMethodStatus: 'Active',
+        createdAt: '',
+        lastModifiedAt: '',
+        customer: {
+          id: customerId,
+          typeId: 'customer',
+        },
+        paymentInterface,
+      };
+
+      const spyer = vi.spyOn(paymentMethodAPI, 'find').mockResolvedValueOnce({
+        count: 1,
+        limit: 100,
+        offset: 0,
+        results: [paymentMethod],
+      });
+
+      //When
+      const result = await ctPaymentMethodService.get({
+        id: paymentId,
+        customerId: customerId,
+        paymentInterface,
+      });
+
+      //Then
+      expect(result).toEqual(paymentMethod);
+
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterface}"`,
+      });
+    });
+
+    test('should return the payment-method even if the interfaceAccount is set on the payment-method but it is not provided as a query param since it is an optional value', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterface = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const paymentMethod: PaymentMethod = {
+        id: paymentId,
+        version: 1,
+        default: false,
+        paymentMethodStatus: 'Active',
+        createdAt: '',
+        lastModifiedAt: '',
+        customer: {
+          id: customerId,
+          typeId: 'customer',
+        },
+        paymentInterface: paymentInterface,
+        interfaceAccount: interfaceAccountValue,
+      };
+
+      const spyer = vi.spyOn(paymentMethodAPI, 'find').mockResolvedValueOnce({
+        count: 1,
+        limit: 100,
+        offset: 0,
+        results: [paymentMethod],
+      });
+
+      //When
+      const result = await ctPaymentMethodService.get({
+        id: paymentId,
+        customerId: customerId,
+        paymentInterface: paymentInterface,
+      });
+
+      //Then
+      expect(result).toEqual(paymentMethod);
+
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterface}"`,
+      });
+    });
+
+    test('should throw an ErrorResourceNotFound if no payment-method could be found', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterface = 'psp-interface';
+
+      const spyer = vi.spyOn(paymentMethodAPI, 'find').mockResolvedValueOnce({
+        count: 0,
+        limit: 100,
+        offset: 0,
+        results: [],
+      });
+
+      //When
+      const result = ctPaymentMethodService.get({
+        id: paymentId,
+        customerId: customerId,
+        paymentInterface,
+      });
+
+      //Then
+      await expect(result).rejects.toThrow(
+        new ErrorResourceNotFound('payment-method', paymentId),
+      );
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterface}"`,
+      });
+    });
+  });
+
+  describe('find', () => {
+    test('should return an empty list if nothing matches', async () => {
+      //Given
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'paymentInterface-value';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 20,
+        offset: 0,
+        count: 0,
+        total: 0,
+        results: [],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.find({
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}"`,
+      });
+      expect(result).toEqual(queryResults);
+    });
+
+    test('should return a list of payment methods that match with the given "customerId" and "paymentInterface"', async () => {
+      //Given
+      const customerId = randomUUID();
+      const paymentId = randomUUID();
+      const paymentInterfaceValue = 'paymentInterface-value';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 1,
+        total: 1,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.find({
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}"`,
+      });
+      expect(result).toEqual(queryResults);
+    });
+
+    test('should return a list of payment methods that match with the given "customerId", "paymentInterface" and "interfaceAccount"', async () => {
+      //Given
+      const customerId = randomUUID();
+      const paymentId = randomUUID();
+      const paymentInterfaceValue = 'paymentInterface-value';
+      const interfaceAccountValue = 'interfaceAccount-value';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 1,
+        total: 1,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.find({
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+        interfaceAccount: interfaceAccountValue,
+      });
+
+      //Then
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+      expect(result).toEqual(queryResults);
+    });
+  });
+
+  describe('save', () => {
+    test('should throw an error if an payment method already exists for that customer with the same token value', async () => {
+      //Given
+      const draft: SavePaymentMethodDraft = {
+        customerId: 'customerId',
+        method: 'scheme',
+        paymentInterface: 'paymentInterface',
+        token: 'token',
+        interfaceAccount: 'interfaceAccount',
+      };
+
+      const spyer = vi
+        .spyOn(ctPaymentMethodService, 'doesTokenBelongsToCustomer')
+        .mockResolvedValueOnce(true);
+
+      //When
+      const result = ctPaymentMethodService.save(draft);
+
+      //Then
+      expect(spyer).toHaveBeenCalledWith({
+        customerId: 'customerId',
+        paymentInterface: 'paymentInterface',
+        interfaceAccount: 'interfaceAccount',
+        tokenValue: 'token',
+      });
+      await expect(result).rejects.toThrow(
+        new ErrorInternalConstraintViolated(
+          'A payment method with the same "token.value" already exists.',
+          {
+            privateFields: {
+              customerId: 'customerId',
+              interfaceAccount: 'interfaceAccount',
+              paymentInterface: 'paymentInterface',
+            },
+          },
+        ),
+      );
+    });
+
+    test('should pass the draft to the underlying API layer and return the result unchanged', async () => {
+      //Given
+      const draft: SavePaymentMethodDraft = {
+        customerId: 'customerId',
+        method: 'scheme',
+        paymentInterface: 'paymentInterface',
+        token: 'token',
+        interfaceAccount: 'interfaceAccount',
+      };
+
+      const paymentId = randomUUID();
+
+      const paymentMethod: PaymentMethod = {
+        id: paymentId,
+        version: 1,
+        default: false,
+        paymentMethodStatus: 'Active',
+        createdAt: '',
+        lastModifiedAt: '',
+        customer: {
+          id: 'customerId',
+          typeId: 'customer',
+        },
+        paymentInterface: 'paymentInterface',
+        interfaceAccount: 'interfaceAccount',
+        token: {
+          value: 'token',
+        },
+      };
+
+      vi.spyOn(
+        ctPaymentMethodService,
+        'doesTokenBelongsToCustomer',
+      ).mockResolvedValueOnce(false);
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'create')
+        .mockResolvedValueOnce(paymentMethod);
+
+      //When
+      const result = await ctPaymentMethodService.save(draft);
+
+      //Then
+      expect(spyer).toHaveBeenCalledWith({
+        customer: {
+          id: 'customerId',
+          typeId: 'customer',
+        },
+        paymentInterface: 'paymentInterface',
+        interfaceAccount: 'interfaceAccount',
+        method: 'scheme',
+        default: false,
+        paymentMethodStatus: 'Active',
+        token: {
+          value: 'token',
+        },
+      });
+      expect(result).toStrictEqual(paymentMethod);
+    });
+  });
+
+  describe('update', () => {
+    test('should throw an ErrorInternalConstraintViolated if the provided customerId does not match the the given paymentMethodId', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'checkIfExistsByPredicate')
+        .mockResolvedValueOnce(false);
+
+      //When
+      const result = ctPaymentMethodService.update({
+        actions: [],
+        customerId: customerId,
+        resource: {
+          id: paymentId,
+          version: 1,
+        },
+      });
+
+      //Then
+      await expect(result).rejects.toThrow(
+        new ErrorInternalConstraintViolated(
+          `The provided payment-method '${paymentId}' does not have a customer '${customerId}' set`,
+          {
+            privateFields: {
+              predicateQueryString: `id="${paymentId}" and customer(id="${customerId}")`,
+            },
+            fields: {
+              customerId,
+              paymentMethodId: paymentId,
+            },
+          },
+        ),
+      );
+
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `id="${paymentId}" and customer(id="${customerId}")`,
+      });
+    });
+
+    test('should pass the update actions to the underlying API layer and return the result unchanged', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+
+      const paymentMethod: PaymentMethod = {
+        id: paymentId,
+        version: 1,
+        default: false,
+        paymentMethodStatus: 'Active',
+        createdAt: '',
+        lastModifiedAt: '',
+        customer: {
+          id: customerId,
+          typeId: 'customer',
+        },
+      };
+
+      vi.spyOn(
+        paymentMethodAPI,
+        'checkIfExistsByPredicate',
+      ).mockResolvedValueOnce(true);
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'update')
+        .mockResolvedValueOnce(paymentMethod);
+
+      //When
+      const updateActions: PaymentMethodUpdateAction[] = [
+        {
+          action: 'setInterfaceAccount',
+          interfaceAccount: 'new-interfaceAccount-value',
+        },
+      ];
+      const result = await ctPaymentMethodService.update({
+        actions: updateActions,
+        customerId: customerId,
+        resource: {
+          id: paymentId,
+          version: 1,
+        },
+      });
+
+      //Then
+      expect(result).toEqual(paymentMethod);
+      expect(spyer).toHaveBeenCalledWith({
+        actions: updateActions,
+        resource: {
+          id: paymentId,
+          version: paymentMethod.version,
+        },
+      });
+    });
+  });
+
+  describe('delete', () => {
+    test('should throw an ErrorInternalConstraintViolated if the provided customerId does not match the the given paymentMethodId', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'checkIfExistsByPredicate')
+        .mockResolvedValueOnce(false);
+
+      //When
+      const result = ctPaymentMethodService.delete({
+        customerId: customerId,
+        id: paymentId,
+        version: 1,
+      });
+
+      //Then
+      await expect(result).rejects.toThrow(
+        new ErrorInternalConstraintViolated(
+          `The provided payment-method '${paymentId}' does not have a customer '${customerId}' set`,
+          {
+            privateFields: {
+              predicateQueryString: `id="${paymentId}" and customer(id="${customerId}")`,
+            },
+            fields: {
+              customerId: customerId,
+              paymentMethodId: paymentId,
+            },
+          },
+        ),
+      );
+
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `id="${paymentId}" and customer(id="${customerId}")`,
+      });
+    });
+
+    test('should pass the delete params to the underlying API layer and return the result unchanged', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+
+      const paymentMethod: PaymentMethod = {
+        id: paymentId,
+        version: 1,
+        default: false,
+        paymentMethodStatus: 'Active',
+        createdAt: '',
+        lastModifiedAt: '',
+        customer: {
+          id: customerId,
+          typeId: 'customer',
+        },
+      };
+
+      vi.spyOn(
+        paymentMethodAPI,
+        'checkIfExistsByPredicate',
+      ).mockResolvedValueOnce(true);
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'delete')
+        .mockResolvedValueOnce(paymentMethod);
+
+      //When
+      const result = await ctPaymentMethodService.delete({
+        customerId: customerId,
+        id: paymentId,
+        version: 1,
+      });
+
+      //Then
+      expect(result).toStrictEqual(paymentMethod);
+      expect(spyer).toHaveBeenCalledWith({
+        id: paymentId,
+        version: 1,
+      });
+    });
+  });
+
+  describe('doesTokenBelongsToCustomer', () => {
+    test('should return "true" if the token belongs to the customer', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const tokenValue = 'tokenValue';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 2,
+        total: 2,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: 'differentTokenValue',
+            },
+          },
+          {
+            id: 'db745569-56d8-4a2f-b78e-3f0cee37dd86',
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: tokenValue,
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.doesTokenBelongsToCustomer({
+        tokenValue: tokenValue,
+        interfaceAccount: interfaceAccountValue,
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      expect(result).toBeTruthy();
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+    });
+
+    test('should return "false" if token does not belong to the customer', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const tokenValue = 'tokenValue';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 1,
+        total: 1,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: tokenValue,
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.doesTokenBelongsToCustomer({
+        tokenValue: 'differentTokenValue',
+        interfaceAccount: interfaceAccountValue,
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      expect(result).toBeFalsy();
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+    });
+  });
+
+  describe('getByTokenValue', () => {
+    test('should return the payment method if the provided tokenValue matches with an payment method which has the corresponding token value set', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const tokenValue = 'tokenValue';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 1,
+        total: 1,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: tokenValue,
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = await ctPaymentMethodService.getByTokenValue({
+        tokenValue: tokenValue,
+        interfaceAccount: interfaceAccountValue,
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      expect(result).toStrictEqual(queryResults.results[0]);
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+    });
+
+    test.skip('should throw an "ErrorInternalConstraintViolated" if more then one payment method with the same token value is found', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const tokenValue = 'tokenValue';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 2,
+        total: 2,
+        results: [
+          {
+            id: paymentId,
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: tokenValue,
+            },
+          },
+          {
+            id: '28e2fadb-2f3d-493c-ab75-d912cc2375f5',
+            version: 1,
+            default: false,
+            paymentMethodStatus: 'Active',
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+            createdAt: '',
+            lastModifiedAt: '',
+            customer: {
+              id: customerId,
+              typeId: 'customer',
+            },
+            token: {
+              value: tokenValue,
+            },
+          },
+        ],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = ctPaymentMethodService.getByTokenValue({
+        tokenValue: tokenValue,
+        interfaceAccount: interfaceAccountValue,
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      await expect(result).rejects.toThrow(
+        new ErrorInternalConstraintViolated(
+          'Found more then one payment method with the same token value.',
+          {
+            privateFields: {
+              customerId,
+              interfaceAccount: 'interfaceaccount-value',
+              paymentInterface: 'psp-interface',
+              paymentMethodIds: [
+                paymentId,
+                '28e2fadb-2f3d-493c-ab75-d912cc2375f5',
+              ],
+            },
+          },
+        ),
+      );
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+    });
+
+    test.skip('should throw an "ErrorResourceNotFound" if no payment method could be found that matches with the given tokenValue', async () => {
+      //Given
+      const customerId = randomUUID();
+      const paymentInterfaceValue = 'psp-interface';
+      const interfaceAccountValue = 'interfaceaccount-value';
+      const tokenValue = 'tokenValue';
+
+      const queryResults: PaymentMethodPagedQueryResponse = {
+        limit: 100,
+        offset: 0,
+        count: 0,
+        total: 0,
+        results: [],
+      };
+
+      const spyer = vi
+        .spyOn(paymentMethodAPI, 'find')
+        .mockResolvedValueOnce(queryResults);
+
+      //When
+      const result = ctPaymentMethodService.getByTokenValue({
+        tokenValue: tokenValue,
+        interfaceAccount: interfaceAccountValue,
+        customerId: customerId,
+        paymentInterface: paymentInterfaceValue,
+      });
+
+      //Then
+      await expect(result).rejects.toThrow(
+        new ErrorResourceNotFound('customer', customerId, {
+          privateFields: {
+            customerId: customerId,
+            paymentInterface: paymentInterfaceValue,
+            interfaceAccount: interfaceAccountValue,
+          },
+        }),
+      );
+      expect(spyer).toHaveBeenCalledWith({
+        queryString: `customer(id="${customerId}") and paymentInterface="${paymentInterfaceValue}" and interfaceAccount="${interfaceAccountValue}"`,
+      });
+    });
+  });
+});