@lookiero/checkout 8.14.0-beta.102 → 8.14.0-beta.2

package/src/infrastructure/projection/checkout/httpFiveItemsDiscountByCustomerIdView.pact.ts

@@ -0,0 +1,57 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { httpFiveItemsDiscountByCustomerIdView } from "./httpFiveItemsDiscountByCustomerIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewFiveItemsDiscountByCustomerId",
+});
+
+const customerId = "fab61a4d-c94d-4e33-b098-1945294a5f75";
+const fiveItemsDiscountResponse = 25;
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.number(fiveItemsDiscountResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewFiveItemsDiscountByCustomerId API", () => {
+  it("returns a five items discount for the given customer id", () => {
+    provider
+      .given("a five items discount for the given customer id")
+      .uponReceiving("five items discount")
+      .withRequest({
+        method: "GET",
+        path: `/api/view-five-items-discount-by-customer-id/${customerId}`,
+        headers: DEFAULT_REQUEST_HEADERS,
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpGet = fetchHttpGet({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpFiveItemsDiscountByCustomerIdView({ httpGet })({
+        customerId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(fiveItemsDiscountResponse);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/httpIsCheckoutEnabledByCustomerIdView.pact.ts

@@ -0,0 +1,57 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { httpIsCheckoutEnabledByCustomerIdView } from "./httpIsCheckoutEnabledByCustomerIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewIsCheckoutEnabledByCustomerId",
+});
+
+const customerId = "fab61a4d-c94d-4e33-b098-1945294a5f75";
+const isCheckoutEnabledResponse = true;
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.boolean(isCheckoutEnabledResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewIsCheckoutEnabledByCustomerId API", () => {
+  it("returns is new checkout enabled for the given customer id", () => {
+    provider
+      .given("is new checkout enabled for the given customer id")
+      .uponReceiving("is new checkout enabled")
+      .withRequest({
+        method: "GET",
+        path: `/api/is-new-checkout-enabled/${customerId}`,
+        headers: DEFAULT_REQUEST_HEADERS,
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpGet = fetchHttpGet({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpIsCheckoutEnabledByCustomerIdView({ httpGet })({
+        customerId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(isCheckoutEnabledResponse);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/httpIsSizeChangeEnabledByCheckoutIdView.pact.ts

@@ -0,0 +1,57 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { httpIsSizeChangeEnabledByCheckoutIdView } from "./httpIsSizeChangeEnabledByCheckoutIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewIsSizeChangeEnabledByCheckoutId",
+});
+
+const checkoutId = "fab61a4d-c94d-4e33-b098-1945294a5f75";
+const isSizeChangeEnabledResponse = true;
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(isSizeChangeEnabledResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewIsSizeChangeEnabledByCheckoutId API", () => {
+  it("returns is size-change enabled for the given checkout id", () => {
+    provider
+      .given("is size-change enabled for the given checkout id")
+      .uponReceiving("is size-change enabled")
+      .withRequest({
+        method: "GET",
+        path: `/api/is-size-change-enabled-by-checkout-id/${checkoutId}`,
+        headers: DEFAULT_REQUEST_HEADERS,
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpGet = fetchHttpGet({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpIsSizeChangeEnabledByCheckoutIdView({ httpGet })({
+        checkoutId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(isSizeChangeEnabledResponse);
+    });
+  });
+});

package/src/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.pact.ts

@@ -0,0 +1,63 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { CheckoutBookingProjection } from "../../../projection/checkoutBooking/checkoutBooking";
+import { checkoutBooking as checkoutBookingMock } from "./checkoutBooking.mock";
+import { httpCheckoutBookingByIdView } from "./httpCheckoutBookingByIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewCheckoutBookingById",
+});
+
+const checkoutBookingProjection = checkoutBookingMock;
+const checkoutBookingId = checkoutBookingProjection.id;
+
+const checkoutBookingResponse: { result: CheckoutBookingProjection } = {
+  result: checkoutBookingProjection,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutBookingResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewCheckoutBookingById API", () => {
+  it("returns a valid checkout booking for the given id", () => {
+    provider
+      .given("a valid checkout booking for the given id")
+      .uponReceiving("checkout booking projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-checkout-booking-by-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutBookingId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpCheckoutBookingByIdView({ httpPost })({
+        checkoutBookingId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutBookingResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.pact.ts

@@ -0,0 +1,64 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutItemProjection } from "../../../projection/checkoutItem/checkoutItem";
+import { checkoutItem } from "./checkoutItem.mock";
+import { httpCheckoutItemByIdView } from "./httpCheckoutItemByIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewCheckoutItemById",
+});
+
+const checkoutItemProjection = checkoutItem({ status: CheckoutItemStatus.INITIAL });
+const checkoutItemId = checkoutItemProjection.id;
+
+const checkoutItemResponse: { result: CheckoutItemProjection } = {
+  result: checkoutItemProjection,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutItemResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewCheckoutItemById API", () => {
+  it("returns a valid checkout item for the given id", () => {
+    provider
+      .given("a valid checkout item for the given id")
+      .uponReceiving("checkout item projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-checkout-item-by-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutItemId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpCheckoutItemByIdView({ httpPost })({
+        checkoutItemId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutItemResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/checkoutQuestion/httpCheckoutQuestionsByCheckoutIdView.pact.ts

@@ -0,0 +1,62 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { CheckoutQuestionProjection } from "../../../projection/checkoutQuestion/checkoutQuestion";
+import { checkoutQuestions } from "./checkoutQuestions.mock";
+import { httpCheckoutQuestionsByCheckoutIdView } from "./httpCheckoutQuestionsByCheckoutIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ListCheckoutQuestionsByCheckoutId",
+});
+
+const checkoutId = "52440ae5-7a4c-498b-8b35-08ecfde15776";
+
+const checkoutQuestionsResponse: { result: CheckoutQuestionProjection[] } = {
+  result: checkoutQuestions,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutQuestionsResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ListCheckoutQuestionsByCheckoutId API", () => {
+  it("returns a valid checkout questions for the given checkout id", () => {
+    provider
+      .given("a valid checkout questions for the given checkout id")
+      .uponReceiving("checkout questions projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/list-checkout-questions-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpCheckoutQuestionsByCheckoutIdView({ httpPost })({
+        checkoutId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutQuestionsResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/payment/httpPaymentFlowPayloadByCheckoutIdView.pact.ts

@@ -0,0 +1,136 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { PaymentFlowPayloadProjection } from "../../../projection/payment/paymentFlowPayload";
+import { httpPaymentFlowPayloadByCheckoutIdView } from "./httpPaymentFlowPayloadByCheckoutIdView";
+import {
+  paymentFlowPayloadForKeptItems,
+  paymentFlowPayloadForReturnedItems,
+  paymentFlowPayloadForReplacedItems,
+} from "./paymentFlowPayload.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewPaymentFlowPayloadByCheckoutId",
+});
+
+const checkoutId = "e2490de5-5bd3-43d5-b7c4-526e33f71304";
+
+const paymentFlowPayloadForKeptItemsResponse: { result: PaymentFlowPayloadProjection } = {
+  result: paymentFlowPayloadForKeptItems,
+};
+const paymentFlowPayloadForReturnedItemsResponse: { result: PaymentFlowPayloadProjection } = {
+  result: paymentFlowPayloadForReturnedItems,
+};
+const paymentFlowPayloadForReplacedItemsResponse: { result: PaymentFlowPayloadProjection } = {
+  result: paymentFlowPayloadForReplacedItems,
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_KEPT_ITEMS = MatchersV3.like(paymentFlowPayloadForKeptItemsResponse);
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_RETURNED_ITEMS = MatchersV3.like(paymentFlowPayloadForReturnedItemsResponse);
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY_FOR_REPLACED_ITEMS = MatchersV3.like(paymentFlowPayloadForReplacedItemsResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewPaymentFlowPayloadByCheckoutId API", () => {
+  it("returns a valid payment-flow payload for the given checkout id [KEPT items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [KEPT items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_KEPT_ITEMS,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+
+      expect(response).toStrictEqual(paymentFlowPayloadForKeptItemsResponse.result);
+    });
+  });
+
+  it("returns a valid payment-flow payload for the given checkout id [RETURNED items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [RETURNED items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_RETURNED_ITEMS,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+
+      expect(response).toStrictEqual(paymentFlowPayloadForReturnedItemsResponse.result);
+    });
+  });
+
+  it("returns a valid payment-flow payload for the given checkout id [REPLACED items] ", () => {
+    provider
+      .given("a valid payment-flow payload for the given checkout id [REPLACED items] ")
+      .uponReceiving("payment-flow payload projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-payment-flow-payload-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY_FOR_REPLACED_ITEMS,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpPaymentFlowPayloadByCheckoutIdView({ httpPost })({ checkoutId, signal: undefined });
+
+      expect(response).toStrictEqual(paymentFlowPayloadForReplacedItemsResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/payment/react/useViewPaymentFlowPayloadByCheckoutId.ts

@@ -27,7 +27,7 @@ const useViewPaymentFlowPayloadByCheckoutId: UseViewPaymentFlowPayloadByCheckout
     query: viewPaymentFlowPayloadByCheckoutId({ checkoutId: checkoutId as string }),
     contextId: MESSAGING_CONTEXT_ID,
     invalidation: shouldInvalidate,
-    options: { refetchOnMount: "always", enabled: Boolean(checkoutId), cacheTime: 0, refetchOnWindowFocus: false },
+    options: { refetchOnMount: "always", enabled: Boolean(checkoutId), cacheTime: 0 },
   });
 
 export { useViewPaymentFlowPayloadByCheckoutId };

package/src/infrastructure/projection/pricing/httpPricingByCheckoutIdView.pact.ts

@@ -0,0 +1,62 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { PricingProjection } from "../../../projection/pricing/pricing";
+import { httpPricingByCheckoutIdView } from "./httpPricingByCheckoutIdView";
+import { pricing } from "./pricing.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewPricingByCheckoutId",
+});
+
+const checkoutId = "6f720954-8039-4bed-9596-34fc5a02131b";
+
+const pricingResponse: { result: PricingProjection } = {
+  result: pricing(),
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(pricingResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewPricingByCheckoutId API", () => {
+  it("returns a valid pricing for the given checkout", () => {
+    provider
+      .given("a valid pricing for the given checkout")
+      .uponReceiving("pricing projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-pricing-by-checkout-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpPricingByCheckoutIdView({ httpPost })({
+        checkoutId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(pricingResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/returnQuestion/httpReturnQuestionsByCheckoutItemIdView.pact.ts

@@ -0,0 +1,62 @@
+import { MatchersV3, PactV3 } from "@pact-foundation/pact";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import {
+  AUTH_TOKEN,
+  DEFAULT_PACT_OPTIONS,
+  DEFAULT_REQUEST_HEADERS,
+  DEFAULT_RESPONSE_HEADERS,
+  fromMockServerUrlToApiUrl,
+} from "../../../../pact.config";
+import { ReturnQuestionProjection } from "../../../projection/returnQuestion/returnQuestion";
+import { httpReturnQuestionsByCheckoutItemIdView } from "./httpReturnQuestionsByCheckoutItemIdView";
+import { returnQuestions } from "./returnQuestions.mock";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ListReturnQuestionsByCheckoutItemId",
+});
+
+const checkoutItemId = "52440ae5-7a4c-498b-8b35-08ecfde15776";
+
+const returnQuestionsResponse: { result: ReturnQuestionProjection[] } = {
+  result: returnQuestions,
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(returnQuestionsResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ListReturnQuestionsByCheckoutItemId API", () => {
+  it("returns a valid return questions for the given checkout item id", () => {
+    provider
+      .given("a valid return questions for the given checkout item id")
+      .uponReceiving("return questions projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/list-return-questions-by-checkout-item-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { checkoutItemId },
+      })
+      .willRespondWith({
+        status: 200,
+        headers: DEFAULT_RESPONSE_HEADERS,
+        body: EXPECTED_BODY,
+      });
+
+    return provider.executeTest(async (mockserver) => {
+      const httpPost = fetchHttpPost({
+        apiUrl: () => fromMockServerUrlToApiUrl(mockserver),
+        getAuthToken: () => Promise.resolve(AUTH_TOKEN),
+        device: "web",
+        version: "1.0.0",
+      });
+
+      const response = await httpReturnQuestionsByCheckoutItemIdView({ httpPost })({
+        checkoutItemId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(returnQuestionsResponse.result);
+    });
+  });
+});

package/src/infrastructure/ui/Root.tsx

@@ -11,7 +11,7 @@ import { Customer } from "../../projection/customer/customer";
 import { Order } from "../../projection/order/order";
 import { Subscription } from "../../projection/subscription/subscription";
 import { KameleoonEnvironment } from "../ab-testing/kameleoonEnvironment";
-import { Routing } from "./routing/Routing";
+import { Routing, RoutingStyle } from "./routing/Routing";
 
 interface RootFunctionArgs {
   readonly Messaging: MessagingRoot;
@@ -33,6 +33,7 @@ interface RootProps {
   readonly order: Order | undefined;
   readonly subscription: Subscription | undefined;
   readonly layout: Layout;
+  readonly style?: Partial<RoutingStyle>;
   readonly onNotAccessible: () => void;
   readonly onCheckoutSubmitted?: () => void;
   readonly useRedirect: () => Record<string, string>;
@@ -51,6 +52,7 @@ const root: RootFunction = ({ Messaging, I18n, getAuthToken, development, sentry
     order,
     subscription,
     layout,
+    style: customStyle,
     onNotAccessible,
     onCheckoutSubmitted,
     useRedirect,
@@ -69,6 +71,7 @@ const root: RootFunction = ({ Messaging, I18n, getAuthToken, development, sentry
           layout={layout}
           locale={locale}
           order={order}
+          style={customStyle}
           subscription={subscription}
           useRedirect={useRedirect}
           useRoutes={useRoutes}