Add tests for helpers

Author: nodkz

src/resolvers/helpers/__tests__/filter-test.js

@@ -0,0 +1,153 @@
+/* @flow */
+
+import { expect, spy } from 'chai';
+import {
+  filterHelperArgs,
+  filterHelper,
+  getIndexedFieldNames,
+} from '../filter';
+import { UserModel } from '../../../__mocks__/userModel.js';
+import { GraphQLInputObjectType, GraphQLNonNull } from 'graphql';
+import { convertModelToGraphQL } from '../../../fieldsConverter';
+import InputTypeComposer from '../../../../../graphql-compose/src/inputTypeComposer';
+
+const UserType = convertModelToGraphQL(UserModel, 'User');
+
+describe('Resolver helper `filter` ->', () => {
+  describe('getIndexedFieldNames()', () => {
+    it('should return array of indexed fieldNames', () => {
+      const indexedFields = getIndexedFieldNames(UserModel);
+      expect(indexedFields).have.members(
+        ['_id', 'employment', 'name']
+      );
+      expect(indexedFields).not.have.members(
+        ['age', 'gender']
+      );
+    });
+  });
+
+  describe('filterHelperArgs()', () => {
+    it('should throw error if `filterTypeName` not provided in opts', () => {
+      expect(() => filterHelperArgs(UserType))
+        .to.throw('provide non-empty `filterTypeName`');
+    });
+
+    it('should return filter field', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+      });
+      expect(args).has.property('filter');
+      expect(args).has.deep.property('filter.name', 'filter');
+      expect(args).has.deep.property('filter.type').instanceof(GraphQLInputObjectType);
+    });
+
+    it('should for opts.isRequired=true return GraphQLNonNull', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+        isRequired: true,
+      });
+      expect(args).has.property('filter');
+      expect(args).has.deep.property('filter.name', 'filter');
+      expect(args).has.deep.property('filter.type').instanceof(GraphQLNonNull);
+    });
+
+    it('should remove fields via opts.removeFields', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+        removeFields: ['name', 'age'],
+      });
+      const inputTypeComposer = new InputTypeComposer(args.filter.type);
+      expect(inputTypeComposer.hasField('name')).to.be.false;
+      expect(inputTypeComposer.hasField('age')).to.be.false;
+      expect(inputTypeComposer.hasField('gender')).to.be.true;
+    });
+
+    it('should set required fields via opts.requiredFields', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+        requiredFields: ['name', 'age'],
+      });
+      const inputTypeComposer = new InputTypeComposer(args.filter.type);
+      expect(inputTypeComposer.getFieldType('name')).instanceof(GraphQLNonNull);
+      expect(inputTypeComposer.getFieldType('age')).instanceof(GraphQLNonNull);
+      expect(inputTypeComposer.getFieldType('gender')).not.instanceof(GraphQLNonNull);
+    });
+
+    it('should throw error if opts.onlyIndexed=true and opts.model not provided', () => {
+      expect(() => {
+        filterHelperArgs(UserType, {
+          filterTypeName: 'FilterUserType',
+          onlyIndexed: true,
+        });
+      }).to.throw('You should provide `model`');
+    });
+
+    it('should leave only indexed fields if opts.onlyIndexed=true', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+        onlyIndexed: true,
+        model: UserModel,
+      });
+      const inputTypeComposer = new InputTypeComposer(args.filter.type);
+      expect(inputTypeComposer.hasField('_id')).to.be.true;
+      expect(inputTypeComposer.hasField('name')).to.be.true;
+      expect(inputTypeComposer.hasField('age')).to.be.false;
+      expect(inputTypeComposer.hasField('gender')).to.be.false;
+    });
+
+    it('should opts.onlyIndexed=true and opts.removeFields works together', () => {
+      const args = filterHelperArgs(UserType, {
+        filterTypeName: 'FilterUserType',
+        onlyIndexed: true,
+        model: UserModel,
+        removeFields: ['name'],
+      });
+      const inputTypeComposer = new InputTypeComposer(args.filter.type);
+      expect(inputTypeComposer.hasField('_id')).to.be.true;
+      expect(inputTypeComposer.hasField('name')).to.be.false;
+      expect(inputTypeComposer.hasField('age')).to.be.false;
+      expect(inputTypeComposer.hasField('gender')).to.be.false;
+    });
+  });
+
+  describe('filterHelper()', () => {
+    let spyFn;
+    let resolveParams;
+
+    beforeEach(() => {
+      spyFn = spy();
+      resolveParams = {
+        query: {
+          where: spyFn,
+        },
+      };
+    });
+
+    it('should not call query.where if args.filter is empty', () => {
+      filterHelper(resolveParams);
+      expect(spyFn).to.have.not.been.called();
+    });
+    it('should call query.where if args.filter is provided', () => {
+      resolveParams.args = {
+        filter: { name: 'nodkz' },
+      };
+      filterHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with({ name: 'nodkz' });
+    });
+    it('should convert deep object in args.filter to dotted object', () => {
+      resolveParams.args = {
+        filter: {
+          name: {
+            first: 'Pavel',
+          },
+          age: 30,
+        },
+      };
+      filterHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with({
+        'name.first': 'Pavel',
+        age: 30,
+      });
+    });
+  });
+});

src/resolvers/helpers/__tests__/input-test.js

@@ -0,0 +1,60 @@
+/* @flow */
+
+import { expect } from 'chai';
+import { inputHelperArgs } from '../input';
+import { UserModel } from '../../../__mocks__/userModel.js';
+import { GraphQLInputObjectType, GraphQLNonNull } from 'graphql';
+import { convertModelToGraphQL } from '../../../fieldsConverter';
+import InputTypeComposer from '../../../../../graphql-compose/src/inputTypeComposer';
+
+const UserType = convertModelToGraphQL(UserModel, 'User');
+
+describe('Resolver helper `input` ->', () => {
+  describe('inputHelperArgs()', () => {
+    it('should throw error if `inputTypeName` not provided in opts', () => {
+      expect(() => inputHelperArgs(UserType))
+        .to.throw('provide non-empty `inputTypeName`');
+    });
+
+    it('should return input field', () => {
+      const args = inputHelperArgs(UserType, {
+        inputTypeName: 'InputUserType',
+      });
+      expect(args).has.property('input');
+      expect(args).has.deep.property('input.name', 'input');
+      expect(args).has.deep.property('input.type').instanceof(GraphQLInputObjectType);
+    });
+
+    it('should for opts.isRequired=true return GraphQLNonNull', () => {
+      const args = inputHelperArgs(UserType, {
+        inputTypeName: 'InputUserType',
+        isRequired: true,
+      });
+      expect(args).has.property('input');
+      expect(args).has.deep.property('input.name', 'input');
+      expect(args).has.deep.property('input.type').instanceof(GraphQLNonNull);
+    });
+
+    it('should remove fields via opts.removeFields', () => {
+      const args = inputHelperArgs(UserType, {
+        inputTypeName: 'InputUserType',
+        removeFields: ['name', 'age'],
+      });
+      const inputTypeComposer = new InputTypeComposer(args.input.type);
+      expect(inputTypeComposer.hasField('name')).to.be.false;
+      expect(inputTypeComposer.hasField('age')).to.be.false;
+      expect(inputTypeComposer.hasField('gender')).to.be.true;
+    });
+
+    it('should set required fields via opts.requiredFields', () => {
+      const args = inputHelperArgs(UserType, {
+        inputTypeName: 'InputUserType',
+        requiredFields: ['name', 'age'],
+      });
+      const inputTypeComposer = new InputTypeComposer(args.input.type);
+      expect(inputTypeComposer.getFieldType('name')).instanceof(GraphQLNonNull);
+      expect(inputTypeComposer.getFieldType('age')).instanceof(GraphQLNonNull);
+      expect(inputTypeComposer.getFieldType('gender')).not.instanceof(GraphQLNonNull);
+    });
+  });
+});

src/resolvers/helpers/__tests__/limit-test.js

@@ -0,0 +1,54 @@
+/* @flow */
+
+import { expect, spy } from 'chai';
+import { limitHelperArgs, limitHelper } from '../limit';
+import {
+  GraphQLInt,
+} from 'graphql';
+
+describe('Resolver helper `limit` ->', () => {
+  describe('limitHelperArgs()', () => {
+    it('should return limit field', () => {
+      const args = limitHelperArgs();
+      expect(args).has.property('limit');
+      expect(args).has.deep.property('limit.name', 'limit');
+      expect(args).has.deep.property('limit.type', GraphQLInt);
+    });
+    it('should process `opts.defaultValue` arg', () => {
+      expect(limitHelperArgs())
+        .has.deep.property('limit.defaultValue', 1000);
+      expect(limitHelperArgs({
+        defaultValue: 333,
+      })).has.deep.property('limit.defaultValue', 333);
+    });
+  });
+
+  describe('limitHelper()', () => {
+    let spyFn;
+    let resolveParams;
+
+    beforeEach(() => {
+      spyFn = spy();
+      resolveParams = {
+        query: {
+          limit: spyFn,
+        },
+      };
+    });
+
+    it('should not call query.limit if args.limit is empty', () => {
+      limitHelper(resolveParams);
+      expect(spyFn).to.have.not.been.called();
+    });
+    it('should call query.limit if args.limit is provided', () => {
+      resolveParams.args = { limit: 333 };
+      limitHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with(333);
+    });
+    it('should convert string to int in args.limit', () => {
+      resolveParams.args = { limit: '444' };
+      limitHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with(444);
+    });
+  });
+});

src/resolvers/helpers/__tests__/projection-test.js

@@ -0,0 +1,30 @@
+/* @flow */
+
+import { expect, spy } from 'chai';
+import { projectionHelper } from '../projection';
+
+describe('Resolver helper `projection` ->', () => {
+  describe('projectionHelper()', () => {
+    let spyFn;
+    let resolveParams;
+
+    beforeEach(() => {
+      spyFn = spy();
+      resolveParams = {
+        query: {
+          select: spyFn,
+        },
+      };
+    });
+
+    it('should not call query.select if projection is empty', () => {
+      projectionHelper(resolveParams);
+      expect(spyFn).to.have.not.been.called();
+    });
+    it('should call query.select if projection is provided', () => {
+      resolveParams.projection = { name: 1, age: 1 };
+      projectionHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with(resolveParams.projection);
+    });
+  });
+});

src/resolvers/helpers/__tests__/skip-test.js

@@ -0,0 +1,47 @@
+/* @flow */
+
+import { expect, spy } from 'chai';
+import { skipHelperArgs, skipHelper } from '../skip';
+import {
+  GraphQLInt,
+} from 'graphql';
+
+describe('Resolver helper `skip` ->', () => {
+  describe('limitHelperArgs()', () => {
+    it('should return skip field', () => {
+      const args = skipHelperArgs();
+      expect(args).has.property('skip');
+      expect(args).has.deep.property('skip.name', 'skip');
+      expect(args).has.deep.property('skip.type', GraphQLInt);
+    });
+  });
+
+  describe('skipHelper()', () => {
+    let spyFn;
+    let resolveParams;
+
+    beforeEach(() => {
+      spyFn = spy();
+      resolveParams = {
+        query: {
+          skip: spyFn,
+        },
+      };
+    });
+
+    it('should not call query.skip if args.skip is empty', () => {
+      skipHelper(resolveParams);
+      expect(spyFn).to.have.not.been.called();
+    });
+    it('should call query.skip if args.skip is provided', () => {
+      resolveParams.args = { skip: 333 };
+      skipHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with(333);
+    });
+    it('should convert skip to int in args.skip', () => {
+      resolveParams.args = { skip: '444' };
+      skipHelper(resolveParams);
+      expect(spyFn).to.have.been.called.with(444);
+    });
+  });
+});