fix broken tests

Author: nodkz

.flowconfig

@@ -1,6 +1,4 @@
 [ignore]
-.*/__tests__/.*
-.*/__mocks__/.*
 .*/lib/.*
 .*/dist/.*
 .*/coverage/.*

flow-typed/npm/mocha_v2.4.x.js

@@ -23,3 +23,8 @@ declare function before(method : TestFunction):void;
 declare function beforeEach(method : TestFunction):void;
 declare function after(method : TestFunction):void;
 declare function afterEach(method : TestFunction):void;
+
+declare function before(description:string, method : TestFunction):void;
+declare function beforeEach(description:string, method : TestFunction):void;
+declare function after(description:string, method : TestFunction):void;
+declare function afterEach(description:string, method : TestFunction):void;

src/__mocks__/userModel.js

@@ -85,6 +85,7 @@ const UserSchema = new Schema(
   }
 );
 
+UserSchema.set('autoIndex', false);
 UserSchema.index({ name: 1, totalExperience: -1 });
 
 UserSchema.virtual('nameVirtual').get(function () { // eslint-disable-line

src/definition.js

@@ -21,6 +21,9 @@ export type MonooseModelIndex = [
 export type MongooseModelT = {
   schema: MongooseModelSchemaT,
   findOne(criteria: ?Object, projection?: Object): MongooseQuery,
+  findById(id: mixed, projection?: Object, options?: Object): MongooseQuery,
+  find(conditions: ?Object, projection?: Object, options?: Object): MongooseQuery,
+  findOneAndRemove(conditions: ?Object, options?: Object): MongooseQuery,
 }
 
 export type MongooseFieldOptionsT = {

src/resolvers/__tests__/findById-test.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findById from '../findById';
@@ -31,7 +33,7 @@ describe('findById() ->', () => {
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = findById(UserModel).resolve();
+      const result = findById(UserModel).resolve({});
       await expect(result).be.fulfilled;
     });
 
@@ -41,7 +43,7 @@ describe('findById() ->', () => {
     });
 
     it('should return null if args.id is empty', async () => {
-      const result = await findById(UserModel).resolve();
+      const result = await findById(UserModel).resolve({});
       expect(result).equal(null);
     });
 

src/resolvers/__tests__/findByIds-test.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findByIds from '../findByIds';
@@ -55,12 +57,12 @@ describe('findByIds() ->', () => {
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = findByIds(UserModel, UserType).resolve();
+      const result = findByIds(UserModel, UserType).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should return empty array if args.ids is empty', async () => {
-      const result = await findByIds(UserModel, UserType).resolve();
+      const result = await findByIds(UserModel, UserType).resolve({});
       expect(result).to.be.instanceOf(Array);
       expect(result).to.be.empty;
     });

src/resolvers/__tests__/findMany-test.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findMany from '../findMany';
@@ -65,12 +67,12 @@ describe('findMany() ->', () => {
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled Promise', async () => {
-      const result = findMany(UserModel, UserType).resolve();
+      const result = findMany(UserModel, UserType).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should return array of documents if args is empty', async () => {
-      const result = await findMany(UserModel, UserType).resolve();
+      const result = await findMany(UserModel, UserType).resolve({});
 
       expect(result).to.be.instanceOf(Array);
       expect(result).to.have.lengthOf(2);

src/resolvers/__tests__/findOne-test.js

@@ -1,7 +1,14 @@
+/* @flow */
+
 import { expect } from 'chai';
 import { UserModel } from '../../__mocks__/userModel.js';
 import findOne from '../findOne';
 import Resolver from '../../../../graphql-compose/src/resolver/resolver';
+import { GraphQLObjectType } from 'graphql';
+
+const UserType = new GraphQLObjectType({
+  name: 'MockUserType',
+});
 
 describe('findOne() ->', () => {
   let user1;
@@ -33,52 +40,52 @@ describe('findOne() ->', () => {
   });
 
   it('should return Resolver object', () => {
-    const resolver = findOne(UserModel);
+    const resolver = findOne(UserModel, UserType);
     expect(resolver).to.be.instanceof(Resolver);
   });
 
   it('Resolver object should have `filter` arg', () => {
-    const resolver = findOne(UserModel);
+    const resolver = findOne(UserModel, UserType);
     expect(resolver.hasArg('filter')).to.be.true;
   });
 
   it('Resolver object should have `skip` arg', () => {
-    const resolver = findOne(UserModel);
+    const resolver = findOne(UserModel, UserType);
     expect(resolver.hasArg('skip')).to.be.true;
   });
 
   it('Resolver object should have `sort` arg', () => {
-    const resolver = findOne(UserModel);
+    const resolver = findOne(UserModel, UserType);
     expect(resolver.hasArg('sort')).to.be.true;
   });
 
   describe('Resolver.resolve():Promise', () => {
     it('should be fulfilled promise', async () => {
-      const result = findOne(UserModel).resolve();
+      const result = findOne(UserModel, UserType).resolve({});
       await expect(result).be.fulfilled;
     });
 
     it('should return one document if args is empty', async () => {
-      const result = await findOne(UserModel).resolve({ args: null });
+      const result = await findOne(UserModel, UserType).resolve({ args: {} });
       expect(result).is.a('object');
       expect(result).have.property('name').that.oneOf([user1.name, user2.name]);
     });
 
     it('should return document if provided existed id', async () => {
-      const result = await findOne(UserModel).resolve({ args: { id: user1._id } });
+      const result = await findOne(UserModel, UserType).resolve({ args: { id: user1._id } });
       expect(result).have.property('name').that.equal(user1.name);
     });
 
     it('should skip records', async () => {
-      const result = await findOne(UserModel).resolve({ args: { skip: 2000 } });
+      const result = await findOne(UserModel, UserType).resolve({ args: { skip: 2000 } });
       expect(result).to.be.null;
     });
 
     it('should sort records', async () => {
-      const result1 = await findOne(UserModel)
+      const result1 = await findOne(UserModel, UserType)
         .resolve({ args: { sort: { _id: 1 } } });
 
-      const result2 = await findOne(UserModel)
+      const result2 = await findOne(UserModel, UserType)
         .resolve({ args: { sort: { _id: -1 } } });
 
       expect(`${result1._id}`).not.equal(`${result2._id}`);

src/resolvers/createOne.js

@@ -0,0 +1 @@
+/* @flow */

src/resolvers/findById.js

@@ -1,7 +1,10 @@
+/* @flow */
+
 import type {
   MongooseModelT,
   GraphQLObjectType,
-} from './definition';
+  ExtendedResolveParams,
+} from '../definition';
 import Resolver from '../../../graphql-compose/src/resolver/resolver';
 
 import {
@@ -22,13 +25,13 @@ export default function findById(model: MongooseModelT, gqType: GraphQLObjectTyp
         type: new GraphQLNonNull(GraphQLID),
       },
     },
-    resolve: (resolveParams = {}) => {
+    resolve: (resolveParams : ExtendedResolveParams = {}) => {
       const args = resolveParams.args || {};
 
       if (args.id) {
-        resolveParams.cursor = model.findById(args.id); // eslint-disable-line
+        resolveParams.query = model.findById(args.id); // eslint-disable-line
         projectionHelper(resolveParams);
-        return resolveParams.cursor.exec();
+        return resolveParams.query.exec();
       }
       return Promise.resolve(null);
     },