|
| 1 | +package graphql.schema |
| 2 | + |
| 3 | +import graphql.schema.idl.SchemaParser |
| 4 | +import graphql.schema.idl.UnExecutableSchemaGenerator |
| 5 | +import graphql.util.TraverserContext |
| 6 | +import spock.lang.Specification |
| 7 | + |
| 8 | +import static graphql.util.TreeTransformerUtil.changeNode |
| 9 | + |
| 10 | +class AstDefinitionPreservationTest extends Specification { |
| 11 | + |
| 12 | + def "copies retain AST metadata for #original.class.simpleName"() { |
| 13 | + given: |
| 14 | + def copies = [ |
| 15 | + original.transform { }, |
| 16 | + original.copy(), |
| 17 | + copyBuilder(original).build(), |
| 18 | + original.withNewChildren(original.childrenWithTypeReferences) |
| 19 | + ] |
| 20 | + |
| 21 | + expect: |
| 22 | + original.definition != null |
| 23 | + copies.each { copied -> assertAstPreserved(original, copied) } |
| 24 | + |
| 25 | + where: |
| 26 | + [original, copyBuilder] << schemaElements() |
| 27 | + } |
| 28 | + |
| 29 | + def "definitions can be explicitly cleared for #original.class.simpleName"() { |
| 30 | + when: |
| 31 | + def cleared = original.transform { it.definition(null) } |
| 32 | + |
| 33 | + then: |
| 34 | + cleared.definition == null |
| 35 | + cleared.copy().definition == null |
| 36 | + original.definition != null |
| 37 | + |
| 38 | + where: |
| 39 | + [original, copyBuilder] << schemaElements() |
| 40 | + } |
| 41 | + |
| 42 | + def "renaming a runtime element retains the original source AST"() { |
| 43 | + given: |
| 44 | + def original = schema().queryType |
| 45 | + |
| 46 | + when: |
| 47 | + def renamed = original.transform { it.name('RenamedQuery') } |
| 48 | + |
| 49 | + then: |
| 50 | + renamed.name == 'RenamedQuery' |
| 51 | + renamed.definition.name == 'Query' |
| 52 | + assertAstPreserved(original, renamed) |
| 53 | + } |
| 54 | + |
| 55 | + def "schema copies retain their definition and extension ASTs - #operation"() { |
| 56 | + given: |
| 57 | + def original = schema() |
| 58 | + |
| 59 | + when: |
| 60 | + def copied = copySchema(original) |
| 61 | + |
| 62 | + then: |
| 63 | + !copied.is(original) |
| 64 | + original.definition != null |
| 65 | + original.extensionDefinitions.size() == 1 |
| 66 | + copied.definition.is(original.definition) |
| 67 | + copied.extensionDefinitions[0].is(original.extensionDefinitions[0]) |
| 68 | + |
| 69 | + where: |
| 70 | + operation | copySchema |
| 71 | + 'transform' | { it.transform { } } |
| 72 | + 'copy builder' | { GraphQLSchema.newSchema(it).build() } |
| 73 | + 'transformWithoutTypes' | { it.transformWithoutTypes { } } |
| 74 | + } |
| 75 | + |
| 76 | + def "schema AST metadata can be explicitly cleared"() { |
| 77 | + given: |
| 78 | + def original = schema() |
| 79 | + |
| 80 | + when: |
| 81 | + def cleared = original.transform { it.definition(null).extensionDefinitions([]) } |
| 82 | + |
| 83 | + then: |
| 84 | + cleared.definition == null |
| 85 | + cleared.extensionDefinitions.empty |
| 86 | + original.definition != null |
| 87 | + original.extensionDefinitions.size() == 1 |
| 88 | + } |
| 89 | + |
| 90 | + def "schema transformation retains ASTs when rebuilding ancestors - with deletes #withDeletes"() { |
| 91 | + given: |
| 92 | + def original = schema() |
| 93 | + def visitor = [visitGraphQLAppliedDirectiveArgument: { |
| 94 | + GraphQLAppliedDirectiveArgument argument, TraverserContext<GraphQLSchemaElement> context -> |
| 95 | + changeNode(context, argument.transform { it.valueProgrammatic('changed') }) |
| 96 | + }] as GraphQLTypeVisitorStub |
| 97 | + |
| 98 | + when: |
| 99 | + def transformed = withDeletes |
| 100 | + ? SchemaTransformer.transformSchemaWithDeletes(original, visitor) |
| 101 | + : SchemaTransformer.transformSchema(original, visitor) |
| 102 | + |
| 103 | + then: |
| 104 | + !transformed.is(original) |
| 105 | + transformed.definition.is(original.definition) |
| 106 | + transformed.extensionDefinitions[0].is(original.extensionDefinitions[0]) |
| 107 | + assertAstPreserved(original.queryType, transformed.queryType) |
| 108 | + assertAstPreserved(original.getType('Color'), transformed.getType('Color')) |
| 109 | + assertAstPreserved(original.getType('Color').getValue('RED'), transformed.getType('Color').getValue('RED')) |
| 110 | + assertAppliedAstPreserved(original.queryType, transformed.queryType) |
| 111 | + assertAppliedAstPreserved(original.getType('Color').getValue('RED'), transformed.getType('Color').getValue('RED')) |
| 112 | + |
| 113 | + where: |
| 114 | + withDeletes << [false, true] |
| 115 | + } |
| 116 | + |
| 117 | + def "schema transformation without changes retains the original schema - with deletes #withDeletes"() { |
| 118 | + given: |
| 119 | + def original = schema() |
| 120 | + def visitor = new GraphQLTypeVisitorStub() |
| 121 | + |
| 122 | + expect: |
| 123 | + def transformed = withDeletes |
| 124 | + ? SchemaTransformer.transformSchemaWithDeletes(original, visitor) |
| 125 | + : SchemaTransformer.transformSchema(original, visitor) |
| 126 | + transformed.is(original) |
| 127 | + |
| 128 | + where: |
| 129 | + withDeletes << [false, true] |
| 130 | + } |
| 131 | + |
| 132 | + private static void assertAstPreserved(GraphQLNamedSchemaElement original, GraphQLNamedSchemaElement copied) { |
| 133 | + assert !copied.is(original) |
| 134 | + assert original.definition != null |
| 135 | + assert copied.definition.is(original.definition) |
| 136 | + if (original.metaClass.respondsTo(original, 'getExtensionDefinitions')) { |
| 137 | + assert original.extensionDefinitions.size() == 1 |
| 138 | + assert copied.extensionDefinitions.size() == 1 |
| 139 | + assert copied.extensionDefinitions[0].is(original.extensionDefinitions[0]) |
| 140 | + } |
| 141 | + } |
| 142 | + |
| 143 | + private static void assertAppliedAstPreserved(GraphQLDirectiveContainer original, GraphQLDirectiveContainer copied) { |
| 144 | + def directive = original.getAppliedDirective('tag') |
| 145 | + def copiedDirective = copied.getAppliedDirective('tag') |
| 146 | + assertAstPreserved(directive, copiedDirective) |
| 147 | + assertAstPreserved(directive.getArgument('arg'), copiedDirective.getArgument('arg')) |
| 148 | + assert copiedDirective.getArgument('arg').value == 'changed' |
| 149 | + } |
| 150 | + |
| 151 | + private static List<List> schemaElements() { |
| 152 | + def original = schema() |
| 153 | + def field = original.queryType.getFieldDefinition('field') |
| 154 | + def applied = original.queryType.getAppliedDirective('tag') |
| 155 | + return [ |
| 156 | + [original.queryType, { GraphQLObjectType.newObject(it) }], |
| 157 | + [original.getType('Node'), { GraphQLInterfaceType.newInterface(it) }], |
| 158 | + [original.getType('Choice'), { GraphQLUnionType.newUnionType(it) }], |
| 159 | + [original.getType('Color'), { GraphQLEnumType.newEnum(it) }], |
| 160 | + [original.getType('Custom'), { GraphQLScalarType.newScalar(it) }], |
| 161 | + [original.getType('Filter'), { GraphQLInputObjectType.newInputObject(it) }], |
| 162 | + [original.getDirective('tag'), { GraphQLDirective.newDirective(it) }], |
| 163 | + [field, { GraphQLFieldDefinition.newFieldDefinition(it) }], |
| 164 | + [field.getArgument('arg'), { GraphQLArgument.newArgument(it) }], |
| 165 | + [original.getType('Filter').getField('value'), { GraphQLInputObjectField.newInputObjectField(it) }], |
| 166 | + [original.getType('Color').getValue('RED'), { GraphQLEnumValueDefinition.newEnumValueDefinition(it) }], |
| 167 | + [applied, { GraphQLAppliedDirective.newDirective(it) }], |
| 168 | + [applied.getArgument('arg'), { GraphQLAppliedDirectiveArgument.newArgument(it) }] |
| 169 | + ] |
| 170 | + } |
| 171 | + |
| 172 | + private static GraphQLSchema schema() { |
| 173 | + def registry = new SchemaParser().parse(''' |
| 174 | + directive @meta repeatable on DIRECTIVE_DEFINITION |
| 175 | + directive @tag(arg: String) @meta repeatable on SCHEMA | OBJECT | ENUM_VALUE |
| 176 | + extend directive @tag @meta |
| 177 | + schema @tag(arg: "schema") { query: Query } |
| 178 | + extend schema @tag(arg: "extension") |
| 179 | + type Query implements Node @tag(arg: "query") { |
| 180 | + id: ID! |
| 181 | + extra: String |
| 182 | + field(arg: Filter): Color |
| 183 | + choice: Choice |
| 184 | + custom: Custom |
| 185 | + } |
| 186 | + extend type Query { more: String } |
| 187 | + interface Node { id: ID! } |
| 188 | + extend interface Node { extra: String } |
| 189 | + type Other { other: String } |
| 190 | + union Choice = Query |
| 191 | + extend union Choice = Other |
| 192 | + scalar Custom |
| 193 | + extend scalar Custom @specifiedBy(url: "https://example.com/custom") |
| 194 | + enum Color { RED @tag(arg: "red") } |
| 195 | + extend enum Color { BLUE } |
| 196 | + input Filter { value: String } |
| 197 | + extend input Filter { other: String } |
| 198 | + ''') |
| 199 | + return UnExecutableSchemaGenerator.makeUnExecutableSchema(registry) |
| 200 | + } |
| 201 | +} |
0 commit comments