@jetshop/core 5.13.0 → 5.13.3-beta.0

package/ChannelHandler/redirectUtilsGroupedChannels.test.js

@@ -0,0 +1,732 @@
+import {
+  createSelectedChannel,
+  getSelectedAndRecommendedChannel
+} from './channelUtils';
+import { MockLink } from 'apollo-link-mock';
+import {
+  InMemoryCache,
+  IntrospectionFragmentMatcher
+} from 'apollo-cache-inmemory';
+import ApolloClient from 'apollo-client';
+import gql from 'graphql-tag';
+import { ChannelHandler } from './ChannelHandler';
+import {
+  groupedChannels as channels,
+  groupedSingleDomainChannels as singleDomainChannels
+} from '../test-utils/variables';
+import { Cookies } from 'react-cookie';
+import { primaryRouteForPathFetcher } from './redirectUtils';
+import PreserveRedirectRouteQuery from './PreserveRedirectRouteQuery.gql';
+import fragmentTypes from '@jetshop/core/data/fragmentTypes';
+
+const startPagePathnameRedirectQuery = gql`
+  query StartPagePathnameRedirectQuery($id: Int!) {
+    StartPage: startPage(id: $id) {
+      id
+      primaryRoute {
+        id
+        path
+        __typename
+      }
+      __typename
+    }
+  }
+`;
+
+const startPagePathnameRedirectRequest = {
+  request: {
+    query: startPagePathnameRedirectQuery,
+    variables: { id: 44 }
+  },
+  result: {
+    data: {
+      StartPage: {
+        id: 44,
+        primaryRoute: {
+          id: '/',
+          path: '/',
+          __typename: 'Route'
+        },
+        __typename: 'StartPage'
+      }
+    }
+  }
+};
+
+const productPathnameRedirectQuery = gql`
+  query ProductPathnameRedirectQuery($id: Int!) {
+    Product: product(id: $id) {
+      id
+      primaryRoute {
+        id
+        path
+        __typename
+      }
+      __typename
+    }
+  }
+`;
+
+const redirectQueryMocks = [
+  {
+    request: {
+      query: PreserveRedirectRouteQuery,
+      variables: {
+        path: '/'
+      }
+    },
+    result: {
+      data: {
+        route: {
+          id: '/',
+          object: {
+            id: 44,
+            __typename: 'StartPage'
+          },
+          __typename: 'Route'
+        },
+        __typename: 'Query'
+      }
+    }
+  },
+  startPagePathnameRedirectRequest,
+  startPagePathnameRedirectRequest,
+  startPagePathnameRedirectRequest,
+  startPagePathnameRedirectRequest,
+  {
+    request: {
+      query: PreserveRedirectRouteQuery,
+      variables: {
+        path: '/accessories/orchid-peach-bag'
+      }
+    },
+    result: {
+      data: {
+        route: {
+          id: '/accessories/orchid-peach-bag',
+          object: {
+            id: 522,
+            __typename: 'Product'
+          },
+          __typename: 'Route'
+        }
+      }
+    }
+  },
+  {
+    request: {
+      query: productPathnameRedirectQuery,
+      variables: { id: 522 }
+    },
+    result: {
+      data: {
+        Product: {
+          id: 522,
+          primaryRoute: {
+            id: '/accessories/bags/orchid-peach-bag-uk',
+            path: '/accessories/bags/orchid-peach-bag-uk',
+            __typename: 'Route'
+          },
+          __typename: 'Product'
+        }
+      }
+    }
+  },
+  {
+    request: {
+      query: productPathnameRedirectQuery,
+      variables: { id: 522 }
+    },
+    result: {
+      data: {
+        Product: {
+          id: 522,
+          primaryRoute: {
+            id: '/accessories/orchid-peach-bag',
+            path: '/accessories/orchid-peach-bag',
+            __typename: 'Route'
+          },
+          __typename: 'Product'
+        }
+      }
+    }
+  }
+];
+
+function createClient(mocks) {
+  return new ApolloClient({
+    cache: new InMemoryCache({
+      addTypename: true,
+      fragmentMatcher: new IntrospectionFragmentMatcher({
+        introspectionQueryResultData: {
+          __schema: {
+            types: fragmentTypes
+          }
+        }
+      })
+    }),
+    link: new MockLink(mocks)
+  });
+}
+
+const client = createClient(redirectQueryMocks);
+const getPrimaryRoutePath = primaryRouteForPathFetcher(client);
+
+const selectedChannelSingleDomain = createSelectedChannel(
+  singleDomainChannels[0]
+);
+
+describe('Channel grouping', () => {
+  beforeEach(() => {
+    // Workaround changes in universal-cookie
+    Object.defineProperty(document, 'cookie', {
+      value: null
+    });
+  });
+});
+
+describe('Grouped channels', () => {
+  beforeEach(() => {
+    // Workaround changes in universal-cookie
+    Object.defineProperty(document, 'cookie', {
+      value: null
+    });
+  });
+  describe('Single domain', () => {
+    it('Only have channels from within the group based on url', () => {
+      const cookies = new Cookies();
+      const { selectedChannel, channels } = getSelectedAndRecommendedChannel({
+        url: singleDomainChannels[0].url,
+        singleDomainMode: true,
+        channels: singleDomainChannels,
+        cookies
+      });
+
+      expect(selectedChannel.groupName).toBe('Brand-1');
+      channels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+    });
+    it('Only have channels from within the group based on cookie', () => {
+      const cookies = new Cookies();
+      cookies.set('channel', singleDomainChannels[0].name);
+      const { selectedChannel, channels } = getSelectedAndRecommendedChannel({
+        url: singleDomainChannels[0].url,
+        singleDomainMode: true,
+        channels: singleDomainChannels,
+        cookies
+      });
+
+      expect(selectedChannel.groupName).toBe('Brand-1');
+      channels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+    });
+    it('Recommend channel from within current group based on GEO-IP', () => {
+      const cookies = new Cookies();
+      const { recommendedChannel, selectedChannel, redirect, channels } =
+        getSelectedAndRecommendedChannel({
+          url: singleDomainChannels[0].url,
+          geoipCountry: 'SE',
+          singleDomainMode: true,
+          disableGeoRedirect: false,
+          channels: singleDomainChannels,
+          cookies
+        });
+
+      expect(selectedChannel.name).toBe('INT');
+
+      channels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.name).toBe('SE');
+      expect(recommendedChannel.groupName).toBe('Brand-1');
+    });
+  });
+  describe('Non single domain', () => {
+    /**
+     * Non single domain
+     */
+    it('Only have channels from within the group based on url', () => {
+      const cookies = new Cookies();
+      const { selectedChannel, channels: availableChannels } =
+        getSelectedAndRecommendedChannel({
+          url: channels[1].url,
+          singleDomainMode: false,
+          channels: channels,
+          cookies
+        });
+
+      expect(selectedChannel.groupName).toBe('Brand-1');
+      availableChannels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+    });
+    it('Only have channels from within the group based on cookie', () => {
+      const cookies = new Cookies();
+      cookies.set('channel', channels[0].name);
+      const { selectedChannel, channels: availableChannels } =
+        getSelectedAndRecommendedChannel({
+          url: channels[0].url,
+          singleDomainMode: false,
+          channels: channels,
+          cookies
+        });
+
+      expect(selectedChannel.groupName).toBe('Brand-1');
+      availableChannels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+    });
+    it('Recommend channel from within current group based on GEO-IP', () => {
+      const cookies = new Cookies();
+      const {
+        recommendedChannel,
+        selectedChannel,
+        redirect,
+        channels: availableChannels
+      } = getSelectedAndRecommendedChannel({
+        url: channels[0].url,
+        geoipCountry: 'SE',
+        singleDomainMode: false,
+        disableGeoRedirect: false,
+        channels: channels,
+        cookies
+      });
+
+      expect(selectedChannel.name).toBe('INT');
+
+      availableChannels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.name).toBe('SE');
+      expect(recommendedChannel.groupName).toBe('Brand-1');
+    });
+    it('Respects change of channel and group using url', () => {
+      const cookies = new Cookies();
+      const prevSelectedChannel = createSelectedChannel(channels[2]);
+
+      expect(prevSelectedChannel.name).toBe('UK');
+      expect(prevSelectedChannel.groupName).toBe('Brand-2');
+
+      const {
+        selectedChannel,
+        redirect,
+        channels: availableChannels
+      } = getSelectedAndRecommendedChannel({
+        url: channels[1].url,
+        singleDomainMode: false,
+        channels: channels,
+        cookies
+      });
+
+      expect(redirect).toBe(false);
+      expect(selectedChannel.name).toBe('SE');
+      expect(selectedChannel.groupName).toBe('Brand-1');
+      availableChannels.forEach((c) => expect(c.groupName).toBe('Brand-1'));
+    });
+  });
+  describe('Redirects', () => {
+    it('Does not redirect to channel outside of current group', () => {
+      const cookies = new Cookies();
+      const selectedChannel = createSelectedChannel(channels[2]);
+      cookies.set('channel', selectedChannel.name);
+
+      const recommendedChannel = createSelectedChannel(channels[0]);
+
+      const { redirect, channels: availableChannel } =
+        getSelectedAndRecommendedChannel({
+          url: recommendedChannel.url,
+          singleDomainMode: false,
+          channels,
+          cookies
+        });
+
+      availableChannel.forEach((channel) =>
+        expect(channel.groupName).toBe('Brand-1')
+      );
+      expect(redirect).toBe(false);
+    });
+
+    it('Can redirect to channel within group', () => {
+      const cookies = new Cookies();
+      const selectedChannel = createSelectedChannel(channels[1]);
+      cookies.set('channel', selectedChannel.name);
+
+      const recommendedChannel = createSelectedChannel(channels[0]);
+
+      const { redirect, channels: availableChannel } =
+        getSelectedAndRecommendedChannel({
+          url: recommendedChannel.url,
+          singleDomainMode: false,
+          channels,
+          cookies
+        });
+
+      availableChannel.forEach((channel) =>
+        expect(channel.groupName).toBe('Brand-1')
+      );
+      expect(redirect).toBe(true);
+    });
+  });
+});
+
+describe('Channel utils with grouped channels', () => {
+  beforeEach(() => {
+    // Workaround changes in universal-cookie
+    Object.defineProperty(document, 'cookie', {
+      value: null
+    });
+  });
+
+  it('successfully redirect to the appropriate channel', () => {
+    const recommendedChannel = createSelectedChannel(channels[1]);
+    const selectedChannel = createSelectedChannel(channels[0]);
+    const channelHandler = new ChannelHandler({
+      selectedChannel,
+      recommendedChannel,
+      getPrimaryRoutePath,
+      channels
+    });
+
+    const redirectUrl = channelHandler.getRedirectUrl({
+      client,
+      url: selectedChannel.url,
+      newChannel: recommendedChannel
+    });
+    expect(redirectUrl).resolves.toBe(
+      'https://flight-m2.jetshop.se/?culture=sv-SE&channelCountry=SE&channel=SE'
+    );
+  });
+
+  it('Will not redirect when there is a channel in the cookie', () => {
+    const cookies = new Cookies();
+    cookies.set('channel', channels[0].name);
+    const { redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url,
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+
+    expect(redirect).toBeFalsy();
+  });
+
+  it('Will not redirect when there is a channel in the query string', () => {
+    const cookies = new Cookies();
+    cookies.set('channel', channels[0].name);
+    const { redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url + '?channelCountry="US"',
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+    expect(redirect).toBeFalsy();
+  });
+
+  it('Will not geo redirect when there is a channel in the query string', () => {
+    const cookies = new Cookies();
+    cookies.set('channel', channels[0].name);
+    const { redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url + '?channelCountry="US"',
+      geoipCountry: 'SE',
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+    expect(redirect).toBeFalsy();
+  });
+
+  it('Will not redirect when the url is already correct', () => {
+    const cookies = new Cookies();
+    const { recommendedChannel, redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url,
+      geoipCountry: 'US',
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+    expect(redirect).toBeFalsy();
+    expect(recommendedChannel).toBeFalsy();
+  });
+
+  it('Will redirect to the channel that has the country set as the default country', () => {
+    const cookies = new Cookies();
+    channels[0].countries.push({
+      name: 'Sweden',
+      code: 'SE',
+      isDefault: false
+    });
+    const { recommendedChannel, redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url,
+      geoipCountry: 'SE',
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+    expect(redirect).toBeTruthy();
+    expect(recommendedChannel.name).toBe('SE');
+  });
+
+  it('Will not redirect when the channel is from an unkown country', () => {
+    const cookies = new Cookies();
+    const { recommendedChannel, redirect } = getSelectedAndRecommendedChannel({
+      url: channels[0].url,
+      geoipCountry: 'CO',
+      singleDomainMode: false,
+      channels,
+      cookies
+    });
+    expect(redirect).toBeFalsy();
+    expect(recommendedChannel).toBeFalsy();
+  });
+  describe('Single domain mode', () => {
+    it('Will not redirect when the channel is default, and the selected channel is also default', () => {
+      const cookies = new Cookies();
+      const { recommendedChannel, redirect } = getSelectedAndRecommendedChannel(
+        {
+          url: selectedChannelSingleDomain.url,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies
+        }
+      );
+      expect(redirect).toBeFalsy();
+      expect(recommendedChannel).toBeFalsy();
+    });
+
+    it('Will redirect when the url is at the wrong channel and the channel is default', () => {
+      const cookies = new Cookies();
+      const { recommendedChannel, redirect } = getSelectedAndRecommendedChannel(
+        {
+          url: channels[0].url,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies
+        }
+      );
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.url).toBe(selectedChannelSingleDomain.url);
+    });
+
+    it('Will not redirect when the redirect is disabled', () => {
+      const cookies = new Cookies();
+      const { redirect } = getSelectedAndRecommendedChannel({
+        url: channels[0].url + '?redirectDisabled=true',
+        singleDomainMode: true,
+        channels: singleDomainChannels,
+        cookies
+      });
+      expect(redirect).toBe(false);
+    });
+
+    it('Will not when the url is at the right channel', () => {
+      const cookies = new Cookies();
+      const { redirect } = getSelectedAndRecommendedChannel({
+        url: selectedChannelSingleDomain.url,
+        singleDomainMode: true,
+        channels: singleDomainChannels,
+        cookies
+      });
+      expect(redirect).toBe(false);
+    });
+
+    it('Will redirect when the url is at the wrong channel but in same group', () => {
+      const cookies = new Cookies();
+      cookies.set('channel', singleDomainChannels[1].name);
+      const { redirect, recommendedChannel } = getSelectedAndRecommendedChannel(
+        {
+          url: selectedChannelSingleDomain.url,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies
+        }
+      );
+
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.url).toBe('https://flight-m2.jetshop.se/se');
+    });
+
+    it('Georedirect will respect single domain mode', () => {
+      const cookies = new Cookies();
+      const { redirect, recommendedChannel } = getSelectedAndRecommendedChannel(
+        {
+          url: selectedChannelSingleDomain.url,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies,
+          geoipCountry: 'SE'
+        }
+      );
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.url).toBe('https://flight-m2.jetshop.se/se');
+    });
+
+    it('Georedirect will respect single domain mode when there is a domain path', async () => {
+      const urlToPreserve = '/accessories/orchid-peach-bag';
+      const cookies = new Cookies();
+      const { redirect, recommendedChannel, selectedChannel } =
+        getSelectedAndRecommendedChannel({
+          url: selectedChannelSingleDomain.url + urlToPreserve,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies,
+          geoipCountry: 'SE'
+        });
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.url).toBe('https://flight-m2.jetshop.se/se');
+      const channelHandler = new ChannelHandler({
+        selectedChannel,
+        recommendedChannel,
+        getPrimaryRoutePath,
+        channels
+      });
+
+      const redirectUrl = channelHandler.getRedirectUrl({
+        client,
+        url: selectedChannelSingleDomain.url + urlToPreserve,
+        newChannel: channelHandler.recommendedChannel,
+        preserveRedirect: true
+      });
+
+      await expect(redirectUrl).resolves.toBe(
+        'https://flight-m2.jetshop.se/se/accessories/bags/orchid-peach-bag-uk?culture=sv-SE&channelCountry=SE&channel=SE'
+      );
+    });
+
+    it('Redirect on single domain mode when the basename shows up in the url', async () => {
+      const urlToPreserve = '/accessories/int/orchid-peach-bag';
+      const cookies = new Cookies();
+      const { redirect, recommendedChannel, selectedChannel } =
+        getSelectedAndRecommendedChannel({
+          url: channels[0].url + urlToPreserve,
+          singleDomainMode: true,
+          channels: singleDomainChannels,
+          cookies,
+          geoipCountry: 'SE'
+        });
+      expect(redirect).toBe(true);
+      const channelHandler = new ChannelHandler({
+        selectedChannel,
+        recommendedChannel,
+        getPrimaryRoutePath,
+        channels
+      });
+
+      const redirectUrl = channelHandler.getRedirectUrl({
+        client,
+        url: channels[0].url + urlToPreserve,
+        newChannel: channelHandler.recommendedChannel,
+        preserveRedirect: false
+      });
+      await expect(redirectUrl).resolves.toBe(
+        `https://flight-m2.jetshop.se/se${urlToPreserve}?culture=sv-SE&channelCountry=SE&channel=SE`
+      );
+    });
+
+    it('Redirect on single domain mode when there is a domain path but no basename', async () => {
+      const urlToPreserve = '/accessories/orchid-peach-bag';
+      const cookies = new Cookies();
+      const {
+        redirect,
+        recommendedChannel,
+        selectedChannel,
+        channels: groupedChannels
+      } = getSelectedAndRecommendedChannel({
+        url: channels[0].url + urlToPreserve,
+        singleDomainMode: true,
+        channels: singleDomainChannels,
+        cookies
+      });
+
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.url).toBe('https://flight-m2.jetshop.se/int');
+
+      const channelHandler = new ChannelHandler({
+        selectedChannel,
+        recommendedChannel,
+        getPrimaryRoutePath,
+        channels: groupedChannels
+      });
+
+      const redirectUrl = channelHandler.getRedirectUrl({
+        client,
+        url: channels[0].url + urlToPreserve,
+        newChannel: channelHandler.recommendedChannel,
+        preserveRedirect: true
+      });
+
+      await expect(redirectUrl).resolves.toBe(
+        `https://flight-m2.jetshop.se/int${urlToPreserve}?culture=en-GB&channelCountry=US&channel=INT`
+      );
+    });
+
+    it('Will set the appropriate language based on basename', async () => {
+      const cookies = new Cookies();
+      const { selectedChannel } = getSelectedAndRecommendedChannel({
+        url: channels[1].url + '/en',
+        channels,
+        cookies
+      });
+      expect(selectedChannel.language.culture).toBe('en-GB');
+    });
+
+    it('Will set the appropriate language based on basename in singledomain mode', async () => {
+      const cookies = new Cookies();
+      const { selectedChannel } = getSelectedAndRecommendedChannel({
+        url: singleDomainChannels[1].url + '/en',
+        channels: singleDomainChannels,
+        cookies,
+        singleDomainMode: true
+      });
+      expect(selectedChannel.language.culture).toBe('en-GB');
+    });
+
+    it('Will redirect to a new language basename based on cookies', async () => {
+      const cookies = new Cookies();
+      cookies.set('culture', 'en-GB');
+      const { selectedChannel, recommendedChannel, redirect } =
+        getSelectedAndRecommendedChannel({
+          url: channels[1].url,
+          channels,
+          cookies
+        });
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.language.culture).toBe('en-GB');
+      const channelHandler = new ChannelHandler({
+        selectedChannel,
+        recommendedChannel,
+        getPrimaryRoutePath,
+        channels
+      });
+      const redirectUrl = channelHandler.getRedirectUrl({
+        client,
+        url: selectedChannel.url,
+        newChannel: recommendedChannel
+      });
+      expect(redirectUrl).resolves.toBe(
+        'https://flight-m2.jetshop.se/en/?culture=en-GB&channelCountry=SE&channel=SE'
+      );
+    });
+
+    it('Will redirect to a new language basename based on cookies in single domain mode', async () => {
+      const cookies = new Cookies();
+      cookies.set('culture', 'en-GB');
+      const { selectedChannel, recommendedChannel, redirect } =
+        getSelectedAndRecommendedChannel({
+          url: singleDomainChannels[1].url,
+          channels: singleDomainChannels,
+          cookies,
+          singleDomainMode: true
+        });
+      expect(redirect).toBe(true);
+      expect(recommendedChannel.language.culture).toBe('en-GB');
+      const channelHandler = new ChannelHandler({
+        selectedChannel,
+        recommendedChannel,
+        getPrimaryRoutePath,
+        channels
+      });
+      const redirectUrl = channelHandler.getRedirectUrl({
+        client,
+        url: selectedChannel.url,
+        newChannel: recommendedChannel
+      });
+      expect(redirectUrl).resolves.toBe(
+        'https://flight-m2.jetshop.se/se/en/?culture=en-GB&channelCountry=SE&channel=SE'
+      );
+    });
+  });
+});