Rename GraphQL operation to query (#615)

Author: tsiq-karold

webtau-feature-testing/examples/scenarios/graphql/Report.groovy

@@ -26,23 +26,23 @@ class Report {
             .map { it.toMap() }
             .forEach { additionalData.putAll(it) }
 
-        validateSkippedOps(additionalData.graphQLSkippedOperations as Set)
-        validateCoveredOps(additionalData.graphQLCoveredOperations as Set)
-        validateOperationStatistics(additionalData.graphQLOperationTimeStatistics)
+        validateSkippedQueries(additionalData.graphQLSkippedQueries as Set)
+        validateCoveredQueries(additionalData.graphQLCoveredQueries as Set)
+        validateQueryStatistics(additionalData.graphQLQueryTimeStatistics)
         validateCoverageSummary(additionalData.graphQLCoverageSummary)
     }
 
-    static void validateSkippedOps(Set skippedOps) {
-        skippedOps.should == [
+    static void validateSkippedQueries(Set skippedQueries) {
+        skippedQueries.should == [
             [
                 name: 'uncomplete',
                 type: 'mutation'
             ]
         ] as Set
     }
 
-    static void validateCoveredOps(Set coveredOps) {
-        coveredOps.should == [
+    static void validateCoveredQueries(Set coveredQueries) {
+        coveredQueries.should == [
             [
                 name: 'allTasks',
                 type: 'query'
@@ -58,20 +58,20 @@ class Report {
         ] as Set
     }
 
-    static void validateOperationStatistics(opStats) {
-        opStats.size().should == 3
+    static void validateQueryStatistics(queryStats) {
+        queryStats.size().should == 3
 
-        def allTasksQueryStats = opStats.find { it.name == 'allTasks' }
+        def allTasksQueryStats = queryStats.find { it.name == 'allTasks' }
         allTasksQueryStats.shouldNot == null
         allTasksQueryStats.type.should == 'query'
         allTasksQueryStats.statistics.size().shouldBe > 0
 
-        def completeMutationStats = opStats.find { it.name == 'complete' }
+        def completeMutationStats = queryStats.find { it.name == 'complete' }
         completeMutationStats.shouldNot == null
         completeMutationStats.type.should == 'mutation'
         completeMutationStats.statistics.size().shouldBe > 0
 
-        def taskByIdQueryStats = opStats.find { it.name == 'taskById' }
+        def taskByIdQueryStats = queryStats.find { it.name == 'taskById' }
         taskByIdQueryStats.shouldNot == null
         taskByIdQueryStats.type.should == 'query'
         taskByIdQueryStats.statistics.size().shouldBe > 0
@@ -81,18 +81,18 @@ class Report {
         summary.should == [
             types: [
                 mutation: [
-                    declaredOperations: 2,
-                    coveredOperations: 1,
+                    declaredQueries: 2,
+                    coveredQueries: 1,
                     coverage: 0.5
                 ],
                 query: [
-                    declaredOperations: 2,
-                    coveredOperations: 2,
+                    declaredQueries: 2,
+                    coveredQueries: 2,
                     coverage: 1.0
                 ]
             ],
-            totalDeclaredOperations: 4,
-            totalCoveredOperations: 3,
+            totalDeclaredQueries: 4,
+            totalCoveredQueries: 3,
             coverage: 0.75
         ]
     }

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoverage.java

@@ -24,34 +24,34 @@
 
 public class GraphQLCoverage {
     private final GraphQLSchema schema;
-    private final GraphQLCoveredOperations coveredOperations = new GraphQLCoveredOperations();
+    private final GraphQLCoveredQueries coveredQueries = new GraphQLCoveredQueries();
 
     public GraphQLCoverage(GraphQLSchema schema) {
         this.schema = schema;
     }
 
-    public void recordOperation(HttpValidationResult validationResult) {
+    public void recordQuery(HttpValidationResult validationResult) {
         if (!schema.isSchemaDefined() || !validationResult.getRequestMethod().equals("POST")) {
             return;
         }
 
-        Set<GraphQLOperation> graphQLOperations = schema.findOperations(validationResult.getRequestBody());
-        graphQLOperations.forEach(operation -> coveredOperations.add(operation, validationResult.getId(), validationResult.getElapsedTime()));
+        Set<GraphQLQuery> graphQLQueries = schema.findQueries(validationResult.getRequestBody());
+        graphQLQueries.forEach(query -> coveredQueries.add(query, validationResult.getId(), validationResult.getElapsedTime()));
     }
 
-    Stream<GraphQLOperation> nonCoveredOperations() {
-        return schema.getSchemaDeclaredOperations().filter(o -> !coveredOperations.contains(o));
+    Stream<GraphQLQuery> nonCoveredQueries() {
+        return schema.getSchemaDeclaredQueries().filter(o -> !coveredQueries.contains(o));
     }
 
-    Stream<GraphQLOperation> coveredOperations() {
-        return coveredOperations.coveredOperations();
+    Stream<GraphQLQuery> coveredQueries() {
+        return coveredQueries.coveredQueries();
     }
 
-    Stream<GraphQLOperation> declaredOperations() {
-        return schema.getSchemaDeclaredOperations();
+    Stream<GraphQLQuery> declaredQueries() {
+        return schema.getSchemaDeclaredQueries();
     }
 
-    Stream<Map.Entry<GraphQLOperation, Set<GraphQLCoveredOperations.Call>>> actualCalls() {
-        return coveredOperations.getActualCalls();
+    Stream<Map.Entry<GraphQLQuery, Set<GraphQLCoveredQueries.Call>>> actualCalls() {
+        return coveredQueries.getActualCalls();
     }
 }

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoverageRecorder.java

@@ -22,6 +22,6 @@
 public class GraphQLCoverageRecorder implements HttpValidationHandler {
     @Override
     public void validate(HttpValidationResult validationResult) {
-        GraphQL.getCoverage().recordOperation(validationResult);
+        GraphQL.getCoverage().recordQuery(validationResult);
     }
 }

…au/graphql/GraphQLCoveredOperations.java …ebtau/graphql/GraphQLCoveredQueries.javawebtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoveredOperations.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoveredQueries.java webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoveredOperations.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLCoveredQueries.java

@@ -22,29 +22,29 @@
 import java.util.Set;
 import java.util.stream.Stream;
 
-public class GraphQLCoveredOperations {
-    private final Map<GraphQLOperation, Set<Call>> actualCallsIdsByOperation;
+public class GraphQLCoveredQueries {
+    private final Map<GraphQLQuery, Set<Call>> actualCallsIdsByQuery;
 
-    GraphQLCoveredOperations() {
-        actualCallsIdsByOperation = new LinkedHashMap<>();
+    GraphQLCoveredQueries() {
+        actualCallsIdsByQuery = new LinkedHashMap<>();
     }
 
-    public void add(GraphQLOperation operation, String id, long elapsedTime) {
-        Set<Call> calls = actualCallsIdsByOperation.computeIfAbsent(operation, k -> new LinkedHashSet<>());
+    public void add(GraphQLQuery query, String id, long elapsedTime) {
+        Set<Call> calls = actualCallsIdsByQuery.computeIfAbsent(query, k -> new LinkedHashSet<>());
 
         calls.add(new Call(id, elapsedTime));
     }
 
-    public boolean contains(GraphQLOperation operation) {
-        return actualCallsIdsByOperation.containsKey(operation);
+    public boolean contains(GraphQLQuery query) {
+        return actualCallsIdsByQuery.containsKey(query);
     }
 
-    Stream<GraphQLOperation> coveredOperations() {
-        return actualCallsIdsByOperation.keySet().stream();
+    Stream<GraphQLQuery> coveredQueries() {
+        return actualCallsIdsByQuery.keySet().stream();
     }
 
-    public Stream<Map.Entry<GraphQLOperation, Set<Call>>> getActualCalls() {
-        return actualCallsIdsByOperation.entrySet().stream();
+    public Stream<Map.Entry<GraphQLQuery, Set<Call>>> getActualCalls() {
+        return actualCallsIdsByQuery.entrySet().stream();
     }
 
     public static class Call {

…ing/webtau/graphql/GraphQLOperation.java …menting/webtau/graphql/GraphQLQuery.javawebtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLOperation.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLQuery.java webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLOperation.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLQuery.java

@@ -20,11 +20,11 @@
 import java.util.Map;
 import java.util.Objects;
 
-public class GraphQLOperation {
+public class GraphQLQuery {
     private final String name;
-    private final GraphQLOperationType type;
+    private final GraphQLQueryType type;
 
-    GraphQLOperation(String name, GraphQLOperationType type) {
+    GraphQLQuery(String name, GraphQLQueryType type) {
         this.name = name;
         this.type = type;
     }
@@ -33,7 +33,7 @@ public String getName() {
         return name;
     }
 
-    public GraphQLOperationType getType() {
+    public GraphQLQueryType getType() {
         return type;
     }
 
@@ -49,7 +49,7 @@ public GraphQLOperationType getType() {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        GraphQLOperation that = (GraphQLOperation) o;
+        GraphQLQuery that = (GraphQLQuery) o;
         return Objects.equals(name, that.name) &&
                 type == that.type;
     }
@@ -61,7 +61,7 @@ public int hashCode() {
 
     @Override
     public String toString() {
-        return "GraphQLOperation{" +
+        return "GraphQLQuery{" +
                 "name='" + name + '\'' +
                 ", type=" + type +
                 '}';

…webtau/graphql/GraphQLOperationType.java …ing/webtau/graphql/GraphQLQueryType.javawebtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLOperationType.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLQueryType.java webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLOperationType.java renamed to webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLQueryType.java

@@ -16,7 +16,7 @@
 
 package org.testingisdocumenting.webtau.graphql;
 
-public enum GraphQLOperationType {
+public enum GraphQLQueryType {
     QUERY,
     MUTATION,
     SUBSCRIPTION

webtau-graphql/src/main/java/org/testingisdocumenting/webtau/graphql/GraphQLReportDataProvider.java

@@ -45,43 +45,43 @@ public GraphQLReportDataProvider(Supplier<GraphQLCoverage> coverageSupplier) {
 
     @Override
     public Stream<ReportCustomData> provide(WebTauTestList tests) {
-        List<? extends Map<String, ?>> nonCoveredOperations = coverageSupplier.get().nonCoveredOperations()
-                .map(GraphQLOperation::toMap)
+        List<? extends Map<String, ?>> nonCoveredQueries = coverageSupplier.get().nonCoveredQueries()
+                .map(GraphQLQuery::toMap)
                 .collect(Collectors.toList());
 
-        List<? extends Map<String, ?>> coveredOperations = coverageSupplier.get().coveredOperations()
-                .map(GraphQLOperation::toMap)
+        List<? extends Map<String, ?>> coveredQueries = coverageSupplier.get().coveredQueries()
+                .map(GraphQLQuery::toMap)
                 .collect(Collectors.toList());
 
-        List<? extends Map<String, ?>> timingByOperation = computeTiming();
+        List<? extends Map<String, ?>> timingByQuery = computeTiming();
 
         Map<String, ?> coverageSummary = computeCoverageSummary();
 
         return Stream.of(
-                new ReportCustomData("graphQLSkippedOperations", nonCoveredOperations),
-                new ReportCustomData("graphQLCoveredOperations", coveredOperations),
-                new ReportCustomData("graphQLOperationTimeStatistics", timingByOperation),
+                new ReportCustomData("graphQLSkippedQueries", nonCoveredQueries),
+                new ReportCustomData("graphQLCoveredQueries", coveredQueries),
+                new ReportCustomData("graphQLQueryTimeStatistics", timingByQuery),
                 new ReportCustomData("graphQLCoverageSummary", coverageSummary));
     }
 
     private List<? extends Map<String, ?>> computeTiming() {
         return coverageSupplier.get().actualCalls().map(GraphQLReportDataProvider::computeTiming).collect(Collectors.toList());
     }
 
-    private static Map<String, ?> computeTiming(Map.Entry<GraphQLOperation, Set<GraphQLCoveredOperations.Call>> entry) {
+    private static Map<String, ?> computeTiming(Map.Entry<GraphQLQuery, Set<GraphQLCoveredQueries.Call>> entry) {
         Map<String, Object> data = new LinkedHashMap<>();
         data.put("name", entry.getKey().getName());
         data.put("type", entry.getKey().getType().name().toLowerCase());
 
         Map<String, Object> statistics = new LinkedHashMap<>();
         data.put("statistics", statistics);
 
-        LongSummaryStatistics summaryStatistics = entry.getValue().stream().collect(Collectors.summarizingLong(GraphQLCoveredOperations.Call::getElapsedTime));
+        LongSummaryStatistics summaryStatistics = entry.getValue().stream().collect(Collectors.summarizingLong(GraphQLCoveredQueries.Call::getElapsedTime));
         statistics.put("mean", summaryStatistics.getAverage());
         statistics.put("min", summaryStatistics.getMin());
         statistics.put("max", summaryStatistics.getMax());
 
-        double[] times = entry.getValue().stream().map(GraphQLCoveredOperations.Call::getElapsedTime).mapToDouble(Long::doubleValue).sorted().toArray();
+        double[] times = entry.getValue().stream().map(GraphQLCoveredQueries.Call::getElapsedTime).mapToDouble(Long::doubleValue).sorted().toArray();
         Percentile percentile = new Percentile();
         statistics.put("p95", percentile.evaluate(times, 95));
         statistics.put("p99", percentile.evaluate(times, 99));
@@ -91,29 +91,29 @@ public Stream<ReportCustomData> provide(WebTauTestList tests) {
 
     private Map<String, ?> computeCoverageSummary() {
         Map<String, Object> summary = new HashMap<>();
-        Map<GraphQLOperationType, List<GraphQLOperation>> declaredOpByType = coverageSupplier.get().declaredOperations().collect(Collectors.groupingBy(GraphQLOperation::getType));
-        Map<GraphQLOperationType, List<GraphQLOperation>> coveredOpsByType = coverageSupplier.get().coveredOperations().collect(Collectors.groupingBy(GraphQLOperation::getType));
+        Map<GraphQLQueryType, List<GraphQLQuery>> declaredQueriesByType = coverageSupplier.get().declaredQueries().collect(Collectors.groupingBy(GraphQLQuery::getType));
+        Map<GraphQLQueryType, List<GraphQLQuery>> coveredQueriesByType = coverageSupplier.get().coveredQueries().collect(Collectors.groupingBy(GraphQLQuery::getType));
 
         Map<String, Object> summaryByType = new HashMap<>();
-        declaredOpByType.forEach((type, ops) -> {
-            double coveredOperations = coveredOpsByType.getOrDefault(type, Collections.emptyList()).size();
-            double coverage = coveredOperations / ops.size();
+        declaredQueriesByType.forEach((type, queries) -> {
+            double coveredQueries = coveredQueriesByType.getOrDefault(type, Collections.emptyList()).size();
+            double coverage = coveredQueries / queries.size();
 
             Map<String, Object> summaryForType = new HashMap<>();
-            summaryForType.put("declaredOperations", ops.size());
-            summaryForType.put("coveredOperations", coveredOperations);
+            summaryForType.put("declaredQueries", queries.size());
+            summaryForType.put("coveredQueries", coveredQueries);
             summaryForType.put("coverage", coverage);
 
             summaryByType.put(type.name().toLowerCase(), summaryForType);
         });
         summary.put("types", summaryByType);
 
-        double coveredOperations = coveredOpsByType.values().stream().mapToInt(List::size).sum();
-        double declaredOperations = declaredOpByType.values().stream().mapToInt(List::size).sum();
-        double totalCoverage = coveredOperations / declaredOperations;
+        double coveredQueries = coveredQueriesByType.values().stream().mapToInt(List::size).sum();
+        double declaredQueries = declaredQueriesByType.values().stream().mapToInt(List::size).sum();
+        double totalCoverage = coveredQueries / declaredQueries;
 
-        summary.put("totalDeclaredOperations", declaredOperations);
-        summary.put("totalCoveredOperations", coveredOperations);
+        summary.put("totalDeclaredQueries", declaredQueries);
+        summary.put("totalCoveredQueries", coveredQueries);
         summary.put("coverage", totalCoverage);
 
         return summary;