Resolver removeById with tests.

Author: nodkz

src/resolvers/__tests__/removeById-test.js

@@ -0,0 +1,125 @@
+/* @flow */
+
+import { expect } from 'chai';
+import { UserModel } from '../../__mocks__/userModel.js';
+import removeById from '../removeById';
+import Resolver from '../../../../graphql-compose/src/resolver/resolver';
+import TypeComposer from '../../../../graphql-compose/src/typeComposer';
+import { convertModelToGraphQL } from '../../fieldsConverter';
+import { GraphQLNonNull } from 'graphql';
+import GraphQLMongoID from '../../types/mongoid';
+
+const UserType = convertModelToGraphQL(UserModel, 'User');
+
+describe('removeById() ->', () => {
+  let user;
+
+  before('clear UserModel collection', (done) => {
+    UserModel.collection.drop(done);
+  });
+
+  beforeEach('add test user document to mongoDB', () => {
+    user = new UserModel({
+      name: 'userName1',
+      skills: ['js', 'ruby', 'php', 'python'],
+      gender: 'male',
+      relocation: true,
+    });
+
+    return Promise.all([
+      user.save(),
+    ]);
+  });
+
+  it('should return Resolver object', () => {
+    const resolver = removeById(UserModel, UserType);
+    expect(resolver).to.be.instanceof(Resolver);
+  });
+
+  describe('Resolver.args', () => {
+    it('should have non-null `_id` arg', () => {
+      const resolver = removeById(UserModel, UserType);
+      expect(resolver.hasArg('_id')).to.be.true;
+      const argConfig = resolver.getArg('_id');
+      expect(argConfig).property('type').that.instanceof(GraphQLNonNull);
+      expect(argConfig).deep.property('type.ofType').that.equal(GraphQLMongoID);
+    });
+  });
+
+  describe('Resolver.resolve():Promise', () => {
+    it('should be promise', () => {
+      const result = removeById(UserModel, UserType).resolve({});
+      expect(result).instanceof(Promise);
+      result.catch(() => 'catch error if appear, hide it from mocha');
+    });
+
+    it('should rejected with Error if args._id is empty', async () => {
+      const result = removeById(UserModel, UserType).resolve({ args: { } });
+      await expect(result).be.rejectedWith(Error, 'requires args._id');
+    });
+
+    it('should return payload.recordId', async () => {
+      const result = await removeById(UserModel, UserType).resolve({
+        args: {
+          _id: user.id,
+        },
+      });
+      expect(result).have.property('recordId', user.id);
+    });
+
+    it('should return payload.recordId even document not exists', async () => {
+      const unexistedId = '500000000000000000000000';
+      const result = await removeById(UserModel, UserType).resolve({
+        args: {
+          _id: unexistedId,
+        },
+      });
+      expect(result).have.property('recordId', unexistedId);
+    });
+
+
+    it('should remove document in database', (done) => {
+      removeById(UserModel, UserType).resolve({
+        args: {
+          _id: user.id,
+        },
+      }).then(() => {
+        UserModel.collection.findOne({ _id: user._id }, (err, doc) => {
+          expect(err).to.be.null;
+          expect(doc).to.be.null;
+          done();
+        });
+      });
+    });
+
+    it('should return payload.record', async () => {
+      const result = await removeById(UserModel, UserType).resolve({
+        args: {
+          _id: user.id,
+        },
+      });
+      expect(result).have.deep.property('record.id', user.id);
+    });
+  });
+
+  describe('Resolver.getOutputType()', () => {
+    it('should have correct output type name', () => {
+      const outputType = removeById(UserModel, UserType).getOutputType();
+      expect(outputType.name).to.equal(`RemoveById${UserType.name}Payload`);
+    });
+
+    it('should have recordId field', () => {
+      const outputType = removeById(UserModel, UserType).getOutputType();
+      const typeComposer = new TypeComposer(outputType);
+      expect(typeComposer.hasField('recordId')).to.be.true;
+      expect(typeComposer.getField('recordId').type).to.equal(GraphQLMongoID);
+    });
+
+    it('should have record field', () => {
+      const outputType = removeById(UserModel, UserType).getOutputType();
+      const typeComposer = new TypeComposer(outputType);
+      expect(typeComposer.hasField('record')).to.be.true;
+      expect(typeComposer.getField('record').type).to.equal(UserType);
+    });
+  });
+});

src/resolvers/removeById.js

@@ -0,0 +1,77 @@
+/* @flow */
+/* eslint-disable no-param-reassign */
+
+import { projectionHelper } from './helpers/projection';
+import findById from './findById';
+import {
+  GraphQLObjectType,
+  GraphQLNonNull,
+} from 'graphql';
+import GraphQLMongoID from '../types/mongoid';
+
+import type {
+  MongooseModelT,
+  ExtendedResolveParams,
+} from '../definition';
+import Resolver from '../../../graphql-compose/src/resolver/resolver';
+
+export default function removeById(
+  model: MongooseModelT,
+  gqType: GraphQLObjectType,
+): Resolver {
+  const resolver = new Resolver({
+    name: 'removeById',
+    kind: 'mutation',
+    description: 'Remove one document: '
+               + '1) Retrieve one document by findById. '
+               + '2) Remove mongoose document with hooks via findByIdAndRemove. '
+               + '3) Return removed document.',
+    outputType: new GraphQLObjectType({
+      name: `RemoveById${gqType.name}Payload`,
+      fields: {
+        recordId: {
+          type: GraphQLMongoID,
+          description: 'Removed document ID',
+        },
+        record: {
+          type: gqType,
+          description: 'Removed document',
+        },
+      },
+    }),
+    args: {
+      _id: {
+        name: '_id',
+        type: new GraphQLNonNull(GraphQLMongoID),
+      },
+    },
+    resolve: (resolveParams: ExtendedResolveParams) => {
+      const args = resolveParams.args || {};
+
+      if (!args._id) {
+        return Promise.reject(
+          new Error(`${gqType.name}.removeById resolver requires args._id value`)
+        );
+      }
+
+      resolveParams.query = model.findByIdAndRemove(args._id);
+      projectionHelper(resolveParams);
+
+      return resolveParams.query.exec()
+        .then(res => {
+          if (res) {
+            return {
+              record: res.toObject(),
+              recordId: res.id,
+            };
+          }
+
+          return {
+            recordId: args._id,
+          };
+        });
+    },
+  });
+
+  return resolver;
+}