@zendesk/laika
Version:
Test, mock, intercept and modify Apollo Client's operations — in both browser and unit tests!
156 lines • 7.28 kB
JavaScript
"use strict";
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const client_1 = require("@apollo/client");
const laika_1 = require("./laika");
const realData = {
data: { sample: 'not mocked' },
};
const mockedData = {
data: { sample: 'mocked' },
};
const alternateMockedData = { data: { sample: 'also mocked' } };
const query = (0, client_1.gql) `
query sampleQuery {
sample
}
`;
const subscriptionQuery = (0, client_1.gql) `
subscription sampleSubscription {
number
}
`;
const sampleLink = new client_1.ApolloLink(() => new client_1.Observable((observer) => {
observer.next(realData);
observer.complete();
}));
const setup = () => {
const laika = new laika_1.Laika();
const link = laika.createLink();
const client = new client_1.ApolloClient({
cache: new client_1.InMemoryCache(),
link: client_1.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 = (0, client_1.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