mock-config-server 3.2.0 → 3.3.1

package/dist/src/utils/helpers/entities/convertToEntityDescriptor/convertToEntityDescriptor.test.ts

@@ -0,0 +1,27 @@
+import { convertToEntityDescriptor } from './convertToEntityDescriptor';
+
+describe('convertToEntityDescriptor', () => {
+  test('Should correctly convert value to descriptor', () => {
+    expect(convertToEntityDescriptor(null)).toEqual({ checkMode: 'equals', value: null });
+    expect(convertToEntityDescriptor(undefined)).toEqual({ checkMode: 'equals', value: undefined });
+    expect(convertToEntityDescriptor(true)).toEqual({ checkMode: 'equals', value: true });
+    expect(convertToEntityDescriptor(1)).toEqual({ checkMode: 'equals', value: 1 });
+    expect(convertToEntityDescriptor('string')).toEqual({ checkMode: 'equals', value: 'string' });
+    expect(convertToEntityDescriptor([])).toEqual({
+      checkMode: 'equals',
+      value: []
+    });
+    expect(convertToEntityDescriptor({ key: 'value' })).toEqual({
+      checkMode: 'equals',
+      value: { key: 'value' }
+    });
+  });
+
+  test('Should return same value if descriptor provided', () => {
+    expect(convertToEntityDescriptor({ checkMode: 'exists' })).toEqual({ checkMode: 'exists' });
+    expect(convertToEntityDescriptor({ checkMode: 'equals', value: 'string' })).toEqual({
+      checkMode: 'equals',
+      value: 'string'
+    });
+  });
+});

package/dist/src/utils/helpers/entities/isEntityDescriptor/isEntityDescriptor.d.ts

@@ -1 +1,2 @@
-export declare const isEntityDescriptor: (value: any) => boolean;
+import type { EntityDescriptor } from '../../../types';
+export declare const isEntityDescriptor: (value: any) => value is EntityDescriptor;

package/dist/src/utils/helpers/entities/isEntityDescriptor/isEntityDescriptor.test.ts

@@ -0,0 +1,15 @@
+import { isEntityDescriptor } from './isEntityDescriptor';
+
+describe('isEntityDescriptor', () => {
+  test('Should correctly define descriptor', () => {
+    expect(isEntityDescriptor(null)).toEqual(false);
+    expect(isEntityDescriptor(undefined)).toEqual(false);
+    expect(isEntityDescriptor(true)).toEqual(false);
+    expect(isEntityDescriptor(1)).toEqual(false);
+    expect(isEntityDescriptor('string')).toEqual(false);
+    expect(isEntityDescriptor([])).toEqual(false);
+    expect(isEntityDescriptor({ key: 'value' })).toEqual(false);
+    expect(isEntityDescriptor({ checkMode: 'exists' })).toEqual(true);
+    expect(isEntityDescriptor({ checkMode: 'equals', value: 'string' })).toEqual(true);
+  });
+});

package/dist/src/utils/helpers/graphql/getGraphQLInput/getGraphQLInput.d.ts

@@ -1,3 +1,8 @@
 import type { Request } from 'express';
-import type { GraphQLInput } from '../../../types';
-export declare const getGraphQLInput: (request: Request) => GraphQLInput;
+import type { PlainObject } from '../../../types';
+interface GetGraphQLInputResult {
+    query: string | undefined;
+    variables: PlainObject | undefined;
+}
+export declare const getGraphQLInput: (request: Request) => GetGraphQLInputResult;
+export {};

package/dist/src/utils/helpers/graphql/getGraphQLInput/getGraphQLInput.js

@@ -6,14 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.getGraphQLInput = void 0;
 const getGraphQLInput = request => {
   if (request.method === 'GET') {
-    var _ref;
     const {
       query,
       variables
     } = request.query;
+
+    // ✅ important:
+    // if 'variables' was sent as encoded uri component then it already decoded into object and we do not need to use JSON.parse
     return {
       query: query === null || query === void 0 ? void 0 : query.toString(),
-      variables: JSON.parse((_ref = variables) !== null && _ref !== void 0 ? _ref : '{}')
+      variables: typeof variables === 'string' ? JSON.parse(variables) : variables
     };
   }
   if (request.method === 'POST') {
@@ -23,9 +25,9 @@ const getGraphQLInput = request => {
     } = request.body;
     return {
       query,
-      variables: variables !== null && variables !== void 0 ? variables : {}
+      variables
     };
   }
-  throw new Error('Not allowed request method for graphql request');
+  throw new Error(`Not allowed request method ${request.method} for graphql request`);
 };
 exports.getGraphQLInput = getGraphQLInput;

package/dist/src/utils/helpers/graphql/getGraphQLInput/getGraphQLInput.test.ts

@@ -0,0 +1,140 @@
+import type { Request } from 'express';
+
+import { getGraphQLInput } from './getGraphQLInput';
+
+describe('getGraphQLInput', () => {
+  test('Should get correct graphQL input from GET request (with object variables)', () => {
+    const mockRequest = {
+      method: 'GET',
+      query: {
+        query: 'query GetCharacters { characters { name } }',
+        variables: { limit: 10 }
+      }
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: 'query GetCharacters { characters { name } }',
+      variables: { limit: 10 }
+    });
+  });
+
+  test('Should get correct graphQL input from GET request (with string variables)', () => {
+    const mockRequest = {
+      method: 'GET',
+      query: {
+        query: 'query GetCharacters { characters { name } }',
+        variables: '{ "limit": 10 }'
+      }
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: 'query GetCharacters { characters { name } }',
+      variables: { limit: 10 }
+    });
+  });
+
+  test('Should get correct graphQL input from GET request with empty variables', () => {
+    const mockRequest = {
+      method: 'GET',
+      query: {
+        query: 'query GetCharacters { characters { name } }'
+      }
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: 'query GetCharacters { characters { name } }',
+      variables: undefined
+    });
+  });
+
+  test('Should get correct graphQL input from GET request with empty query and variables', () => {
+    const mockRequest = {
+      method: 'GET',
+      query: {}
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: undefined,
+      variables: undefined
+    });
+  });
+
+  test('Should get correct graphQL input from POST request', () => {
+    const mockRequest = {
+      method: 'POST',
+      body: {
+        query: 'query GetCharacters { characters { name } }',
+        variables: { limit: 10 }
+      }
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: 'query GetCharacters { characters { name } }',
+      variables: { limit: 10 }
+    });
+  });
+
+  test('Should get correct graphQL input from POST with empty variables', () => {
+    const mockRequest = {
+      method: 'POST',
+      body: {
+        query: 'query GetCharacters { characters { name } }'
+      }
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: 'query GetCharacters { characters { name } }',
+      variables: undefined
+    });
+  });
+
+  test('Should get correct graphQL input from POST with empty query and variables', () => {
+    const mockRequest = {
+      method: 'POST',
+      body: {}
+    } as unknown as Request;
+
+    const graphQLInput = getGraphQLInput(mockRequest);
+
+    expect(graphQLInput).toStrictEqual({
+      query: undefined,
+      variables: undefined
+    });
+  });
+
+  test('Should throw error if request method is not GET or POST', () => {
+    const deleteMockRequest = {
+      method: 'DELETE',
+      query: {
+        query: 'query GetCharacters { characters { name } }'
+      }
+    } as unknown as Request;
+
+    expect(() => getGraphQLInput(deleteMockRequest)).toThrow(
+      'Not allowed request method DELETE for graphql request'
+    );
+
+    const putMockRequest = {
+      method: 'PUT',
+      body: {
+        query: 'query GetCharacters { characters { name } }'
+      }
+    } as unknown as Request;
+
+    expect(() => getGraphQLInput(putMockRequest)).toThrow(
+      'Not allowed request method PUT for graphql request'
+    );
+  });
+});

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.d.ts

@@ -1,7 +1,7 @@
 import type { OperationTypeNode } from 'graphql';
 interface ParseDocumentNodeResult {
     operationType: OperationTypeNode;
-    operationName: string;
+    operationName: string | undefined;
 }
 export declare const parseQuery: (query: string) => ParseDocumentNodeResult | null;
 export {};

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.js

@@ -10,7 +10,7 @@ const parseDocumentNode = node => {
   const operationDefinition = node.definitions.find(definition => definition.kind === 'OperationDefinition');
   return {
     operationType: operationDefinition.operation,
-    operationName: (_operationDefinition$ = (_operationDefinition$2 = operationDefinition.name) === null || _operationDefinition$2 === void 0 ? void 0 : _operationDefinition$2.value) !== null && _operationDefinition$ !== void 0 ? _operationDefinition$ : ''
+    operationName: (_operationDefinition$ = (_operationDefinition$2 = operationDefinition.name) === null || _operationDefinition$2 === void 0 ? void 0 : _operationDefinition$2.value) !== null && _operationDefinition$ !== void 0 ? _operationDefinition$ : undefined
   };
 };
 const parseQuery = query => {

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.test.ts

@@ -0,0 +1,32 @@
+import { parseQuery } from './parseQuery';
+
+describe('parseQuery', () => {
+  test('Should parse graphQL query', () => {
+    const parsedQuery = parseQuery('query GetCharacters { characters { name } }');
+
+    expect(parsedQuery).toStrictEqual({
+      operationType: 'query',
+      operationName: 'GetCharacters'
+    });
+  });
+
+  test('Should parse graphQL mutation', () => {
+    const parsedQuery = parseQuery(
+      'mutation CreateCharacters($name: String!) { createCharacters(name: $name) { name } }'
+    );
+
+    expect(parsedQuery).toStrictEqual({
+      operationType: 'mutation',
+      operationName: 'CreateCharacters'
+    });
+  });
+
+  test('Should parse graphQL query with empty operationName', () => {
+    const parsedQuery = parseQuery('query { characters { name } }');
+
+    expect(parsedQuery).toStrictEqual({
+      operationType: 'query',
+      operationName: undefined
+    });
+  });
+});

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptors.test.ts

@@ -0,0 +1,53 @@
+import type { Request } from 'express';
+
+import type { RequestInterceptor } from '@/utils/types';
+
+import { callRequestInterceptor } from './callRequestInterceptor';
+
+describe('callRequestInterceptors: order of calls', () => {
+  test('Should call passed request interceptor', () => {
+    const request = {} as Request;
+    const interceptor = jest.fn();
+
+    callRequestInterceptor({ request, interceptor });
+    expect(interceptor.mock.calls.length).toBe(1);
+  });
+});
+
+describe('callRequestInterceptors: params functions', () => {
+  test('Should correctly get header from request.headers object when use getHeader param', () => {
+    const request = { headers: { name: 'value' } };
+    const getHeaderRequestInterceptor: RequestInterceptor = ({ getHeader }) => {
+      expect(getHeader('name')).toBe('value');
+    };
+
+    callRequestInterceptor({
+      request: request as unknown as Request,
+      interceptor: getHeaderRequestInterceptor
+    });
+  });
+
+  test('Should correctly get headers as request.headers object when use getHeaders param', () => {
+    const request = { headers: { name: 'value' } };
+    const getHeadersRequestInterceptor: RequestInterceptor = ({ getHeaders }) => {
+      expect(getHeaders()).toStrictEqual({ name: 'value' });
+    };
+
+    callRequestInterceptor({
+      request: request as unknown as Request,
+      interceptor: getHeadersRequestInterceptor
+    });
+  });
+
+  test('Should correctly get cookie from request.cookies object when use getCookie param', () => {
+    const request = { cookies: { name: 'value' } };
+    const getCookieRequestInterceptor: RequestInterceptor = ({ getCookie }) => {
+      expect(getCookie('name')).toBe('value');
+    };
+
+    callRequestInterceptor({
+      request: request as unknown as Request,
+      interceptor: getCookieRequestInterceptor
+    });
+  });
+});

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.js

@@ -14,21 +14,30 @@ const callResponseInterceptors = async params => {
   } = params;
   const getHeader = field => response.getHeader(field);
   const getHeaders = () => response.getHeaders();
-  const getCookie = name => request.cookies[name];
+  const setHeader = (field, value) => {
+    response.set(field, value);
+  };
+  const appendHeader = (field, value) => {
+    response.append(field, value);
+  };
   const setStatusCode = statusCode => {
     response.statusCode = statusCode;
   };
-  const setHeader = (field, value) => response.set(field, value);
-  const appendHeader = (field, value) => response.append(field, value);
+  const getCookie = name => request.cookies[name];
   const setCookie = (name, value, options) => {
     if (options) {
       response.cookie(name, value, options);
+      return;
     }
     response.cookie(name, value);
   };
-  const clearCookie = (name, options) => response.clearCookie(name, options);
-  const attachment = filename => response.attachment(filename);
-  const ResponseInterceptorParams = {
+  const clearCookie = (name, options) => {
+    response.clearCookie(name, options);
+  };
+  const attachment = filename => {
+    response.attachment(filename);
+  };
+  const responseInterceptorParams = {
     request,
     response,
     setDelay: _setDelay.setDelay,
@@ -44,16 +53,16 @@ const callResponseInterceptors = async params => {
   };
   let updatedData = data;
   if (interceptors !== null && interceptors !== void 0 && interceptors.routeInterceptor) {
-    updatedData = await interceptors.routeInterceptor(updatedData, ResponseInterceptorParams);
+    updatedData = await interceptors.routeInterceptor(updatedData, responseInterceptorParams);
   }
   if (interceptors !== null && interceptors !== void 0 && interceptors.requestInterceptor) {
-    updatedData = await interceptors.requestInterceptor(updatedData, ResponseInterceptorParams);
+    updatedData = await interceptors.requestInterceptor(updatedData, responseInterceptorParams);
   }
   if (interceptors !== null && interceptors !== void 0 && interceptors.apiInterceptor) {
-    updatedData = await interceptors.apiInterceptor(updatedData, ResponseInterceptorParams);
+    updatedData = await interceptors.apiInterceptor(updatedData, responseInterceptorParams);
   }
   if (interceptors !== null && interceptors !== void 0 && interceptors.serverInterceptor) {
-    updatedData = await interceptors.serverInterceptor(updatedData, ResponseInterceptorParams);
+    updatedData = await interceptors.serverInterceptor(updatedData, responseInterceptorParams);
   }
   return updatedData;
 };

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.test.ts

@@ -0,0 +1,262 @@
+import type { Request, Response } from 'express';
+
+import type { ResponseInterceptor } from '@/utils/types';
+
+import { callResponseInterceptors } from './callResponseInterceptors';
+
+describe('callResponseInterceptors: order of calls', () => {
+  test('Should call all passed response interceptors in order: route -> request -> api -> server', async () => {
+    const initialData = '';
+    const request = {} as Request;
+    const response = {} as Response;
+    const routeInterceptor = jest.fn((data) => `${data}routeInterceptor;`);
+    const requestInterceptor = jest.fn((data) => `${data}requestInterceptor;`);
+    const apiInterceptor = jest.fn((data) => `${data}apiInterceptor;`);
+    const serverInterceptor = jest.fn((data) => `${data}serverInterceptor`);
+
+    expect(
+      await callResponseInterceptors({
+        data: initialData,
+        request,
+        response
+      })
+    ).toBe('');
+    expect(routeInterceptor.mock.calls.length).toBe(0);
+    expect(requestInterceptor.mock.calls.length).toBe(0);
+    expect(apiInterceptor.mock.calls.length).toBe(0);
+    expect(serverInterceptor.mock.calls.length).toBe(0);
+
+    expect(
+      await callResponseInterceptors({
+        data: initialData,
+        request,
+        response,
+        interceptors: {
+          routeInterceptor,
+          apiInterceptor,
+          requestInterceptor,
+          serverInterceptor
+        }
+      })
+    ).toBe('routeInterceptor;requestInterceptor;apiInterceptor;serverInterceptor');
+    expect(routeInterceptor.mock.calls.length).toBe(1);
+    expect(requestInterceptor.mock.calls.length).toBe(1);
+    expect(apiInterceptor.mock.calls.length).toBe(1);
+    expect(serverInterceptor.mock.calls.length).toBe(1);
+
+    expect(routeInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
+      requestInterceptor.mock.invocationCallOrder[0]
+    );
+    expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
+      apiInterceptor.mock.invocationCallOrder[0]
+    );
+    expect(apiInterceptor.mock.invocationCallOrder[0]).toBeLessThan(
+      serverInterceptor.mock.invocationCallOrder[0]
+    );
+  });
+});
+
+describe('callResponseInterceptors: params functions', () => {
+  test('Should correctly call response getHeader method when use getHeader param', async () => {
+    const data = null;
+    const request = {};
+    const response = { getHeader: jest.fn() };
+
+    const getHeaderRouteInterceptor: ResponseInterceptor = (data, { getHeader }) => {
+      getHeader('header');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: getHeaderRouteInterceptor
+      }
+    });
+    expect(response.getHeader).toHaveBeenCalledWith('header');
+    expect(response.getHeader).toHaveBeenCalledTimes(1);
+  });
+
+  test('Should correctly call response getHeaders method when use getHeaders param', async () => {
+    const data = null;
+    const request = {};
+    const response = { getHeaders: jest.fn() };
+
+    const getHeadersRouteInterceptor: ResponseInterceptor = (data, { getHeaders }) => {
+      getHeaders();
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: getHeadersRouteInterceptor
+      }
+    });
+    expect(response.getHeaders).toHaveBeenCalledWith();
+    expect(response.getHeaders).toHaveBeenCalledTimes(1);
+  });
+
+  test('Should correctly call response set method when use setHeader param', async () => {
+    const data = null;
+    const request = {};
+    const response = { set: jest.fn() };
+
+    const setHeaderRouteInterceptor: ResponseInterceptor = (data, { setHeader }) => {
+      setHeader('name', 'value');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: setHeaderRouteInterceptor
+      }
+    });
+    expect(response.set).toHaveBeenCalledWith('name', 'value');
+    expect(response.set).toHaveBeenCalledTimes(1);
+  });
+
+  test('Should correctly call response append method when use appendHeader param', async () => {
+    const data = null;
+    const request = {};
+    const response = { append: jest.fn() };
+
+    const appendHeaderRouteInterceptor: ResponseInterceptor = (data, { appendHeader }) => {
+      appendHeader('name', 'value');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: appendHeaderRouteInterceptor
+      }
+    });
+    expect(response.append).toHaveBeenCalledWith('name', 'value');
+    expect(response.append).toHaveBeenCalledTimes(1);
+  });
+
+  test('Should correctly set statusCode into response when use setStatusCode param', async () => {
+    const data = null;
+    const request = {} as Request;
+    const response = {} as Response;
+
+    const setStatusCodeRouteInterceptor: ResponseInterceptor = (data, { setStatusCode }) => {
+      setStatusCode(204);
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request,
+      response,
+      interceptors: {
+        routeInterceptor: setStatusCodeRouteInterceptor
+      }
+    });
+    expect(response.statusCode).toBe(204);
+  });
+
+  test('Should correctly get cookie from request.cookies object when use getCookie param', async () => {
+    const data = null;
+    const request = { cookies: { name: 'value' } };
+    const response = {};
+
+    const getCookieRouteInterceptor: ResponseInterceptor = (data, { getCookie }) => {
+      expect(getCookie('name')).toBe('value');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as unknown as Request,
+      response: response as Response,
+      interceptors: {
+        routeInterceptor: getCookieRouteInterceptor
+      }
+    });
+  });
+
+  test('Should correctly call response cookie method with/without options when use setCookie param', async () => {
+    const data = null;
+    const request = {};
+    const response = { cookie: jest.fn() };
+
+    const setCookieWithoutOptionsRouteInterceptor: ResponseInterceptor = (data, { setCookie }) => {
+      setCookie('name', 'value');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: setCookieWithoutOptionsRouteInterceptor
+      }
+    });
+    expect(response.cookie).toHaveBeenCalledWith('name', 'value');
+    expect(response.cookie).toHaveBeenCalledTimes(1);
+
+    response.cookie.mockClear();
+
+    const setCookieWithOptionsRouteInterceptor: ResponseInterceptor = (data, { setCookie }) => {
+      setCookie('name', 'value', { path: '/your/path' });
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: setCookieWithOptionsRouteInterceptor
+      }
+    });
+    expect(response.cookie).toHaveBeenCalledWith('name', 'value', { path: '/your/path' });
+    expect(response.cookie).toBeCalledTimes(1);
+  });
+
+  test('Should correctly call response clearCookie method when use clearCookie param', async () => {
+    const data = null;
+    const request = {};
+    const response = { clearCookie: jest.fn() };
+
+    const clearCookieRouteInterceptor: ResponseInterceptor = (data, { clearCookie }) => {
+      clearCookie('name', { path: '/your/path' });
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: clearCookieRouteInterceptor
+      }
+    });
+    expect(response.clearCookie).toHaveBeenCalledWith('name', { path: '/your/path' });
+    expect(response.clearCookie).toHaveBeenCalledTimes(1);
+  });
+
+  test('Should correctly call response attachment method when use attachment param', async () => {
+    const data = null;
+    const request = {};
+    const response = { attachment: jest.fn() };
+
+    const attachmentRouteInterceptor: ResponseInterceptor = (data, { attachment }) => {
+      attachment('filename');
+      return data;
+    };
+    await callResponseInterceptors({
+      data,
+      request: request as Request,
+      response: response as unknown as Response,
+      interceptors: {
+        routeInterceptor: attachmentRouteInterceptor
+      }
+    });
+    expect(response.attachment).toHaveBeenCalledWith('filename');
+    expect(response.attachment).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/src/utils/helpers/isPlainObject/isPlainObject.test.ts

@@ -0,0 +1,20 @@
+import { isPlainObject } from './isPlainObject';
+
+describe('isPlainObject', () => {
+  test('Object value should return true', () => {
+    expect(isPlainObject(Object({}))).toBe(true);
+  });
+
+  test('All Primitive, array, function values should return false', () => {
+    expect(isPlainObject(Number(1))).toBe(false);
+    expect(isPlainObject(BigInt(9007199254740991n))).toBe(false);
+    expect(isPlainObject(String('test'))).toBe(false);
+    expect(isPlainObject(Boolean(true))).toBe(false);
+    expect(isPlainObject(Symbol('test'))).toBe(false);
+    expect(isPlainObject(Array([]))).toBe(false);
+    expect(isPlainObject(() => {})).toBe(false);
+    expect(isPlainObject(undefined)).toBe(false);
+    expect(isPlainObject(null)).toBe(false);
+    expect(isPlainObject(/\d/)).toBe(false);
+  });
+});