@lookiero/checkout 5.3.0-beta.2 → 6.0.0-beta.0

package/src/infrastructure/projection/checkout/httpCheckoutByIdView.test.ts

@@ -0,0 +1,56 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutDto, toCheckoutProjection } from "./checkout";
+import { checkoutDto } from "./checkout.mock";
+import { httpCheckoutByIdView as sut } from "./httpCheckoutByIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpPost: fetchHttpPost({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const checkoutId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutResponse: { result: CheckoutDto } = {
+  result: checkoutDto({ items: [{ status: CheckoutItemStatus.KEPT }] }),
+};
+const checkoutResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(checkoutResponse)),
+} as Response;
+const checkoutResponseNotFound: Response = {
+  ok: false,
+  status: 404,
+} as Response;
+const checkoutResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpCheckoutByIdView", () => {
+  it("returns a Checkout projection for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseOk));
+
+    const returnedCheckout = await view({ checkoutId, signal });
+
+    expect(returnedCheckout).toStrictEqual(toCheckoutProjection(checkoutResponse.result));
+  });
+
+  it("returns null for a 404 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseNotFound));
+
+    const returnedCheckout = await view({ checkoutId, signal });
+
+    expect(returnedCheckout).toBeNull();
+  });
+
+  it("returns null for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseError));
+
+    const returnedCheckout = await view({ checkoutId, signal });
+
+    expect(returnedCheckout).toBeNull();
+  });
+});

package/src/infrastructure/projection/checkout/httpCheckoutByIdView.ts

@@ -0,0 +1,32 @@
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import { CheckoutByIdView, ViewCheckoutByIdResult } from "../../../projection/checkout/viewCheckoutById";
+import { CheckoutDto, toCheckoutProjection } from "./checkout";
+
+interface HttpCheckoutByIdView extends CheckoutByIdView {}
+
+interface HttpCheckoutByIdViewFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutByIdViewFunction {
+  (args: HttpCheckoutByIdViewFunctionArgs): HttpCheckoutByIdView;
+}
+
+interface ViewCheckoutByIdResponse {
+  readonly result: CheckoutDto;
+}
+
+const httpCheckoutByIdView: HttpCheckoutByIdViewFunction =
+  ({ httpPost }) =>
+  async ({ checkoutId, signal }) =>
+    await httpPost<ViewCheckoutByIdResponse, ViewCheckoutByIdResult>({
+      endpoint: "/view-checkout-by-id",
+      body: { checkoutId },
+      signal,
+      result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+      },
+    });
+
+export { httpCheckoutByIdView };

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

@@ -0,0 +1,61 @@
+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 { CheckoutProjection } from "../../../projection/checkout/checkout";
+import { checkout } from "./checkout.mock";
+import { httpFirstAvailableCheckoutByCustomerIdView } from "./httpFirstAvailableCheckoutByCustomerIdView";
+
+const provider = new PactV3({
+  ...DEFAULT_PACT_OPTIONS,
+  consumer: "STY-BOX_CHECKOUT-FRONT",
+  provider: "STY-BOX_CHECKOUT-BACK_ViewFirstAvailableCheckoutByCustomerId",
+});
+
+const customerId = "fab61a4d-c94d-4e33-b098-1945294a5f75";
+
+const checkoutResponse: { result: CheckoutProjection } = {
+  result: checkout({ items: [{ status: CheckoutItemStatus.KEPT }] }),
+};
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const EXPECTED_BODY = MatchersV3.like(checkoutResponse);
+
+describe("STY-BOX_CHECKOUT-BACK_ViewFirstAvailableCheckoutByCustomerId API", () => {
+  it("returns a first available checkout for the given customer id", () => {
+    provider
+      .given("a first available checkout for the given customer id")
+      .uponReceiving("checkout projection")
+      .withRequest({
+        method: "POST",
+        path: "/api/view-first-available-checkout-by-customer-id",
+        headers: DEFAULT_REQUEST_HEADERS,
+        body: { customerId },
+      })
+      .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),
+      });
+
+      const response = await httpFirstAvailableCheckoutByCustomerIdView({ httpPost })({
+        customerId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(checkoutResponse.result);
+    });
+  });
+});

package/src/infrastructure/projection/checkout/httpFirstAvailableCheckoutByCustomerIdView.test.ts

@@ -0,0 +1,56 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpPost } from "@lookiero/sty-psp-http";
+import { CheckoutItemStatus } from "../../../domain/checkoutItem/model/checkoutItem";
+import { CheckoutDto, toCheckoutProjection } from "./checkout";
+import { checkoutDto } from "./checkout.mock";
+import { httpFirstAvailableCheckoutByCustomerIdView as sut } from "./httpFirstAvailableCheckoutByCustomerIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpPost: fetchHttpPost({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutResponse: { result: CheckoutDto } = {
+  result: checkoutDto({ items: [{ status: CheckoutItemStatus.KEPT }] }),
+};
+const checkoutResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(checkoutResponse)),
+} as Response;
+const checkoutResponseNotFound: Response = {
+  ok: false,
+  status: 404,
+} as Response;
+const checkoutResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpFirstAvailableCheckoutByCustomerIdView", () => {
+  it("returns a Checkout projection for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseOk));
+
+    const returnedCheckout = await view({ customerId, signal });
+
+    expect(returnedCheckout).toStrictEqual(toCheckoutProjection(checkoutResponse.result));
+  });
+
+  it("returns null for a 404 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseNotFound));
+
+    const returnedCheckout = await view({ customerId, signal });
+
+    expect(returnedCheckout).toBeNull();
+  });
+
+  it("returns null for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseError));
+
+    const returnedCheckout = await view({ customerId, signal });
+
+    expect(returnedCheckout).toBeNull();
+  });
+});

package/src/infrastructure/projection/checkout/httpFirstAvailableCheckoutByCustomerIdView.ts

@@ -0,0 +1,35 @@
+import { HttpPostFunction } from "@lookiero/sty-psp-http";
+import {
+  FirstAvailableCheckoutByCustomerIdView,
+  ViewFirstAvailableCheckoutByCustomerIdResult,
+} from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { CheckoutDto, toCheckoutProjection } from "./checkout";
+
+interface HttpFirstAvailableCheckoutByCustomerIdView extends FirstAvailableCheckoutByCustomerIdView {}
+
+interface HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpFirstAvailableCheckoutByCustomerIdViewFunction {
+  (args: HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs): HttpFirstAvailableCheckoutByCustomerIdView;
+}
+
+interface ViewFirstAvailableCheckoutByCustomerIdResponse {
+  readonly result: CheckoutDto;
+}
+
+const httpFirstAvailableCheckoutByCustomerIdView: HttpFirstAvailableCheckoutByCustomerIdViewFunction =
+  ({ httpPost }) =>
+  async ({ customerId, signal }) =>
+    await httpPost<ViewFirstAvailableCheckoutByCustomerIdResponse, ViewFirstAvailableCheckoutByCustomerIdResult>({
+      endpoint: "/view-first-available-checkout-by-customer-id",
+      body: { customerId },
+      signal,
+      result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+      },
+    });
+
+export { httpFirstAvailableCheckoutByCustomerIdView };

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

@@ -0,0 +1,55 @@
+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),
+      });
+
+      const response = await httpFiveItemsDiscountByCustomerIdView({ httpGet })({
+        customerId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(fiveItemsDiscountResponse);
+    });
+  });
+});

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

@@ -0,0 +1,39 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import { httpFiveItemsDiscountByCustomerIdView as sut } from "./httpFiveItemsDiscountByCustomerIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpGet: fetchHttpGet({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const fiveItemsDiscount = 25;
+const fiveItemsDiscountResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(fiveItemsDiscount)),
+} as Response;
+const fiveItemsDiscountResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpFiveItemsDiscountByCustomerIdView", () => {
+  it("returns five items discount if enabled/not for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(fiveItemsDiscountResponseOk));
+
+    const enabled = await view({ customerId, signal });
+
+    expect(enabled).toBe(fiveItemsDiscount);
+  });
+
+  it("returns 0 for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(fiveItemsDiscountResponseError));
+
+    const enabled = await view({ customerId, signal });
+
+    expect(enabled).toBe(0);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { HttpGetFunction } from "@lookiero/sty-psp-http";
+import {
+  FiveItemsDiscountByCustomerIdProjection,
+  FiveItemsDiscountByCustomerIdView,
+} from "../../../projection/checkout/viewFiveItemsDiscountByCustomerId";
+
+interface HttpFiveItemsDiscountByCustomerIdView extends FiveItemsDiscountByCustomerIdView {}
+
+interface HttpFiveItemsDiscountByCustomerIdViewFunctionArgs {
+  readonly httpGet: HttpGetFunction;
+}
+
+interface HttpFiveItemsDiscountByCustomerIdViewFunction {
+  (args: HttpFiveItemsDiscountByCustomerIdViewFunctionArgs): HttpFiveItemsDiscountByCustomerIdView;
+}
+
+const httpFiveItemsDiscountByCustomerIdView: HttpFiveItemsDiscountByCustomerIdViewFunction =
+  ({ httpGet }) =>
+  async ({ customerId, signal }) =>
+    await httpGet<FiveItemsDiscountByCustomerIdProjection>({
+      endpoint: `/view-five-items-discount-by-customer-id/${customerId}`,
+      signal,
+      result: {
+        error: 0,
+        success: (response) => response,
+      },
+    });
+
+export { httpFiveItemsDiscountByCustomerIdView };

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

@@ -0,0 +1,55 @@
+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),
+      });
+
+      const response = await httpIsCheckoutEnabledByCustomerIdView({ httpGet })({
+        customerId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(isCheckoutEnabledResponse);
+    });
+  });
+});

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

@@ -0,0 +1,38 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import { httpIsCheckoutEnabledByCustomerIdView as sut } from "./httpIsCheckoutEnabledByCustomerIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpGet: fetchHttpGet({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutResponseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(true)),
+} as Response;
+const checkoutResponseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpIsCheckoutEnabledByCustomerIdView", () => {
+  it("returns true/false if enabled/not for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseOk));
+
+    const enabled = await view({ customerId, signal });
+
+    expect(enabled).toBe(true);
+  });
+
+  it("returns false for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(checkoutResponseError));
+
+    const enabled = await view({ customerId, signal });
+
+    expect(enabled).toBe(false);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { HttpGetFunction } from "@lookiero/sty-psp-http";
+import {
+  IsCheckoutEnabledByCustomerIdProjection,
+  IsCheckoutEnabledByCustomerIdView,
+} from "../../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+
+interface HttpIsCheckoutEnabledByCustomerIdView extends IsCheckoutEnabledByCustomerIdView {}
+
+interface HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs {
+  readonly httpGet: HttpGetFunction;
+}
+
+interface HttpIsCheckoutEnabledByCustomerIdViewFunction {
+  (args: HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs): HttpIsCheckoutEnabledByCustomerIdView;
+}
+
+const httpIsCheckoutEnabledByCustomerIdView: HttpIsCheckoutEnabledByCustomerIdViewFunction =
+  ({ httpGet }) =>
+  async ({ customerId, signal }) =>
+    await httpGet<IsCheckoutEnabledByCustomerIdProjection>({
+      endpoint: `/is-new-checkout-enabled/${customerId}`,
+      signal,
+      result: {
+        error: false,
+        success: (response) => response,
+      },
+    });
+
+export { httpIsCheckoutEnabledByCustomerIdView };

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

@@ -0,0 +1,55 @@
+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),
+      });
+
+      const response = await httpIsSizeChangeEnabledByCheckoutIdView({ httpGet })({
+        checkoutId,
+        signal: undefined,
+      });
+
+      expect(response).toStrictEqual(isSizeChangeEnabledResponse);
+    });
+  });
+});

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

@@ -0,0 +1,38 @@
+import { mock } from "jest-mock-extended";
+import { fetchHttpGet } from "@lookiero/sty-psp-http";
+import { httpIsSizeChangeEnabledByCheckoutIdView as sut } from "./httpIsSizeChangeEnabledByCheckoutIdView";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+const apiUrl = "/api";
+const getAuthToken = () => Promise.resolve("token");
+const view = sut({ httpGet: fetchHttpGet({ apiUrl: () => apiUrl, getAuthToken }) });
+const signal = mock<AbortSignal>();
+
+const checkoutId = "29790d24-b139-4ab8-b618-d796d101e974";
+const responseOk: Response = {
+  ok: true,
+  status: 200,
+  text: () => Promise.resolve(JSON.stringify(true)),
+} as Response;
+const responseError: Response = {
+  ok: false,
+} as Response;
+
+describe("httpIsSizeChangeEnabledByCheckoutIdView", () => {
+  it("returns true/false if enabled/not for a 200 response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(responseOk));
+
+    const enabled = await view({ checkoutId, signal });
+
+    expect(enabled).toBe(true);
+  });
+
+  it("returns false for a non successfull response", async () => {
+    fetchMock.mockReturnValue(Promise.resolve(responseError));
+
+    const enabled = await view({ checkoutId, signal });
+
+    expect(enabled).toBe(false);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { HttpGetFunction } from "@lookiero/sty-psp-http";
+import {
+  IsSizeChangeEnabledByCheckoutIdProjection,
+  IsSizeChangeEnabledByCheckoutIdView,
+} from "../../../projection/checkout/viewIsSizeChangeEnabledByCheckoutId";
+
+interface HttpIsSizeChangeEnabledByCheckoutIdView extends IsSizeChangeEnabledByCheckoutIdView {}
+
+interface HttpIsSizeChangeEnabledByCheckoutIdViewFunctionArgs {
+  readonly httpGet: HttpGetFunction;
+}
+
+interface HttpIsSizeChangeEnabledByCheckoutIdViewFunction {
+  (args: HttpIsSizeChangeEnabledByCheckoutIdViewFunctionArgs): HttpIsSizeChangeEnabledByCheckoutIdView;
+}
+
+const httpIsSizeChangeEnabledByCheckoutIdView: HttpIsSizeChangeEnabledByCheckoutIdViewFunction =
+  ({ httpGet }) =>
+  async ({ checkoutId, signal }) =>
+    await httpGet<IsSizeChangeEnabledByCheckoutIdProjection>({
+      endpoint: `/is-size-change-enabled-by-checkout-id/${checkoutId}`,
+      signal,
+      result: {
+        error: false,
+        success: (response) => response,
+      },
+    });
+
+export { httpIsSizeChangeEnabledByCheckoutIdView };

package/src/infrastructure/projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId.test.ts

@@ -0,0 +1,29 @@
+import { renderHook, waitFor } from "@testing-library/react-native";
+import { bootstrap, QueryStatus } from "@lookiero/messaging-react";
+import { CheckoutProjection } from "../../../../projection/checkout/checkout";
+import {
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+} from "../../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+import { useViewFirstAvailableCheckoutByCustomerId as sut } from "./useViewFirstAvailableCheckoutByCustomerId";
+
+const customerId = "29790d24-b139-4ab8-b618-d796d101e974";
+const checkoutProjection: CheckoutProjection = { id: "75574065-5838-42de-9924-c712f7854347" } as CheckoutProjection;
+const view = jest.fn().mockReturnValue(checkoutProjection);
+const { Component: Messaging } = bootstrap({ id: MESSAGING_CONTEXT_ID })
+  .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, { view })
+  .build();
+
+describe("useViewFirstAvailableCheckoutByCustomerId integration hook", () => {
+  it("returns success as the query status and the result itself after rendering the hook", async () => {
+    const { result } = renderHook(() => sut({ customerId }), { wrapper: Messaging });
+
+    await waitFor(() => {
+      const [projection, status] = result.current;
+
+      expect(projection).toStrictEqual(checkoutProjection);
+      expect(status).toBe(QueryStatus.SUCCESS);
+    });
+  });
+});