web/packages/booking-flow/lib/stores/enter-details/helpers.test.ts

import { describe, expect, it } from "vitest"

import { CurrencyEnum } from "@scandic-hotels/common/constants/currency"

import {
  getAdditionalPrice,
  getRedemptionPrice,
  getRegularPrice,
  getVoucherPrice,
} from "./helpers"

type GetAdditionalPriceParams = Parameters<typeof getAdditionalPrice>
describe("getAdditionalPrice", () => {
  it("should calculate additional price correctly with only additional price", () => {
    const total: GetAdditionalPriceParams[0] = {
      local: {
        additionalPrice: 0,
        additionalPriceCurrency: CurrencyEnum.CC,
      },
    }
    const adults = 1
    const nights = 1
    const breakfast = undefined
    const packages = undefined
    const additionalPrice = 100
    const additionalPriceCurrency = CurrencyEnum.SEK

    getAdditionalPrice(
      total,
      adults,
      breakfast,
      nights,
      packages,
      additionalPrice,
      additionalPriceCurrency
    )

    expect(total.local.additionalPrice).toBe(100)
  })

  it("should set additional price currency correctly when missing in total", () => {
    const total: GetAdditionalPriceParams[0] = {
      local: {
        additionalPrice: 0,
      },
    }
    const adults = 1
    const nights = 1
    const breakfast = undefined
    const packages = undefined
    const additionalPrice = 100
    const additionalPriceCurrency = CurrencyEnum.SEK

    getAdditionalPrice(
      total,
      adults,
      breakfast,
      nights,
      packages,
      additionalPrice,
      additionalPriceCurrency
    )

    expect(total.local.additionalPriceCurrency).toBe(CurrencyEnum.SEK)
  })

  it("should calculate price correctly with breakfast", () => {
    const total: GetAdditionalPriceParams[0] = {
      local: {
        additionalPrice: 0,
      },
    }
    const adults = 2
    const nights = 2
    const breakfast = { localPrice: { price: 50, currency: CurrencyEnum.SEK } }
    const packages: never[] = []

    getAdditionalPrice(total, adults, breakfast, nights, packages)

    expect(total.local.additionalPrice).toBe(200)
  })

  it("should calculate price correctly with packages", () => {
    const total: GetAdditionalPriceParams[0] = {
      local: {
        additionalPrice: 0,
      },
    }
    const adults = 2
    const nights = 2
    const breakfast = undefined
    const packages = [
      {
        localPrice: { totalPrice: 50, currency: CurrencyEnum.SEK },
      },
      {
        localPrice: { totalPrice: 25, currency: CurrencyEnum.SEK },
      },
    ]

    getAdditionalPrice(total, adults, breakfast, nights, packages)

    expect(total.local.additionalPrice).toBe(75)
  })

  it("should calculate price correctly with breakfast, packages and additionalPrice", () => {
    const total: GetAdditionalPriceParams[0] = {
      local: {
        additionalPrice: 0,
      },
    }
    const adults = 2
    const nights = 2
    const breakfast = { localPrice: { price: 50, currency: CurrencyEnum.SEK } }
    const packages = [
      {
        localPrice: { totalPrice: 50, currency: CurrencyEnum.SEK },
      },
      {
        localPrice: { totalPrice: 25, currency: CurrencyEnum.SEK },
      },
    ]
    const additionalPrice = 33
    const additionalPriceCurrency = CurrencyEnum.SEK

    getAdditionalPrice(
      total,
      adults,
      breakfast,
      nights,
      packages,
      additionalPrice,
      additionalPriceCurrency
    )

    expect(total.local.additionalPrice).toBe(308)
  })
})

describe("getRedemptionPrice", () => {
  it("returns price 0 and default currency when rooms are empty", () => {
    const result = getRedemptionPrice([], 1)

    expect(result).toEqual({
      local: { price: 0, currency: CurrencyEnum.POINTS },
      requested: undefined,
    })
  })

  it("returns price 0 and set currency when rooms are empty", () => {
    const result = getRedemptionPrice([], 1, CurrencyEnum.EUROBONUS)

    expect(result).toEqual({
      local: { price: 0, currency: CurrencyEnum.EUROBONUS },
      requested: undefined,
    })
  })

  it("returns price for single room with redemption price", () => {
    const nights = 1
    const result = getRedemptionPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 100,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 100,
        currency: CurrencyEnum.POINTS,
        additionalPrice: 0,
        additionalPriceCurrency: CurrencyEnum.POINTS,
      },
      requested: undefined,
    })
  })

  it("returns price for single room with multiple nights", () => {
    const nights = 3
    const result = getRedemptionPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 100,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 100,
        currency: CurrencyEnum.POINTS,
        additionalPrice: 0,
        additionalPriceCurrency: CurrencyEnum.POINTS,
      },
      requested: undefined,
    })
  })

  it("returns price for multiple rooms with multiple nights", () => {
    const nights = 3
    const result = getRedemptionPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 100,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 150,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 250,
        currency: CurrencyEnum.POINTS,
        additionalPrice: 0,
        additionalPriceCurrency: CurrencyEnum.POINTS,
      },
      requested: undefined,
    })
  })

  it("does not return price for room without redemption", () => {
    const nights = 3
    const result = getRedemptionPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            public: {
              price: 150,
            },
          },
        },
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 150,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 150,
        currency: CurrencyEnum.POINTS,
        additionalPrice: 0,
        additionalPriceCurrency: CurrencyEnum.POINTS,
      },
      requested: undefined,
    })
  })
})

it("returns price and additionalPrice for single room with room features", () => {
  const nights = 2
  const result = getRedemptionPrice(
    [
      {
        adults: 1,
        breakfast: false,
        roomFeatures: [
          {
            localPrice: { totalPrice: 33 },
            requestedPrice: { totalPrice: 33 },
          },
        ],
        roomRate: {
          redemption: {
            localPrice: {
              pointsPerStay: 100,
              currency: CurrencyEnum.POINTS,
              additionalPricePerStay: 0,
            },
          },
        },
      },
    ],
    nights
  )

  expect(result).toEqual({
    local: {
      price: 100,
      currency: CurrencyEnum.POINTS,
      additionalPrice: 33,
      additionalPriceCurrency: CurrencyEnum.POINTS,
    },
    requested: undefined,
  })
})

describe("getVoucherPrice", () => {
  it("returns price 0 and default currency when rooms are empty", () => {
    const result = getVoucherPrice([], 1)

    expect(result).toEqual({
      local: { price: 0, currency: CurrencyEnum.Voucher },
      requested: undefined,
    })
  })

  it("returns price for single room with voucher price", () => {
    const nights = 1
    const result = getVoucherPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            voucher: {
              numberOfVouchers: 1,
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 1,
        currency: CurrencyEnum.Voucher,
        additionalPrice: 0,
      },
      requested: undefined,
    })
  })

  it("returns price for single room with multiple nights", () => {
    const nights = 3
    const result = getVoucherPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            voucher: {
              numberOfVouchers: 3,
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 3,
        currency: CurrencyEnum.Voucher,
        additionalPrice: 0,
      },
      requested: undefined,
    })
  })

  it("returns price for multiple rooms with multiple nights", () => {
    const nights = 3
    const result = getVoucherPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            voucher: {
              numberOfVouchers: 3,
            },
          },
        },
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            voucher: {
              numberOfVouchers: 2,
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 5,
        currency: CurrencyEnum.Voucher,
        additionalPrice: 0,
      },
      requested: undefined,
    })
  })

  it("does not return price for room without voucher", () => {
    const nights = 3
    const result = getVoucherPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            redemption: {
              localPrice: {
                pointsPerStay: 150,
                currency: CurrencyEnum.POINTS,
                additionalPricePerStay: 0,
              },
            },
          },
        },
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          roomRate: {
            voucher: {
              numberOfVouchers: 2,
            },
          },
        },
      ],
      nights
    )

    expect(result).toEqual({
      local: {
        price: 2,
        currency: CurrencyEnum.Voucher,
        additionalPrice: 0,
      },
      requested: undefined,
    })
  })
})

describe("getRegularPrice", () => {
  it("returns price 0 for empty rooms", () => {
    const isMember = false
    const nights = 1
    const result = getRegularPrice([], isMember, nights)

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.Unknown,
        price: 0,
        regularPrice: 0,
      },
      requested: undefined,
    })
  })

  it("returns price 0 for rooms without public or member rate", () => {
    const isMember = false
    const nights = 1
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: false,
          guest,
          roomFeatures: [],
          roomRate: {},
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.Unknown,
        price: 0,
        regularPrice: 0,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for non-member", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: null,
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 0,
        regularPrice: 100,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for member", () => {
    const isMember = true
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 0,
        regularPrice: 100,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for member without public rate", () => {
    const isMember = true
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          guest,
          roomRate: {
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 0,
        regularPrice: 50,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for non-member without member rate", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: false,
          roomFeatures: [],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 0,
        regularPrice: 50,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for non-member with breakfast", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: { localPrice: { price: 20, currency: CurrencyEnum.SEK } },
          roomFeatures: [],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 40,
        regularPrice: 140,
      },
      requested: undefined,
    })
  })

  it("calculates regular price for non-member with breakfast and room features", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: { localPrice: { price: 20, currency: CurrencyEnum.SEK } },
          roomFeatures: [
            {
              localPrice: { totalPrice: 3, currency: CurrencyEnum.SEK },
              requestedPrice: { totalPrice: 3, currency: CurrencyEnum.SEK },
            },
            {
              localPrice: { totalPrice: 7, currency: CurrencyEnum.SEK },
              requestedPrice: { totalPrice: 7, currency: CurrencyEnum.SEK },
            },
          ],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 50,
        regularPrice: 150,
      },
      requested: undefined,
    })
  })

  it("calculates regular price to 0 when price is same or larger than regular price", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: { localPrice: { price: 0, currency: CurrencyEnum.SEK } },
          roomFeatures: [
            {
              localPrice: { totalPrice: 100, currency: CurrencyEnum.SEK },
              requestedPrice: { totalPrice: 3, currency: CurrencyEnum.SEK },
            },
          ],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 0,
                regularPricePerStay: 0,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 100,
        regularPrice: 0,
      },
      requested: undefined,
    })
  })

  it("calculates requested price with breakfast and room features", () => {
    const isMember = false
    const nights = 2
    const guest = { join: false }
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: {
            localPrice: { price: 30, currency: CurrencyEnum.SEK },
            requestedPrice: { price: 3, currency: CurrencyEnum.EUR },
          },
          roomFeatures: [
            {
              localPrice: { totalPrice: 20, currency: CurrencyEnum.SEK },
              requestedPrice: { totalPrice: 2, currency: CurrencyEnum.EUR },
            },
          ],
          guest,
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
              requestedPrice: {
                currency: CurrencyEnum.EUR,
                pricePerNight: 10,
                regularPricePerStay: 10,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 80,
        regularPrice: 180,
      },
      requested: {
        currency: CurrencyEnum.EUR,
        price: 8,
      },
    })
  })

  it("calculates prices for multi-room", () => {
    const isMember = true
    const nights = 2
    const result = getRegularPrice(
      [
        {
          adults: 1,
          breakfast: { localPrice: { price: 20, currency: CurrencyEnum.SEK } },
          roomFeatures: null,
          guest: { join: false },
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 100,
                regularPricePerStay: 100,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 50,
                regularPricePerStay: 50,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
        {
          adults: 1,
          breakfast: { localPrice: { price: 25, currency: CurrencyEnum.SEK } },
          roomFeatures: null,
          guest: { join: true },
          roomRate: {
            public: {
              localPrice: {
                pricePerNight: 75,
                regularPricePerStay: 75,
                currency: CurrencyEnum.SEK,
              },
            },
            member: {
              localPrice: {
                pricePerNight: 30,
                regularPricePerStay: 30,
                currency: CurrencyEnum.SEK,
              },
            },
          },
        },
      ],
      isMember,
      nights
    )

    expect(result).toEqual({
      local: {
        currency: CurrencyEnum.SEK,
        price: 90,
        regularPrice: 265,
      },
      requested: undefined,
    })
  })
})