introduce 'missingHandlerPolicy' argument

Author: mykolavlasov

src/mockClient.integration.test.ts

@@ -5,7 +5,6 @@ import { ApolloQueryResult, gql, InMemoryCache } from '@apollo/client/core';
 
 import { createMockClient, MockApolloClient } from './mockClient';
 import { createMockSubscription, IMockSubscription } from './mockSubscription';
-import { print } from "graphql";
 
 describe('MockClient integration tests', () => {
   let mockClient: MockApolloClient;
@@ -56,10 +55,9 @@ describe('MockClient integration tests', () => {
     });
 
     describe('Given request handler is not defined', () => {
-      it('returns a promise which rejects due to handler not being defined', async () => {
-        let promise =  mockClient.query({ query: queryTwo });
-
-        await expect(promise).rejects.toThrowError('Request handler not defined for query');
+      it('throws when executing the query', () => {
+        expect(() => mockClient.query({ query: queryTwo }))
+          .toThrowError('Request handler not defined for query');
       });
     });
   });
@@ -543,27 +541,9 @@ describe('MockClient integration tests', () => {
     });
 
     describe('Given request handler is not defined', () => {
-      it('returns an observable which returns error if handler not defined for query', async () => {
-        let onNext = jest.fn();
-        let onError = jest.fn();
-        let onComplete = jest.fn();
-
-        const observable = mockClient.subscribe({ query: queryTwo });
-
-        observable.subscribe(
-            onNext,
-            onError,
-            onComplete
-        );
-
-        await new Promise(r => setTimeout(r, 0));
-
-        mockSubscription.next({ data: { one: 'A' } });
-
-        expect(onNext).not.toHaveBeenCalled();
-        expect(onError).toHaveBeenCalledWith(new Error(`Request handler not defined for query: ${print(queryTwo)}`));
-        expect(onError).toHaveBeenCalledTimes(1);
-        expect(onComplete).not.toHaveBeenCalled();
+      it('throws when attempting to subscribe to query', () => {
+        expect(() => mockClient.subscribe({ query: queryTwo }))
+          .toThrowError('Request handler not defined for query');
       });
     });
   });

src/mockClient.ts

@@ -1,6 +1,6 @@
 import { ApolloClientOptions, ApolloClient, DocumentNode } from '@apollo/client/core';
 import { InMemoryCache as Cache, NormalizedCacheObject } from '@apollo/client/cache';
-import { MockLink } from './mockLink';
+import { MissingHandlerPolicy, MockLink } from './mockLink';
 import { IMockSubscription } from './mockSubscription';
 
 export type RequestHandler<TData = any, TVariables = any> =
@@ -15,7 +15,11 @@ export type RequestHandlerResponse<T> =
 export type MockApolloClient = ApolloClient<NormalizedCacheObject> &
   { setRequestHandler: (query: DocumentNode, handler: RequestHandler) => void };
 
-export type MockApolloClientOptions = Partial<Omit<ApolloClientOptions<NormalizedCacheObject>, 'link'>> | undefined;
+interface LocalOptions {
+  missingHandlerPolicy?: MissingHandlerPolicy;
+}
+
+export type MockApolloClientOptions = Partial<Omit<ApolloClientOptions<NormalizedCacheObject>, 'link'>> & LocalOptions | undefined;
 
 export const createMockClient = (options?: MockApolloClientOptions): MockApolloClient => {
   if ((options as any)?.link) {

src/mockLink.test.ts

@@ -10,6 +10,14 @@ describe('class MockLink', () => {
   const queryOne = gql`query One {one}`;
   const queryTwo = gql`query Two {two}`;
 
+  const queryOneOperation = { query: queryOne, variables: { a: 'one' } } as Partial<Operation> as Operation;
+
+  const createMockObserver = (): jest.Mocked<Observer<any>> => ({
+    next: jest.fn(),
+    error: jest.fn(),
+    complete: jest.fn(),
+  });
+
   beforeEach(() => {
     jest.spyOn(console, 'warn')
       .mockReset();
@@ -81,28 +89,6 @@ describe('class MockLink', () => {
   });
 
   describe('method request', () => {
-    const queryOneOperation = { query: queryOne, variables: { a: 'one' } } as Partial<Operation> as Operation;
-
-    const createMockObserver = (): jest.Mocked<Observer<any>> => ({
-      next: jest.fn(),
-      error: jest.fn(),
-      complete: jest.fn(),
-    });
-
-    it('returns an error when a handler is not defined for the query', async () => {
-      const observable = mockLink.request(queryOneOperation);
-      const observer = createMockObserver();
-
-      observable.subscribe(observer);
-
-      await new Promise(r => setTimeout(r, 0));
-
-      expect(observer.next).not.toBeCalled();
-      expect(observer.error).toBeCalledTimes(1);
-      expect(observer.error).toBeCalledWith(new Error(`Request handler not defined for query: ${print(queryOne)}`));
-      expect(observer.complete).not.toBeCalled();
-    });
-
     it('correctly executes the handler when the handler is defined as a promise and it and successfully resolves', async () => {
       const handler = jest.fn().mockResolvedValue({ data: 'Query one result' });
       mockLink.setRequestHandler(queryOne, handler);
@@ -251,4 +237,44 @@ describe('class MockLink', () => {
       expect(observer.complete).toBeCalledTimes(1);
     });
   });
+
+  describe('constructor option "missingHandlerPolicy"', () => {
+    it('when "error" throws when a handler is not defined for the query', () => {
+      expect(() => mockLink.request(queryOneOperation))
+        .toThrowError(`Request handler not defined for query: ${print(queryOne)}`)
+    });
+
+    it('when "warn" logs a warning when a handler is not defined for the query', async () => {
+      mockLink = new MockLink({missingHandlerPolicy: 'warn-and-return-error'})
+
+      const observable = mockLink.request(queryOneOperation);
+      const observer = createMockObserver();
+
+      observable.subscribe(observer);
+
+      await new Promise(r => setTimeout(r, 0));
+
+      expect(observer.next).not.toBeCalled();
+      expect(observer.error).toBeCalled();
+      expect(observer.complete).not.toBeCalled();
+      expect(console.warn).toBeCalledTimes(1);
+      expect(console.warn).toBeCalledWith(`Request handler not defined for query: ${print(queryOne)}`);
+    });
+
+    it('when "ignore" returns an error when a handler is not defined for the query', async () => {
+      mockLink = new MockLink({missingHandlerPolicy: 'return-error'})
+
+      const observable = mockLink.request(queryOneOperation);
+      const observer = createMockObserver();
+
+      observable.subscribe(observer);
+
+      await new Promise(r => setTimeout(r, 0));
+
+      expect(observer.next).not.toBeCalled();
+      expect(observer.error).toBeCalledTimes(1);
+      expect(observer.error).toBeCalledWith(new Error(`Request handler not defined for query: ${print(queryOne)}`));
+      expect(observer.complete).not.toBeCalled();
+    });
+  })
 });

src/mockLink.ts

@@ -4,7 +4,22 @@ import { RequestHandler, RequestHandlerResponse } from './mockClient';
 import { removeClientSetsFromDocument, removeConnectionDirectiveFromDocument } from '@apollo/client/utilities';
 import { IMockSubscription, MockSubscription } from './mockSubscription';
 
+export type MissingHandlerPolicy = 'throw-error' | 'warn-and-return-error' | 'return-error';
+
+interface MockLinkOptions {
+  missingHandlerPolicy?: MissingHandlerPolicy;
+}
+
+const DEFAULT_MISSING_HANDLER_POLICY: MissingHandlerPolicy = 'throw-error';
+
 export class MockLink extends ApolloLink {
+  constructor(options?: MockLinkOptions) {
+    super();
+
+    this.missingHandlerPolicy = options?.missingHandlerPolicy || DEFAULT_MISSING_HANDLER_POLICY;
+  }
+
+  private readonly missingHandlerPolicy: MissingHandlerPolicy;
   private requestHandlers: Record<string, RequestHandler | undefined> = {};
 
   setRequestHandler(requestQuery: DocumentNode, handler: RequestHandler): void {
@@ -25,15 +40,23 @@ export class MockLink extends ApolloLink {
   }
 
   request = (operation: Operation) => {
-    return new Observable<FetchResult>(observer => {
-      const key = requestToKey(operation.query);
+    const key = requestToKey(operation.query);
+
+    const handler = this.requestHandlers[key];
 
-      const handler = this.requestHandlers[key];
+    if (!handler && this.missingHandlerPolicy === 'throw-error') {
+      throw new Error(getNotDefinedHandlerMessage(operation));
+    }
 
+    return new Observable<FetchResult>(observer => {
       if (!handler) {
-        throw new Error(`Request handler not defined for query: ${print(operation.query)}`);
+        if (this.missingHandlerPolicy === 'warn-and-return-error') {
+          console.warn(getNotDefinedHandlerMessage(operation));
+        }
+        throw new Error(getNotDefinedHandlerMessage(operation));
       }
 
+
       let result:
         | Promise<RequestHandlerResponse<any>>
         | IMockSubscription<any>
@@ -101,3 +124,7 @@ const isPromise = (maybePromise: any): maybePromise is Promise<any> =>
 
 const isSubscription = (maybeSubscription: any): maybeSubscription is MockSubscription<any> =>
   maybeSubscription && maybeSubscription instanceof MockSubscription;
+
+const getNotDefinedHandlerMessage = (operation: Operation) => {
+  return `Request handler not defined for query: ${print(operation.query)}`
+}