@duffel/components 2.7.19 → 3.0.0-canary

package/src/tests/lib/createPriceFormatters.test.tsx

@@ -0,0 +1,152 @@
+import { createPriceFormatters } from "@lib/createPriceFormatters";
+
+describe("createPriceFormatters", () => {
+  it("should return an empty object if neither markup nor priceFormatters are supplied", () => {
+    const formatters = createPriceFormatters(undefined, undefined);
+    expect(formatters).toEqual({});
+  });
+
+  it("should return an empty object if both markup and priceFormatters are empty", () => {
+    const formatters = createPriceFormatters({}, {});
+    expect(formatters).toEqual({});
+  });
+
+  it("should convert the markup into a price formatter for bags", () => {
+    const markup = {
+      rate: 0.1,
+      amount: 100,
+    };
+
+    const formatters = createPriceFormatters({ bags: markup }, {});
+
+    // Force unwrap the price formatter and use 'any' to avoid type errors.
+    // We know this is safe because we created the function right above this.
+    const formattedPrice = formatters.bags!(100, "GBP", {} as any);
+
+    /**
+     * Note: This test is also confirming that we apply the rate, followed by
+     * the amount, rather than the other way around.
+     * For example, if we applied the amount first, the result would be 220.
+     */
+
+    const originalPrice = 100;
+    const expectedFormattedPrice =
+      originalPrice * (1 + markup.rate) + markup.amount;
+
+    expect(formattedPrice).toEqual({
+      amount: expectedFormattedPrice,
+      currency: "GBP",
+    });
+
+    expect(formatters.seats).toBeUndefined();
+  });
+
+  it("should convert the markup into a price formatter for seats", () => {
+    const markup = {
+      rate: 0.1,
+      amount: 100,
+    };
+
+    const formatters = createPriceFormatters({ seats: markup }, {});
+
+    // Force unwrap the price formatter and use 'any' to avoid type errors.
+    // We know this is safe because we created the function right above this.
+    const formattedPrice = formatters.seats!(100, "GBP", {} as any);
+
+    const originalPrice = 100;
+    const expectedFormattedPrice =
+      originalPrice * (1 + markup.rate) + markup.amount;
+
+    expect(formattedPrice).toEqual({
+      amount: expectedFormattedPrice,
+      currency: "GBP",
+    });
+    expect(formatters.bags).toBeUndefined();
+  });
+
+  it("should convert the markup into a price formatter for both bags and seats", () => {
+    const formatters = createPriceFormatters(
+      {
+        bags: {
+          rate: 0.5,
+          amount: 1,
+        },
+        seats: {
+          rate: 0.1,
+          amount: 100,
+        },
+      },
+      undefined
+    );
+
+    // Force unwrap the price formatter and use 'any' to avoid type errors.
+    // We know this is safe because we created the function right above this.
+    const formattedPriceForBags = formatters.bags!(100, "GBP", {} as any);
+    expect(formattedPriceForBags).toEqual({ amount: 151, currency: "GBP" });
+
+    const formattedPriceForSeats = formatters.seats!(100, "GBP", {} as any);
+    expect(formattedPriceForSeats).toEqual({ amount: 210, currency: "GBP" });
+  });
+
+  it("should pass through pre-defined priceFormatters unchanged", () => {
+    const priceFormatters = {
+      bags: (amount: number) => ({ amount: amount + 100 }),
+      seats: (amount: number) => ({ amount: amount + 200 }),
+    };
+
+    const formatters = createPriceFormatters(undefined, priceFormatters);
+
+    // Pass the same arguments to both the priceFormatters and the formatters
+    // to ensure they're the same functions.
+    expect(formatters.bags!(100, "GBP", {} as any)).toEqual(
+      priceFormatters.bags(100)
+    );
+    expect(formatters.seats!(100, "GBP", {} as any)).toEqual(
+      priceFormatters.seats(100)
+    );
+  });
+
+  it("should allow markup and priceFormatters to be mixed if they're for different services", () => {
+    const markup = {
+      bags: {
+        rate: 0.1,
+        amount: 100,
+      },
+    };
+
+    const priceFormatters = {
+      seats: (amount: number) => ({ amount: amount + 100 }),
+    };
+
+    const formatters = createPriceFormatters(markup, priceFormatters);
+
+    expect(formatters.bags!(100, "GBP", {} as any)).toEqual({
+      amount: 210,
+      currency: "GBP",
+    });
+    expect(formatters.seats!(100, "GBP", {} as any)).toEqual(
+      priceFormatters.seats(100)
+    );
+  });
+
+  it("should throw when both markup and priceFormatters are supplied", () => {
+    expect(() => {
+      createPriceFormatters(
+        {
+          bags: {
+            rate: 0.1,
+            amount: 100,
+          },
+          seats: {
+            rate: 0.2,
+            amount: 100,
+          },
+        },
+        {
+          bags: () => ({ amount: 100 }),
+          seats: () => ({ amount: 100 }),
+        }
+      );
+    }).toThrowError();
+  });
+});

package/src/tests/lib/formatAvailableServices.test.tsx

@@ -0,0 +1,79 @@
+import { formatAvailableServices } from "@lib/formatAvailableServices";
+import { OfferAvailableServiceBaggage } from "../../types/Offer";
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const offer = require("../../fixtures/offers/off_1.json");
+/* eslint-enable @typescript-eslint/no-var-requires */
+
+describe("formatAvailableServices", () => {
+  it("should return the offer unchanged if no formatters are passed in", () => {
+    const result = formatAvailableServices(offer);
+    expect(result).toBe(offer);
+  });
+
+  it("should return the offer unchanged if the formatters are empty", () => {
+    const result = formatAvailableServices(offer, {});
+    expect(result).toEqual(offer);
+  });
+
+  it("should transform the price and currency of available services correctly", () => {
+    const result = formatAvailableServices(offer, {
+      bags: () => ({ amount: 100, currency: "Duffel points" }),
+      cancel_for_any_reason: () => ({ amount: 200, currency: "Duffel points" }),
+    });
+    expect(result.available_services[0].total_amount).toBe("100");
+    expect(result.available_services[0].total_currency).toBe("Duffel points");
+
+    expect(result.available_services[2].total_amount).toBe("200");
+    expect(result.available_services[2].total_currency).toBe("Duffel points");
+  });
+
+  it("should throw if more than one currency is used", () => {
+    const mockAvailableService = {
+      type: "baggage",
+      total_amount: "100",
+      total_currency: "GBP",
+      maximum_quantity: 1,
+      passenger_ids: [],
+      segment_ids: [],
+      metadata: {
+        type: "checked",
+        maximum_depth_cm: 25,
+        maximum_height_cm: 55,
+        maximum_length_cm: 35,
+        maximum_weight_kg: 23,
+      },
+    };
+
+    const availableServicesWithDifferentCurrencies: OfferAvailableServiceBaggage[] =
+      [
+        {
+          ...mockAvailableService,
+          id: "1",
+        } as OfferAvailableServiceBaggage,
+        {
+          ...mockAvailableService,
+          id: "2",
+        } as OfferAvailableServiceBaggage,
+      ];
+
+    expect(() => {
+      formatAvailableServices(
+        {
+          ...offer,
+          available_services: availableServicesWithDifferentCurrencies,
+        },
+        {
+          bags: (amount, _currency, service) => {
+            return {
+              amount,
+              // Change the currency for each service,
+              // so that the function throws.
+              currency: service.id === "1" ? "GBP" : "USD",
+            };
+          },
+        }
+      );
+    }).toThrow();
+  });
+});

package/src/tests/lib/formatSeatMaps.test.tsx

@@ -0,0 +1,49 @@
+import { formatSeatMaps } from "@lib/formatSeatMaps";
+import { getFirstSeatElementMatchingCriteria } from "@lib/getFirstSeatElementMatchingCriteria";
+import { SeatMapCabinRowSectionElementSeat } from "../../types/SeatMap";
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const seatMaps = require("../../fixtures/seat-maps/off_1.json");
+/* eslint-enable @typescript-eslint/no-var-requires */
+
+describe("formatSeatMaps", () => {
+  it("should return the seat maps unchanged if no formatter is passed in", () => {
+    const result = formatSeatMaps(seatMaps);
+    expect(result).toBe(seatMaps);
+  });
+
+  it("should format seat maps price and currency correctly", () => {
+    const result = formatSeatMaps(seatMaps, () => ({
+      amount: 100,
+      currency: "Duffel points",
+    }));
+    const firstElementWithServices = getFirstSeatElementMatchingCriteria(
+      result,
+      (element) =>
+        element.type === "seat" && element.available_services.length > 0
+    ) as SeatMapCabinRowSectionElementSeat;
+
+    expect(firstElementWithServices?.available_services[0].total_amount).toBe(
+      "100"
+    );
+    expect(firstElementWithServices?.available_services[0].total_currency).toBe(
+      "Duffel points"
+    );
+  });
+
+  it("should throw if more than one currency is used", () => {
+    expect(() => {
+      // Keep track of how many times the function has been called.
+      // It's a basic hack to simulate different currencies being used,
+      // causing the error to be thrown.
+      let numberOfCalls = 0;
+      formatSeatMaps(seatMaps, () => {
+        numberOfCalls++;
+        return {
+          amount: 100,
+          currency: numberOfCalls % 2 === 0 ? "GBP" : "USD",
+        };
+      });
+    }).toThrow();
+  });
+});

package/src/tests/lib/getCurrencyForServices.test.tsx

@@ -0,0 +1,44 @@
+import { getCurrencyForServices } from "@lib/getCurrencyForServices";
+import { Offer } from "../../types/Offer";
+
+describe("getCurrencyForServices", () => {
+  it("should return GBP when the first service has that currency", () => {
+    const offer = {
+      available_services: [
+        {
+          type: "baggage",
+          total_currency: "GBP",
+        },
+        {
+          type: "baggage",
+          total_currency: "USD",
+        },
+      ],
+    };
+    expect(getCurrencyForServices(offer as Offer, "baggage")).toEqual("GBP");
+  });
+
+  it("should throw when there are no available services", () => {
+    const offer = {
+      available_services: [],
+    };
+    // Using 'any' here because we want to test the error message, not the type.
+    expect(() => getCurrencyForServices(offer as any, "baggage")).toThrow();
+  });
+
+  it("should throw when there are no available services matching the type requested", () => {
+    const offer = {
+      available_services: [
+        {
+          type: "seat",
+          total_currency: "GBP",
+        },
+        {
+          type: "seat",
+          total_currency: "GBP",
+        },
+      ],
+    };
+    expect(() => getCurrencyForServices(offer as Offer, "baggage")).toThrow();
+  });
+});

package/src/tests/lib/hasServiceOfSameMetadataTypeAlreadyBeenSelected.test.ts

@@ -0,0 +1,86 @@
+import { hasServiceOfSameMetadataTypeAlreadyBeenSelected } from "@lib/hasServiceOfSameMetadataTypeAlreadyBeenSelected";
+import { CreateOrderPayloadService } from "../../types/CreateOrderPayload";
+import { OfferAvailableBaggageService } from "../../types/Offer";
+
+const availableService: OfferAvailableBaggageService = {
+  id: "available_service_id",
+  metadata: { type: "checked" },
+  // using as any because we don't need to test the whole type
+} as any;
+
+const selectedService: CreateOrderPayloadService = {
+  id: "selected_service_id",
+  serviceInformation: {
+    segmentId: "segment_id",
+    passengerId: "passenger_id",
+    type: "checked",
+  },
+} as any;
+
+describe("hasServiceOfSameMetadataTypeAlreadyBeenSelected", () => {
+  it("Should return false if no services selected", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected is the availableService we are checking", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [{ ...selectedService, id: availableService.id }],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected are for different passenger", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id_wont_match",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected are for different segment", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id_wont_match",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected is of different type", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id",
+        { ...availableService, metadata: { type: "carry_on" } } as any
+      )
+    ).toBe(false);
+  });
+
+  it("Should return true if service selected is of same type for same passenger and segment", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(true);
+  });
+});

package/src/tests/lib/logging.test.tsx

@@ -0,0 +1,32 @@
+import { initializeLogger } from "@lib/logging";
+
+const consoleSpies = {
+  log: jest.spyOn(console, "log"),
+  groupCollapsed: jest.spyOn(console, "groupCollapsed"),
+  groupEnd: jest.spyOn(console, "groupEnd"),
+};
+
+describe("initializeLogger", () => {
+  it("should return functions that do nothing when debugMode is false", () => {
+    const logger = initializeLogger(false);
+    logger.log("This should not be logged");
+    expect(consoleSpies.log).not.toHaveBeenCalled();
+  });
+
+  it("should return functions that log a message when debugMode is true", () => {
+    const logger = initializeLogger(true);
+    logger.log("This should be logged");
+
+    // Twice because initializeLogger logs a message when it's called,
+    // and then the message we're testing.
+    expect(consoleSpies.log).toHaveBeenCalledTimes(2);
+
+    logger.logGroup("This should be logged", ["one", "two"]);
+    expect(consoleSpies.groupCollapsed).toHaveBeenCalledTimes(1);
+    expect(consoleSpies.groupEnd).toHaveBeenCalledTimes(1);
+
+    // Four times: once for the initializeLogger message, once for the
+    // earlier message, and twice for the array passed to logGroup.
+    expect(consoleSpies.log).toHaveBeenCalledTimes(4);
+  });
+});

package/src/tests/lib/moneyStringFormatter.test.tsx

@@ -0,0 +1,12 @@
+import { moneyStringFormatter } from "@lib/moneyStringFormatter";
+
+describe("moneyStringFormatter", () => {
+  it("should format known currencies correctly", () => {
+    expect(moneyStringFormatter("GBP")(10.23)).toEqual("£10.23");
+  });
+  it("should fall back to value + currency for unknown currencies", () => {
+    expect(moneyStringFormatter("Duffel house points")(10.23)).toEqual(
+      "10.23 Duffel house points"
+    );
+  });
+});

package/src/tests/lib/validateProps.test.tsx

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/**
+ * In this file, we want to allow usage of @ts-ignore so
+ * that we can test functions with invalid props.
+ */
+
+import { hasCommonRequiredProps } from "@lib/validateProps";
+import { Ancillaries } from "../../types/DuffelAncillariesProps";
+
+describe("hasCommonRequiredProps", () => {
+  it("should pass when all required props are provided", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      passengers: [],
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+    expect(hasCommonRequiredProps(props)).toBeTruthy();
+  });
+
+  it("should fail when services is missing", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      passengers: [],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+
+  it("should fail when onPayloadReady is missing", () => {
+    const props = {
+      passengers: [],
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+
+  it("should fail when passengers is missing", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+});

package/src/types/Aircraft.ts

@@ -0,0 +1,16 @@
+export interface Aircraft {
+  /**
+   * The three-character IATA code for the aircraft
+   */
+  iata_code: string;
+
+  /**
+   * Duffel's unique identifier for the aircraft
+   */
+  id: string;
+
+  /**
+   * The name of the aircraft
+   */
+  name: string;
+}

package/src/types/Airline.ts

@@ -0,0 +1,16 @@
+export interface Airline {
+  /**
+   * The two-character IATA code for the airline. This may be null for non-IATA carriers.
+   */
+  iata_code: string | null;
+
+  /**
+   * Duffel's unique identifier for the airline
+   */
+  id: string;
+
+  /**
+   * The name of the airline
+   */
+  name: string;
+}

package/src/types/Airport.ts

@@ -0,0 +1,54 @@
+import { City } from "./City";
+
+export interface Airport {
+  /**
+   * The three-character IATA code for the airport
+   */
+  iata_code: string | null;
+
+  /**
+   * Duffel's unique identifier for the airport
+   */
+  id: string;
+
+  /**
+   * The name of the airport
+   */
+  name: string;
+
+  /**
+   * The ISO 3166-1 alpha-2 code for the country where the airport is located
+   */
+  iata_country_code: string;
+
+  /**
+   * The latitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -90° and 90°
+   */
+  latitude: number;
+
+  /**
+   * The longitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -180° and 180°
+   */
+  longitude: number;
+
+  /**
+   * The four-character ICAO code for the airport
+   */
+  icao_code: string | null;
+
+  /**
+   * The time zone of the airport, specified by name from the [tz database](https://en.wikipedia.org/wiki/Tz_database)
+   */
+  time_zone: string;
+
+  /**
+   * The name of the city (or cities separated by a `/`) where the airport is located
+   */
+  city_name: string;
+
+  /**
+   * The metropolitan area where the airport is located.
+   * Only present for airports which are registered with IATA as belonging to a metropolitan area.
+   */
+  city: City;
+}

package/src/types/City.ts

@@ -0,0 +1,21 @@
+export interface City {
+  /**
+   * The three-character IATA code for the city
+   */
+  iata_code: string;
+
+  /**
+   * Duffel's unique identifier for the city
+   */
+  id: string;
+
+  /**
+   * The ISO 3166-1 alpha-2 code for the country where the city is located
+   */
+  iata_country_code: string;
+
+  /**
+   * The name of the city
+   */
+  name: string;
+}