@jetshop/core/hooks/ProductList/list-transforms.test.js

import {
  flattenList,
  getVariantFromProductDetails,
  getProductDetailForFlattenedProductList,
  normalizeServerList
} from './list-transforms';

const MOCK_LIST = {
  '6952315': {
    options: { quantity: 1 },
    variants: {
      '6952315-170-white': {
        options: {
          quantity: 1
        },
        parentArticleNumber: '6952315'
      }
    }
  },
  '502935480': {
    variants: null,
    options: {
      quantity: 1
    }
  },
  '441922-Classic-16': {
    variants: null,
    options: {
      quantity: 1
    }
  },
  'without-base': {
    options: null,
    variants: {
      'with-variant': {
        options: {
          quantity: 1
        },
        parentArticleNumber: 'without-base'
      }
    }
  }
};

const MOCK_PRODUCT_WITH_VARIANTS = {
  variants: {
    options: [
      {
        name: 'Size',
        values: ['36', '37', '38'],
        __typename: 'ProductVariantOption'
      }
    ],
    values: [
      {
        id: '441728-36',
        articleNumber: '441728-36',
        values: ['36'],
        stockStatus: {
          buyable: true,
          text: 'In stock',
          __typename: 'StockStatus'
        },
        images: [
          {
            alt: '441728',
            title: 'Belt Light',
            url: 'https://www.demostore.se/pub_images/original/441728.jpg',
            __typename: 'ProductImage'
          }
        ],
        __typename: 'ProductVariant'
      },
      {
        id: '441728-37',
        articleNumber: '441728-37',
        values: ['37'],
        stockStatus: {
          buyable: true,
          text: 'In stock',
          __typename: 'StockStatus'
        },
        images: [
          {
            alt: 'Belt Light',
            title: 'Belt Light',
            url: 'https://www.demostore.se/pub_images/original/441728.jpg',
            __typename: 'ProductImage'
          }
        ],
        __typename: 'ProductVariant'
      },
      {
        id: '441728-38',
        articleNumber: '441728-38',
        values: ['38'],
        stockStatus: {
          buyable: true,
          text: 'In stock',
          __typename: 'StockStatus'
        },
        images: [
          {
            alt: 'Belt Light',
            title: 'Belt Light',
            url: 'https://www.demostore.se/pub_images/original/441728.jpg',
            __typename: 'ProductImage'
          }
        ],
        __typename: 'ProductVariant'
      }
    ],
    __typename: 'ProductVariants'
  },
  id: 483,
  articleNumber: '441728',
  name: 'Belt Light',
  hasConfigurations: false,
  hasVariants: true,
  isPreOrder: false,
  stockStatus: {
    buyable: true,
    text: 'In stock',
    __typename: 'StockStatus'
  },
  __typename: 'Product',
  images: [
    {
      alt: '441728',
      title: 'Belt Light',
      url: 'https://www.demostore.se/pub_images/original/441728.jpg',
      __typename: 'ProductImage'
    }
  ]
};

const MOCK_PRODUCT_QUERY_RESULT = {
  loading: false,
  data: {
    products: [
      {
        variants: {
          options: [
            {
              name: 'Size',
              values: ['36', '37', '38'],
              __typename: 'ProductVariantOption'
            }
          ],
          values: [
            {
              id: '441728-36',
              articleNumber: '441728-36',
              values: ['36'],
              stockStatus: {
                buyable: true,
                text: 'In stock',
                __typename: 'StockStatus'
              },
              images: [
                {
                  alt: '441728',
                  title: 'Belt Light',
                  url:
                    'https://www.demostore.se/pub_images/original/VARIANTIMAGE.jpg',
                  __typename: 'ProductImage'
                }
              ],
              __typename: 'ProductVariant'
            },
            {
              id: '441728-37',
              articleNumber: '441728-37',
              values: ['37'],
              stockStatus: {
                buyable: true,
                text: 'In stock',
                __typename: 'StockStatus'
              },
              images: [
                {
                  alt: 'Belt Light',
                  title: 'Belt Light',
                  url:
                    'https://www.demostore.se/pub_images/original/441728.jpg',
                  __typename: 'ProductImage'
                }
              ],
              __typename: 'ProductVariant'
            },
            {
              id: '441728-38',
              articleNumber: '441728-38',
              values: ['38'],
              stockStatus: {
                buyable: true,
                text: 'In stock',
                __typename: 'StockStatus'
              },
              images: [
                {
                  alt: 'Belt Light',
                  title: 'Belt Light',
                  url:
                    'https://www.demostore.se/pub_images/original/441728.jpg',
                  __typename: 'ProductImage'
                }
              ],
              __typename: 'ProductVariant'
            }
          ],
          __typename: 'ProductVariants'
        },
        id: 483,
        articleNumber: '441728',
        name: 'Belt Light',
        subName: 'PantsUp',
        hasConfigurations: false,
        hasVariants: true,
        isPreOrder: false,
        stockStatus: {
          buyable: true,
          text: 'In stock',
          __typename: 'StockStatus'
        },
        primaryRoute: {
          id: 'accessories/belts/belt-light',
          path: '/accessories/belts/belt-light',
          slug: 'belt-light',
          __typename: 'Route'
        },
        price: {
          incVat: 500,
          exVat: 400,
          vat: 100,
          __typename: 'Price'
        },
        previousPrice: {
          incVat: 1375,
          exVat: 1100,
          vat: 275,
          __typename: 'Price'
        },
        __typename: 'Product',
        badges: [
          {
            name: 'SALE Top Left',
            url:
              'https://www.demostore.se/M1/production/images/overlay/overlay8_en-GB.png',
            location: 'TOP_LEFT',
            style: '',
            text: '',
            __typename: 'ProductBadge'
          }
        ],
        images: [
          {
            alt: '441728',
            title: 'Belt Light',
            url: 'https://www.demostore.se/pub_images/original/441728.jpg',
            __typename: 'ProductImage'
          }
        ]
      }
    ]
  }
};

describe('flattenList', () => {
  it('takes a normalized list and returns an array of items', () => {
    const flattened = flattenList(MOCK_LIST);

    expect(flattened).toMatchSnapshot();
  });

  it('creates a unique entry for each variant', () => {
    const options = { quantity: 1 };

    const list = {
      baseProduct: {
        options: null,
        variants: {
          'variant-one': {
            options,
            parentArticleNumber: 'baseProduct'
          },
          'variant-two': {
            options,
            parentArticleNumber: 'baseProduct'
          }
        }
      }
    };

    const flattened = flattenList(list);
    expect(flattened).toHaveLength(2);
    expect(flattened[0].articleNumber).toBe('variant-one');
    expect(flattened[1].articleNumber).toBe('variant-two');
  });
  it('creates unique entries for variants and the base product', () => {
    const options = { quantity: 1 };

    const list = {
      baseProduct: {
        options: options,
        variants: {
          'variant-one': {
            options,
            parentArticleNumber: 'baseProduct'
          },
          'variant-two': {
            options,
            parentArticleNumber: 'baseProduct'
          }
        }
      }
    };

    const flattened = flattenList(list);
    expect(flattened).toHaveLength(3);
    expect(flattened[0].articleNumber).toBe('variant-one');
    expect(flattened[1].articleNumber).toBe('variant-two');
    expect(flattened[2].articleNumber).toBe('baseProduct');
  });
});

describe('getVariantFromProductDetails', () => {
  it('returns null when no variant is given', () => {
    const result = getVariantFromProductDetails(
      undefined,
      MOCK_PRODUCT_WITH_VARIANTS
    );

    expect(result).toBe(null);
  });
  it('returns the correct variant when a variant article number is given', () => {
    const result = getVariantFromProductDetails(
      '441728-37',
      MOCK_PRODUCT_WITH_VARIANTS
    );

    expect(result).toBe(
      MOCK_PRODUCT_WITH_VARIANTS.variants.values.find(
        variant => variant.articleNumber === '441728-37'
      )
    );
  });
  it('returns null when a variant cannot be found', () => {
    const result = getVariantFromProductDetails(
      'fgdgdfg',
      MOCK_PRODUCT_WITH_VARIANTS
    );

    expect(result).toBe(null);
  });
});

describe('getProductDetailForFlattenedProductList', () => {
  let result;
  let baseProduct;
  let variant;
  beforeEach(() => {
    const options = { quantity: 2 };
    const list = [
      {
        articleNumber: '441728',
        options
      },
      {
        articleNumber: '441728-36',
        options,
        parentArticleNumber: '441728'
      }
    ];
    const queryResult = MOCK_PRODUCT_QUERY_RESULT;

    result = getProductDetailForFlattenedProductList(list, queryResult);
    baseProduct = result[0];
    variant = result[1];
  });
  it(`gets product detail for each item in a flattened list`, () => {
    expect(result.length).toBe(2);
  });
  it(`returns validation messages for products that can't be added to the cart`, () => {
    expect(baseProduct.validation.status).toBe(`missingVariant`);
  });
  it(`appends variant detail to variant key and sets isVariant`, () => {
    expect(variant.variant.articleNumber).toBe('441728-36');
    expect(variant.isVariant).toBe(true);
    expect(baseProduct.variant).toBe(null);
    expect(baseProduct.isVariant).toBe(false);
  });
});

describe('normalizeServerList', () => {
  let serverList;
  beforeEach(() => {
    serverList = {
      customerProductList: {
        items: [
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'without-variants'
            },
            variant: null
          },
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'with-variants'
            },
            variant: {
              articleNumber: 'the-variant'
            }
          },
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'with-many-variants'
            },
            variant: {
              articleNumber: 'variant-one'
            }
          },
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'with-many-variants'
            },
            variant: {
              articleNumber: 'variant-two'
            }
          },
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'with-base-and-variants'
            },
            variant: null
          },
          {
            quantity: 1,
            description: 'hello',
            product: {
              articleNumber: 'with-base-and-variants'
            },
            variant: {
              articleNumber: 'variant-one'
            }
          }
        ]
      }
    };
  });
  it('returns an empty object if an invalid list if passed in', () => {
    const result = normalizeServerList({ not: 'a list' });

    expect(result).toEqual({});
  });
  it('creates the expected shape', () => {
    const result = normalizeServerList(serverList);

    expect(result['without-variants'].variants).toBe(null);
    expect(result['without-variants'].options.quantity).toBe(1);

    expect(result['with-variants'].options).toBe(null);
    expect(
      result['with-variants'].variants['the-variant'].options.quantity
    ).toBe(1);

    expect(result['with-many-variants'].options).toBe(null);
    expect(result['with-many-variants'].variants['variant-one']).toBeDefined();
    expect(result['with-many-variants'].variants['variant-two']).toBeDefined();

    expect(result['with-base-and-variants'].options).toBeDefined();
    expect(
      result['with-base-and-variants'].variants['variant-one']
    ).toBeDefined();
  });
});