@jetshop/core 6.3.8-alpha.33 → 6.3.9-alpha.1

package/boot/server/IntervalQuery.test.js

@@ -0,0 +1,276 @@
+import {
+  ApolloClient,
+  ApolloError,
+  InMemoryCache,
+  HttpLink,
+  gql
+} from '@apollo/client';
+import { IntervalQuery } from './IntervalQuery';
+import nock from 'nock';
+beforeAll(() => {
+  jest.useFakeTimers();
+  nock.disableNetConnect();
+});
+afterAll(() => {
+  jest.useRealTimers();
+  nock.enableNetConnect();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.clearAllTimers();
+  nock.enableNetConnect();
+});
+const query = gql`
+  query ChannelsQuery {
+    channels {
+      id
+      name
+    }
+  }
+`;
+const apolloConfig = {
+  shopid: '...',
+  graphQLURI: 'http://localhost/graphql',
+  token: '...',
+  enableGateway: false
+};
+
+/**
+ * Mocks response for `/graphql`
+ * Only for **one** request, it resets on each call.
+ */
+function mockResponse({ channels = null, statusCode = 200, errors }) {
+  const data = {
+    errors,
+    data: {
+      channels: Array.isArray(channels)
+        ? channels.map((channel) =>
+            Object.assign({ __typename: 'Channel' }, channel)
+          )
+        : null
+    }
+  };
+  const res = jest.fn(() => data);
+  nock('http://localhost').post('/graphql').reply(statusCode, res);
+  return res;
+}
+test('does request on init', async () => {
+  const firstCall = mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test'
+      }
+    ]
+  });
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval: 60e3
+  });
+  await intervalQuery.getPendingResponse();
+  expect(firstCall).toHaveBeenCalled();
+  const res = await intervalQuery.results();
+  expect(res.channels).toHaveLength(1);
+  expect(res.channels[0].id).toBe(1);
+});
+test('does request on intervals', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  {
+    const res = await intervalQuery.results();
+    expect(res.channels[0].name).toBe('test1');
+    nock.cleanAll();
+  }
+  {
+    const mock = mockResponse({
+      channels: [
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await intervalQuery.getPendingResponse();
+    const res = await intervalQuery.results();
+    expect(mock).toHaveBeenCalled();
+    expect(res.channels[0].name).toBe('test2');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 3,
+          name: 'test3'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await intervalQuery.getPendingResponse();
+    const res = await intervalQuery.results();
+    expect(res.channels[0].name).toBe('test3');
+  }
+});
+test('propagates bad statusCodes', async () => {
+  mockResponse({ statusCode: 500 });
+  const onError = jest.fn();
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval,
+    onError
+  });
+  expect.assertions(3);
+  try {
+    await intervalQuery.getPendingResponse();
+  } catch (err) {
+    expect(err.networkError.statusCode).toBe(500);
+    expect(onError).toHaveBeenCalledTimes(1);
+  }
+  // successful response after
+  mockResponse({ channels: [] });
+  const res = await intervalQuery.results();
+  expect(res.channels).toEqual([]);
+});
+test('propagates when response contains GraphQL-errors', async () => {
+  const errorMessage = 'Something went wrong';
+  mockResponse({
+    errors: [
+      {
+        message: errorMessage,
+        locations: null
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  expect.assertions(2);
+  try {
+    await intervalQuery.getPendingResponse();
+  } catch (_err) {
+    const err = _err;
+    expect(err).toBeInstanceOf(ApolloError);
+    expect(err.message).toBe(`GraphQL error: ${errorMessage}`);
+  }
+});
+test('extracting and using cache in new client', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  await intervalQuery.getPendingResponse();
+  {
+    const cache = intervalQuery.extractCache();
+    expect(cache).toHaveProperty('Channel:1');
+    expect(cache['Channel:1'].name).toBe('test1');
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query
+    });
+    expect(res.channels).toHaveLength(1);
+    expect(res.channels[0].name).toBe('test1');
+  }
+  // update data in new request
+  {
+    const mock = mockResponse({
+      channels: [
+        {
+          id: 1,
+          name: 'test1--updated'
+        },
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await intervalQuery.getPendingResponse();
+    expect(mock).toHaveBeenCalled();
+    const cache = intervalQuery.extractCache();
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query
+    });
+    expect(res.channels).toHaveLength(2);
+    expect(res.channels[0].name).toBe('test1--updated');
+    expect(res.channels[1].name).toBe('test2');
+  }
+});
+
+test(`internal state doesn't get overridden by erroneous requests`, async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  await intervalQuery.getPendingResponse();
+
+  mockResponse({
+    errors: [
+      {
+        message: 'Something went wrong',
+        locations: null
+      }
+    ]
+  });
+  jest.advanceTimersByTime(pollInterval);
+  let err;
+  try {
+    await intervalQuery.getPendingResponse();
+  } catch (_err) {
+    err = _err;
+  }
+  expect(err).toBeInstanceOf(Error);
+
+  const cache = intervalQuery.extractCache();
+  expect(cache['Channel:1']).toBeTruthy();
+  expect(cache['Channel:1'].name).toBe('test1');
+
+  const res = await intervalQuery.results();
+
+  expect(res.channels[0].name).toBe('test1');
+});

package/boot/server/PersistedApolloClient.test.js

@@ -0,0 +1,234 @@
+// TODO
+// File reverted from TypeScript, should be reverted when pipeline supports it
+// https://gitlab.jetshop.se/jetshop/flight/merge_requests/409/diffs?commit_id=d30490f833ec2d2eec94e5a75ed99de71e666377
+// https://gitlab.jetshop.se/jetshop/flight/blob/94b6108017f6205e7d31f6bedb19c14f278d227a/packages/core/boot/server/PersistedApolloClient.test.ts
+
+import {
+  ApolloClient,
+  ApolloError,
+  InMemoryCache,
+  HttpLink
+} from '@apollo/client';
+import { PersistedApolloClient } from './PersistedApolloClient';
+import nock from 'nock';
+import channelsQuery from '../ChannelsQuery.gql';
+
+global.__IN_SERVER__ = true;
+jest.useFakeTimers();
+beforeEach(() => {
+  nock.disableNetConnect();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.clearAllTimers();
+  nock.enableNetConnect();
+  nock.cleanAll();
+});
+const apolloConfig = {
+  shopid: '...',
+  graphQLURI: 'http://localhost/graphql',
+  token: '...',
+  enableGateway: false,
+  channelsQuery
+};
+function getPendingResponse(persitedClient) {
+  const channelsIntervalQuery = persitedClient.channelsIntervalQuery;
+  return channelsIntervalQuery.getPendingResponse();
+}
+/**
+ * Mocks response for `/graphql`
+ * Only for **one** request, it resets on each call.
+ */
+function mockResponse({ channels = null, statusCode = 200, errors }) {
+  const data = {
+    errors,
+    data: {
+      channels: Array.isArray(channels)
+        ? channels.map((channel) =>
+            Object.assign(
+              {
+                __typename: 'Channel',
+                requiresAuth: false,
+                countries: null,
+                currencies: null,
+                defaultCurrency: null,
+                defaultLanguage: null,
+                displayName: null,
+                groupName: null,
+                isDefault: null,
+                languages: null,
+                settings: null,
+                name: null,
+                url: null,
+                imageUrl: null
+              },
+              channel
+            )
+          )
+        : null
+    }
+  };
+  const res = jest.fn(() => data);
+  nock('http://localhost').post('/graphql').reply(statusCode, res);
+  return res;
+}
+test('does request on init', async () => {
+  const firstCall = mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test'
+      }
+    ]
+  });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  await getPendingResponse(persistedClient);
+  expect(firstCall).toHaveBeenCalled();
+  const channels = await persistedClient.getChannels();
+  expect(channels).toHaveLength(1);
+  expect(channels[0].id).toBe(1);
+});
+test('does request on intervals', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const channelsPollInterval = 60e3;
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig },
+    channelsPollInterval
+  });
+  {
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test1');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(channelsPollInterval + 1);
+    await getPendingResponse(persistedClient);
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test2');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 3,
+          name: 'test3'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(channelsPollInterval);
+    await getPendingResponse(persistedClient);
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test3');
+  }
+});
+test('propagates bad statusCodes', async () => {
+  mockResponse({ statusCode: 500 });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  expect.assertions(1);
+  try {
+    await getPendingResponse(persistedClient);
+  } catch (err) {
+    expect(err.networkError.statusCode).toBe(500);
+  }
+});
+test('propagates when response contains GraphQL-errors', async () => {
+  const errorMessage = 'Something went wrong';
+  mockResponse({
+    errors: [
+      {
+        message: errorMessage,
+        locations: null
+      }
+    ]
+  });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  expect.assertions(2);
+  try {
+    await getPendingResponse(persistedClient);
+  } catch (_err) {
+    const err = _err;
+    expect(err).toBeInstanceOf(ApolloError);
+    expect(err.message).toBe(`GraphQL error: ${errorMessage}`);
+  }
+});
+test('extracting and using cache in new client', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const channelsPollInterval = 60e3;
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig },
+    channelsPollInterval
+  });
+  await getPendingResponse(persistedClient);
+  {
+    const cache = persistedClient.extractCache();
+    expect(cache).toHaveProperty('Channel:1');
+    expect(cache['Channel:1'].name).toBe('test1');
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query: channelsQuery
+    });
+    expect(res.channels).toHaveLength(1);
+    expect(res.channels[0].name).toBe('test1');
+  }
+  // update data in new request
+  {
+    const mock = mockResponse({
+      channels: [
+        {
+          id: 1,
+          name: 'test1--updated'
+        },
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await getPendingResponse(persistedClient);
+    expect(mock).toHaveBeenCalled();
+    const cache = persistedClient.extractCache();
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query: channelsQuery
+    });
+    expect(res.channels).toHaveLength(2);
+    expect(res.channels[0].name).toBe('test1--updated');
+    expect(res.channels[1].name).toBe('test2');
+  }
+});
+//# sourceMappingURL=PersistedApolloClient.test.js.map

package/boot/server/createApolloServer.test.js

@@ -0,0 +1,114 @@
+import express from 'express';
+import { ApolloServer, gql } from 'apollo-server-express';
+import listen from './listen';
+import createApolloServer from './createApolloServer';
+import fetch from 'node-fetch';
+import { GraphQLError } from 'graphql';
+
+function createGraphqlClient(port) {
+  const url = `http://localhost:${port}/graphql`;
+
+  return async function request({ query, variables }) {
+    const body = { query, variables };
+
+    const resBody = await fetch(url, {
+      method: 'post',
+      body: JSON.stringify(body),
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.json());
+
+    return resBody;
+  };
+}
+
+async function createTargetServer() {
+  const typeDefs = gql`
+    type Query {
+      hello(name: String!): String!
+    }
+  `;
+
+  const resolvers = {
+    Query: {
+      hello: async (_source, { name }) => {
+        if (name === '') {
+          throw new GraphQLError(`Name can't be empty`);
+        }
+
+        return `Hello ${name}`;
+      }
+    }
+  };
+
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    resolvers
+  });
+
+  const app = express();
+
+  apolloServer.applyMiddleware({ app });
+
+  const { port, close } = await listen({ app, port: 0 });
+  const query = createGraphqlClient(port);
+
+  return { port, close, query };
+}
+async function createLocalServer({ targetPort }) {
+  const { apolloServer } = await createApolloServer({
+    apolloConfig: {
+      graphQLURI: `http://localhost:${targetPort}/graphql`
+    }
+  });
+
+  const app = express();
+  apolloServer.applyMiddleware({ app });
+
+  const { port, close } = await listen({ app, port: 0 });
+  const query = createGraphqlClient(port);
+
+  return { port, close, query };
+}
+
+let targetServer;
+let localServer;
+
+afterEach(async () => {
+  if (localServer) {
+    await localServer.close();
+  }
+  if (targetServer) {
+    await targetServer.close();
+  }
+  localServer = null;
+  targetServer = null;
+});
+
+test('forwarding queries', async () => {
+  targetServer = await createTargetServer();
+  localServer = await createLocalServer({ targetPort: targetServer.port });
+
+  const { data } = await localServer.query({
+    query: '{ hello(name: "World") }'
+  });
+
+  expect(data.hello).toBe('Hello World');
+});
+
+test('propagating errors', async () => {
+  targetServer = await createTargetServer();
+  localServer = await createLocalServer({ targetPort: targetServer.port });
+
+  const query = '{ hello(name: "") }'; // should trigger "Name can't be empty"
+
+  const { errors: expectedErrors } = await targetServer.query({ query });
+  const { errors: actualErrors } = await localServer.query({ query });
+
+  expect(expectedErrors).toHaveLength(1);
+  expect(actualErrors).toHaveLength(1);
+
+  expect(expectedErrors[0].message).toBe(`Name can't be empty`);
+
+  expect(actualErrors[0].message).toBe(expectedErrors[0].message);
+  expect(actualErrors[0].path).toEqual(expectedErrors[0].path);
+});