Skip to content

Commit 87f7128

Browse files
committed
Rename query complexity factory to newLimitsWithDefaults
1 parent 750405a commit 87f7128

11 files changed

Lines changed: 74 additions & 74 deletions

‎src/jmh/java/benchmark/FragmentExpansionValidationBenchmark.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ public void setup() {
6464
if ("default".equals(occurrences)) {
6565
occurrenceLimit = QueryComplexityLimits.DEFAULT_MAX_FIELD_OCCURRENCES;
6666
}
67-
complexityLimits = QueryComplexityLimits.newLimits().maxDepth(100).maxMergedFieldCount(10_000)
67+
complexityLimits = QueryComplexityLimits.newLimitsWithDefaults().maxDepth(100).maxMergedFieldCount(10_000)
6868
.maxFieldOccurrences(occurrenceLimit).build();
6969
verifyFixture(query);
7070
verifyMergedFieldCount();
@@ -121,10 +121,10 @@ private int countGrammarTokens(String query) {
121121
}
122122

123123
private void verifyMergedFieldCount() {
124-
QueryComplexityLimits twoFields = QueryComplexityLimits.newLimits().maxMergedFieldCount(2).maxDepth(2)
124+
QueryComplexityLimits twoFields = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(2).maxDepth(2)
125125
.maxFieldOccurrences(Integer.MAX_VALUE).build();
126126
assertTrue(new Validator().validateDocument(schema, document, rule -> true, Locale.ENGLISH, twoFields).isEmpty());
127-
QueryComplexityLimits oneField = QueryComplexityLimits.newLimits().maxMergedFieldCount(1).maxDepth(2)
127+
QueryComplexityLimits oneField = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(1).maxDepth(2)
128128
.maxFieldOccurrences(Integer.MAX_VALUE).build();
129129
List<ValidationError> errors = new Validator().validateDocument(schema, document, rule -> true, Locale.ENGLISH, oneField);
130130
assertTrue(errors.size() == 1 && errors.get(0).getValidationErrorType() == ValidationErrorType.MaxQueryMergedFieldCountExceeded);

‎src/jmh/java/benchmark/GeneralQueryComplexityBenchmark.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -68,11 +68,11 @@ private QueryComplexityLimits configuredLimits() {
6868
return QueryComplexityLimits.NONE;
6969
}
7070
if ("withoutOccurrences".equals(limits)) {
71-
return QueryComplexityLimits.newLimits().maxDepth(100).maxMergedFieldCount(10_000)
71+
return QueryComplexityLimits.newLimitsWithDefaults().maxDepth(100).maxMergedFieldCount(10_000)
7272
.maxFieldOccurrences(Integer.MAX_VALUE).build();
7373
}
7474
if ("highOccurrences".equals(limits)) {
75-
return QueryComplexityLimits.newLimits().maxDepth(100).maxMergedFieldCount(10_000)
75+
return QueryComplexityLimits.newLimitsWithDefaults().maxDepth(100).maxMergedFieldCount(10_000)
7676
.maxFieldOccurrences(Integer.MAX_VALUE - 1).build();
7777
}
7878
return QueryComplexityLimits.DEFAULT;

‎src/main/java/graphql/introspection/GoodFaithIntrospection.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -106,7 +106,7 @@ public static boolean isEnabled(GraphQLContext graphQLContext) {
106106
public static QueryComplexityLimits goodFaithLimits(QueryComplexityLimits existing) {
107107
int maxMergedFieldCount = Math.min(existing.getMaxMergedFieldCount(), GOOD_FAITH_MAX_MERGED_FIELD_COUNT);
108108
int maxDepth = Math.min(existing.getMaxDepth(), GOOD_FAITH_MAX_DEPTH_COUNT);
109-
return QueryComplexityLimits.newLimits()
109+
return QueryComplexityLimits.newLimitsWithDefaults()
110110
.maxMergedFieldCount(maxMergedFieldCount)
111111
.maxDepth(maxDepth)
112112
.maxFieldOccurrences(existing.getMaxFieldOccurrences())

‎src/main/java/graphql/validation/QueryComplexityLimits.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@
3535
* to disable all general complexity limits.
3636
* To customize limits per-request, put a custom instance in the GraphQLContext:
3737
* <pre>{@code
38-
* QueryComplexityLimits limits = QueryComplexityLimits.newLimits()
38+
* QueryComplexityLimits limits = QueryComplexityLimits.newLimitsWithDefaults()
3939
* .maxDepth(10)
4040
* .maxMergedFieldCount(100)
4141
* .maxFieldOccurrences(100_000)
@@ -152,7 +152,7 @@ public int getMaxFieldOccurrences() {
152152
*
153153
* @return a new builder initialized with the current JVM-wide defaults
154154
*/
155-
public static Builder newLimits() {
155+
public static Builder newLimitsWithDefaults() {
156156
return new Builder(getDefaultLimits());
157157
}
158158

‎src/test/groovy/graphql/introspection/GoodFaithIntrospectionTest.groovy‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -290,7 +290,7 @@ class GoodFaithIntrospectionTest extends Specification {
290290

291291
def "good faith limits are applied on top of custom user limits"() {
292292
given:
293-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(200).maxDepth(15).build()
293+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(200).maxDepth(15).build()
294294
def executionInput = ExecutionInput.newExecutionInput(IntrospectionQuery.INTROSPECTION_QUERY)
295295
.graphQLContext([(QueryComplexityLimits.KEY): limits])
296296
.build()

‎src/test/groovy/graphql/introspection/GoodFaithMergedFieldsTest.groovy‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -199,7 +199,7 @@ class GoodFaithMergedFieldsTest extends Specification {
199199
def "general limits use merged fields for introspection too"() {
200200
given:
201201
def graphQL = GraphQL.newGraphQL(schema).build()
202-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(limit).build()
202+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(limit).build()
203203
def input = ExecutionInput.newExecutionInput('{ __schema { types { name name name name } } }')
204204
.graphQLContext([(QueryComplexityLimits.KEY): limits]).build()
205205

@@ -218,7 +218,7 @@ class GoodFaithMergedFieldsTest extends Specification {
218218
def "a tighter generic depth limit still applies to introspection"() {
219219
given:
220220
def graphQL = GraphQL.newGraphQL(schema).build()
221-
def limits = QueryComplexityLimits.newLimits().maxDepth(2).build()
221+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxDepth(2).build()
222222
def input = ExecutionInput.newExecutionInput('{ __type(name: "Query") { ofType { name } } }')
223223
.graphQLContext([(QueryComplexityLimits.KEY): limits]).build()
224224

@@ -352,7 +352,7 @@ class GoodFaithMergedFieldsTest extends Specification {
352352

353353
def "public limit helper preserves tighter caller limits"() {
354354
given:
355-
def requested = QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFieldCount).maxDepth(depth).maxFieldOccurrences(1234).build()
355+
def requested = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFieldCount).maxDepth(depth).maxFieldOccurrences(1234).build()
356356

357357
when:
358358
def bounded = GoodFaithIntrospection.goodFaithLimits(requested)

‎src/test/groovy/graphql/validation/FieldOccurrencesTest.groovy‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,8 @@ class FieldOccurrencesTest extends Specification {
5151
[ValidationErrorType.MaxQueryFieldOccurrencesExceeded]
5252

5353
where:
54-
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimits().build(),
55-
QueryComplexityLimits.newLimits().maxDepth(50).build()]
54+
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimitsWithDefaults().build(),
55+
QueryComplexityLimits.newLimitsWithDefaults().maxDepth(50).build()]
5656
}
5757

5858
def "default merged limit accepts 10000 and rejects 10001"() {
@@ -67,8 +67,8 @@ class FieldOccurrencesTest extends Specification {
6767
[ValidationErrorType.MaxQueryMergedFieldCountExceeded]
6868

6969
where:
70-
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimits().build(),
71-
QueryComplexityLimits.newLimits().maxDepth(50).build()]
70+
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimitsWithDefaults().build(),
71+
QueryComplexityLimits.newLimitsWithDefaults().maxDepth(50).build()]
7272
}
7373

7474
def "default depth limit remains enabled when other limits are customized"() {
@@ -81,9 +81,9 @@ class FieldOccurrencesTest extends Specification {
8181
validateWithLimits(above, limits)*.validationErrorType == [ValidationErrorType.MaxQueryDepthExceeded]
8282

8383
where:
84-
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimits().build(),
85-
QueryComplexityLimits.newLimits().maxMergedFieldCount(50_000).build(),
86-
QueryComplexityLimits.newLimits().maxFieldOccurrences(200_000).build()]
84+
limits << [QueryComplexityLimits.DEFAULT, QueryComplexityLimits.newLimitsWithDefaults().build(),
85+
QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(50_000).build(),
86+
QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(200_000).build()]
8787
}
8888

8989
def "cached fragment totals and running totals are independent across operations"() {
@@ -124,16 +124,16 @@ class FieldOccurrencesTest extends Specification {
124124

125125
expect:
126126
new Validator().validateDocument(abstractSchema, document, { rule -> true }, Locale.ENGLISH,
127-
QueryComplexityLimits.newLimits().maxFieldOccurrences(6).build()).empty
127+
QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(6).build()).empty
128128
new Validator().validateDocument(abstractSchema, document, { rule -> true }, Locale.ENGLISH,
129-
QueryComplexityLimits.newLimits().maxFieldOccurrences(5).build())*.validationErrorType ==
129+
QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(5).build())*.validationErrorType ==
130130
[ValidationErrorType.MaxQueryFieldOccurrencesExceeded]
131131
}
132132

133133
def "fragment occurrence accounting also works when every validation rule is disabled"() {
134134
given:
135135
def document = Parser.parse('{ node { ...F ...F } } fragment F on Node { name name }')
136-
def limits = QueryComplexityLimits.newLimits().maxFieldOccurrences(4).build()
136+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(4).build()
137137

138138
expect:
139139
new Validator().validateDocument(schema, document, { rule -> false }, Locale.ENGLISH, limits)*.validationErrorType ==
@@ -142,7 +142,7 @@ class FieldOccurrencesTest extends Specification {
142142

143143
def "occurrence limits are independent of validation rule selection"() {
144144
given:
145-
def limits = QueryComplexityLimits.newLimits().maxFieldOccurrences(2).build()
145+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(2).build()
146146
def document = Parser.parse('{ node { name name } }')
147147

148148
expect:
@@ -168,9 +168,9 @@ class FieldOccurrencesTest extends Specification {
168168
def "the exact benchmark document is rejected by default and can disable only occurrence counting"() {
169169
given:
170170
def query = doublingFragments(25)
171-
def mergedOnly = QueryComplexityLimits.newLimits().maxMergedFieldCount(2).maxDepth(2)
171+
def mergedOnly = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(2).maxDepth(2)
172172
.maxFieldOccurrences(Integer.MAX_VALUE).build()
173-
def occurrenceOnly = QueryComplexityLimits.newLimits().maxMergedFieldCount(Integer.MAX_VALUE)
173+
def occurrenceOnly = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(Integer.MAX_VALUE)
174174
.maxDepth(Integer.MAX_VALUE).maxFieldOccurrences(100_000).build()
175175

176176
expect:
@@ -200,8 +200,8 @@ class FieldOccurrencesTest extends Specification {
200200

201201
def "explicit builders enable standard limits and NONE disables all limits"() {
202202
given:
203-
def empty = QueryComplexityLimits.newLimits().build()
204-
def depthOnly = QueryComplexityLimits.newLimits().maxDepth(10).build()
203+
def empty = QueryComplexityLimits.newLimitsWithDefaults().build()
204+
def depthOnly = QueryComplexityLimits.newLimitsWithDefaults().maxDepth(10).build()
205205

206206
expect:
207207
empty.maxMergedFieldCount == QueryComplexityLimits.DEFAULT.maxMergedFieldCount
@@ -213,12 +213,12 @@ class FieldOccurrencesTest extends Specification {
213213
QueryComplexityLimits.NONE.maxDepth == Integer.MAX_VALUE
214214
QueryComplexityLimits.NONE.maxMergedFieldCount == Integer.MAX_VALUE
215215
QueryComplexityLimits.NONE.maxFieldOccurrences == Integer.MAX_VALUE
216-
QueryComplexityLimits.newLimits().maxFieldOccurrences(123).build().toString().contains('maxFieldOccurrences=123')
216+
QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(123).build().toString().contains('maxFieldOccurrences=123')
217217
}
218218

219219
def "occurrence limits must be positive"() {
220220
when:
221-
QueryComplexityLimits.newLimits().maxFieldOccurrences(limit).build()
221+
QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(limit).build()
222222

223223
then:
224224
thrown(IllegalArgumentException)
@@ -231,7 +231,7 @@ class FieldOccurrencesTest extends Specification {
231231
given:
232232
def graphQL = GraphQL.newGraphQL(schema).build()
233233
def input = ExecutionInput.newExecutionInput('{ node { name name } }')
234-
.graphQLContext([(QueryComplexityLimits.KEY): QueryComplexityLimits.newLimits().maxFieldOccurrences(limit).build()])
234+
.graphQLContext([(QueryComplexityLimits.KEY): QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(limit).build()])
235235
.build()
236236

237237
expect:
@@ -259,7 +259,7 @@ class FieldOccurrencesTest extends Specification {
259259
}
260260

261261
private List<ValidationError> validate(String query, int occurrences) {
262-
validateWithLimits(query, QueryComplexityLimits.newLimits().maxFieldOccurrences(occurrences).build())
262+
validateWithLimits(query, QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(occurrences).build())
263263
}
264264

265265
private List<ValidationError> validateWithLimits(String query, QueryComplexityLimits limits) {

‎src/test/groovy/graphql/validation/FragmentStackSafetyTest.groovy‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ class FragmentStackSafetyTest extends Specification {
2929
String query = '{ node { ...F0 } }' + chain('Node', 'name')
3030
// Parsing uses the default limits: shallow definitions fit even though references form a long chain.
3131
Document document = Parser.parse(query)
32-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(2).maxFieldOccurrences(2).maxDepth(2).build()
32+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(2).maxFieldOccurrences(2).maxDepth(2).build()
3333
def graphql = GraphQL.newGraphQL(schema).build()
3434
def input = ExecutionInput.newExecutionInput().query(query).root([node: [name: 'value']]).build()
3535
def validation = new FutureTask({ ->
@@ -61,7 +61,7 @@ class FragmentStackSafetyTest extends Specification {
6161
def document = new Document([operation])
6262

6363
expect:
64-
validate(document, QueryComplexityLimits.newLimits().maxMergedFieldCount(2).maxFieldOccurrences(2).maxDepth(2).build()).empty
64+
validate(document, QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(2).maxFieldOccurrences(2).maxDepth(2).build()).empty
6565
}
6666

6767
def "long root fragment chains preserve #operation validation"() {
@@ -84,10 +84,10 @@ class FragmentStackSafetyTest extends Specification {
8484
def document = Parser.parse("{ node { $selection } }" + chain('Node', 'name'))
8585

8686
expect:
87-
validate(document, QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFields).maxFieldOccurrences(occurrences).maxDepth(depth).build()).empty
88-
validate(document, QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFields - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryMergedFieldCountExceeded]
89-
validate(document, QueryComplexityLimits.newLimits().maxFieldOccurrences(occurrences - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryFieldOccurrencesExceeded]
90-
validate(document, QueryComplexityLimits.newLimits().maxDepth(depth - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryDepthExceeded]
87+
validate(document, QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFields).maxFieldOccurrences(occurrences).maxDepth(depth).build()).empty
88+
validate(document, QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFields - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryMergedFieldCountExceeded]
89+
validate(document, QueryComplexityLimits.newLimitsWithDefaults().maxFieldOccurrences(occurrences - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryFieldOccurrencesExceeded]
90+
validate(document, QueryComplexityLimits.newLimitsWithDefaults().maxDepth(depth - 1).build())*.validationErrorType == [ValidationErrorType.MaxQueryDepthExceeded]
9191

9292
where:
9393
selection | mergedFields | occurrences | depth

‎src/test/groovy/graphql/validation/LargeSchemaQueryComplexityTest.groovy‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -67,9 +67,9 @@ class LargeSchemaQueryComplexityTest extends Specification {
6767

6868
def "large schema query has exact #metric boundary #count"() {
6969
given:
70-
def exact = QueryComplexityLimits.newLimits()
70+
def exact = QueryComplexityLimits.newLimitsWithDefaults()
7171
exact."$metric"(count)
72-
def below = QueryComplexityLimits.newLimits()
72+
def below = QueryComplexityLimits.newLimitsWithDefaults()
7373
below."$metric"(count - 1)
7474

7575
expect:

‎src/test/groovy/graphql/validation/MergedQueryComplexityTest.groovy‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ class MergedQueryComplexityTest extends Specification {
9999
given:
100100
def graphQL = GraphQL.newGraphQL(schema).build()
101101
def input = ExecutionInput.newExecutionInput('{ node { name name name } }')
102-
.graphQLContext([(QueryComplexityLimits.KEY): QueryComplexityLimits.newLimits().maxMergedFieldCount(limit).build()])
102+
.graphQLContext([(QueryComplexityLimits.KEY): QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(limit).build()])
103103
.build()
104104

105105
expect:
@@ -114,7 +114,7 @@ class MergedQueryComplexityTest extends Specification {
114114
def "general limits apply independently of enabled validation rules"() {
115115
given:
116116
def document = Parser.parse('{ node { name child { name } } }')
117-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(3).build()
117+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(3).build()
118118

119119
expect:
120120
new Validator().validateDocument(schema, document, predicate, Locale.ENGLISH, limits)*.validationErrorType ==
@@ -207,8 +207,8 @@ class MergedQueryComplexityTest extends Specification {
207207
union U = A | B
208208
''')
209209
def document = Parser.parse("{ $selection } $fragments")
210-
def exact = QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFieldCount).build()
211-
def below = QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFieldCount - 1).build()
210+
def exact = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFieldCount).build()
211+
def below = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFieldCount - 1).build()
212212

213213
expect:
214214
new Validator().validateDocument(abstractSchema, document, { rule -> true }, Locale.ENGLISH, exact).empty
@@ -231,7 +231,7 @@ class MergedQueryComplexityTest extends Specification {
231231
def query = '{ node { ...F0 } }' + (0..<40).collect {
232232
"fragment F$it on Node { ...F${it + 1} ...F${it + 1} }"
233233
}.join(' ') + 'fragment F40 on Node { name name }'
234-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(2).maxDepth(2)
234+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(2).maxDepth(2)
235235
.maxFieldOccurrences(Integer.MAX_VALUE).build()
236236

237237
expect:
@@ -302,7 +302,7 @@ class MergedQueryComplexityTest extends Specification {
302302
}
303303

304304
private List<ValidationError> validate(String query, int mergedFieldCount, int depth) {
305-
def limits = QueryComplexityLimits.newLimits().maxMergedFieldCount(mergedFieldCount).maxDepth(depth).build()
305+
def limits = QueryComplexityLimits.newLimitsWithDefaults().maxMergedFieldCount(mergedFieldCount).maxDepth(depth).build()
306306
new Validator().validateDocument(schema, Parser.parse(query), { rule -> true }, Locale.ENGLISH, limits)
307307
}
308308
}

0 commit comments

Comments
 (0)