@paypal/checkout-components 5.0.301 → 5.0.302-alpha.1

package/src/shopper-insights/shopperSession.test.js

@@ -0,0 +1,376 @@
+/* @flow */
+import { vi, describe, expect } from "vitest";
+
+import { ValidationError } from "../lib";
+
+import { ShopperSession } from "./shopperSession";
+
+const mockStateObject = {};
+const mockStorage = {
+  get: (key) => mockStateObject[key],
+  set: (key, value) => {
+    mockStateObject[key] = value;
+  },
+};
+
+const mockFindEligiblePaymentsRequest = (
+  eligibility = {
+    paypal: {
+      can_be_vaulted: true,
+      eligible_in_paypal_network: true,
+      recommended: true,
+      recommended_priority: 1,
+    },
+  }
+) =>
+  vi.fn().mockResolvedValue({
+    body: {
+      eligible_methods: eligibility,
+    },
+  });
+
+const defaultSdkConfig = {
+  sdkToken: "sdk client token",
+  pageType: "checkout",
+  clientToken: "",
+  userIDToken: "",
+  paypalApiDomain: "https://api.paypal.com",
+  environment: "test",
+  buyerCountry: "US",
+  currency: "USD",
+};
+
+const createShopperSession = ({
+  sdkConfig = defaultSdkConfig,
+  logger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    track: vi.fn(),
+    metricCounter: vi.fn(),
+  },
+  sessionState = mockStorage,
+  request = mockFindEligiblePaymentsRequest(),
+} = {}) =>
+  new ShopperSession({
+    sdkConfig,
+    // $FlowIssue
+    logger,
+    sessionState,
+    request,
+  });
+
+describe("shopper insights component - getRecommendedPaymentMethods()", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should get recommended payment methods using the shopper insights API", async () => {
+    const shopperSession = createShopperSession();
+    const recommendedPaymentMethods =
+      await shopperSession.getRecommendedPaymentMethods({
+        email: "email@test.com",
+        phone: {
+          countryCode: "1",
+          nationalNumber: "2345678901",
+        },
+      });
+
+    expect.assertions(1);
+    expect(recommendedPaymentMethods).toEqual({
+      isPayPalRecommended: true,
+      isVenmoRecommended: false,
+    });
+  });
+
+  test("catch errors from the API", async () => {
+    const mockRequest = vi.fn().mockRejectedValue(new Error("Error with API"));
+    const shopperSession = createShopperSession({ request: mockRequest });
+
+    expect.assertions(2);
+    await expect(() =>
+      shopperSession.getRecommendedPaymentMethods({
+        email: "email@test.com",
+        phone: {
+          countryCode: "1",
+          nationalNumber: "2345678905",
+        },
+      })
+    ).rejects.toThrow(new Error("Error with API"));
+    expect(mockRequest).toHaveBeenCalled();
+  });
+
+  test("create payload with email and phone number", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email10@test.com",
+      phone: {
+        countryCode: "1",
+        nationalNumber: "2345678906",
+      },
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          customer: expect.objectContaining({
+            email: "email10@test.com",
+            phone: expect.objectContaining({
+              country_code: "1",
+              national_number: "2345678906",
+            }),
+          }),
+        }),
+      })
+    );
+  });
+
+  test("create payload with email only", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email2@test.com",
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          customer: expect.objectContaining({
+            email: "email2@test.com",
+          }),
+        }),
+      })
+    );
+  });
+
+  test("create payload with phone only", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email5@test.com",
+      phone: {
+        countryCode: "1",
+        nationalNumber: "2345678901",
+      },
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          customer: expect.objectContaining({
+            phone: expect.objectContaining({
+              country_code: "1",
+              national_number: "2345678901",
+            }),
+          }),
+        }),
+      })
+    );
+  });
+
+  test("throw error for invalid email", () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+
+    expect(
+      shopperSession.getRecommendedPaymentMethods({
+        email: "not_an_email",
+        phone: {
+          countryCode: "1",
+          nationalNumber: "2345678901",
+        },
+      })
+    ).rejects.toEqual(
+      new ValidationError(
+        "Expected shopper information to include a valid email format"
+      )
+    );
+  });
+
+  test("throw error for invalid phone number", () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+
+    expect(
+      shopperSession.getRecommendedPaymentMethods({
+        phone: {
+          countryCode: "1",
+          nationalNumber: "not a phone",
+        },
+      })
+    ).rejects.toEqual(
+      new ValidationError(
+        "Expected shopper information to be a valid phone number format"
+      )
+    );
+  });
+
+  test("throw error for missing phone number attributes", () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+
+    expect(
+      shopperSession.getRecommendedPaymentMethods({
+        phone: {
+          nationalNumber: "2345678901",
+        },
+      })
+    ).rejects.toEqual(
+      new ValidationError(
+        "Expected phone number for shopper insights to include nationalNumber and countryCode"
+      )
+    );
+
+    expect(
+      shopperSession.getRecommendedPaymentMethods({
+        phone: {
+          countryCode: "1",
+        },
+      })
+    ).rejects.toEqual(
+      new ValidationError(
+        "Expected phone number for shopper insights to include nationalNumber and countryCode"
+      )
+    );
+  });
+
+  test("should default purchase units with currency code in the payload", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email6@test.com",
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          purchase_units: expect.arrayContaining([
+            expect.objectContaining({
+              amount: expect.objectContaining({
+                currency_code: "USD",
+              }),
+            }),
+          ]),
+        }),
+      })
+    );
+  });
+
+  test("should use the SDK buyer-country parameter if country code is not passed in a non-prod env", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({
+      request: mockRequest,
+      sdkConfig: {
+        ...defaultSdkConfig,
+        environment: "test",
+        buyerCountry: "US",
+      },
+    });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email7@test.com",
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          customer: expect.objectContaining({
+            country_code: "US",
+          }),
+        }),
+      })
+    );
+  });
+
+  test("should not set country code in prod env in the payload", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({
+      request: mockRequest,
+      sdkConfig: {
+        ...defaultSdkConfig,
+        environment: "production",
+        buyerCountry: "US",
+      },
+    });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email@test.com",
+    });
+
+    // $FlowIssue
+    expect(mockRequest.mock.calls[0][0].data.customer.country_code).toEqual(
+      undefined
+    );
+  });
+
+  test("should request recommended payment methods by setting account details in the payload", async () => {
+    const mockRequest = mockFindEligiblePaymentsRequest();
+    const shopperSession = createShopperSession({ request: mockRequest });
+    await shopperSession.getRecommendedPaymentMethods({
+      email: "email9@test.com",
+    });
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          preferences: expect.objectContaining({
+            include_account_details: true,
+          }),
+        }),
+      })
+    );
+  });
+});
+
+describe("shopper insights component - validateSdkConfig()", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should throw if sdk token is not passed", () => {
+    expect(() =>
+      createShopperSession({
+        sdkConfig: {
+          ...defaultSdkConfig,
+          sdkToken: "",
+          pageType: "",
+          userIDToken: "",
+          clientToken: "",
+        },
+      })
+    ).toThrowError(
+      "script data attribute sdk-client-token is required but was not passed"
+    );
+  });
+
+  test("should throw if page type is not passed", () => {
+    expect(() =>
+      createShopperSession({
+        sdkConfig: {
+          ...defaultSdkConfig,
+          sdkToken: "sdk-token",
+          pageType: "",
+          userIDToken: "",
+          clientToken: "",
+        },
+      })
+    ).toThrowError(
+      "script data attribute page-type is required but was not passed"
+    );
+  });
+
+  test("should throw if ID token is passed", () => {
+    expect(() =>
+      createShopperSession({
+        sdkConfig: {
+          ...defaultSdkConfig,
+          sdkToken: "sdk-token",
+          pageType: "product-listing",
+          userIDToken: "id-token",
+          clientToken: "",
+        },
+      })
+    ).toThrowError(
+      "use script data attribute sdk-client-token instead of user-id-token"
+    );
+  });
+});

package/src/api/shopper-insights/validation.js

@@ -1,120 +0,0 @@
-/* @flow */
-
-import { getLogger } from "@paypal/sdk-client/src";
-
-import {
-  SHOPPER_INSIGHTS_METRIC_NAME,
-  type MerchantPayloadData,
-} from "../../constants/api";
-import { ValidationError } from "../../lib";
-
-type MerchantConfigParams = {|
-  sdkToken: ?string,
-  pageType: ?string,
-  userIDToken: ?string,
-  clientToken: ?string,
-|};
-
-export function validateMerchantConfig({
-  sdkToken,
-  pageType,
-  userIDToken,
-  clientToken,
-}: MerchantConfigParams) {
-  const logger = getLogger();
-  if (!sdkToken) {
-    logger.metricCounter({
-      namespace: SHOPPER_INSIGHTS_METRIC_NAME,
-      event: "error",
-      dimensions: {
-        errorType: "merchant_configuration_validation_error",
-        validationDetails: "sdk_token_not_present",
-      },
-    });
-
-    throw new ValidationError(
-      `script data attribute sdk-client-token is required but was not passed`
-    );
-  }
-
-  if (!pageType) {
-    logger.metricCounter({
-      namespace: SHOPPER_INSIGHTS_METRIC_NAME,
-      event: "error",
-      dimensions: {
-        errorType: "merchant_configuration_validation_error",
-        validationDetails: "page_type_not_present",
-      },
-    });
-
-    throw new ValidationError(
-      `script data attribute page-type is required but was not passed`
-    );
-  }
-
-  if (userIDToken) {
-    logger.metricCounter({
-      namespace: SHOPPER_INSIGHTS_METRIC_NAME,
-      event: "error",
-      dimensions: {
-        errorType: "merchant_configuration_validation_error",
-        validationDetails: "sdk_token_and_id_token_present",
-      },
-    });
-
-    throw new ValidationError(
-      `use script data attribute sdk-client-token instead of user-id-token`
-    );
-  }
-
-  // Client token has widely adopted integrations in the SDK that we do not want
-  // to support anymore. For now, we will be only enforcing a warning. We should
-  // expand on this warning with upgrade guides when we have them.
-  if (clientToken) {
-    // eslint-disable-next-line no-console
-    console.warn(`script data attribute client-token is not recommended`);
-  }
-}
-
-export const hasEmail = (merchantPayload: MerchantPayloadData): boolean =>
-  Boolean(merchantPayload?.email);
-
-export const hasPhoneNumber = (merchantPayload: MerchantPayloadData): boolean =>
-  Boolean(
-    merchantPayload?.phone?.countryCode &&
-      merchantPayload?.phone?.nationalNumber
-  );
-
-const isValidEmailFormat = (email: ?string): boolean =>
-  typeof email === "string" && email.length < 320 && /^.+@.+$/.test(email);
-
-const isValidPhoneNumberFormat = (phoneNumber: ?string): boolean =>
-  typeof phoneNumber === "string" && /\d{5,}/.test(phoneNumber);
-
-export function validateMerchantPayload(merchantPayload: MerchantPayloadData) {
-  const hasEmailOrPhoneNumber =
-    hasEmail(merchantPayload) || hasPhoneNumber(merchantPayload);
-  if (typeof merchantPayload !== "object" || !hasEmailOrPhoneNumber) {
-    throw new ValidationError(
-      `Expected either email or phone number for get recommended payment methods`
-    );
-  }
-
-  if (
-    hasEmail(merchantPayload) &&
-    !isValidEmailFormat(merchantPayload?.email)
-  ) {
-    throw new ValidationError(
-      `Expected shopper information to include a valid email format`
-    );
-  }
-
-  if (
-    hasPhoneNumber(merchantPayload) &&
-    !isValidPhoneNumberFormat(merchantPayload?.phone?.nationalNumber)
-  ) {
-    throw new ValidationError(
-      `Expected shopper information to be a valid phone number format`
-    );
-  }
-}

package/src/api/shopper-insights/validation.test.js

@@ -1,150 +0,0 @@
-/* @flow */
-import { vi, describe, expect } from "vitest";
-
-import { validateMerchantConfig, validateMerchantPayload } from "./validation";
-
-vi.mock("@paypal/sdk-client/src", () => {
-  return {
-    getLogger: () => ({
-      metricCounter: vi.fn().mockReturnThis(),
-    }),
-  };
-});
-
-describe("shopper insights merchant SDK config validation", () => {
-  test("should throw if sdk token is not passed", () => {
-    expect(() =>
-      validateMerchantConfig({
-        sdkToken: "",
-        pageType: "",
-        userIDToken: "",
-        clientToken: "",
-      })
-    ).toThrowError(
-      "script data attribute sdk-client-token is required but was not passed"
-    );
-  });
-
-  test("should throw if page type is not passed", () => {
-    expect(() =>
-      validateMerchantConfig({
-        sdkToken: "sdk-token",
-        pageType: "",
-        userIDToken: "",
-        clientToken: "",
-      })
-    ).toThrowError(
-      "script data attribute page-type is required but was not passed"
-    );
-  });
-
-  test("should throw if ID token is passed", () => {
-    expect(() =>
-      validateMerchantConfig({
-        sdkToken: "sdk-token",
-        pageType: "product-listing",
-        userIDToken: "id-token",
-        clientToken: "",
-      })
-    ).toThrowError(
-      "use script data attribute sdk-client-token instead of user-id-token"
-    );
-  });
-});
-
-describe("shopper insights merchant payload validation", () => {
-  test("should have successful validation if email is only passed", () => {
-    expect(() =>
-      validateMerchantPayload({
-        email: "email@test.com",
-      })
-    ).not.toThrowError();
-  });
-
-  test("should have successful validation if phone is only passed", () => {
-    expect(() =>
-      validateMerchantPayload({
-        phone: {
-          countryCode: "1",
-          nationalNumber: "2345678901",
-        },
-      })
-    ).not.toThrowError();
-  });
-
-  test("should have successful validation if email and phone is passed", () => {
-    expect(() =>
-      validateMerchantPayload({
-        email: "email@test.com",
-        phone: {
-          countryCode: "1",
-          nationalNumber: "2345678901",
-        },
-      })
-    ).not.toThrowError();
-  });
-
-  test("should throw if email or phone is not passed", () => {
-    expect(() => validateMerchantPayload({})).toThrowError(
-      "Expected either email or phone number for get recommended payment methods"
-    );
-
-    expect(() =>
-      // $FlowIssue
-      validateMerchantPayload()
-    ).toThrowError(
-      "Expected either email or phone number for get recommended payment methods"
-    );
-  });
-
-  test("should throw if countryCode or nationalNumber in phone is not passed or is empty", () => {
-    expect.assertions(2);
-    expect(() =>
-      validateMerchantPayload({
-        phone: {
-          nationalNumber: "",
-          countryCode: "",
-        },
-      })
-    ).toThrowError(
-      "Expected either email or phone number for get recommended payment methods"
-    );
-
-    expect(() =>
-      validateMerchantPayload(
-        // $FlowFixMe
-        { phone: {} }
-      )
-    ).toThrowError(
-      "Expected either email or phone number for get recommended payment methods"
-    );
-  });
-
-  test("should throw if phone is in an invalid format", () => {
-    expect(() =>
-      validateMerchantPayload({
-        phone: { countryCode: "1", nationalNumber: "2.354" },
-      })
-    ).toThrowError(
-      "Expected shopper information to be a valid phone number format"
-    );
-    expect(() =>
-      validateMerchantPayload({
-        phone: { countryCode: "1", nationalNumber: "2-354" },
-      })
-    ).toThrowError(
-      "Expected shopper information to be a valid phone number format"
-    );
-    expect.assertions(2);
-  });
-
-  test("should throw if email is in an invalid format", () => {
-    expect(() =>
-      validateMerchantPayload({
-        email: "123",
-      })
-    ).toThrowError(
-      "Expected shopper information to include a valid email format"
-    );
-  });
-});