@commercetools-frontend/experimental-components 0.0.2 → 0.0.3

package/src/utils/graphql/graphql.spec.js

@@ -1,1129 +0,0 @@
-import {
-  transformLocalizedFieldsForCategory,
-  mapShippingRateTierToGraphQL,
-  createGraphQlUpdateActions,
-  createAttributeTypeValue,
-  transformCustomFieldsRawToCustomFields,
-  extractErrorFromGraphQlResponse,
-  getIsLocalizedString,
-} from './graphql';
-import { PRECISION_TYPES } from '../constants';
-
-describe('transformCustomFieldsRawToCustomFields', () => {
-  let result;
-  describe('when raw custom fields are not defined', () => {
-    beforeEach(() => {
-      result = transformCustomFieldsRawToCustomFields();
-    });
-    it('should return null', () => {
-      expect(result).toBe(null);
-    });
-  });
-  describe('when raw custom fields are empty', () => {
-    beforeEach(() => {
-      result = transformCustomFieldsRawToCustomFields([]);
-    });
-    it('should return null', () => {
-      expect(result).toBe(null);
-    });
-  });
-  describe('when raw custom fields are non empty and defined', () => {
-    beforeEach(() => {
-      result = transformCustomFieldsRawToCustomFields([
-        { name: 'fieldA', value: 'Hello' },
-        { name: 'fieldB', value: 'Ciao' },
-      ]);
-    });
-    it('should return a CustomField object', () => {
-      expect(result).toEqual({ fieldA: 'Hello', fieldB: 'Ciao' });
-    });
-  });
-});
-
-describe('transformLocalizedFieldsForCategory', () => {
-  describe('no parent and no ancestors', () => {
-    const expected = {
-      id: '1',
-      name: {
-        en: 'name',
-        de: 'name',
-      },
-      slug: {
-        en: 'slug',
-        de: 'slug',
-      },
-      externalId: 'xxx',
-    };
-
-    const mapped = transformLocalizedFieldsForCategory(
-      {
-        id: '1',
-        nameAllLocales: [
-          {
-            locale: 'en',
-            value: 'name',
-          },
-          {
-            locale: 'de',
-            value: 'name',
-          },
-        ],
-        slugAllLocales: [
-          {
-            locale: 'en',
-            value: 'slug',
-          },
-          {
-            locale: 'de',
-            value: 'slug',
-          },
-        ],
-        externalId: 'xxx',
-      },
-      [
-        {
-          from: 'nameAllLocales',
-          to: 'name',
-        },
-        {
-          from: 'slugAllLocales',
-          to: 'slug',
-        },
-      ]
-    );
-
-    it('map correctly to category representation', () => {
-      expect(mapped).toEqual(expected);
-    });
-  });
-  describe('with parent', () => {
-    const expected = {
-      id: '1',
-      name: { en: 'name' },
-      parent: { id: '2', name: { en: 'name' } },
-    };
-
-    const mapped = transformLocalizedFieldsForCategory({
-      id: '1',
-      nameAllLocales: [{ locale: 'en', value: 'name' }],
-      parent: { id: '2', nameAllLocales: [{ locale: 'en', value: 'name' }] },
-    });
-
-    it('map correctly to category representation', () => {
-      expect(mapped).toEqual(expected);
-    });
-  });
-  describe('with ancestors', () => {
-    const expected = {
-      id: '1',
-      name: { en: 'name' },
-      ancestors: [
-        { id: '2', name: { en: 'name' } },
-        { id: '3', name: { en: 'name' } },
-      ],
-    };
-
-    const mapped = transformLocalizedFieldsForCategory({
-      id: '1',
-      nameAllLocales: [{ locale: 'en', value: 'name' }],
-      ancestors: [
-        { id: '2', nameAllLocales: [{ locale: 'en', value: 'name' }] },
-        { id: '3', nameAllLocales: [{ locale: 'en', value: 'name' }] },
-      ],
-    });
-
-    it('map correctly to category representation', () => {
-      expect(mapped).toEqual(expected);
-    });
-  });
-});
-
-describe('mapShippingRateTierToGraphQL', () => {
-  const expected = [
-    {
-      CartValue: {
-        score: 10,
-      },
-    },
-  ];
-
-  const mapped = mapShippingRateTierToGraphQL([
-    {
-      type: 'CartValue',
-      price: undefined,
-      minimumCentAmount: undefined,
-      value: undefined,
-      priceFunction: null,
-      score: 10,
-    },
-  ]);
-
-  it('correctly transform and omit shipping rate tier fields', () => {
-    expect(mapped).toEqual(expected);
-  });
-});
-
-describe('createGraphQlUpdateActions', () => {
-  let syncActions;
-  describe('with actions', () => {
-    beforeEach(() => {
-      syncActions = [{ action: 'fooAction', payload: { foo: 'bar' } }];
-    });
-    it('should map `action` names to the object key', () => {
-      expect(createGraphQlUpdateActions(syncActions)).toEqual([
-        { [syncActions[0].action]: expect.any(Object) },
-      ]);
-    });
-
-    it('should map `action` payload to the object value', () => {
-      expect(createGraphQlUpdateActions(syncActions)[0].fooAction).toEqual({
-        payload: { foo: 'bar' },
-      });
-    });
-
-    describe('with `setCustomField` action', () => {
-      const customFieldActions = [
-        {
-          action: 'setCustomField',
-          name: 'String-149-84-6976',
-          value: 'bhss',
-        },
-      ];
-
-      it('should stringify the `action` payload as the object value', () => {
-        expect(
-          createGraphQlUpdateActions(customFieldActions)[0].setCustomField.value
-        ).toEqual(JSON.stringify(customFieldActions[0].value));
-      });
-    });
-
-    describe('with `removeLocation` action', () => {
-      const zoneActions = [
-        {
-          action: 'removeLocation',
-          location: { country: 'ES' },
-        },
-      ];
-
-      it('should build the graphql action with only the country', () => {
-        expect(createGraphQlUpdateActions(zoneActions)[0]).toEqual({
-          removeLocation: { location: { country: 'ES' } },
-        });
-      });
-    });
-
-    describe('with `addLocation` action', () => {
-      const zoneActions = [
-        {
-          action: 'addLocation',
-          location: { country: 'ES' },
-        },
-      ];
-
-      it('should build the graphql action with only the country', () => {
-        expect(createGraphQlUpdateActions(zoneActions)[0]).toEqual({
-          addLocation: { location: { country: 'ES' } },
-        });
-      });
-    });
-
-    describe('with `replaceTaxRate` action', () => {
-      const taxCategoryWithNoSubRatesActions = [
-        {
-          action: 'replaceTaxRate',
-          taxRate: {
-            id: 'some-id',
-            name: 'Test',
-            country: 'ES',
-            amount: 1,
-            subRates: [],
-          },
-          taxRateId: 'some-id',
-        },
-      ];
-
-      const taxCategoryWithSubRatesActions = [
-        {
-          action: 'replaceTaxRate',
-          taxRate: {
-            id: 'some-id',
-            name: 'Test',
-            country: 'ES',
-            amount: 1,
-            subRates: [{ name: 'sub-rate', amount: 1 }],
-          },
-          taxRateId: 'some-id',
-        },
-      ];
-
-      it('should build the graphql action taxRate including empty subRates but without the id', () => {
-        expect(
-          createGraphQlUpdateActions(taxCategoryWithNoSubRatesActions)[0]
-        ).toEqual({
-          replaceTaxRate: {
-            taxRateId: 'some-id',
-            taxRate: { name: 'Test', country: 'ES', amount: 1, subRates: [] },
-          },
-        });
-      });
-
-      it('should build the graphql action taxRate including subRates but without the id', () => {
-        expect(
-          createGraphQlUpdateActions(taxCategoryWithSubRatesActions)[0]
-        ).toEqual({
-          replaceTaxRate: {
-            taxRateId: 'some-id',
-            taxRate: {
-              name: 'Test',
-              country: 'ES',
-              amount: 1,
-              subRates: [{ name: 'sub-rate', amount: 1 }],
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `addZone` action', () => {
-      const shippingMethodActions = [
-        {
-          action: 'addZone',
-          zone: {
-            id: 'z1',
-            typeId: 'zone',
-          },
-          typename: 'shippingMethod',
-        },
-      ];
-
-      it('should build the graphql action shippingMethod without the other props', () => {
-        expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-          addZone: {
-            zone: {
-              id: 'z1',
-              typeId: 'zone',
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `removeZone` action', () => {
-      const shippingMethodActions = [
-        {
-          action: 'removeZone',
-          zone: {
-            id: 'z1',
-            name: 'Zone 1',
-            typeId: 'zone',
-          },
-          typename: 'shippingMethod',
-        },
-      ];
-
-      it('should build the graphql action shippingMethod without the other props', () => {
-        expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-          removeZone: {
-            zone: {
-              id: 'z1',
-              typeId: 'zone',
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `changeTaxCategory` action', () => {
-      const shippingMethodActions = [
-        {
-          action: 'changeTaxCategory',
-          taxCategory: {
-            id: 'tc1',
-            name: 'Tax 1',
-            typeId: 'tax-category',
-          },
-          typename: 'shippingMethod',
-        },
-      ];
-
-      it('should build the graphql action shippingMethod without the other props', () => {
-        expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-          changeTaxCategory: {
-            taxCategory: {
-              id: 'tc1',
-              typeId: 'tax-category',
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `addShippingRate` action', () => {
-      const shippingMethodActions = [
-        {
-          action: 'addShippingRate',
-          zone: {
-            id: 'z1',
-            typeId: 'zone',
-          },
-          typename: 'shippingMethod',
-          shippingRate: {
-            price: {
-              centAmount: 10,
-              currencyCode: 'EUR',
-            },
-            freeAbove: null,
-            tiers: null,
-          },
-        },
-      ];
-
-      it('should build the graphql action shippingMethod without the other props', () => {
-        expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-          addShippingRate: {
-            zone: {
-              id: 'z1',
-              typeId: 'zone',
-            },
-            shippingRate: {
-              price: {
-                centAmount: 10,
-                currencyCode: 'EUR',
-              },
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `removeShippingRate` action', () => {
-      const shippingMethodActions = [
-        {
-          action: 'removeShippingRate',
-          zone: {
-            id: 'z1',
-            typeId: 'zone',
-          },
-          typename: 'shippingMethod',
-          shippingRate: {
-            price: {
-              centAmount: 10,
-              currencyCode: 'EUR',
-            },
-            freeAbove: null,
-            tiers: null,
-          },
-        },
-      ];
-
-      it('should build the graphql action shippingMethod without the other props', () => {
-        expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-          removeShippingRate: {
-            zone: {
-              id: 'z1',
-              typeId: 'zone',
-            },
-            shippingRate: {
-              price: {
-                centAmount: 10,
-                currencyCode: 'EUR',
-              },
-            },
-          },
-        });
-      });
-    });
-
-    describe('with `changeValue` action', () => {
-      const changeValueActions = [
-        {
-          action: 'changeValue',
-          value: {
-            type: 'relative',
-            permyriad: '1200',
-          },
-        },
-      ];
-
-      it('should build the graphql action changeValue', () => {
-        expect(createGraphQlUpdateActions(changeValueActions)).toEqual([
-          {
-            changeValue: {
-              value: {
-                relative: {
-                  permyriad: '1200',
-                },
-              },
-            },
-          },
-        ]);
-      });
-    });
-
-    describe('with `changeLabel`', () => {
-      beforeEach(() => {
-        syncActions = [
-          {
-            action: 'changeLabel',
-            attributeName: 'foo',
-            label: { en: 'bar', de: 'baz' },
-          },
-        ];
-      });
-      it('should return attribute-type name as action and transform label', () => {
-        expect(createGraphQlUpdateActions(syncActions)).toEqual([
-          {
-            changeLabel: {
-              attributeName: 'foo',
-              label: [
-                { locale: 'de', value: 'baz' },
-                { locale: 'en', value: 'bar' },
-              ],
-            },
-          },
-        ]);
-      });
-    });
-    describe('with `changeLocalizedEnumValueLabel`', () => {
-      beforeEach(() => {
-        syncActions = [
-          {
-            action: 'changeLocalizedEnumValueLabel',
-            attributeName: 'foo',
-            newValue: {
-              key: 'bar',
-              label: { en: 'bar', de: 'baz' },
-            },
-          },
-        ];
-      });
-      it('should return attribute-type name as action and transform label', () => {
-        expect(createGraphQlUpdateActions(syncActions)).toEqual([
-          {
-            changeLocalizedEnumValueLabel: {
-              attributeName: 'foo',
-              newValue: {
-                key: 'bar',
-                label: [
-                  { locale: 'de', value: 'baz' },
-                  { locale: 'en', value: 'bar' },
-                ],
-              },
-            },
-          },
-        ]);
-      });
-    });
-    describe('with `addLocalizedEnumValue`', () => {
-      beforeEach(() => {
-        syncActions = [
-          {
-            action: 'addLocalizedEnumValue',
-            attributeName: 'foo',
-            value: {
-              key: 'bar',
-              label: { de: 'baz', en: 'bar' },
-            },
-          },
-        ];
-      });
-      it('should return attribute-type name as action and transform label', () => {
-        expect(createGraphQlUpdateActions(syncActions)).toEqual([
-          {
-            addLocalizedEnumValue: {
-              attributeName: 'foo',
-              value: {
-                key: 'bar',
-                label: [
-                  { locale: 'de', value: 'baz' },
-                  { locale: 'en', value: 'bar' },
-                ],
-              },
-            },
-          },
-        ]);
-      });
-    });
-
-    describe('with `setInputTip`', () => {
-      beforeEach(() => {
-        syncActions = [
-          {
-            action: 'setInputTip',
-            attributeName: 'foo',
-            inputTip: { en: 'bar', de: 'baz' },
-          },
-        ];
-      });
-      it('should return attribute-type name as action and transform inputTip', () => {
-        expect(createGraphQlUpdateActions(syncActions)).toEqual([
-          {
-            setInputTip: {
-              attributeName: 'foo',
-              inputTip: [
-                { locale: 'de', value: 'baz' },
-                { locale: 'en', value: 'bar' },
-              ],
-            },
-          },
-        ]);
-      });
-    });
-
-    describe('with `addAttributeDefinition`', () => {
-      const createAddAttributeAction = (custom) => ({
-        action: 'addAttributeDefinition',
-        attribute: {
-          label: { en: 'foo' },
-          inputTip: { en: 'foo' },
-          type: { name: 'text' },
-        },
-        ...custom,
-      });
-      describe('with text', () => {
-        beforeEach(() => {
-          syncActions = [createAddAttributeAction()];
-        });
-        it('should match snapshot', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toMatchSnapshot();
-        });
-        it('should return attribute-type name as action', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              addAttributeDefinition: {
-                attributeDefinition: expect.objectContaining({
-                  type: {
-                    text: {},
-                  },
-                }),
-              },
-            },
-          ]);
-        });
-        it('should convert localized fields', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              addAttributeDefinition: {
-                attributeDefinition: expect.objectContaining({
-                  label: [{ locale: 'en', value: 'foo' }],
-                  inputTip: [{ locale: 'en', value: 'foo' }],
-                }),
-              },
-            },
-          ]);
-        });
-      });
-      describe('with reference', () => {
-        beforeEach(() => {
-          syncActions = [
-            createAddAttributeAction({
-              attribute: {
-                type: {
-                  name: 'reference',
-                  referenceTypeId: 'product',
-                },
-              },
-            }),
-          ];
-        });
-        it('should match snapshot', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toMatchSnapshot();
-        });
-        it('should return attribute-type name as action', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              addAttributeDefinition: {
-                attributeDefinition: expect.objectContaining({
-                  type: {
-                    reference: {
-                      referenceTypeId: 'product',
-                    },
-                  },
-                }),
-              },
-            },
-          ]);
-        });
-      });
-    });
-
-    describe('with `setShippingRateInputType`', () => {
-      describe('when `type` is `CartClassification`', () => {
-        beforeEach(() => {
-          syncActions = [
-            {
-              action: 'setShippingRateInputType',
-              shippingRateInputType: {
-                type: 'CartClassification',
-                values: [
-                  {
-                    key: 'foo',
-                    allLocaleLabels: [{ locale: 'en', value: 'Foo' }],
-                  },
-                ],
-              },
-            },
-          ];
-        });
-        it('should return `type` and `values` on `setShippingRateInputType`', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              setShippingRateInputType: {
-                shippingRateInputType: {
-                  [syncActions[0].shippingRateInputType.type]: {
-                    values: [
-                      {
-                        key: 'foo',
-                        label: [{ locale: 'en', value: 'Foo' }],
-                      },
-                    ],
-                  },
-                },
-              },
-            },
-          ]);
-        });
-      });
-      describe('when `type` is `CartScore`', () => {
-        beforeEach(() => {
-          syncActions = [
-            {
-              action: 'setShippingRateInputType',
-              shippingRateInputType: {
-                type: 'CartScore',
-                values: null,
-              },
-            },
-          ];
-        });
-        it('should return `type` and unset `values` on `setShippingRateInputType`', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              setShippingRateInputType: {
-                shippingRateInputType: {
-                  [syncActions[0].shippingRateInputType.type]: {},
-                },
-              },
-            },
-          ]);
-        });
-      });
-      describe('when `type` is `CartValue`', () => {
-        beforeEach(() => {
-          syncActions = [
-            {
-              action: 'setShippingRateInputType',
-              shippingRateInputType: {
-                type: 'CartValue',
-                values: null,
-              },
-            },
-          ];
-        });
-        it('should return `type` and unset `values` on `setShippingRateInputType`', () => {
-          expect(createGraphQlUpdateActions(syncActions)).toEqual([
-            {
-              setShippingRateInputType: {
-                shippingRateInputType: {
-                  [syncActions[0].shippingRateInputType.type]: {},
-                },
-              },
-            },
-          ]);
-        });
-      });
-    });
-
-    describe('with `addCustomLineItem` action', () => {
-      describe('with high-precision money type', () => {
-        const cartUpdateActions = [
-          {
-            action: 'addCustomLineItem',
-            slug: 'slug',
-            quantity: 2,
-            name: { en: 'foo' },
-            taxCategory: 'tax-1',
-            money: {
-              type: PRECISION_TYPES.highPrecision,
-              fractionDigits: 2,
-              centAmount: 100,
-              currencyCode: 'EUR',
-            },
-          },
-        ];
-        it('should build the graphql action `addCustomLineItem`', () => {
-          expect(createGraphQlUpdateActions(cartUpdateActions)[0]).toEqual({
-            addCustomLineItem: {
-              name: [{ locale: 'en', value: 'foo' }],
-              slug: 'slug',
-              quantity: 2,
-              taxCategory: 'tax-1',
-              money: {
-                [PRECISION_TYPES.highPrecision]: {
-                  centAmount: 100,
-                  currencyCode: 'EUR',
-                  fractionDigits: 2,
-                },
-              },
-            },
-          });
-        });
-      });
-      describe('with cent-precision money type', () => {
-        const cartUpdateActions = [
-          {
-            action: 'addCustomLineItem',
-            slug: 'slug',
-            quantity: 2,
-            name: { en: 'foo' },
-            taxCategory: 'tax-1',
-            money: {
-              type: PRECISION_TYPES.centPrecision,
-              fractionDigits: 2,
-              centAmount: 100,
-              currencyCode: 'EUR',
-            },
-          },
-        ];
-
-        it('should build the graphql action `addCustomLineItem`', () => {
-          expect(createGraphQlUpdateActions(cartUpdateActions)[0]).toEqual({
-            addCustomLineItem: {
-              name: [{ locale: 'en', value: 'foo' }],
-              slug: 'slug',
-              quantity: 2,
-              taxCategory: 'tax-1',
-              money: {
-                [PRECISION_TYPES.centPrecision]: {
-                  centAmount: 100,
-                  currencyCode: 'EUR',
-                },
-              },
-            },
-          });
-        });
-      });
-    });
-
-    describe('with `setCustomType` action', () => {
-      const cartUpdateActions = [
-        {
-          action: 'setCustomType',
-          type: {
-            id: 'type-id',
-          },
-          fields: {
-            field1: 'foo',
-            field2: 'bar',
-          },
-        },
-      ];
-
-      it('should build the graphql action `addCustomLineItem`', () => {
-        expect(createGraphQlUpdateActions(cartUpdateActions)[0]).toEqual({
-          setCustomType: {
-            typeId: 'type-id',
-            fields: [
-              {
-                name: 'field1',
-                value: '"foo"',
-              },
-              {
-                name: 'field2',
-                value: '"bar"',
-              },
-            ],
-          },
-        });
-      });
-    });
-    describe('with `changeName`', () => {
-      const productDiscountActions = [
-        {
-          action: 'changeName',
-          name: {
-            en: 'change name',
-          },
-        },
-      ];
-      it('should build graphql action `changeName`', () => {
-        expect(createGraphQlUpdateActions(productDiscountActions)[0]).toEqual({
-          changeName: {
-            name: [
-              {
-                locale: 'en',
-                value: 'change name',
-              },
-            ],
-          },
-        });
-      });
-    });
-    describe('with `setDescription`', () => {
-      describe('when description is a localized string', () => {
-        const productDiscountActions = [
-          {
-            action: 'setDescription',
-            description: {
-              en: 'change description',
-            },
-          },
-        ];
-        it('should build graphql action `setDescription` with localized string', () => {
-          expect(createGraphQlUpdateActions(productDiscountActions)[0]).toEqual(
-            {
-              setDescription: {
-                description: [
-                  {
-                    locale: 'en',
-                    value: 'change description',
-                  },
-                ],
-              },
-            }
-          );
-        });
-      });
-      describe('when description is a string', () => {
-        const productDiscountActions = [
-          {
-            action: 'setDescription',
-            description: 'change description',
-          },
-        ];
-        it('should build graphql action `setDescription` with string', () => {
-          expect(createGraphQlUpdateActions(productDiscountActions)[0]).toEqual(
-            {
-              setDescription: {
-                description: 'change description',
-              },
-            }
-          );
-        });
-      });
-      describe('with `setLocalizedDescription`', () => {
-        const shippingMethodActions = [
-          {
-            action: 'setLocalizedDescription',
-            localizedDescription: {
-              en: 'change description',
-            },
-          },
-        ];
-        it('should build graphql action `setLocalizedDescription` with localized string', () => {
-          expect(createGraphQlUpdateActions(shippingMethodActions)[0]).toEqual({
-            setLocalizedDescription: {
-              localizedDescription: [
-                {
-                  locale: 'en',
-                  value: 'change description',
-                },
-              ],
-            },
-          });
-        });
-      });
-    });
-  });
-
-  describe('without actions', () => {
-    it('should return an empty `Array`', () => {
-      expect(createGraphQlUpdateActions([])).toEqual([]);
-    });
-  });
-
-  describe('utils', () => {
-    describe('createAttributeTypeValue', () => {
-      let attribute;
-      describe('with text', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'text' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            text: {},
-          });
-        });
-      });
-      describe('with ltext', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'ltext' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            ltext: {},
-          });
-        });
-      });
-      describe('with boolean', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'boolean' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            boolean: {},
-          });
-        });
-      });
-      describe('with date', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'date' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            date: {},
-          });
-        });
-      });
-      describe('with time', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'time' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            time: {},
-          });
-        });
-      });
-      describe('with datetime', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'datetime' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            datetime: {},
-          });
-        });
-      });
-      describe('with number', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'number' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            number: {},
-          });
-        });
-      });
-      describe('with money', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'money' },
-          };
-        });
-        it('should return attribute type with name', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            money: {},
-          });
-        });
-      });
-      describe('with reference', () => {
-        beforeEach(() => {
-          attribute = {
-            type: { name: 'reference', referenceTypeId: 'product' },
-          };
-        });
-        it('should return attribute type with name and referenceTypeId', () => {
-          expect(createAttributeTypeValue(attribute)).toEqual({
-            reference: {
-              referenceTypeId: 'product',
-            },
-          });
-        });
-      });
-    });
-  });
-});
-
-describe('extractErrorFromGraphQlResponse', () => {
-  describe('given a `networkError` with errors exists', () => {
-    const graphQlResponseWithNetworkErrors = {
-      networkError: {
-        result: {
-          errors: [
-            {
-              code: 'a network error',
-            },
-          ],
-        },
-      },
-    };
-
-    it('should rethrow the network errors', () => {
-      expect(
-        extractErrorFromGraphQlResponse(graphQlResponseWithNetworkErrors)
-      ).toEqual(graphQlResponseWithNetworkErrors.networkError.result.errors);
-    });
-  });
-
-  describe('given a `graphQLErrors` exists', () => {
-    const graphQlResponseWithGraphQLErrors = {
-      graphQLErrors: [
-        {
-          code: 'a graphql error',
-        },
-      ],
-    };
-
-    it('should rethrow the network errors', () => {
-      expect(
-        extractErrorFromGraphQlResponse(graphQlResponseWithGraphQLErrors)
-      ).toEqual(graphQlResponseWithGraphQLErrors.graphQLErrors);
-    });
-  });
-
-  describe('given no `graphqlErrors` and no `networkErrors` exist', () => {
-    const graphQlResponseWithoutGraphQLErrorsAndNetworkErrors = {
-      graphQLErrors: [],
-      networkError: {},
-    };
-
-    it('should rethrow the response', () => {
-      expect(
-        extractErrorFromGraphQlResponse(
-          graphQlResponseWithoutGraphQLErrorsAndNetworkErrors
-        )
-      ).toEqual(graphQlResponseWithoutGraphQLErrorsAndNetworkErrors);
-    });
-  });
-});
-
-describe('getIsLocalizedString', () => {
-  describe('when input is not defined', () => {
-    it('should indicate that it is not a localied string', () => {
-      expect(getIsLocalizedString(null)).toBe(false);
-      expect(getIsLocalizedString(undefined)).toBe(false);
-    });
-  });
-  describe('when input is a string', () => {
-    it('should indicate that it is not a localied string', () => {
-      expect(getIsLocalizedString('foo')).toBe(false);
-    });
-  });
-  describe('when input is an object', () => {
-    describe('with less than one property', () => {
-      it('should indicate that it is not a localied string', () => {
-        expect(getIsLocalizedString({})).toBe(false);
-      });
-    });
-    describe('with more than one property', () => {
-      it('should indicate that it is an localied string', () => {
-        expect(getIsLocalizedString({ de: 'Hallo' })).toBe(true);
-      });
-    });
-  });
-});