@zendesk/laika/esm/integration.test.js

Test, mock, intercept and modify Apollo Client's operations — in both browser and unit tests!

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { ApolloClient, ApolloLink, gql, InMemoryCache, Observable, } from '@apollo/client';
import { Laika } from './laika';
const realData = {
    data: { sample: 'not mocked' },
};
const mockedData = {
    data: { sample: 'mocked' },
};
const alternateMockedData = { data: { sample: 'also mocked' } };
const query = gql `
  query sampleQuery {
    sample
  }
`;
const subscriptionQuery = gql `
  subscription sampleSubscription {
    number
  }
`;
const sampleLink = new ApolloLink(() => new Observable((observer) => {
    observer.next(realData);
    observer.complete();
}));
const setup = () => {
    const laika = new Laika();
    const link = laika.createLink();
    const client = new ApolloClient({
        cache: new InMemoryCache(),
        link: ApolloLink.from([link, sampleLink]),
        defaultOptions: { query: { fetchPolicy: 'no-cache' } },
    });
    return [laika, client];
};
describe('Apollo Client integration', () => {
    it('returns the original value when not mocked', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const intercept = laika.intercept();
        expect.assertions(3);
        yield expect(client.query({ query })).resolves.toMatchObject(realData);
        yield expect(client.query({ query })).resolves.toMatchObject(realData);
        expect(intercept.calls).toHaveLength(2);
    }));
    it('returns a mocked value with mockResult', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const intercept = laika.intercept();
        intercept.mockResult({ result: mockedData });
        expect.assertions(3);
        yield expect(client.query({ query })).resolves.toMatchObject(mockedData);
        yield expect(client.query({ query })).resolves.toMatchObject(mockedData);
        expect(intercept.calls).toHaveLength(2);
    }));
    it('returns queued mockResultOnce values before falling back', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const intercept = laika.intercept();
        intercept
            .mockResultOnce({ result: mockedData })
            .mockResultOnce({ result: alternateMockedData });
        expect.assertions(4);
        yield expect(client.query({ query })).resolves.toMatchObject(mockedData);
        yield expect(client.query({ query })).resolves.toMatchObject(alternateMockedData);
        yield expect(client.query({ query })).resolves.toMatchObject(realData);
        expect(intercept.calls).toHaveLength(3);
    }));
    it('supports mockResultOnce followed by a persistent mockResult', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const intercept = laika.intercept();
        intercept
            .mockResultOnce({ result: mockedData })
            .mockResult({ result: alternateMockedData });
        expect.assertions(4);
        yield expect(client.query({ query })).resolves.toMatchObject(mockedData);
        yield expect(client.query({ query })).resolves.toMatchObject(alternateMockedData);
        yield expect(client.query({ query })).resolves.toMatchObject(alternateMockedData);
        expect(intercept.calls).toHaveLength(3);
    }));
    it('rejects queries with mocked errors', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const intercept = laika.intercept();
        intercept.mockResult({ error: new Error('An error occurred') });
        yield expect(client.query({ query })).rejects.toThrow('An error occurred');
    }));
    it('modifies remote results', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        const enhancedQuery = gql `
      query sampleQuery {
        sample
        modifiedValue
      }
    `;
        expect.assertions(3);
        laika.modifyRemote({ operationName: 'sampleQuery' }, (result, operation) => {
            expect(result).toMatchObject(realData);
            expect(operation.operationName).toBe('sampleQuery');
            return Object.assign(Object.assign({}, result), { data: Object.assign(Object.assign({}, result.data), { modifiedValue: 'present' }) });
        });
        yield expect(client.query({ query: enhancedQuery })).resolves.toMatchObject({
            data: { modifiedValue: 'present', sample: 'not mocked' },
        });
    }));
    it('mockRestoreAll removes modifyRemote interceptors', () => __awaiter(void 0, void 0, void 0, function* () {
        const [laika, client] = setup();
        laika.modifyRemote({ operationName: 'sampleQuery' }, (result) => (Object.assign(Object.assign({}, result), { data: Object.assign(Object.assign({}, result.data), { sample: 'modified' }) })));
        yield expect(client.query({ query })).resolves.toMatchObject({
            data: { sample: 'modified' },
        });
        laika.mockRestoreAll();
        yield expect(client.query({ query })).resolves.toMatchObject(realData);
    }));
    it('pushes subscription updates and errors', () => __awaiter(void 0, void 0, void 0, function* () {
        var _a, _b, _c;
        const [laika, client] = setup();
        const intercept = laika.intercept();
        const next = jest.fn();
        const error = jest.fn();
        const subscription = client
            .subscribe({ query: subscriptionQuery })
            .subscribe({
            next,
            error,
        });
        yield intercept.waitForActiveSubscription();
        intercept.fireSubscriptionUpdate({
            result: {
                data: { number: 1 },
            },
        });
        intercept.fireSubscriptionUpdate({
            result: {
                data: { number: 2 },
            },
        });
        intercept.fireSubscriptionUpdate({
            error: new Error('An error occurred'),
        });
        expect(next).toHaveBeenNthCalledWith(1, { data: { number: 1 } });
        expect(next).toHaveBeenNthCalledWith(2, { data: { number: 2 } });
        expect([
            (_a = error.mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0],
            (_c = (_b = next.mock.calls[2]) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.error,
        ]).toContainEqual(new Error('An error occurred'));
        expect([2, 3]).toContain(next.mock.calls.length);
        subscription.unsubscribe();
    }));
});
//# sourceMappingURL=integration.test.js.map