FSXARemoteApi.spec.ts

import { faker } from '@faker-js/faker'
import { FSXAApiErrors, FSXAContentMode, HttpStatus } from '../enums'
import { FetchResponse, QueryBuilderQuery, SortParams } from '../types'
import { FSXARemoteApi } from './FSXARemoteApi'
import {
  ArrayQueryOperatorEnum,
  ComparisonQueryOperatorEnum,
} from './QueryBuilder'

import { generateRandomConfig } from '../testutils/generateRandomConfig'

import 'jest-fetch-mock'
import {
  createDataEntry,
  createMediaPicture,
  createMediaPictureReference,
} from '../testutils'
import { getMappedMediaPicture } from '../testutils/getMappedMediaPicture'
require('jest-fetch-mock').enableFetchMocks()

describe('FSXARemoteAPI', () => {
  beforeEach(() => {
    fetchMock.resetMocks()
  })
  describe('The initialization', () => {
    let config: any
    let remoteApi: FSXARemoteApi
    beforeEach(() => {
      config = generateRandomConfig()
    })
    it('should get initialized', () => {
      remoteApi = new FSXARemoteApi(config)
      expect(remoteApi).not.toBeNull()
    })
    it('should throw an error if the API_KEY is not set', () => {
      delete config.apikey
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_API_KEY)
    })
    it('should throw an error if the CAAS_URL is not set', () => {
      delete config.caasURL
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_CAAS_URL)
    })
    it('should throw an error if the NAVIGATION_SERVICE_URL is not set', () => {
      delete config.navigationServiceURL
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_NAVIGATION_SERVICE_URL)
    })
    it('should throw an error if the PROJECT_ID is not set', () => {
      delete config.projectID
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_PROJECT_ID)
    })
    it('should throw an error if the TENANT_ID is not set', () => {
      delete config.tenantID
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_TENANT_ID)
    })
    it('should throw an error if remotes are provided without id', () => {
      delete config.remotes.remote.id
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_REMOTE_ID)
    })
    it('should throw an error if remotes are provided without locale', () => {
      delete config.remotes.remote.locale
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.MISSING_REMOTE_LOCALE)
    })
    it('should throw an error if contentMode is not set', () => {
      delete config.contentMode
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.UNKNOWN_CONTENT_MODE)
    })
    it('should throw an error if an invalid content mode is set', () => {
      config.contentMode = faker.string.alpha()
      expect(() => {
        new FSXARemoteApi(config)
      }).toThrow(FSXAApiErrors.UNKNOWN_CONTENT_MODE)
    })
  })
  describe('buildAuthorizationHeaders', () => {
    it('should return the correct authorization object', () => {
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualAuthorizationHeaders = remoteApi.authorizationHeader
      const expectedAuthorizationHeaders = {
        authorization: `Bearer ${config.apikey}`,
      }
      expect(actualAuthorizationHeaders).toStrictEqual(
        expectedAuthorizationHeaders
      )
    })
  })
  describe('buildCaaSUrl', () => {
    it('should return the correct caas url', () => {
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl()
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url for a remote project', () => {
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const remoteProjectId = config.remotes.remote.id
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        remoteProject: remoteProjectId,
      })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${remoteProjectId}.${config.contentMode}.content`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should use the remote contentMode if provided', () => {
      const config = generateRandomConfig()
      const remoteProjectId = config.remotes.remote.id

      config.contentMode = FSXAContentMode.RELEASE
      ;(config.remotes.remote as any).contentMode = FSXAContentMode.PREVIEW

      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        remoteProject: remoteProjectId,
      })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${remoteProjectId}.preview.content`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url with a locale but no id', () => {
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ locale })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when an id is set', () => {
      const id = faker.string.uuid()
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ id })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content/${id}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when additionalParameter are set', () => {
      const value = { firstValue: 1, secondValue: 1 }
      const additionalParams = { keys: value }
      const encodedValue = encodeURIComponent(JSON.stringify(value))
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ additionalParams })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?keys=${encodedValue}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when id, locale and additionalParameter are set', () => {
      const id = faker.string.uuid()
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const keysValue = { firstValue: 1, secondValue: 1 }
      const sortValue = { firstName: 1 }
      const additionalParams = { keys: keysValue, sort: sortValue }
      const encodedKeysValue = encodeURIComponent(
        JSON.stringify({ firstValue: 1, secondValue: 1 })
      )
      const encodedSortValue = encodeURIComponent(
        JSON.stringify({ firstName: 1 })
      )
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        id,
        locale,
        additionalParams,
      })
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content/${id}.${locale}?keys=${encodedKeysValue}&sort=${encodedSortValue}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when filters are set', () => {
      const firstValue = faker.lorem.word()
      const secondValue = faker.lorem.word()
      const firstField = faker.lorem.word()
      const secondField = faker.lorem.word()
      const firstOperator = ComparisonQueryOperatorEnum.EQUALS
      const secondOperator = ComparisonQueryOperatorEnum.EQUALS
      const filters: QueryBuilderQuery[] = [
        {
          value: firstValue,
          field: firstField,
          operator: firstOperator,
        },
        {
          value: secondValue,
          field: secondField,
          operator: secondOperator,
        },
      ]
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ filters })
      const encodedFirstFilterValue = encodeURIComponent(
        `{"${firstField}":{"${firstOperator}":"${firstValue}"}}`
      )
      const encodedSecondFilterValue = encodeURIComponent(
        `{"${secondField}":{"${secondOperator}":"${secondValue}"}}`
      )
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?filter=${encodedFirstFilterValue}&filter=${encodedSecondFilterValue}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when filters and additionalParams are set', () => {
      const filterField = faker.lorem.word()
      const filterValue = faker.lorem.word()
      const filterOperator = ComparisonQueryOperatorEnum.EQUALS
      const filters: QueryBuilderQuery[] = [
        {
          value: filterValue,
          field: filterField,
          operator: filterOperator,
        },
      ]
      const additionalParams = {
        keys: {
          identifier: 1,
        },
      }
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        filters,
        additionalParams,
      })
      const encodedAdditionalParamsValue =
        encodeURIComponent(`{"identifier":1}`)
      const encodedFilterValue = encodeURIComponent(
        `{"${filterField}":{"${filterOperator}":"${filterValue}"}}`
      )
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?keys=${encodedAdditionalParamsValue}&filter=${encodedFilterValue}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when filters and complex additionalParams are set', () => {
      const filterField = faker.lorem.word()
      const filterValue = faker.lorem.word()
      const filterOperator = ComparisonQueryOperatorEnum.EQUALS
      const filters: QueryBuilderQuery[] = [
        {
          value: filterValue,
          field: filterField,
          operator: filterOperator,
        },
      ]
      const additionalParams = {
        keys: {
          identifier: 1,
        },
        filter: [
          { schema: 'newsroom' },
          { entityType: { $in: ['item', 'type'] } },
        ],
      }
      const firstEncodedParamsValue = encodeURIComponent(
        JSON.stringify({ identifier: 1 })
      )
      const secondEncodedParamsValue = encodeURIComponent(
        JSON.stringify({ schema: 'newsroom' })
      )
      const thirdEncodedParamsValue = encodeURIComponent(
        JSON.stringify({ entityType: { $in: ['item', 'type'] } })
      )
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        filters,
        additionalParams,
      })
      const additionalParamsQuery = `keys=${firstEncodedParamsValue}&filter=${secondEncodedParamsValue}&filter=${thirdEncodedParamsValue}`
      const encodedFilterValue = encodeURIComponent(
        `{"${filterField}":{"${filterOperator}":"${filterValue}"}}`
      )
      const filterQuery = `filter=${encodedFilterValue}`
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?${additionalParamsQuery}&${filterQuery}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when page is set', () => {
      const page = faker.number.int()
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ page })
      const pageQuery = `page=${page}`
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?${pageQuery}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when pagesize is set', () => {
      const pagesize = faker.number.int()
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({ pagesize })
      const pagesizeQuery = `pagesize=${pagesize}`
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?${pagesizeQuery}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should throw an error for an invalid remote project', () => {
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)

      try {
        remoteApi.buildCaaSUrl({ remoteProject: 'unknown project' })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_REMOTE)
        expect(error.statusCode).toBe(HttpStatus.NOT_FOUND)
      }
    })
    it('should return the correct caas url when special chars are used in id, locale, page or pagesize', () => {
      const specialChars = "*_'();:@&=+$,?%#[]_*'();:@&=+$,?%#[]"
      const id = specialChars
      const locale = specialChars
      const page = specialChars
      const pagesize = specialChars
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        id,
        locale,
        // @ts-ignore
        page,
        // @ts-ignore
        pagesize,
      })
      const encodedId = encodeURIComponent(id)
      const encodedLocale = encodeURIComponent(locale)
      const encodedPage = encodeURIComponent(page)
      const encodedPagesize = encodeURIComponent(pagesize)
      const baseURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content/`
      const expectedCaaSUrl = `${baseURL}${encodedId}.${encodedLocale}?page=${encodedPage}&pagesize=${encodedPagesize}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when special chars are used in additionalParams', () => {
      const specialChars = "*_'();:@&=+$,?%#[]_*'();:@&=+$,?%#[]"
      const additionalParams = {
        [specialChars]: [
          { [specialChars]: specialChars },
          { [specialChars]: specialChars },
        ],
      }
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        additionalParams,
      })
      const encodedKey = encodeURIComponent(`${specialChars}`)
      const encodedValue = encodeURIComponent(
        JSON.stringify({ [specialChars]: specialChars })
      )
      const expectedCaaSUrl = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?${encodedKey}=${encodedValue}&${encodedKey}=${encodedValue}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should return the correct caas url when special chars are used in filters or sort', () => {
      const specialChars = "*_'();:@&=+$,?%#[]_*'();:@&=+$,?%#[]"
      const locale = specialChars
      const filterOperator = ComparisonQueryOperatorEnum.EQUALS
      const filters: QueryBuilderQuery[] = [
        {
          value: `firstVal${specialChars}`,
          field: `firstField${specialChars}`,
          operator: filterOperator,
        },
        {
          value: `secondVal${specialChars}`,
          field: `secondField${specialChars}`,
          operator: filterOperator,
        },
      ]
      const sort: SortParams[] = [
        { name: specialChars, order: 'desc' },
        { name: specialChars, order: 'asc' },
      ]
      const config = generateRandomConfig()
      const remoteApi = new FSXARemoteApi(config)
      const actualCaaSUrl = remoteApi.buildCaaSUrl({
        locale,
        filters,
        sort,
      })
      const firstEncodedFilter = encodeURIComponent(
        `{"${`firstField${specialChars}`}":{"${filterOperator}":"${`firstVal${specialChars}`}"}}`
      )
      const secondEncodedFilter = encodeURIComponent(
        `{"${`secondField${specialChars}`}":{"${filterOperator}":"${`secondVal${specialChars}`}"}}`
      )
      const thirdEncodedFilter = encodeURIComponent(
        `{"locale.language":{"${filterOperator}":"${
          specialChars.split('_')[0]
        }"}}`
      )
      const fourthEncodedFilter = encodeURIComponent(
        `{"locale.country":{"${filterOperator}":"${
          specialChars.split('_')[1]
        }"}}`
      )
      const encodedSortName = encodeURIComponent(specialChars)
      const encodedSort = `sort=-${encodedSortName}&sort=${encodedSortName}`
      const baseURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content`
      const expectedCaaSUrl = `${baseURL}?filter=${firstEncodedFilter}&filter=${secondEncodedFilter}&filter=${thirdEncodedFilter}&filter=${fourthEncodedFilter}&${encodedSort}`
      expect(actualCaaSUrl).toStrictEqual(expectedCaaSUrl)
    })
    it('should thrown an error when invalid locale is passed', () => {
      const locale = 'invalidlocale'
      const config = generateRandomConfig()
      const filters: QueryBuilderQuery[] = [
        {
          value: faker.lorem.word(),
          field: faker.lorem.word(),
          operator: ComparisonQueryOperatorEnum.EQUALS,
        },
      ]
      const remoteApi = new FSXARemoteApi(config)
      try {
        remoteApi.buildCaaSUrl({ filters, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.INVALID_LOCALE)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
  })
  describe('buildNavigationServiceUrl', () => {
    let remoteApi: FSXARemoteApi
    let config
    beforeEach(() => {
      config = generateRandomConfig()
      remoteApi = new FSXARemoteApi(config)
    })
    it('should return a correct url', () => {
      const correctURL =
        /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/g

      const navigationServiceApi = remoteApi.buildNavigationServiceUrl()

      expect(correctURL.test(navigationServiceApi)).toBe(true)
    })
    it('should return a correct url when passing the locale', () => {
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const actualNavigationSericeUrl = remoteApi.buildNavigationServiceUrl({
        locale,
      })
      const expectedEndOfNavigationServiceUrl = `?depth=99&format=caas&language=${locale}`
      expect(
        actualNavigationSericeUrl.endsWith(expectedEndOfNavigationServiceUrl)
      ).toBe(true)
    })
    it('should return a correct url when passing the initialPath', () => {
      const initialPath = faker.lorem.words(3).split(' ').join('/')

      const actualNavigationSericeUrl = remoteApi.buildNavigationServiceUrl({
        initialPath,
      })
      const expectedEndOfNavigationServiceUrl = `/by-seo-route/${initialPath}?depth=99&format=caas`
      expect(
        actualNavigationSericeUrl.endsWith(expectedEndOfNavigationServiceUrl)
      ).toBe(true)
    })
    it('should not return the seo-route url when initialPath is /', () => {
      const initialPath = '/'
      const actualNavigationSericeUrl = remoteApi.buildNavigationServiceUrl({
        initialPath,
      })
      const expectedEndOfNavigationServiceUrl = `/by-seo-route/${initialPath}?depth=99&format=caas&all`
      expect(
        actualNavigationSericeUrl.endsWith(expectedEndOfNavigationServiceUrl)
      ).not.toBe(true)
    })
  })
  describe('fetchElement', () => {
    let remoteApi: FSXARemoteApi
    let config: any
    let uuid: string
    let locale: string
    beforeEach(() => {
      uuid = faker.string.uuid()
      locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase().toUpperCase()}`
      config = generateRandomConfig()
      remoteApi = new FSXARemoteApi(config)
    })
    it('should call fetchByFilter internally', async () => {
      const data = createDataEntry()
      fetchMock.mockResponseOnce(JSON.stringify(data))
      remoteApi.fetchByFilter = jest.fn().mockResolvedValue({
        page: 1,
        pagesize: 1,
        items: ['myItem'] as any,
      } as FetchResponse)
      await remoteApi.fetchElement({
        id: data.identifier,
        locale,
        fetchOptions: {},
        additionalParams: {},
        filterContext: {},
      })
      expect(remoteApi.fetchByFilter).toHaveBeenCalledTimes(1)
      expect(remoteApi.fetchByFilter).toHaveBeenCalledWith({
        filters: [
          {
            operator: ComparisonQueryOperatorEnum.EQUALS,
            field: 'identifier',
            value: data.identifier,
          },
        ],
        additionalParams: {},
        fetchOptions: {},
        filterContext: {},
        normalized: true,
        remoteProject: undefined,
        locale,
      })
    })
    it('should throw a not found error when the response is 404', async () => {
      remoteApi.fetchByFilter = jest
        .fn()
        .mockResolvedValue({ page: 1, pagesize: 1, items: [] } as FetchResponse)
      try {
        await remoteApi.fetchElement({ id: uuid, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.NOT_FOUND)
        expect(error.statusCode).toBe(HttpStatus.NOT_FOUND)
      }
    })
    it('should throw an unauthorized error when the response is 401', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.UNAUTHORIZED })
      try {
        await remoteApi.fetchElement({ id: uuid, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.NOT_AUTHORIZED)
        expect(error.statusCode).toBe(HttpStatus.UNAUTHORIZED)
      }
    })
    it('should throw an unknown error with status 400 when the response is not ok', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.BAD_REQUEST })
      try {
        await remoteApi.fetchElement({ id: uuid, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_ERROR)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
    it('should return the response', async () => {
      const caasApiItem = createDataEntry()
      const mockRes = {
        _embedded: {
          'rh:doc': [caasApiItem],
        },
      }
      fetchMock.mockResponse(JSON.stringify(mockRes))
      const actualRequest = await remoteApi.fetchElement({ id: uuid, locale })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual(caasApiItem)
    })
    it('should return a mapped response when additionalParams are set', async () => {
      const item = createDataEntry()
      const mockRes = {
        _embedded: {
          'rh:doc': [item],
        },
      }
      fetchMock.mockResponse(JSON.stringify(mockRes))
      const actualRequest = await remoteApi.fetchElement({
        id: uuid,
        locale,
        additionalParams: { depth: 99 },
      })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual(item)
    })
  })
  describe('fetchByFilter', () => {
    let remoteApi: FSXARemoteApi
    let config: ReturnType<typeof generateRandomConfig>
    let filters: QueryBuilderQuery[]
    let filterValue: string
    let filterField: string
    let localeLanguage: string
    let localeCountry: string
    let locale: string
    let json: Record<string, any>
    beforeEach(() => {
      filterValue = faker.lorem.word()
      filterField = faker.lorem.word()
      filters = [
        {
          value: filterValue,
          field: filterField,
          operator: ComparisonQueryOperatorEnum.EQUALS,
        },
      ]
      localeLanguage = faker.lorem.word(2).toLowerCase()
      localeCountry = faker.lorem.word(2).toUpperCase()
      locale = localeLanguage + '_' + localeCountry
      config = generateRandomConfig()
      remoteApi = new FSXARemoteApi(config)
      json = {
        _embedded: {
          'rh:doc': faker.helpers.multiple(() => faker.lorem.word()),
        },
      }
    })
    it('should trigger the fetch method with the correct params', async () => {
      fetchMock.mockResponseOnce(JSON.stringify(json))
      await remoteApi.fetchByFilter({ filters, locale })
      const actualURL = fetchMock.mock.calls[0][0]
      const firstEncodedFilterValue = encodeURIComponent(
        `{"${filterField}":{"$eq":"${filterValue}"}}`
      )
      const secondEncodedFilterValue = encodeURIComponent(
        `{"locale.language":{"$eq":"${localeLanguage}"}}`
      )
      const thirdEncodedFilterValue = encodeURIComponent(
        `{"locale.country":{"$eq":"${localeCountry}"}}`
      )
      const expectedURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?rep=hal&filter=${firstEncodedFilterValue}&filter=${secondEncodedFilterValue}&filter=${thirdEncodedFilterValue}&page=1&pagesize=30`
      expect(actualURL).toBe(expectedURL)
    })
    it('should trigger the fetch method with the sort param', async () => {
      fetchMock.mockResponseOnce(JSON.stringify(json))
      const sort = [
        { name: 'displayName', order: 'asc' },
        { name: 'template.name', order: 'desc' },
      ] as SortParams[]
      await remoteApi.fetchByFilter({ filters, locale, sort })
      const actualURL = fetchMock.mock.calls[0][0]
      const firstEncodedFilterValue = encodeURIComponent(
        `{"${filterField}":{"$eq":"${filterValue}"}}`
      )
      const secondEncodedFilterValue = encodeURIComponent(
        `{"locale.language":{"$eq":"${localeLanguage}"}}`
      )
      const thirdEncodedFilterValue = encodeURIComponent(
        `{"locale.country":{"$eq":"${localeCountry}"}}`
      )
      const expectedURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?rep=hal&filter=${firstEncodedFilterValue}&filter=${secondEncodedFilterValue}&filter=${thirdEncodedFilterValue}&page=1&pagesize=30&sort=${sort[0].name}&sort=-${sort[1].name}`
      expect(actualURL).toBe(expectedURL)
    })
    it('should throw an unauthorized error when the response is 401', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.UNAUTHORIZED })
      try {
        await remoteApi.fetchByFilter({ filters, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.NOT_AUTHORIZED)
        expect(error.statusCode).toBe(HttpStatus.UNAUTHORIZED)
      }
    })
    it('should throw an unknown error when the response is not ok', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.BAD_REQUEST })
      try {
        await remoteApi.fetchByFilter({ filters, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_ERROR)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
    it('should return the response', async () => {
      const items = [createDataEntry()]
      const caasApiItems = { _embedded: { 'rh:doc': items } }
      fetchMock.mockResponseOnce(JSON.stringify(caasApiItems))
      const actualRequest = await remoteApi.fetchByFilter({ filters, locale })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items,
      })
    })
    it('should return normalized response if normalized is switched on', async () => {
      const items = [createDataEntry()]
      const caasApiItems = { _embedded: { 'rh:doc': items } }
      fetchMock.mockResponseOnce(JSON.stringify(caasApiItems))
      const actualRequest = await remoteApi.fetchByFilter({
        filters,
        locale,
        normalized: true,
      })
      expect(actualRequest).toBeDefined()

      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items,
        referenceMap: {},
        resolvedReferences: { [items[0]._id]: items[0] },
      })
    })
    it('should return empty array on empty response', async () => {
      // CaaS API omits _embedded attribute in response for empty collections or
      // queries that don't match any documents.
      const emptyResponse = {}
      fetchMock.mockResponseOnce(JSON.stringify(emptyResponse))
      const actualRequest = await remoteApi.fetchByFilter({ filters, locale })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items: [],
      })
    })
    it('should return empty array on broken response', async () => {
      const brokenResponse = { _embedded: {} }
      fetchMock.mockResponseOnce(JSON.stringify(brokenResponse))
      const actualRequest = await remoteApi.fetchByFilter({ filters, locale })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items: [],
      })
    })
    it('boolean values pass the typecheck', async () => {
      const comparisonFilter: QueryBuilderQuery[] = [
        {
          value: true,
          field: filterField,
          operator: ComparisonQueryOperatorEnum.EQUALS,
        },
      ]
      const arrayFilter: QueryBuilderQuery[] = [
        {
          value: [true, false, true],
          field: filterField,
          operator: ArrayQueryOperatorEnum.ALL,
        },
      ]
      fetchMock.mockResponseOnce(JSON.stringify(json))
      await remoteApi.fetchByFilter({ filters: comparisonFilter, locale })
      fetchMock.mockResponseOnce(JSON.stringify(json))
      await remoteApi.fetchByFilter({ filters: arrayFilter, locale })
      expect(fetchMock).toHaveBeenCalledTimes(2)
    })
    it('should allow comparison with null values', async () => {
      const filter1: QueryBuilderQuery[] = [
        {
          value: null,
          field: filterField,
          operator: ComparisonQueryOperatorEnum.EQUALS,
        },
      ]
      const filter2: QueryBuilderQuery[] = [
        {
          value: null,
          field: filterField,
          operator: ComparisonQueryOperatorEnum.NOT_EQUALS,
        },
      ]
      fetchMock.mockResponseOnce(JSON.stringify(json))
      await remoteApi.fetchByFilter({ filters: filter1, locale })
      fetchMock.mockResponseOnce(JSON.stringify(json))
      await remoteApi.fetchByFilter({ filters: filter2, locale })
      expect(fetchMock).toHaveBeenCalledTimes(2)
    })
    it('should return right data if no locale is provided', async () => {
      const id = faker.string.uuid()
      const id2 = faker.string.uuid()
      const localeLanguage = faker.lorem.word(2).toLowerCase()
      const localeCountry = faker.lorem.word(2).toUpperCase()
      const locale2 = localeLanguage + '_' + localeCountry
      const items = [createDataEntry(id, locale), createDataEntry(id2, locale2)]
      const caasApiItems = { _embedded: { 'rh:doc': items } }
      fetchMock.mockResponseOnce(JSON.stringify(caasApiItems))
      const actualRequest = await remoteApi.fetchByFilter({
        filters,
      })
      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items,
      })
    })
    it('should return items when fetching remote items', async () => {
      const mainMedia = createMediaPicture(
        undefined,
        config.remotes.remote.locale
      )
      const referencedMedia = createMediaPicture(
        undefined,
        config.remotes.remote.locale
      )

      mainMedia.metaFormData.fsRef = createMediaPictureReference(
        referencedMedia._id
      )

      const firstResponse = { _embedded: { 'rh:doc': [mainMedia] } }
      const secondResponse = { _embedded: { 'rh:doc': [referencedMedia] } }

      fetchMock
        .mockResponseOnce(JSON.stringify(firstResponse))
        .mockResponseOnce(JSON.stringify(secondResponse))

      const actualRequest = await remoteApi.fetchByFilter({
        filters,
        locale: 'de_DE',
        remoteProject: config.remotes.remote.id,
      })

      const mappedMainMedia = getMappedMediaPicture(
        mainMedia,
        config.remotes.remote.locale,
        config.remotes.remote.id
      )
      const mappedReferencedMedia = getMappedMediaPicture(
        referencedMedia,
        config.remotes.remote.locale,
        config.remotes.remote.id
      )

      mappedMainMedia.meta.fsRef = mappedReferencedMedia

      expect(actualRequest).toBeDefined()
      expect(actualRequest).toStrictEqual({
        page: 1,
        pagesize: 30,
        size: undefined,
        totalPages: undefined,
        items: [mappedMainMedia],
      })
    })
  })
  describe('fetchNavigation', () => {
    let remoteApi: FSXARemoteApi
    let config: any
    beforeEach(() => {
      config = generateRandomConfig()
      remoteApi = new FSXARemoteApi(config)
    })
    it('should trigger the fetch method with locale', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const initialPath = '/'
      remoteApi.fetchNavigation({ initialPath, locale })

      const actualURL = fetchMock.mock.calls[0][0]

      const expectedURL = `${config.navigationServiceURL}/${config.contentMode}.${config.projectID}?depth=99&format=caas&language=${locale}`
      expect(actualURL).toBe(expectedURL)
    })
    it('should trigger the fetch method with initialPath = /', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      remoteApi.fetchNavigation({ locale })

      const actualURL = fetchMock.mock.calls[0][0]

      const expectedURL = `${config.navigationServiceURL}/${config.contentMode}.${config.projectID}?depth=99&format=caas&language=${locale}`
      expect(actualURL).toBe(expectedURL)
    })
    it('should trigger the fetch method with initialPath', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const initialPath = faker.lorem.words(3).split(' ').join('/')

      remoteApi.fetchNavigation({ initialPath, locale })

      const actualURL = fetchMock.mock.calls[0][0]

      const expectedURL = `${config.navigationServiceURL}/${config.contentMode}.${config.projectID}/by-seo-route/${initialPath}?depth=99&format=caas&all`
      expect(actualURL).toBe(expectedURL)
    })
    it('should throw an not found error when the response is 404', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.NOT_FOUND })
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      try {
        await remoteApi.fetchNavigation({ locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.NOT_FOUND)
        expect(error.statusCode).toBe(HttpStatus.NOT_FOUND)
      }
    })
    it('should throw an unknown error when the response is not ok', async () => {
      fetchMock.mockResponseOnce('', { status: HttpStatus.BAD_REQUEST })
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      try {
        await remoteApi.fetchNavigation({ locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_ERROR)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
    it('should return the response', async () => {
      const expectedResponse = JSON.stringify(faker.helpers.fake("{{lorem.word}}"))
      fetchMock.mockResponseOnce(JSON.stringify(expectedResponse))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const actualResponse = await remoteApi.fetchNavigation({ locale })
      expect(actualResponse).toEqual(expectedResponse)
    })
    it('should throw an unknown error when ? is used in initial path', async () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const initialPath = faker.lorem.words(3).split(' ').join('/') + '?'
      try {
        await remoteApi.fetchNavigation({ initialPath, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_ERROR)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
    it('should throw an unknown error when # is used in initial path', async () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = `${faker.location.countryCode().toLowerCase()}_${faker.location.countryCode().toLowerCase()}`
      const initialPath = faker.lorem.words(3).split(' ').join('/') + '#'
      try {
        await remoteApi.fetchNavigation({ initialPath, locale })
      } catch (error: any) {
        expect(error.message).toBe(FSXAApiErrors.UNKNOWN_ERROR)
        expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST)
      }
    })
    it('should trigger the fetch method with encoded params when special chars are used in locale or initial path', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const locale = "*_'();:@&=+$,?%#[]_*'();:@&=+$,?%#[]"
      const initialPath = "*_'();:@&=+$,%[]"
      remoteApi.fetchNavigation({ initialPath, locale })
      const encodedInitialPath = encodeURI(initialPath)
      const actualURL = fetchMock.mock.calls[0][0]
      const expectedURL = `${config.navigationServiceURL}/${config.contentMode}.${config.projectID}/by-seo-route/${encodedInitialPath}?depth=99&format=caas&all`
      expect(actualURL).toBe(expectedURL)
    })
  })
  describe('fetchProjectProperties', () => {
    let remoteApi: FSXARemoteApi
    let config: any
    beforeEach(() => {
      config = generateRandomConfig()
      remoteApi = new FSXARemoteApi(config)
    })
    it('should trigger fetchByFilter with correct params', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const localeLanguage = faker.lorem.word(2).toLowerCase()
      const localeCountry = faker.lorem.word(2).toUpperCase()
      const locale = localeLanguage + '_' + localeCountry
      remoteApi.fetchProjectProperties({ locale })
      const actualURL = fetchMock.mock.calls[0][0]
      const firstEncodedFilterValue = encodeURIComponent(
        `{"fsType":{"$eq":"ProjectProperties"}}`
      )
      const secondEncodedFilterValue = encodeURIComponent(
        `{"locale.language":{"$eq":"${localeLanguage}"}}`
      )
      const thirdEncodedFilterValue = encodeURIComponent(
        `{"locale.country":{"$eq":"${localeCountry}"}}`
      )
      const expectedURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?rep=hal&filter=${firstEncodedFilterValue}&filter=${secondEncodedFilterValue}&filter=${thirdEncodedFilterValue}&page=1&pagesize=30`
      expect(actualURL).toBe(expectedURL)
    })
    it('should trigger fetchByFilter with encoded params when special chars in locale are used', () => {
      fetchMock.mockResponseOnce(JSON.stringify(faker.helpers.fake("{{lorem.word}}")))
      const localeLanguage = "*'();:@&=+$,?%#[]"
      const localeCountry = "*'();:@&=+$,?%#[]"
      const locale = localeLanguage + '_' + localeCountry
      remoteApi.fetchProjectProperties({ locale })
      const actualURL = fetchMock.mock.calls[0][0]
      const firstEncodedFilterValue = encodeURIComponent(
        `{"fsType":{"$eq":"ProjectProperties"}}`
      )
      const secondEncodedFilterValue = encodeURIComponent(
        `{"locale.language":{"$eq":"${localeLanguage}"}}`
      )
      const thirdEncodeddFilterValue = encodeURIComponent(
        `{"locale.country":{"$eq":"${localeCountry}"}}`
      )
      const expectedURL = `${config.caasURL}/${config.tenantID}/${config.projectID}.${config.contentMode}.content?rep=hal&filter=${firstEncodedFilterValue}&filter=${secondEncodedFilterValue}&filter=${thirdEncodeddFilterValue}&page=1&pagesize=30`
      expect(actualURL).toBe(expectedURL)
    })
  })
  describe('additionalHooks', () => {
    const firstId = faker.string.uuid()
    const firstlabel = faker.string.alpha()
    const firstSeoRoute = `/${firstlabel}/`

    const secondId = faker.string.uuid()
    const secondlabel = faker.string.alpha()
    const secondSeoRoute = `/${secondlabel}/`

    const thirdId = faker.string.uuid()
    const thirdlabel = faker.string.alpha()
    const thirdSeoRoute = `/${thirdlabel}/`

    const responseJSON = {
      idMap: {
        [firstId]: {
          id: firstId,
          label: firstlabel,
          seoRoute: firstSeoRoute,
        },
        [secondId]: {
          id: secondId,
          label: secondlabel,
          seoRoute: secondSeoRoute,
        },
        [thirdId]: {
          id: thirdId,
          label: thirdlabel,
          seoRoute: thirdSeoRoute,
        },
      },
      seoRouteMap: {
        [firstSeoRoute]: firstId,
        [secondSeoRoute]: secondId,
        [thirdSeoRoute]: thirdId,
      },
      structure: [
        {
          id: firstId,
          children: [
            {
              id: secondId,
              children: [],
            },
          ],
        },
        {
          id: thirdId,
          children: [],
        },
      ],
    }
  })
})