google / rejoiner / 102

pending completion

Build # 102

Build Type

Pull #53

travis-ci

Committed by

web-flow

Commit Message

Fix GqlInputConverter#createProtoBuf() bug.

Bug was introduced in 6a9323c0c. This
commit aimed to convert underscore_case field names to camelCase.
While the GraphQLInputObjectField's name was converted,
GqlInputConverter#createProtoBuf(), which converts Map<String, Object>
to a protobuf Message, did not do the same conversion. This resulted
in fields like "id" working, but fields like "user_id" being ignored.

This change fixes the bug and adds an assertion that all input fields
were consumed.

Pull Request Pull Request #53: Fix GqlInputConverter#createProtoBuf() bug.

Run Details

11 of 11 new or added lines in 1 file covered. (100.0%)

809 of 1933 relevant lines covered (41.85%)

0.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.58

/rejoiner/src/main/java/com/google/api/graphql/rejoiner/GqlInputConverter.java

// Copyright 2017 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.api.graphql.rejoiner;

import static graphql.Scalars.GraphQLString;
import com.google.common.base.CaseFormat;
import com.google.common.base.Converter;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableBiMap;
import com.google.protobuf.Descriptors.Descriptor;
import com.google.protobuf.Descriptors.EnumDescriptor;
import com.google.protobuf.Descriptors.FieldDescriptor;
import com.google.protobuf.Descriptors.FileDescriptor;
import com.google.protobuf.Descriptors.GenericDescriptor;
import com.google.protobuf.Message;
import graphql.schema.GraphQLArgument;
import graphql.schema.GraphQLInputObjectField;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLInputType;
import graphql.schema.GraphQLList;
import graphql.schema.GraphQLType;
import graphql.schema.GraphQLTypeReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Converts GraphQL inputs into Protobuf message.
 *
 * <p>Keeps a mapping from type name to Proto descriptor for Message and Enum types.
 */
final class GqlInputConverter {

  private final BiMap<String, Descriptor> descriptorMapping;
  private final BiMap<String, EnumDescriptor> enumMapping;

  private static final Converter<String, String> UNDERSCORE_TO_CAMEL =
      CaseFormat.LOWER_UNDERSCORE.converterTo(CaseFormat.LOWER_CAMEL);

  private GqlInputConverter(
      BiMap<String, Descriptor> descriptorMapping, BiMap<String, EnumDescriptor> enumMapping) {
    this.descriptorMapping = descriptorMapping;
    this.enumMapping = enumMapping;
  }

  static Builder newBuilder() {
    return new Builder();
  }

  Message createProtoBuf(
      Descriptor descriptor, Message.Builder builder, Map<String, Object> input) {

    if (input == null) {
      return builder.build();
    }

    Map<String, Object> remainingInput = new HashMap<>(input);
    for (FieldDescriptor field : descriptor.getFields()) {
      String fieldName = getFieldName(field);

      if (!remainingInput.containsKey(fieldName)) {
        // TODO: validate required fields
        continue;
      }

      if (field.isRepeated()) {
        List<Object> values = (List<Object>) remainingInput.remove(fieldName);
        for (Object value : values) {
          builder.addRepeatedField(field, getValueForField(field, value, builder));
        }
      } else {
        builder.setField(field, getValueForField(field, remainingInput.remove(fieldName), builder));
      }
    }

    if (!remainingInput.isEmpty()) {
      throw new AssertionError(
          "All fields in input should have been consumed. Remaining: " + remainingInput);
    }

    return builder.build();
  }

  GraphQLType getInputType(Descriptor descriptor) {
    GraphQLInputObjectType.Builder builder =
        GraphQLInputObjectType.newInputObject().name(getReferenceName(descriptor));

    if (descriptor.getFields().isEmpty()) {
      builder.field(STATIC_FIELD);
    }
    for (FieldDescriptor field : descriptor.getFields()) {
      GraphQLType fieldType = getFieldType(field);
      GraphQLInputObjectField.Builder inputBuilder =
          GraphQLInputObjectField.newInputObjectField().name(getFieldName(field));
      if (field.isRepeated()) {
        inputBuilder.type(new GraphQLList(fieldType));
      } else {
        inputBuilder.type((GraphQLInputType) fieldType);
      }

      builder.field(inputBuilder.build());
    }
    return builder.build();
  }

  private Object getValueForField(FieldDescriptor field, Object value, Message.Builder builder) {
    // TODO: handle groups, oneof
    if (field.getType() == FieldDescriptor.Type.MESSAGE) {
      Descriptor fieldTypeDescriptor =
          descriptorMapping.get(getReferenceName(field.getMessageType()));
      return createProtoBuf(
          fieldTypeDescriptor, builder.newBuilderForField(field), (Map<String, Object>) value);
    }

    if (field.getType() == FieldDescriptor.Type.ENUM) {
      EnumDescriptor enumDescriptor =
          enumMapping.get(ProtoToGql.getReferenceName(field.getEnumType()));
      return enumDescriptor.findValueByName(value.toString());
    }

    return value;
  }

  static GraphQLArgument createArgument(Descriptor descriptor, String name) {
    return GraphQLArgument.newArgument().name(name).type(getInputTypeReference(descriptor)).build();
  }

  static String getReferenceName(GenericDescriptor descriptor) {
    return "Input_" + ProtoToGql.getReferenceName(descriptor);
  }

  /** Field names with under_scores are converted to camelCase. */
  private String getFieldName(FieldDescriptor field) {
    String fieldName = field.getName();
    return fieldName.contains("_") ? UNDERSCORE_TO_CAMEL.convert(fieldName) : fieldName;
  }

  private GraphQLType getFieldType(FieldDescriptor field) {
    if (field.getType() == FieldDescriptor.Type.MESSAGE
        || field.getType() == FieldDescriptor.Type.GROUP) {
      return new GraphQLTypeReference(getReferenceName(field.getMessageType()));
    }
    if (field.getType() == FieldDescriptor.Type.ENUM) {
      return new GraphQLTypeReference(ProtoToGql.getReferenceName(field.getEnumType()));
    }
    GraphQLType type = ProtoToGql.convertType(field);
    if (type instanceof GraphQLList) {
      return ((GraphQLList) type).getWrappedType();
    }
    return type;
  }

  private static GraphQLInputType getInputTypeReference(Descriptor descriptor) {
    return new GraphQLTypeReference(getReferenceName(descriptor));
  }

  private static final GraphQLInputObjectField STATIC_FIELD =
      GraphQLInputObjectField.newInputObjectField()
          .type(GraphQLString)
          .name("_")
          .defaultValue("")
          .description("NOT USED")
          .build();

  // Based on ProtoRegistry.Builder, but builds a map of descriptors rather than types.

  /** Builder for GqlInputConverter. */
  static class Builder {
    private final ArrayList<FileDescriptor> fileDescriptors = new ArrayList<>();
    private final ArrayList<Descriptor> descriptors = new ArrayList<>();
    private final ArrayList<EnumDescriptor> enumDescriptors = new ArrayList<>();

    Builder add(FileDescriptor fileDescriptor) {
      fileDescriptors.add(fileDescriptor);
      return this;
    }

    GqlInputConverter build() {
      HashBiMap<String, Descriptor> mapping = HashBiMap.create();
      HashBiMap<String, EnumDescriptor> enumMapping = HashBiMap.create(getEnumMap(enumDescriptors));
      LinkedList<Descriptor> loop = new LinkedList<>(descriptors);

      Set<FileDescriptor> fileDescriptorSet = ProtoRegistry.extractDependencies(fileDescriptors);

      for (FileDescriptor fileDescriptor : fileDescriptorSet) {
        loop.addAll(fileDescriptor.getMessageTypes());
        enumMapping.putAll(getEnumMap(fileDescriptor.getEnumTypes()));
      }

      while (!loop.isEmpty()) {
        Descriptor descriptor = loop.pop();
        if (!mapping.containsKey(descriptor.getFullName())) {
          mapping.put(getReferenceName(descriptor), descriptor);
          loop.addAll(descriptor.getNestedTypes());
          enumMapping.putAll(getEnumMap(descriptor.getEnumTypes()));
        }
      }

      return new GqlInputConverter(
          ImmutableBiMap.copyOf(mapping), ImmutableBiMap.copyOf(enumMapping));
    }

    private static BiMap<String, EnumDescriptor> getEnumMap(Iterable<EnumDescriptor> descriptors) {
      HashBiMap<String, EnumDescriptor> mapping = HashBiMap.create();
      for (EnumDescriptor enumDescriptor : descriptors) {
        mapping.put(ProtoToGql.getReferenceName(enumDescriptor), enumDescriptor);
      }
      return mapping;
    }
  }
}

1	// Copyright 2017 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package com.google.api.graphql.rejoiner;
16
17	import static graphql.Scalars.GraphQLString;
18	import com.google.common.base.CaseFormat;
19	import com.google.common.base.Converter;
20	import com.google.common.collect.BiMap;
21	import com.google.common.collect.HashBiMap;
22	import com.google.common.collect.ImmutableBiMap;
23	import com.google.protobuf.Descriptors.Descriptor;
24	import com.google.protobuf.Descriptors.EnumDescriptor;
25	import com.google.protobuf.Descriptors.FieldDescriptor;
26	import com.google.protobuf.Descriptors.FileDescriptor;
27	import com.google.protobuf.Descriptors.GenericDescriptor;
28	import com.google.protobuf.Message;
29	import graphql.schema.GraphQLArgument;
30	import graphql.schema.GraphQLInputObjectField;
31	import graphql.schema.GraphQLInputObjectType;
32	import graphql.schema.GraphQLInputType;
33	import graphql.schema.GraphQLList;
34	import graphql.schema.GraphQLType;
35	import graphql.schema.GraphQLTypeReference;
36	import java.util.ArrayList;
37	import java.util.HashMap;
38	import java.util.LinkedList;
39	import java.util.List;
40	import java.util.Map;
41	import java.util.Set;
42
43	/**
44	* Converts GraphQL inputs into Protobuf message.
45	*
46	* <p>Keeps a mapping from type name to Proto descriptor for Message and Enum types.
47	*/
48	final class GqlInputConverter {
49
50	private final BiMap<String, Descriptor> descriptorMapping;
51	private final BiMap<String, EnumDescriptor> enumMapping;
52
53	private static final Converter<String, String> UNDERSCORE_TO_CAMEL =	1✔
54	CaseFormat.LOWER_UNDERSCORE.converterTo(CaseFormat.LOWER_CAMEL);	1✔
55
56	private GqlInputConverter(
57	BiMap<String, Descriptor> descriptorMapping, BiMap<String, EnumDescriptor> enumMapping) {	1✔
58	this.descriptorMapping = descriptorMapping;	1✔
59	this.enumMapping = enumMapping;	1✔
60	}	1✔
61
62	static Builder newBuilder() {
63	return new Builder();	1✔
64	}
65
66	Message createProtoBuf(
67	Descriptor descriptor, Message.Builder builder, Map<String, Object> input) {
68
69	if (input == null) {	1✔
70	return builder.build();	1✔
71	}
72
73	Map<String, Object> remainingInput = new HashMap<>(input);	1✔
74	for (FieldDescriptor field : descriptor.getFields()) {	1✔
75	String fieldName = getFieldName(field);	1✔
76
77	if (!remainingInput.containsKey(fieldName)) {	1✔
78	// TODO: validate required fields
79	continue;	1✔
80	}
81
82	if (field.isRepeated()) {	1✔
83	List<Object> values = (List<Object>) remainingInput.remove(fieldName);	×
84	for (Object value : values) {	×
85	builder.addRepeatedField(field, getValueForField(field, value, builder));	×
86	}	×
87	} else {	×
88	builder.setField(field, getValueForField(field, remainingInput.remove(fieldName), builder));	1✔
89	}
90	}	1✔
91
92	if (!remainingInput.isEmpty()) {	1✔
93	throw new AssertionError(	×
94	"All fields in input should have been consumed. Remaining: " + remainingInput);
95	}
96
97	return builder.build();	1✔
98	}
99
100	GraphQLType getInputType(Descriptor descriptor) {
101	GraphQLInputObjectType.Builder builder =
102	GraphQLInputObjectType.newInputObject().name(getReferenceName(descriptor));	1✔
103
104	if (descriptor.getFields().isEmpty()) {	1✔
105	builder.field(STATIC_FIELD);	×
106	}
107	for (FieldDescriptor field : descriptor.getFields()) {	1✔
108	GraphQLType fieldType = getFieldType(field);	1✔
109	GraphQLInputObjectField.Builder inputBuilder =
110	GraphQLInputObjectField.newInputObjectField().name(getFieldName(field));	1✔
111	if (field.isRepeated()) {	1✔
112	inputBuilder.type(new GraphQLList(fieldType));	1✔
113	} else {
114	inputBuilder.type((GraphQLInputType) fieldType);	1✔
115	}
116
117	builder.field(inputBuilder.build());	1✔
118	}	1✔
119	return builder.build();	1✔
120	}
121
122	private Object getValueForField(FieldDescriptor field, Object value, Message.Builder builder) {
123	// TODO: handle groups, oneof
124	if (field.getType() == FieldDescriptor.Type.MESSAGE) {	1✔
125	Descriptor fieldTypeDescriptor =	1✔
126	descriptorMapping.get(getReferenceName(field.getMessageType()));	1✔
127	return createProtoBuf(	1✔
128	fieldTypeDescriptor, builder.newBuilderForField(field), (Map<String, Object>) value);	1✔
129	}
130
131	if (field.getType() == FieldDescriptor.Type.ENUM) {	1✔
132	EnumDescriptor enumDescriptor =	×
133	enumMapping.get(ProtoToGql.getReferenceName(field.getEnumType()));	×
134	return enumDescriptor.findValueByName(value.toString());	×
135	}
136
137	return value;	1✔
138	}
139
140	static GraphQLArgument createArgument(Descriptor descriptor, String name) {
141	return GraphQLArgument.newArgument().name(name).type(getInputTypeReference(descriptor)).build();	1✔
142	}
143
144	static String getReferenceName(GenericDescriptor descriptor) {
145	return "Input_" + ProtoToGql.getReferenceName(descriptor);	1✔
146	}
147
148	/** Field names with under_scores are converted to camelCase. */
149	private String getFieldName(FieldDescriptor field) {
150	String fieldName = field.getName();	1✔
151	return fieldName.contains("_") ? UNDERSCORE_TO_CAMEL.convert(fieldName) : fieldName;	1✔
152	}
153
154	private GraphQLType getFieldType(FieldDescriptor field) {
155	if (field.getType() == FieldDescriptor.Type.MESSAGE	1✔
156	\|\| field.getType() == FieldDescriptor.Type.GROUP) {	1✔
157	return new GraphQLTypeReference(getReferenceName(field.getMessageType()));	1✔
158	}
159	if (field.getType() == FieldDescriptor.Type.ENUM) {	1✔
160	return new GraphQLTypeReference(ProtoToGql.getReferenceName(field.getEnumType()));	1✔
161	}
162	GraphQLType type = ProtoToGql.convertType(field);	1✔
163	if (type instanceof GraphQLList) {	1✔
164	return ((GraphQLList) type).getWrappedType();	1✔
165	}
166	return type;	1✔
167	}
168
169	private static GraphQLInputType getInputTypeReference(Descriptor descriptor) {
170	return new GraphQLTypeReference(getReferenceName(descriptor));	1✔
171	}
172
173	private static final GraphQLInputObjectField STATIC_FIELD =	1✔
174	GraphQLInputObjectField.newInputObjectField()	1✔
175	.type(GraphQLString)	1✔
176	.name("_")	1✔
177	.defaultValue("")	1✔
178	.description("NOT USED")	1✔
179	.build();	1✔
180
181	// Based on ProtoRegistry.Builder, but builds a map of descriptors rather than types.
182
183	/** Builder for GqlInputConverter. */
184	static class Builder {	1✔
185	private final ArrayList<FileDescriptor> fileDescriptors = new ArrayList<>();	1✔
186	private final ArrayList<Descriptor> descriptors = new ArrayList<>();	1✔
187	private final ArrayList<EnumDescriptor> enumDescriptors = new ArrayList<>();	1✔
188
189	Builder add(FileDescriptor fileDescriptor) {
190	fileDescriptors.add(fileDescriptor);	1✔
191	return this;	1✔
192	}
193
194	GqlInputConverter build() {
195	HashBiMap<String, Descriptor> mapping = HashBiMap.create();	1✔
196	HashBiMap<String, EnumDescriptor> enumMapping = HashBiMap.create(getEnumMap(enumDescriptors));	1✔
197	LinkedList<Descriptor> loop = new LinkedList<>(descriptors);	1✔
198
199	Set<FileDescriptor> fileDescriptorSet = ProtoRegistry.extractDependencies(fileDescriptors);	1✔
200
201	for (FileDescriptor fileDescriptor : fileDescriptorSet) {	1✔
202	loop.addAll(fileDescriptor.getMessageTypes());	1✔
203	enumMapping.putAll(getEnumMap(fileDescriptor.getEnumTypes()));	1✔
204	}	1✔
205
206	while (!loop.isEmpty()) {	1✔
207	Descriptor descriptor = loop.pop();	1✔
208	if (!mapping.containsKey(descriptor.getFullName())) {	1✔
209	mapping.put(getReferenceName(descriptor), descriptor);	1✔
210	loop.addAll(descriptor.getNestedTypes());	1✔
211	enumMapping.putAll(getEnumMap(descriptor.getEnumTypes()));	1✔
212	}
213	}	1✔
214
215	return new GqlInputConverter(	1✔
216	ImmutableBiMap.copyOf(mapping), ImmutableBiMap.copyOf(enumMapping));	1✔
217	}
218
219	private static BiMap<String, EnumDescriptor> getEnumMap(Iterable<EnumDescriptor> descriptors) {
220	HashBiMap<String, EnumDescriptor> mapping = HashBiMap.create();	1✔
221	for (EnumDescriptor enumDescriptor : descriptors) {	1✔
222	mapping.put(ProtoToGql.getReferenceName(enumDescriptor), enumDescriptor);	1✔
223	}	1✔
224	return mapping;	1✔
225	}
226	}
227	}

google / rejoiner / 102

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous