Skip to content

Commit 4015f0d

Browse files
committed
1764: Add tests for field and arguments check
1 parent 465e4a9 commit 4015f0d

2 files changed

Lines changed: 262 additions & 57 deletions

File tree

‎src/main/java/graphql/schema/idl/ImplementingTypesChecker.java‎

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -32,14 +32,14 @@
3232
import java.util.Set;
3333
import java.util.function.BinaryOperator;
3434
import java.util.function.Function;
35-
import java.util.stream.Collectors;
3635
import java.util.stream.Stream;
3736

3837
import static java.util.Collections.emptyList;
38+
import static java.util.stream.Collectors.toMap;
3939
import static java.util.stream.Collectors.toSet;
4040

4141
/**
42-
* A support class to help break up the large SchemaTypeChecker class. This handles
42+
* A support class to help break up the large SchemaTypeChecker class. This handles
4343
* the checking of {@link graphql.language.ImplementingTypeDefinition}s.
4444
*/
4545
@Internal
@@ -53,42 +53,50 @@ class ImplementingTypesChecker {
5353
TYPE_OF_MAP.put(InterfaceTypeExtensionDefinition.class, "interface extension");
5454
}
5555

56+
/*
57+
* "Implementing types" (i.e.: types that might implement interfaces) have the potential to be invalid if incorrectly defined.
58+
*
59+
* The same interface might not be implemented more than once by a type and its extensions
60+
* The implementing type must implement all the transitive interfaces
61+
* An interface implementation must not result in a circular reference (i.e.: an interface implementing itself)
62+
* All fields declared by an interface have to be correctly declared by its implementing type, including the proper field arguments
63+
*/
5664
void checkImplementingTypes(List<GraphQLError> errors, TypeDefinitionRegistry typeRegistry) {
57-
final List<InterfaceTypeDefinition> interfaces = typeRegistry.getTypes(InterfaceTypeDefinition.class);
58-
final List<ObjectTypeDefinition> objects = typeRegistry.getTypes(ObjectTypeDefinition.class);
65+
List<InterfaceTypeDefinition> interfaces = typeRegistry.getTypes(InterfaceTypeDefinition.class);
66+
List<ObjectTypeDefinition> objects = typeRegistry.getTypes(ObjectTypeDefinition.class);
5967

60-
Stream.of(
61-
interfaces.stream(),
62-
objects.stream()
63-
)
68+
Stream.of(interfaces.stream(), objects.stream())
6469
.flatMap(Function.identity())
65-
.forEach(type -> checkImplementingType(TYPE_OF_MAP.get(type.getClass()), errors, typeRegistry, type));
66-
70+
.forEach(type -> checkImplementingType(errors, typeRegistry, type));
6771
}
6872

6973
private void checkImplementingType(
70-
String typeOfType,
7174
List<GraphQLError> errors,
7275
TypeDefinitionRegistry typeRegistry,
7376
ImplementingTypeDefinition type) {
7477

7578
Map<InterfaceTypeDefinition, ImplementingTypeDefinition> implementedInterfaces =
7679
checkInterfacesNotImplementedMoreThanOnce(errors, type, typeRegistry);
7780

78-
checkInterfaceIsImplemented(typeOfType, typeRegistry, errors, type, implementedInterfaces);
81+
checkInterfaceIsImplemented(errors, typeRegistry, type, implementedInterfaces);
7982

80-
checkAncestorImplementation(typeOfType, errors, typeRegistry, type, implementedInterfaces);
83+
checkAncestorImplementation(errors, typeRegistry, type, implementedInterfaces);
8184
}
8285

83-
private Map<InterfaceTypeDefinition, ImplementingTypeDefinition> checkInterfacesNotImplementedMoreThanOnce(List<GraphQLError> errors, ImplementingTypeDefinition type, TypeDefinitionRegistry typeRegistry) {
84-
Map<InterfaceTypeDefinition, List<ImplementingTypeDefinition>> implementedInterfaces = getLogicallyImplementedInterfaces(type, typeRegistry);
86+
private Map<InterfaceTypeDefinition, ImplementingTypeDefinition> checkInterfacesNotImplementedMoreThanOnce(
87+
List<GraphQLError> errors,
88+
ImplementingTypeDefinition type,
89+
TypeDefinitionRegistry typeRegistry
90+
) {
91+
Map<InterfaceTypeDefinition, List<ImplementingTypeDefinition>> implementedInterfaces =
92+
getLogicallyImplementedInterfaces(type, typeRegistry);
8593

8694
Map<InterfaceTypeDefinition, ImplementingTypeDefinition> interfacesImplementedOnce = implementedInterfaces.entrySet()
8795
.stream()
8896
.filter(entry -> entry.getValue().size() == 1)
89-
.collect(Collectors.toMap(
97+
.collect(toMap(
9098
Map.Entry::getKey,
91-
e -> e.getValue().get(0)
99+
entry -> entry.getValue().get(0)
92100
));
93101

94102
implementedInterfaces.entrySet().stream()
@@ -103,69 +111,59 @@ private Map<InterfaceTypeDefinition, ImplementingTypeDefinition> checkInterfaces
103111
}
104112

105113
private void checkAncestorImplementation(
106-
String typeOfType,
107114
List<GraphQLError> errors,
108115
TypeDefinitionRegistry typeRegistry,
109116
ImplementingTypeDefinition type,
110117
Map<InterfaceTypeDefinition, ImplementingTypeDefinition> implementedInterfaces) {
111118

112119
if (implementedInterfaces.containsKey(type)) {
113-
errors.add(new InterfaceImplementingItselfError(typeOfType, type));
120+
errors.add(new InterfaceImplementingItselfError(TYPE_OF_MAP.get(type.getClass()), type));
114121
return;
115122
}
116123

117-
implementedInterfaces.keySet().forEach(implementedInterface -> {
124+
implementedInterfaces.forEach((implementedInterface, implementingType) -> {
118125
Set<InterfaceTypeDefinition> transitiveInterfaces = getLogicallyImplementedInterfaces(implementedInterface, typeRegistry).keySet();
119126

120127
transitiveInterfaces.forEach(transitiveInterface -> {
121128
if (transitiveInterface.equals(type)) {
122-
errors.add(new InterfaceWithCircularImplementationHierarchyError(typeOfType, type, implementedInterface));
129+
errors.add(new InterfaceWithCircularImplementationHierarchyError(TYPE_OF_MAP.get(type.getClass()), type, implementedInterface));
123130
} else if (!implementedInterfaces.containsKey(transitiveInterface)) {
124-
ImplementingTypeDefinition offendingType = implementedInterfaces.get(implementedInterface);
125-
126-
errors.add(new MissingTransitiveInterfaceError(TYPE_OF_MAP.get(offendingType.getClass()), offendingType, implementedInterface, transitiveInterface));
131+
errors.add(new MissingTransitiveInterfaceError(TYPE_OF_MAP.get(implementingType.getClass()), implementingType, implementedInterface, transitiveInterface));
127132
}
128133
});
129134
});
130135
}
131136

132137
private void checkInterfaceIsImplemented(
133-
String typeOfType,
134-
TypeDefinitionRegistry typeRegistry,
135138
List<GraphQLError> errors,
139+
TypeDefinitionRegistry typeRegistry,
136140
ImplementingTypeDefinition type,
137141
Map<InterfaceTypeDefinition, ImplementingTypeDefinition> implementedInterfaces
138142
) {
139-
implementedInterfaces.entrySet().forEach(entry -> {
140-
InterfaceTypeDefinition implementedInterface = entry.getKey();
141-
142-
Set<FieldDefinition> fieldDefinitions = getLogicallyDeclaredFields(type, typeRegistry);
143+
Set<FieldDefinition> fieldDefinitions = getLogicallyDeclaredFields(type, typeRegistry);
143144

144-
Map<String, FieldDefinition> objectFields = fieldDefinitions.stream()
145-
.collect(Collectors.toMap(
146-
FieldDefinition::getName, Function.identity(), mergeFirstValue()
147-
));
145+
Map<String, FieldDefinition> typeFields = fieldDefinitions.stream()
146+
.collect(toMap(FieldDefinition::getName, Function.identity(), mergeFirstValue()));
148147

148+
implementedInterfaces.forEach((implementedInterface, implementingType) -> {
149149
implementedInterface.getFieldDefinitions().forEach(interfaceFieldDef -> {
150-
FieldDefinition objectFieldDef = objectFields.get(interfaceFieldDef.getName());
151-
if (objectFieldDef == null) {
152-
ImplementingTypeDefinition offendingType = entry.getValue();
153-
errors.add(new MissingInterfaceFieldError(TYPE_OF_MAP.get(offendingType.getClass()), offendingType, implementedInterface, interfaceFieldDef));
150+
FieldDefinition typeFieldDef = typeFields.get(interfaceFieldDef.getName());
151+
if (typeFieldDef == null) {
152+
errors.add(new MissingInterfaceFieldError(TYPE_OF_MAP.get(implementingType.getClass()), implementingType, implementedInterface, interfaceFieldDef));
154153
} else {
155-
if (!typeRegistry.isSubTypeOf(objectFieldDef.getType(), interfaceFieldDef.getType())) {
154+
if (!typeRegistry.isSubTypeOf(typeFieldDef.getType(), interfaceFieldDef.getType())) {
156155
String interfaceFieldType = AstPrinter.printAst(interfaceFieldDef.getType());
157-
String objectFieldType = AstPrinter.printAst(objectFieldDef.getType());
158-
ImplementingTypeDefinition offendingType = entry.getValue();
159-
// errors.add(new InterfaceFieldRedefinitionError(TYPE_OF_MAP.get(offendingType.getClass()), offendingType, implementedInterface, objectFieldDef, objectFieldType, interfaceFieldType));
156+
String objectFieldType = AstPrinter.printAst(typeFieldDef.getType());
157+
errors.add(new InterfaceFieldRedefinitionError(TYPE_OF_MAP.get(implementingType.getClass()), implementingType, implementedInterface, typeFieldDef, objectFieldType, interfaceFieldType));
160158
}
161159

162160
// look at arguments
163-
List<InputValueDefinition> objectArgs = objectFieldDef.getInputValueDefinitions();
161+
List<InputValueDefinition> objectArgs = typeFieldDef.getInputValueDefinitions();
164162
List<InputValueDefinition> interfaceArgs = interfaceFieldDef.getInputValueDefinitions();
165163
if (objectArgs.size() < interfaceArgs.size()) {
166-
// errors.add(new MissingInterfaceFieldArgumentsError(typeOfType, type, implementedInterface, objectFieldDef));
164+
errors.add(new MissingInterfaceFieldArgumentsError(TYPE_OF_MAP.get(implementingType.getClass()), implementingType, implementedInterface, typeFieldDef));
167165
} else {
168-
checkArgumentConsistency(typeOfType, type, implementedInterface, objectFieldDef, interfaceFieldDef, errors);
166+
checkArgumentConsistency(TYPE_OF_MAP.get(implementingType.getClass()), implementingType, implementedInterface, typeFieldDef, interfaceFieldDef, errors);
169167
}
170168
}
171169
});
@@ -188,7 +186,7 @@ private void checkArgumentConsistency(
188186
String interfaceArgStr = AstPrinter.printAstCompact(interfaceArg);
189187
String objectArgStr = AstPrinter.printAstCompact(objectArg);
190188
if (!interfaceArgStr.equals(objectArgStr)) {
191-
// errors.add(new InterfaceFieldArgumentRedefinitionError(typeOfType, objectTypeDef, interfaceTypeDef, objectFieldDef, objectArgStr, interfaceArgStr));
189+
errors.add(new InterfaceFieldArgumentRedefinitionError(typeOfType, objectTypeDef, interfaceTypeDef, objectFieldDef, objectArgStr, interfaceArgStr));
192190
}
193191
}
194192

@@ -197,7 +195,7 @@ private void checkArgumentConsistency(
197195
InputValueDefinition objectArg = objectArgs.get(i);
198196
if (objectArg.getType() instanceof NonNullType) {
199197
String objectArgStr = AstPrinter.printAst(objectArg);
200-
// errors.add(new InterfaceFieldArgumentNotOptionalError(typeOfType, objectTypeDef, interfaceTypeDef, objectFieldDef, objectArgStr));
198+
errors.add(new InterfaceFieldArgumentNotOptionalError(typeOfType, objectTypeDef, interfaceTypeDef, objectFieldDef, objectArgStr));
201199
}
202200
}
203201
}
@@ -230,16 +228,18 @@ private Set<FieldDefinition> getLogicallyDeclaredFields(
230228
ImplementingTypeDefinition type,
231229
TypeDefinitionRegistry typeRegistry
232230
) {
233-
final Stream<FieldDefinition> directFields = type.getFieldDefinitions().stream();
234231

235-
final Stream<FieldDefinition> extensionFields = Stream.<ImplementingTypeDefinition>concat(
232+
Stream<ImplementingTypeDefinition> extensions = Stream.concat(
236233
typeRegistry.interfaceTypeExtensions().getOrDefault(type.getName(), emptyList()).stream(),
237234
typeRegistry.objectTypeExtensions().getOrDefault(type.getName(), emptyList()).stream()
238-
)
239-
.map(ImplementingTypeDefinition::getFieldDefinitions)
240-
.flatMap(Collection::stream);
235+
);
241236

242-
return Stream.concat(directFields, extensionFields).collect(toSet());
237+
return Stream.concat(Stream.of(type), extensions)
238+
.flatMap(implementingType -> {
239+
List<FieldDefinition> fieldDefinitions = implementingType.getFieldDefinitions();
240+
return fieldDefinitions.stream();
241+
})
242+
.collect(toSet());
243243
}
244244

245245
private <T> BinaryOperator<T> mergeFirstValue() {

0 commit comments

Comments
 (0)