test: Make tests compatible with Jest

Author: nodkz

.eslintrc

@@ -29,7 +29,12 @@
     "no-unused-expressions": 0,
   },
   "env": {
-    "mocha": true
+    "jasmine": true,
+    "jest": true
+  },
+  "globals": {
+    "Class": true,
+    "$Shape": true,
   },
   "plugins": [
     "flowtype",

src/__tests__/composeWithRelay-test.js

@@ -1,6 +1,5 @@
 /* @flow */
 
-import { expect } from 'chai';
 import { TypeComposer, graphql } from 'graphql-compose';
 import { composeWithRelay } from '../composeWithRelay';
 import { userTypeComposer } from '../__mocks__/userTypeComposer';
@@ -17,44 +16,45 @@ describe('composeWithRelay', () => {
 
   describe('basic checks', () => {
     it('should return TypeComposer', () => {
-      expect(userComposer).instanceof(TypeComposer);
+      expect(userComposer).toBeInstanceOf(TypeComposer);
     });
 
     it('should throw error if got a not TypeComposer', () => {
-      expect(() => composeWithRelay(123)).to.throw('should provide TypeComposer instance');
+      expect(() => composeWithRelay(123)).toThrowError('should provide TypeComposer instance');
     });
 
     it('should throw error if TypeComposer without recordIdFn', () => {
       const tc = userTypeComposer.clone('AnotherUserType2');
       delete tc.gqType._gqcGetRecordIdFn;
-      expect(() => composeWithRelay(tc)).to.throw('should have recordIdFn');
+      expect(() => composeWithRelay(tc)).toThrowError('should have recordIdFn');
     });
 
     it('should thow error if typeComposer does not have findById resolver', () => {
       const tc = userTypeComposer.clone('AnotherUserType');
       tc.removeResolver('findById');
-      expect(() => composeWithRelay(tc)).to.throw("does not have resolver with name 'findById'");
+      expect(() => composeWithRelay(tc)).toThrowError(
+        "does not have resolver with name 'findById'"
+      );
     });
   });
 
   describe('when pass RootQuery type composer', () => {
     it('should add `node` field to RootQuery', () => {
       const nodeField = rootQueryComposer.getField('node');
-      expect(nodeField).to.be.ok;
-      expect(nodeField).property('type').instanceof(GraphQLInterfaceType);
-      expect(nodeField).nested.property('type.name').to.equal('Node');
+      expect(nodeField.type).toBeInstanceOf(GraphQLInterfaceType);
+      expect(nodeField.type.name).toBe('Node');
     });
   });
 
   describe('when pass User type composer (not RootQuery)', () => {
     it('should add or override id field', () => {
       const idField = userComposer.getField('id');
-      expect(idField.description).to.contain('globally unique ID');
+      expect(idField.description).toContain('globally unique ID');
     });
 
     it('should make id field NonNull', () => {
       const idField = userComposer.getField('id');
-      expect(idField.type).instanceof(GraphQLNonNull);
+      expect(idField.type).toBeInstanceOf(GraphQLNonNull);
     });
 
     it('should resolve globalId in `user.id` field', async () => {
@@ -72,8 +72,8 @@ describe('composeWithRelay', () => {
         }
       }`;
       const result = await graphql.graphql(schema, query);
-      expect(result).nested.property('data.user.id').equal(toGlobalId('User', 1));
-      expect(result).nested.property('data.user.name').equal('Pavel');
+      expect(result.data.user.id).toBe(toGlobalId('User', 1));
+      expect(result.data.user.name).toBe('Pavel');
     });
 
     it('should resolve globalId in `node.id` field', async () => {
@@ -94,8 +94,8 @@ describe('composeWithRelay', () => {
         name
       }`;
       const result = await graphql.graphql(schema, query);
-      expect(result).nested.property('data.node.id').equal(toGlobalId('User', 1));
-      expect(result).nested.property('data.node.name').equal('Pavel');
+      expect(result.data.node.id).toBe(toGlobalId('User', 1));
+      expect(result.data.node.name).toBe('Pavel');
     });
 
     it('should passthru clientMutationId in mutations', async () => {
@@ -116,8 +116,8 @@ describe('composeWithRelay', () => {
         }
       }`;
       const result = await graphql.graphql(schema, query);
-      expect(result).nested.property('data.createUser.record.name').equal('Ok');
-      expect(result).nested.property('data.createUser.clientMutationId').equal('123');
+      expect(result.data.createUser.record.name).toBe('Ok');
+      expect(result.data.createUser.clientMutationId).toBe('123');
     });
   });
 });

src/__tests__/globalId-test.js

@@ -1,30 +1,29 @@
 /* @flow */
 
-import { expect } from 'chai';
 import { base64, unbase64, toGlobalId, fromGlobalId } from '../globalId';
 
 describe('globalId', () => {
   it('should have correct method base64()', () => {
-    expect(base64('123')).to.equal('MTIz');
-    expect(base64('lksdnfkksdknsdc:123')).to.equal('bGtzZG5ma2tzZGtuc2RjOjEyMw==');
+    expect(base64('123')).toBe('MTIz');
+    expect(base64('lksdnfkksdknsdc:123')).toBe('bGtzZG5ma2tzZGtuc2RjOjEyMw==');
   });
 
   it('should have correct method unbase64()', () => {
-    expect(unbase64('MTIz')).to.equal('123');
-    expect(unbase64('bGtzZG5ma2tzZGtuc2RjOjEyMw==')).to.equal('lksdnfkksdknsdc:123');
+    expect(unbase64('MTIz')).toBe('123');
+    expect(unbase64('bGtzZG5ma2tzZGtuc2RjOjEyMw==')).toBe('lksdnfkksdknsdc:123');
   });
 
   it('should have correct method toGlobalId()', () => {
-    expect(toGlobalId('User', '789')).to.equal('VXNlcjo3ODk=');
-    expect(toGlobalId('Article', 22)).to.equal('QXJ0aWNsZToyMg==');
+    expect(toGlobalId('User', '789')).toBe('VXNlcjo3ODk=');
+    expect(toGlobalId('Article', 22)).toBe('QXJ0aWNsZToyMg==');
   });
 
   it('should have correct method fromGlobalId()', () => {
-    expect(fromGlobalId('VXNlcjo3ODk=')).to.deep.equal({
+    expect(fromGlobalId('VXNlcjo3ODk=')).toEqual({
       type: 'User',
       id: '789',
     });
-    expect(fromGlobalId('QXJ0aWNsZToyMg==')).to.deep.equal({
+    expect(fromGlobalId('QXJ0aWNsZToyMg==')).toEqual({
       type: 'Article',
       id: '22',
     });

src/__tests__/nodeFieldConfig-test.js

@@ -1,6 +1,5 @@
 /* @flow */
 
-import { expect } from 'chai';
 import { graphql } from 'graphql-compose';
 import { findByIdResolver, userTypeComposer } from '../__mocks__/userTypeComposer';
 import { toGlobalId } from '../globalId';
@@ -18,33 +17,35 @@ describe('nodeFieldConfig', () => {
   const config = getNodeFieldConfig(typeToFindByIdMap);
 
   it('should have type GraphQLInterfaceType', () => {
-    expect(config).to.be.ok;
-    expect(config).property('type').instanceof(GraphQLInterfaceType);
-    expect(config).nested.property('type.name').to.equal('Node');
+    expect(config).toBeTruthy();
+    expect(config.type).toBeInstanceOf(GraphQLInterfaceType);
+    expect(config.type.name).toBe('Node');
   });
 
   it('should have args with id', () => {
-    expect(config).nested.property('args.id.type').instanceof(GraphQLNonNull);
+    expect(config.args.id.type).toBeInstanceOf(GraphQLNonNull);
   });
 
   it('should have resolve function', () => {
-    expect(config).respondTo('resolve');
+    expect(config.resolve).toBeDefined();
+    expect(config.resolve.call).toBeDefined();
+    expect(config.resolve.apply).toBeDefined();
   });
 
   it('should return null if args.id not defined', () => {
-    expect(config.resolve({}, {})).to.be.null;
+    expect(config.resolve({}, {})).toBeNull();
   });
 
   it('should return null if findById not defined for type', () => {
-    expect(config.resolve({}, { id: toGlobalId('UnexistedType', 1) })).to.be.null;
+    expect(config.resolve({}, { id: toGlobalId('UnexistedType', 1) })).toBeNull();
   });
 
   it('should return Promise if type exists, but id not exist', () => {
-    expect(config.resolve({}, { id: toGlobalId('User', 666) })).instanceof(Promise);
+    expect(config.resolve({}, { id: toGlobalId('User', 666) })).toBeInstanceOf(Promise);
   });
 
   it('should return Promise with user data', async () => {
     const res = await config.resolve({}, { id: toGlobalId('User', 1) });
-    expect(res).property('name').to.equal('Pavel');
+    expect(res.name).toBe('Pavel');
   });
 });

src/__tests__/wrapMutationResolver.js

@@ -1,6 +1,5 @@
 /* @flow */
 
-import { expect } from 'chai';
 import { TypeComposer, InputTypeComposer, graphql } from 'graphql-compose';
 import { composeWithRelay } from '../composeWithRelay';
 import { userTypeComposer } from '../__mocks__/userTypeComposer';
@@ -21,62 +20,64 @@ describe('wrapMutationResolver', () => {
   describe('args', () => {
     it('should add `clientMutationId` field to args.input', () => {
       const itc = new InputTypeComposer(fieldConfig.args.input.type);
-      expect(itc.hasField('clientMutationId')).to.be.true;
-      expect(itc.getFieldType('clientMutationId')).equal(GraphQLString);
+      expect(itc.hasField('clientMutationId')).toBe(true);
+      expect(itc.getFieldType('clientMutationId')).toBe(GraphQLString);
     });
 
     it('should create required args.input! if not exists', () => {
-      expect(fieldConfigManyArgsWithoutInput.args).property('input').to.be.ok;
+      expect(fieldConfigManyArgsWithoutInput.args.input).toBeTruthy();
 
-      expect(fieldConfigManyArgsWithoutInput.args).nested
-        .property('input.type')
-        .instanceof(GraphQLNonNull);
+      expect(fieldConfigManyArgsWithoutInput.args.input.type).toBeInstanceOf(GraphQLNonNull);
     });
 
     it('should create args.input if not exists and move all args into it', () => {
-      expect(fieldConfigManyArgsWithoutInput.args).to.have.all.keys(['input']);
+      expect(Object.keys(fieldConfigManyArgsWithoutInput.args)).toEqual(
+        expect.arrayContaining(['input'])
+      );
 
       const type = getNamedType(fieldConfigManyArgsWithoutInput.args.input.type);
       const itc = new InputTypeComposer(type);
-      expect(itc.hasField('sort')).to.be.true;
-      expect(itc.hasField('limit')).to.be.true;
-      expect(itc.hasField('clientMutationId')).to.be.true;
+      expect(itc.hasField('sort')).toBe(true);
+      expect(itc.hasField('limit')).toBe(true);
+      expect(itc.hasField('clientMutationId')).toBe(true);
     });
 
     it('should leave other arg untouched if args.input exists', () => {
-      expect(fieldConfigManyArgsWithInput.args).to.have.all.keys(['input', 'sort', 'limit']);
+      expect(Object.keys(fieldConfigManyArgsWithInput.args)).toEqual(
+        expect.arrayContaining(['input', 'sort', 'limit'])
+      );
 
       const type = getNamedType(fieldConfigManyArgsWithInput.args.input.type);
       const itc = new InputTypeComposer(type);
-      expect(itc.hasField('sort')).to.be.false;
-      expect(itc.hasField('limit')).to.be.false;
-      expect(itc.hasField('clientMutationId')).to.be.true;
+      expect(itc.hasField('sort')).toBe(false);
+      expect(itc.hasField('limit')).toBe(false);
+      expect(itc.hasField('clientMutationId')).toBe(true);
     });
   });
 
   describe('outputType', () => {
     it('should add `clientMutationId` field to payload', () => {
       const tc = new TypeComposer(fieldConfig.type);
-      expect(tc.hasField('clientMutationId')).to.be.true;
-      expect(tc.getFieldType('clientMutationId')).equal(GraphQLString);
+      expect(tc.hasField('clientMutationId')).toBe(true);
+      expect(tc.getFieldType('clientMutationId')).toBe(GraphQLString);
     });
 
     it('should add `nodeId` field to payload', () => {
       const tc = new TypeComposer(fieldConfig.type);
-      expect(tc.hasField('nodeId')).to.be.true;
-      expect(tc.getFieldType('nodeId')).equal(GraphQLID);
+      expect(tc.hasField('nodeId')).toBe(true);
+      expect(tc.getFieldType('nodeId')).toBe(GraphQLID);
     });
   });
 
   describe('resolve', () => {
     it('should passthru `clientMutationId`', async () => {
       const result = await fieldConfig.resolve({}, { input: { clientMutationId: '333' } });
-      expect(result).property('clientMutationId').equal('333');
+      expect(result.clientMutationId).toBe('333');
     });
 
     it('should return `nodeId` with globalId', async () => {
       const result = await fieldConfig.resolve({}, { input: { id: 'newRecord' } });
-      expect(result).property('nodeId').equal(toGlobalId('User', 'newRecord'));
+      expect(result.nodeId).toBe(toGlobalId('User', 'newRecord'));
     });
   });
 });