@lookiero/checkout 0.1.1

package/src/infrastructure/delivery/_mock/checkout.mock.ts

@@ -0,0 +1,81 @@
+import { v4 as uuid } from "uuid";
+import {
+  CheckoutItemProjection,
+  CheckoutItemStatus,
+  CheckoutProjection,
+  CheckoutStatus,
+  Currency,
+  MediaPerspective,
+} from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+
+interface CheckoutItemFunctionArgs {
+  readonly status: CheckoutItemStatus;
+}
+
+interface CheckoutItemFunction {
+  (args: CheckoutItemFunctionArgs): CheckoutItemProjection;
+}
+
+const checkoutItem: CheckoutItemFunction = ({ status }) => ({
+  id: uuid(),
+  status,
+  productVariant: {
+    id: uuid(),
+    media: [
+      {
+        id: uuid(),
+        url: "https://cdn-catalog-back-prod.envs.lookiero.tech/d2/65/d2655b80-7745-4537-bb17-eb38f960a8de.jpg",
+        perspective: MediaPerspective.FRONT,
+      },
+    ],
+    brand: "CKS",
+    name: "Sari Tshirt lines",
+    price: {
+      amount: 3999,
+      currency: Currency.EUR,
+    },
+    size: {
+      id: uuid(),
+      lookiero: "M",
+      uk: "M",
+      it: "M",
+      europe: "M",
+      unique: false,
+    },
+    color: {
+      id: uuid(),
+      label: "black_C2",
+    },
+  },
+});
+
+interface CheckoutWithItemsFunctionArgs {
+  readonly items: CheckoutItemProjection[];
+}
+
+interface CheckoutWithItemsFunction {
+  (args: CheckoutWithItemsFunctionArgs): CheckoutProjection;
+}
+
+const checkoutWithItems: CheckoutWithItemsFunction = ({ items }) => ({
+  id: uuid(),
+  status: CheckoutStatus.STARTED,
+  customerId: uuid(),
+  boxId: uuid(),
+  bookingId: uuid(),
+  expiresOn: new Date("2022-09-20"),
+  items,
+});
+
+interface StartedCheckoutWithStatusFunctionArgs {
+  readonly status: CheckoutItemStatus[];
+}
+
+interface StartedCheckoutWithStatusFunction {
+  (args: StartedCheckoutWithStatusFunctionArgs): CheckoutProjection;
+}
+
+const startedCheckoutWithItems: StartedCheckoutWithStatusFunction = ({ status }) =>
+  checkoutWithItems({ items: status.map((status) => checkoutItem({ status })) });
+
+export { startedCheckoutWithItems };

package/src/infrastructure/delivery/bootstrap.ts

@@ -0,0 +1,42 @@
+import { bootstrap as messagingBootstrap, BuildBootstrapFunctionReturn } from "@lookiero/messaging-react";
+import {
+  viewFirstAvailableCheckoutByCustomerIdHandler,
+  VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID,
+} from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import {
+  viewIsCheckoutAccessibleByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID,
+} from "../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import {
+  viewIsCheckoutEnabledByCustomerIdHandler,
+  VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID,
+} from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { httpFirstAvailableCheckoutByCustomerIdView } from "../projection/httpFirstAvailableCheckoutByCustomerIdView";
+import { httpIsCheckoutEnabledByCustomerIdView } from "../projection/httpIsCheckoutEnabledByCustomerIdView";
+import { fetchHttpGet, fetchHttpPost } from "./http/fetchHttpClient";
+
+interface BootstrapFunctionArgs {
+  readonly getAuthToken: () => string;
+  readonly apiUrl: string;
+}
+
+interface BootstrapFunction {
+  (args: BootstrapFunctionArgs): BuildBootstrapFunctionReturn;
+}
+
+const bootstrap: BootstrapFunction = ({ apiUrl, getAuthToken }) => {
+  const httpGet = fetchHttpGet({ apiUrl, getAuthToken });
+  const httpPost = fetchHttpPost({ apiUrl, getAuthToken });
+
+  return messagingBootstrap({ id: "Checkout" })
+    .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, {
+      view: httpFirstAvailableCheckoutByCustomerIdView({ httpPost }),
+    })
+    .query(VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerIdHandler, {
+      view: httpIsCheckoutEnabledByCustomerIdView({ httpGet }),
+    })
+    .query(VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, viewIsCheckoutAccessibleByCustomerIdHandler, {})
+    .build();
+};
+
+export { bootstrap };

package/src/infrastructure/delivery/http/fetchHttpClient.test.ts

@@ -0,0 +1,51 @@
+import { fetchHttpGet as sutGet, fetchHttpPost as sutPost } from "./fetchHttpClient";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+
+const apiUrl = "/api";
+const authToken = "token";
+const post = sutPost({ apiUrl, getAuthToken: () => authToken });
+const get = sutGet({ apiUrl, getAuthToken: () => authToken });
+
+afterEach(() => {
+  fetchMock.mockClear();
+});
+
+describe("fetchHttpClient", () => {
+  it("does a POST http request with the expected parameters", async () => {
+    const endpoint = "/dummy-endpoint";
+    const body = { foo: "bar" };
+    const expectedEndpoint = `${apiUrl}${endpoint}`;
+    const expectedPayload = {
+      method: "POST",
+      headers: {
+        ["Content-Type"]: "application/json",
+        authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify(body),
+    };
+
+    await post({ endpoint, body });
+
+    expect(fetchMock).toHaveBeenCalledWith(expectedEndpoint, expectedPayload);
+  });
+
+  it("does a GET http request with the expected parameters", async () => {
+    const endpoint = "/dummy-endpoint";
+    const expectedEndpoint = `${apiUrl}${endpoint}`;
+    const expectedPayload = {
+      method: "GET",
+      credentials: "include",
+      mode: "no-cors",
+      headers: {
+        authorization: `Bearer ${authToken}`,
+      },
+      referrer: "",
+    };
+
+    await get({ endpoint });
+
+    expect(fetchMock).toHaveBeenCalledWith(expectedEndpoint, expectedPayload);
+  });
+});

package/src/infrastructure/delivery/http/fetchHttpClient.ts

@@ -0,0 +1,41 @@
+import { HttpGetFunction, HttpPostFunction } from "./httpClient";
+
+interface FetchHttpFunctionArgs {
+  readonly apiUrl: string;
+  readonly getAuthToken: () => string;
+}
+
+interface FetchHttpPostFunction {
+  (args: FetchHttpFunctionArgs): HttpPostFunction;
+}
+
+interface FetchHttpGetFunction {
+  (args: FetchHttpFunctionArgs): HttpGetFunction;
+}
+
+const fetchHttpPost: FetchHttpPostFunction =
+  ({ apiUrl, getAuthToken }) =>
+  async ({ endpoint, body }) =>
+    fetch(`${apiUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        ["Content-Type"]: "application/json",
+        authorization: `Bearer ${getAuthToken()}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+const fetchHttpGet: FetchHttpGetFunction =
+  ({ apiUrl, getAuthToken }) =>
+  async ({ endpoint }) =>
+    fetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      credentials: "include",
+      mode: "no-cors",
+      headers: {
+        authorization: `Bearer ${getAuthToken()}`,
+      },
+      referrer: "",
+    });
+
+export { fetchHttpGet, fetchHttpPost };

package/src/infrastructure/delivery/http/httpClient.ts

@@ -0,0 +1,18 @@
+interface HttpGetFunctionArgs {
+  readonly endpoint: string;
+}
+
+interface HttpGetFunction {
+  (args: HttpGetFunctionArgs): Promise<Response>;
+}
+
+interface HttpPostFunctionArgs {
+  readonly endpoint: string;
+  readonly body: Record<string, unknown>;
+}
+
+interface HttpPostFunction {
+  (args: HttpPostFunctionArgs): Promise<Response>;
+}
+
+export { HttpGetFunction, HttpPostFunction };

package/src/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.test.ts

@@ -0,0 +1,45 @@
+import { v4 as uuid } from "uuid";
+import { saveCheckoutBooking as sut } from "./httpCheckoutBookings";
+
+const saveCheckoutBookingResponseOk: Response = {
+  ok: true,
+} as Response;
+const saveCheckoutBookingResponseError: Response = {
+  ok: false,
+} as Response;
+
+const httpPostMock = jest.fn();
+
+const checkoutBooking = {
+  checkoutId: "this-should-be-a-uuid",
+  checkoutItemId: "this-should-be-a-uuid",
+  checkoutBookingId: "this-should-be-a-uuid",
+};
+
+describe("httpCheckoutBookings", () => {
+  it("saveCheckoutBooking: calls '/book-size-replaceable-product-variants-for-checkout-item' endpoint", async () => {
+    const expectedEndpoint = "/book-size-replaceable-product-variants-for-checkout-item";
+    httpPostMock.mockReturnValue(Promise.resolve(saveCheckoutBookingResponseOk));
+
+    const checkoutBookingsSave = { aggregateId: uuid(), ...checkoutBooking, domainEvents: [] };
+
+    await sut({ httpPost: httpPostMock })(checkoutBookingsSave);
+
+    expect(httpPostMock).toBeCalledWith({
+      endpoint: expectedEndpoint,
+      body: {
+        checkout_id: checkoutBooking.checkoutId,
+        checkout_item_id: checkoutBooking.checkoutItemId,
+        checkout_booking_id: checkoutBooking.checkoutBookingId,
+      },
+    });
+  });
+
+  it("saveCheckoutBooking: throws for an unsuccessfull response", async () => {
+    httpPostMock.mockReturnValue(Promise.resolve(saveCheckoutBookingResponseError));
+
+    const checkoutBookingsSave = { aggregateId: uuid(), ...checkoutBooking, domainEvents: [] };
+
+    await expect(sut({ httpPost: httpPostMock })(checkoutBookingsSave)).rejects.toThrow();
+  });
+});

package/src/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.ts

@@ -0,0 +1,32 @@
+import { CheckoutBookingsSaveFunction } from "../../../../domain/checkoutBooking/model/checkoutBookings";
+import { HttpPostFunction } from "../../../delivery/http/httpClient";
+
+interface HttpCheckoutBookingsSaveFunctionArgs {
+  readonly httpPost: HttpPostFunction;
+}
+
+interface HttpCheckoutBookingsSaveFunction {
+  (args: HttpCheckoutBookingsSaveFunctionArgs): CheckoutBookingsSaveFunction;
+}
+
+export const saveCheckoutBooking: HttpCheckoutBookingsSaveFunction =
+  ({ httpPost }) =>
+  async ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
+    try {
+      const response = await httpPost({
+        endpoint: "/book-size-replaceable-product-variants-for-checkout-item",
+        body: {
+          checkout_id: checkoutId,
+          checkout_item_id: checkoutItemId,
+          checkout_booking_id: checkoutBookingId,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error("Book size replaceable product variants for checkout item");
+      }
+      return;
+    } catch (ignored) {
+      throw new Error("Could not fetch BookSizeReplaceableProductVariantsForCheckoutItem");
+    }
+  };

package/src/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.test.ts

@@ -0,0 +1,38 @@
+import { bootstrap, CommandStatus } from "@lookiero/messaging-react";
+import { act, renderHook } from "@testing-library/react-hooks";
+import { BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM } from "../../../domain/checkoutBooking/command/bookSizeReplaceableProductVariantsForCheckoutItem";
+import { bookSizeReplaceableProductVariantsForCheckoutItemHandler } from "../../../domain/checkoutBooking/model/checkoutBooking";
+import { useBookSizeReplaceableProductVariantsForCheckoutItem as sut } from "./useBookSizeReplaceableProductVariantsForCheckoutItem";
+
+const checkoutBooking = {
+  checkoutId: "this-should-be-a-uuid",
+  checkoutItemId: "this-should-be-a-uuid",
+  checkoutBookingId: "this-should-be-a-uuid",
+};
+
+const saveMock = jest.fn();
+const { Component: Messaging } = bootstrap()
+  .command(
+    BOOK_SIZE_REPLACEABLE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM,
+    bookSizeReplaceableProductVariantsForCheckoutItemHandler,
+    {
+      get: jest.fn(),
+      save: saveMock,
+    },
+  )
+  .build();
+
+describe("useBookSizeReplaceableProductVariantsForCheckoutItem integration hook", () => {
+  it("returns success as the status right after calling 'book'", async () => {
+    saveMock.mockResolvedValue("success");
+    const { result, waitFor } = renderHook(() => sut({ ...checkoutBooking }), { wrapper: Messaging });
+
+    expect(result.current.status).toBe(CommandStatus.IDLE);
+
+    await act(() => result.current.book());
+
+    await waitFor(() => {
+      expect(result.current.status).toBe(CommandStatus.SUCCESS);
+    });
+  });
+});

package/src/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.ts

@@ -0,0 +1,44 @@
+import { CommandStatus, useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { bookSizeReplaceableProductVariantsForCheckoutItem } from "../../../domain/checkoutBooking/command/bookSizeReplaceableProductVariantsForCheckoutItem";
+
+interface UseBookSizeReplaceableProductVariantsForCheckoutItem {
+  readonly book: () => Promise<void>;
+  readonly status: CommandStatus;
+}
+
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
+  readonly checkoutId: string;
+  readonly checkoutItemId: string;
+  readonly checkoutBookingId: string;
+}
+
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunction {
+  (
+    args: UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs,
+  ): UseBookSizeReplaceableProductVariantsForCheckoutItem;
+}
+
+export const useBookSizeReplaceableProductVariantsForCheckoutItem: UseBookSizeReplaceableProductVariantsForCheckoutItemFunction =
+  ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
+    const [commandBus, status] = useCommand();
+
+    const book = useCallback(
+      async () =>
+        await commandBus(
+          bookSizeReplaceableProductVariantsForCheckoutItem({
+            aggregateId: uuid(),
+            checkoutId,
+            checkoutItemId,
+            checkoutBookingId,
+          }),
+        ),
+      [checkoutBookingId, checkoutId, checkoutItemId, commandBus],
+    );
+
+    return {
+      book,
+      status,
+    };
+  };

package/src/infrastructure/domain/react/useUpdateUiSetting.test.ts

@@ -0,0 +1,31 @@
+import { bootstrap, CommandStatus } from "@lookiero/messaging-react";
+import { act, renderHook } from "@testing-library/react-hooks";
+import { UPDATE_UI_SETTING } from "../../../domain/uiSetting/command/updateUiSetting";
+import { updateUiSettingHandler } from "../../../domain/uiSetting/model/uiSetting";
+import { useUpdateUiSetting as sut } from "./useUpdateUiSetting";
+
+const uiSettingKey = "ui_setting_key";
+const uiSettingValue = "ui_setting_value";
+
+const saveMock = jest.fn();
+const { Component: Messaging } = bootstrap()
+  .command(UPDATE_UI_SETTING, updateUiSettingHandler, {
+    get: jest.fn(),
+    save: saveMock,
+  })
+  .build();
+
+describe("useUpdateUiSetting integration hook", () => {
+  it("returns success as the status right after calling 'update'", async () => {
+    saveMock.mockResolvedValue("success");
+    const { result, waitFor } = renderHook(() => sut(), { wrapper: Messaging });
+
+    expect(result.current.status).toBe(CommandStatus.IDLE);
+
+    await act(() => result.current.update({ key: uiSettingKey, value: uiSettingValue }));
+
+    await waitFor(() => {
+      expect(result.current.status).toBe(CommandStatus.SUCCESS);
+    });
+  });
+});

package/src/infrastructure/domain/react/useUpdateUiSetting.ts

@@ -0,0 +1,43 @@
+import { CommandStatus, useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { updateUiSetting } from "../../../domain/uiSetting/command/updateUiSetting";
+
+interface UpdateFunctionArgs {
+  readonly key: string;
+  readonly value: unknown;
+}
+
+interface UpdateFunction {
+  (args: UpdateFunctionArgs): Promise<void>;
+}
+
+interface UseUpdateUiSetting {
+  readonly update: UpdateFunction;
+  readonly status: CommandStatus;
+}
+
+interface UseUpdateUiSettingFunction {
+  (): UseUpdateUiSetting;
+}
+
+export const useUpdateUiSetting: UseUpdateUiSettingFunction = () => {
+  const [commandBus, status] = useCommand();
+
+  const update: UpdateFunction = useCallback(
+    async ({ key, value }) =>
+      await commandBus(
+        updateUiSetting({
+          aggregateId: uuid(),
+          key,
+          value,
+        }),
+      ),
+    [commandBus],
+  );
+
+  return {
+    update,
+    status,
+  };
+};

package/src/infrastructure/domain/uiSetting/model/storageUiSettings.test.ts

@@ -0,0 +1,50 @@
+import { v4 as uuid } from "uuid";
+import { getUiSetting as getSut, saveUiSetting as saveSut } from "./storageUiSettings";
+
+const readMock = jest.fn();
+const writeMock = jest.fn();
+
+describe("storageUiSettings", () => {
+  it("gets uiSetting based on the given ui setting key", async () => {
+    const aggregateId = uuid();
+    const uiSettingKey = "ui_setting_key";
+    const uiSettingValue = "ui_setting_value";
+
+    readMock.mockReturnValue({
+      id: aggregateId,
+      key: uiSettingKey,
+      value: uiSettingValue,
+    });
+
+    const getResponse = await getSut({ read: readMock })(uiSettingKey);
+
+    expect(getResponse).toEqual({ aggregateId, key: uiSettingKey, value: uiSettingValue, domainEvents: [] });
+  });
+
+  it("throws an Error when uiSetting based on the given ui setting key does not exist", async () => {
+    const uiSettingKey = "ui_setting_key";
+
+    readMock.mockReturnValue(undefined);
+
+    await expect(getSut({ read: readMock })(uiSettingKey)).rejects.toThrow();
+  });
+
+  it("saves the given uiSetting", async () => {
+    const aggregateId = uuid();
+    const uiSettingKey = "ui_setting_key";
+    const uiSettingValue = "ui_setting_value";
+
+    const uiSettingDto = { aggregateId, key: uiSettingKey, value: uiSettingValue };
+    const uiSetting = { ...uiSettingDto, domainEvents: [] };
+
+    writeMock.mockResolvedValue("success");
+
+    await saveSut({ write: writeMock })(uiSetting);
+
+    expect(writeMock).toHaveBeenCalledWith(uiSettingKey, {
+      id: aggregateId,
+      key: uiSettingKey,
+      value: uiSettingValue,
+    });
+  });
+});

package/src/infrastructure/domain/uiSetting/model/storageUiSettings.ts

@@ -0,0 +1,50 @@
+import { UiSetting } from "../../../../domain/uiSetting/model/uiSetting";
+import { UiSettingGetFunction, UiSettingSaveFunction } from "../../../../domain/uiSetting/model/uiSettings";
+import { ReadFunction, WriteFunction } from "../../../persistence/storage";
+import { UiSettingDto } from "../../../persistence/uiSettingData";
+
+const toDomain = (uiSettingDto: UiSettingDto): UiSetting => ({
+  aggregateId: uiSettingDto.id,
+  key: uiSettingDto.key,
+  value: uiSettingDto.value,
+  domainEvents: [],
+});
+
+const fromDomain = (uiSetting: UiSetting): UiSettingDto => ({
+  id: uiSetting.aggregateId,
+  key: uiSetting.key,
+  value: uiSetting.value,
+});
+
+interface StorageUiSettingsGetFunctionArgs {
+  readonly read: ReadFunction<UiSettingDto>;
+}
+
+interface StorageUiSettingsGetFunction {
+  (args: StorageUiSettingsGetFunctionArgs): UiSettingGetFunction;
+}
+
+export const getUiSetting: StorageUiSettingsGetFunction =
+  ({ read }) =>
+  async (uiSettingKey) => {
+    const uiSettingDto = await read(uiSettingKey);
+
+    if (!uiSettingDto) {
+      throw new Error(`UiSetting not found: ${uiSettingKey}`);
+    }
+
+    return toDomain(uiSettingDto);
+  };
+
+interface StorageUiSettingsSaveFunctionArgs {
+  readonly write: WriteFunction<UiSettingDto>;
+}
+
+interface StorageUiSettingsSaveFunction {
+  (args: StorageUiSettingsSaveFunctionArgs): UiSettingSaveFunction;
+}
+
+export const saveUiSetting: StorageUiSettingsSaveFunction =
+  ({ write }) =>
+  async (aggregateRoot) =>
+    await write(aggregateRoot.key, fromDomain(aggregateRoot));

package/src/infrastructure/persistence/asyncStorageStorage.ts

@@ -0,0 +1,12 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { ReadFunction, WriteFunction } from "./storage";
+import { UiSettingDto } from "./uiSettingData";
+
+export const read: ReadFunction<UiSettingDto> = async (key) => {
+  const value = await AsyncStorage.getItem(key);
+
+  return value ? JSON.parse(value) : undefined;
+};
+
+export const write: WriteFunction<UiSettingDto> = async (key, value) =>
+  AsyncStorage.setItem(key, JSON.stringify(value));

package/src/infrastructure/persistence/storage.ts

@@ -0,0 +1,7 @@
+export interface ReadFunction<T> {
+  (key: string): Promise<T | undefined>;
+}
+
+export interface WriteFunction<T> {
+  (key: string, value: T): Promise<void>;
+}

package/src/infrastructure/persistence/uiSettingData.ts

@@ -0,0 +1,5 @@
+export interface UiSettingDto {
+  readonly id: string;
+  readonly key: string;
+  readonly value: unknown;
+}

package/src/infrastructure/projection/httpBookedSizeReplaceableProductVariantsForCheckoutItemView.test.ts

@@ -0,0 +1,65 @@
+import {
+  BookedSizeReplaceableProductVariantsDto,
+  httpBookedSizeReplaceableProductVariantsForCheckoutItemView,
+  toBookedSizeReplaceableProductVariants,
+} from "./httpBookedSizeReplaceableProductVariantsForCheckoutItemView";
+
+const checkoutItemId = "6f720954-8039-4bed-9596-34fc5a02131b";
+const bookedSizeReplaceableProductVariantsResponse: { result: BookedSizeReplaceableProductVariantsDto } = {
+  result: {
+    booking: "b00e2c2d-7d9c-4808-88a4-e1c845ae6889",
+    product_variants: [
+      {
+        id: "383fab95-56eb-4639-bb18-530ab792b4d3",
+        size: {
+          id: "4f8a26b8-8d2d-4012-b49a-7d2820095598",
+          europe: { size: "36", format: "36" },
+          lookiero: { size: "S", format: "S" },
+          uk: { size: "8", format: "8" },
+          it: { size: "M", format: "M" },
+        },
+      },
+    ],
+  },
+};
+const bookedSizeReplaceableProductVariantsResponseOk: Response = {
+  ok: true,
+  status: 200,
+  json: () => Promise.resolve(bookedSizeReplaceableProductVariantsResponse),
+} as Response;
+const bookedSizeReplaceableProductVariantsResponseNotFound: Response = {
+  ok: false,
+  status: 404,
+} as Response;
+const bookedSizeReplaceableProductVariantsResponseError: Response = {
+  ok: false,
+} as Response;
+
+const httpPostMock = jest.fn();
+const view = httpBookedSizeReplaceableProductVariantsForCheckoutItemView({ httpPost: httpPostMock });
+
+describe("httpBookedSizeReplaceableProductVariantsForCheckoutItemView", () => {
+  it("returns a BookedSizeReplaceableProductVariants projection for a 200 response", async () => {
+    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseOk));
+
+    const returnedBookedSizeReplaceableProductVariants = await view({ checkoutItemId });
+
+    expect(returnedBookedSizeReplaceableProductVariants).toStrictEqual(
+      toBookedSizeReplaceableProductVariants(bookedSizeReplaceableProductVariantsResponse.result),
+    );
+  });
+
+  it("returns undefined for a 404 response", async () => {
+    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseNotFound));
+
+    const returnedBookedSizeReplaceableProductVariants = await view({ checkoutItemId });
+
+    expect(returnedBookedSizeReplaceableProductVariants).toBeUndefined();
+  });
+
+  it("throws for an unsuccessfull response", async () => {
+    httpPostMock.mockReturnValue(Promise.resolve(bookedSizeReplaceableProductVariantsResponseError));
+
+    await expect(view({ checkoutItemId })).rejects.toThrow();
+  });
+});