Add tests

Author: nodkz

package.json

@@ -63,8 +63,8 @@
   },
   "scripts": {
     "build": "npm run build-cjs && npm run build-es",
-    "build-cjs": "rimraf lib && BABEL_ENV=cjs babel src -d lib && cp src/definition.js lib/definition.js",
-    "build-es": "rimraf es && BABEL_ENV=es babel src -d es && cp src/definition.js es/definition.js",
+    "build-cjs": "rimraf lib && BABEL_ENV=cjs babel src --ignore __tests__,__mocks__ -d lib && cp src/definition.js lib/definition.js",
+    "build-es": "rimraf es && BABEL_ENV=es babel src --ignore __tests__,__mocks__ -d es && cp src/definition.js es/definition.js",
     "lint": "eslint src test *.js",
     "prepublish": "npm run build",
     "test": "mocha --compilers js:babel-core/register --reporter dot --require ./resources/mocha-bootload src/**/__tests__/**/*-test.js",

src/__mocks__/rootMutationTypeComposer.js

@@ -0,0 +1,12 @@
+import { TypeComposer } from 'graphql-compose';
+import {
+  GraphQLObjectType,
+} from 'graphql';
+
+const RootMutation = new GraphQLObjectType({
+  name: 'RootMutation',
+  fields: {
+  },
+});
+
+export const rootMutationTypeComposer = new TypeComposer(RootMutation);

src/__mocks__/rootQueryTypeComposer.js

@@ -0,0 +1,12 @@
+import { TypeComposer } from 'graphql-compose';
+import {
+  GraphQLObjectType,
+} from 'graphql';
+
+const RootQuery = new GraphQLObjectType({
+  name: 'RootQuery',
+  fields: {
+  },
+});
+
+export const rootQueryTypeComposer = new TypeComposer(RootQuery);

src/__mocks__/userTypeComposer.js

@@ -0,0 +1,88 @@
+import { TypeComposer, Resolver } from 'graphql-compose';
+import {
+  GraphQLString,
+  GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLNonNull,
+  GraphQLInt,
+} from 'graphql';
+
+export const UserType = new GraphQLObjectType({
+  name: 'User',
+  fields: {
+    id: {
+      type: GraphQLInt,
+    },
+    name: {
+      type: GraphQLString,
+    },
+    nickname: {
+      type: GraphQLString,
+    },
+  },
+});
+
+export const userTypeComposer = new TypeComposer(UserType);
+userTypeComposer.setRecordIdFn(obj => obj.id);
+
+export const findByIdResolver = new Resolver(userTypeComposer, {
+  name: 'findById',
+  kind: 'query',
+  outputType: UserType,
+  args: {
+    _id: {
+      name: '_id',
+      type: new GraphQLNonNull(GraphQLInt),
+    },
+  },
+  resolve: (resolveParams) => {
+    const args = resolveParams.args || {};
+    if (args._id.toString() === '1') {
+      return Promise.resolve({
+        id: 1,
+        name: 'Pavel',
+        nickname: '@nodkz',
+      });
+    }
+    if (args._id.toString() === '2') {
+      return Promise.resolve({
+        id: 2,
+        name: 'Lee',
+        nickname: '@leeb',
+      });
+    }
+    return Promise.resolve(null);
+  },
+});
+
+export const createOneResolver = new Resolver(userTypeComposer, {
+  name: 'createOne',
+  kind: 'mutation',
+  outputType: new GraphQLObjectType({
+    name: 'UserPayload',
+    fields: {
+      record: {
+        type: UserType,
+      },
+    },
+  }),
+  args: {
+    input: {
+      name: 'input',
+      type: new GraphQLInputObjectType({
+        name: 'UserInput',
+        fields: {
+          name: {
+            type: GraphQLString,
+          },
+        },
+      }),
+    },
+  },
+  resolve: (resolveParams) => {
+    return Promise.resolve({
+      recordId: resolveParams.args.input.id,
+      record: resolveParams.args && resolveParams.args.input || {},
+    });
+  },
+});

src/__tests__/composeWithRelay-test.js

@@ -0,0 +1,124 @@
+import { expect } from 'chai';
+import { TypeComposer } from 'graphql-compose';
+import { composeWithRelay } from '../composeWithRelay';
+import { userTypeComposer } from '../__mocks__/userTypeComposer';
+import { rootQueryTypeComposer } from '../__mocks__/rootQueryTypeComposer';
+import { rootMutationTypeComposer } from '../__mocks__/rootMutationTypeComposer';
+import { toGlobalId } from '../globalId';
+import {
+  graphql,
+  GraphQLInterfaceType,
+  GraphQLSchema,
+  GraphQLNonNull,
+} from 'graphql';
+
+describe('composeWithRelay', () => {
+  const userComposer = composeWithRelay(userTypeComposer);
+  const rootQueryComposer = composeWithRelay(rootQueryTypeComposer);
+  const rootMutationComposer = composeWithRelay(rootMutationTypeComposer);
+
+  describe('basic checks', () => {
+    it('should return TypeComposer', () => {
+      expect(userComposer).instanceof(TypeComposer);
+    });
+
+    it('should throw error if get not TypeComposer', () => {
+      expect(() => composeWithRelay(123)).to.throw('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');
+    });
+
+    it('should thow error if typeComposer does not have findById resolver', () => {
+      const tc = userTypeComposer.clone('AnotherUserType');
+      tc.removeResolver('findById');
+      expect(() => composeWithRelay(tc)).to.throw('should have findById resolver');
+    });
+  });
+
+  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).deep.property('type.name').to.equal('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');
+    });
+
+    it('should make id field NonNull', () => {
+      const idField = userComposer.getField('id');
+      expect(idField.type).instanceof(GraphQLNonNull);
+    });
+
+    it('should resolve globalId in `user.id` field', async () => {
+      rootQueryTypeComposer.addField('user',
+        userTypeComposer.getResolver('findById').getFieldConfig()
+      );
+      const schema = new GraphQLSchema({
+        query: rootQueryTypeComposer.getType(),
+      });
+      const query = `{
+        user(_id: 1) {
+          id
+          name
+        }
+      }`;
+      const result = await graphql(schema, query);
+      expect(result).deep.property('data.user.id').equal(toGlobalId('User', 1));
+      expect(result).deep.property('data.user.name').equal('Pavel');
+    });
+
+    it('should resolve globalId in `node.id` field', async () => {
+      rootQueryTypeComposer.addField('user',
+        userTypeComposer.getResolver('findById').getFieldConfig()
+      );
+      const schema = new GraphQLSchema({
+        query: rootQueryTypeComposer.getType(),
+      });
+      const query = `{
+        node(id: "${toGlobalId('User', 1)}") {
+          ...user
+        }
+      }
+      fragment user on User {
+        id
+        name
+      }`;
+      const result = await graphql(schema, query);
+      expect(result).deep.property('data.node.id').equal(toGlobalId('User', 1));
+      expect(result).deep.property('data.node.name').equal('Pavel');
+    });
+
+    it('should passthru clientMutationId in mutations', async () => {
+      rootMutationComposer.addField('createUser',
+        userTypeComposer.getResolver('createOne').getFieldConfig()
+      );
+      const schema = new GraphQLSchema({
+        query: rootQueryTypeComposer.getType(),
+        mutation: rootMutationComposer.getType(),
+      });
+      const query = `mutation {
+        createUser(input: { name: "Ok", clientMutationId: "123" }) {
+          record {
+            name
+          }
+          clientMutationId
+        }
+      }`;
+      const result = await graphql(schema, query);
+      expect(result).deep.property('data.createUser.record.name')
+        .equal('Ok');
+      expect(result).deep.property('data.createUser.clientMutationId')
+        .equal('123');
+    });
+  });
+});

src/__tests__/mutationMiddleware-test.js

@@ -0,0 +1,54 @@
+import { expect } from 'chai';
+import { TypeComposer, InputTypeComposer } from 'graphql-compose';
+import { composeWithRelay } from '../composeWithRelay';
+import { userTypeComposer } from '../__mocks__/userTypeComposer';
+import { toGlobalId } from '../globalId';
+import {
+  GraphQLString,
+  GraphQLID,
+} from 'graphql';
+
+describe('MutationMiddleware', () => {
+  composeWithRelay(userTypeComposer);
+  const fieldConfig = userTypeComposer.getResolver('createOne').getFieldConfig();
+
+  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);
+    });
+  });
+
+  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);
+    });
+
+    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);
+    });
+  });
+
+  describe('resolve', () => {
+    it('should passthru `clientMutationId`', async () => {
+      const result = await fieldConfig.resolve(
+        {},
+        { input: { clientMutationId: '333' } },
+      );
+      expect(result).property('clientMutationId').equal('333');
+    });
+
+    it('should return `nodeId` with globalId', async () => {
+      const result = await fieldConfig.resolve(
+        {},
+        { input: { id: 'newRecord' } },
+      );
+      expect(result).property('nodeId').equal(toGlobalId('User', 'newRecord'));
+    });
+  });
+});

src/__tests__/nodeFieldConfig-test.js

@@ -0,0 +1,50 @@
+import { expect } from 'chai';
+import { findByIdResolver } from '../__mocks__/userTypeComposer';
+import { toGlobalId } from '../globalId';
+import { getNodeFieldConfig } from '../nodeFieldConfig';
+import {
+  GraphQLInterfaceType,
+  GraphQLNonNull,
+} from 'graphql';
+
+describe('nodeFieldConfig', () => {
+  const typeToFindByIdMap = {
+    'User': findByIdResolver,
+  };
+  const config = getNodeFieldConfig(typeToFindByIdMap);
+
+  it('should have type GraphQLInterfaceType', () => {
+    expect(config).to.be.ok;
+    expect(config).property('type').instanceof(GraphQLInterfaceType);
+    expect(config).deep.property('type.name').to.equal('Node');
+  });
+
+  it('should have args with id', () => {
+    expect(config).deep.property('args.id.type').instanceof(GraphQLNonNull);
+  });
+
+  it('should have resolve function', () => {
+    expect(config).respondTo('resolve');
+  });
+
+  it('should return null if args.id not defined', () => {
+    expect(config.resolve({}, {})).to.be.null;
+  });
+
+  it('should return null if findById not defined for type', () => {
+    expect(
+      config.resolve({}, { id: toGlobalId('UnexistedType', 1) })
+    ).to.be.null;
+  });
+
+  it('should return Promise if type exists, but id not exist', () => {
+    expect(
+      config.resolve({}, { id: toGlobalId('User', 666) })
+    ).instanceof(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');
+  });
+});