Correctly parse enum values from variables

This adds a test suite to ensure the proper handling of enum types.

In doing so, it fixed an issue where enum values were not being properly parsed when provided as variables.

Fixes #123

Author: leebyron

src/type/__tests__/enumType.js

@@ -0,0 +1,226 @@
+/**
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import {
+  graphql,
+  GraphQLSchema,
+  GraphQLEnumType,
+  GraphQLObjectType,
+  GraphQLInt,
+  GraphQLString,
+} from '../../';
+
+
+describe('Type System: Enum Values', () => {
+
+  var ColorType = new GraphQLEnumType({
+    name: 'Color',
+    values: {
+      RED: { value: 0 },
+      GREEN: { value: 1 },
+      BLUE: { value: 2 },
+    }
+  });
+
+  var QueryType = new GraphQLObjectType({
+    name: 'Query',
+    fields: {
+      colorEnum: {
+        type: ColorType,
+        args: {
+          fromEnum: { type: ColorType },
+          fromInt: { type: GraphQLInt },
+          fromString: { type: GraphQLString },
+        },
+        resolve(value, { fromEnum, fromInt, fromString }) {
+          return fromInt !== undefined ? fromInt :
+            fromString !== undefined ? fromString :
+            fromEnum;
+        }
+      },
+      colorInt: {
+        type: GraphQLInt,
+        args: {
+          fromEnum: { type: ColorType },
+          fromInt: { type: GraphQLInt },
+        },
+        resolve(value, { fromEnum, fromInt }) {
+          return fromInt !== undefined ? fromInt : fromEnum;
+        }
+      }
+    }
+  });
+
+  var schema = new GraphQLSchema({ query: QueryType });
+
+  it('accepts enum literals as input', async () => {
+    expect(
+      await graphql(schema, '{ colorInt(fromEnum: GREEN) }')
+    ).to.deep.equal({
+      data: {
+        colorInt: 1
+      }
+    });
+  });
+
+  it('enum may be output type', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromInt: 1) }')
+    ).to.deep.equal({
+      data: {
+        colorEnum: 'GREEN'
+      }
+    });
+  });
+
+  it('enum may be both input and output type', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromEnum: GREEN) }')
+    ).to.deep.equal({
+      data: {
+        colorEnum: 'GREEN'
+      }
+    });
+  });
+
+  it('does not accept string literals', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromEnum: "GREEN") }')
+    ).to.deep.equal({
+      errors: [
+        { message:
+            'Argument "fromEnum" expected type "Color" but got: "GREEN".' }
+      ]
+    });
+  });
+
+  it('does not accept incorrect internal value', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromString: "GREEN") }')
+    ).to.deep.equal({
+      data: {
+        colorEnum: null
+      }
+    });
+  });
+
+  it('does not accept internal value in place of enum literal', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromEnum: 1) }')
+    ).to.deep.equal({
+      errors: [
+        { message: 'Argument "fromEnum" expected type "Color" but got: 1.' }
+      ]
+    });
+  });
+
+  it('does not accept enum literal in place of int', async () => {
+    expect(
+      await graphql(schema, '{ colorEnum(fromInt: GREEN) }')
+    ).to.deep.equal({
+      errors: [
+        { message: 'Argument "fromInt" expected type "Int" but got: GREEN.' }
+      ]
+    });
+  });
+
+  it('accepts JSON string as enum variable', async () => {
+    expect(
+      await graphql(
+        schema,
+        'query test($color: Color!) { colorEnum(fromEnum: $color) }',
+        null,
+        { color: 'BLUE' }
+      )
+    ).to.deep.equal({
+      data: {
+        colorEnum: 'BLUE'
+      }
+    });
+  });
+
+  it('does not accept internal value as enum variable', async () => {
+    expect(
+      await graphql(
+        schema,
+        'query test($color: Color!) { colorEnum(fromEnum: $color) }',
+        null,
+        { color: 2 }
+      )
+    ).to.deep.equal({
+      errors: [
+        { message:
+            'Variable "$color" expected value of type "Color!" but got: 2.' }
+      ]
+    });
+  });
+
+  it('does not accept string variables as enum input', async () => {
+    expect(
+      await graphql(
+        schema,
+        'query test($color: String!) { colorEnum(fromEnum: $color) }',
+        null,
+        { color: 'BLUE' }
+      )
+    ).to.deep.equal({
+      errors: [
+        { message: 'Variable "$color" of type "String!" used in position ' +
+          'expecting type "Color".' }
+      ]
+    });
+  });
+
+  it('does not accept internal value variable as enum input', async () => {
+    expect(
+      await graphql(
+        schema,
+        'query test($color: Int!) { colorEnum(fromEnum: $color) }',
+        null,
+        { color: 2 }
+      )
+    ).to.deep.equal({
+      errors: [
+        { message: 'Variable "$color" of type "Int!" used in position ' +
+          'expecting type "Color".' }
+      ]
+    });
+  });
+
+  it('enum value may have an internal value of 0', async () => {
+    expect(
+      await graphql(schema, `{
+        colorEnum(fromEnum: RED)
+        colorInt(fromEnum: RED)
+      }`)
+    ).to.deep.equal({
+      data: {
+        colorEnum: 'RED',
+        colorInt: 0
+      }
+    });
+  });
+
+  it('enum inputs may be nullable', async () => {
+    expect(
+      await graphql(schema, `{
+        colorEnum
+        colorInt
+      }`)
+    ).to.deep.equal({
+      data: {
+        colorEnum: null,
+        colorInt: null
+      }
+    });
+  });
+
+});

src/type/definition.js

@@ -652,8 +652,10 @@ export class GraphQLEnumType/* <T> */ {
   }
 
   parseValue(value: any): ?any/* T */ {
-    var enumValue = this._getValueLookup().get((value: any));
-    return enumValue ? enumValue.name : null;
+    var enumValue = this._getNameLookup().get(value);
+    if (enumValue) {
+      return enumValue.value;
+    }
   }
 
   parseLiteral(valueAST: Value): ?any/* T */ {