add unit test for nonNull()

Author: iamchenxin

src/node/__tests__/plural.js

@@ -15,11 +15,17 @@ import {
   GraphQLObjectType,
   GraphQLSchema,
   GraphQLString,
+  GraphQLInputObjectType,
+  GraphQLScalarType,
+  GraphQLEnumType,
+  GraphQLList,
+  GraphQLNonNull,
   graphql
 } from 'graphql';
 
 import {
-  pluralIdentifyingRootField
+  pluralIdentifyingRootField,
+  nonNull
 } from '../plural';
 
 var userType = new GraphQLObjectType({
@@ -42,6 +48,7 @@ var queryType = new GraphQLObjectType({
       description: 'Map from a username to the user',
       inputType: GraphQLString,
       outputType: userType,
+      // $FlowFixMe : rootValue Graphql(mixed) -> relay(object)
       resolveSingleInput: (username, context, {rootValue: {lang}}) => ({
         username: username,
         url: 'www.facebook.com/' + username + '?lang=' + lang
@@ -157,3 +164,60 @@ describe('pluralIdentifyingRootField()', () => {
     return expect(graphql(schema, query)).to.become({data: expected});
   });
 });
+
+describe('nonNull()', () => {
+  function qlScalar() {
+    return new GraphQLScalarType({
+      name: 'scalar',
+      serialize: String,
+      description: 'test'
+    });
+  }
+
+  it('covert GraphQLInputObjectType to NonNull type', () => {
+    const inputType = new GraphQLInputObjectType({
+      name: 'input',
+      fields: {
+        test: {
+          type: qlScalar()
+        }
+      }
+    });
+    const result = nonNull(inputType);
+    expect(result).to.be.an.instanceof(GraphQLNonNull);
+    expect(result.ofType).to.deep.equal(inputType);
+  });
+
+  it('covert GraphQLScalarType to NonNull type', () => {
+    const scalarType = qlScalar();
+    const result = nonNull(scalarType);
+    expect(result).to.be.an.instanceof(GraphQLNonNull);
+    expect(result.ofType).to.deep.equal(scalarType);
+  });
+
+  it('covert GraphQLEnumType to NonNull type', () => {
+    const enumType = new GraphQLEnumType({
+      name: 'EM',
+      values: {
+        E: { value: 0},
+        M: { value: 1}
+      }
+    });
+    const result = nonNull(enumType);
+    expect(result).to.be.an.instanceof(GraphQLNonNull);
+    expect(result.ofType).to.deep.equal(enumType);
+  });
+
+  it('covert GraphQLList to NonNull type', () => {
+    const listType = new GraphQLList(GraphQLString);
+    const result = nonNull(listType);
+    expect(result).to.be.an.instanceof(GraphQLNonNull);
+    expect(result.ofType).to.deep.equal(listType);
+  });
+
+  it('does nothing to GraphQLNonNull Type', () => {
+    const nonNullType = new GraphQLNonNull(GraphQLString);
+    const result = nonNull(nonNullType);
+    expect(result).to.deep.equal(nonNullType);
+  });
+});

src/node/plural.js

@@ -64,7 +64,7 @@ type NonNullInputType = GraphQLNonNull<
     GraphQLInputObjectType |
     GraphQLList<GraphQLInputType> >;
 
-function nonNull(type:GraphQLInputType):NonNullInputType {
+export function nonNull(type:GraphQLInputType):NonNullInputType {
   if ( type instanceof GraphQLNonNull) {
     return type;
   } else {