[ML-DataFrame] allow aggs as abbreviation for aggregations

client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java

@@ -1697,7 +1697,7 @@ public void testCRUDIndexTemplateWithTypes() throws Exception {
         assertTrue(template2.mappings().containsKey("custom_doc_type"));
 
         List<String> names = randomBoolean()
-            ? Arrays.asList("*-1", "template-2")
+            ? Arrays.asList("*plate-1", "template-2")
             : Arrays.asList("template-*");
         GetIndexTemplatesRequest getBothRequest = new GetIndexTemplatesRequest(names);
         org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse getBoth = execute(
@@ -1834,7 +1834,7 @@ public void testIndexTemplatesExist() throws Exception {
 
         {
             final List<String> templateNames = randomBoolean()
-                ? Arrays.asList("*-1", "template-2")
+                ? Arrays.asList("*plate-1", "template-2")
                 : Arrays.asList("template-*");
 
             final IndexTemplatesExistRequest bothRequest = new IndexTemplatesExistRequest(templateNames);

x-pack/plugin/data-frame/src/main/java/org/elasticsearch/xpack/dataframe/transforms/pivot/PivotConfig.java

@@ -22,12 +22,15 @@
 import java.util.Objects;
 
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
+import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
 public class PivotConfig implements Writeable, ToXContentObject {
 
     private static final String NAME = "data_frame_transform_pivot";
     private static final ParseField GROUP_BY = new ParseField("group_by");
     private static final ParseField AGGREGATIONS = new ParseField("aggregations");
+    private static final ParseField AGGS = new ParseField("aggs");
+
 
     private final List<GroupConfig> groups;
     private final AggregationConfig aggregationConfig;
@@ -40,14 +43,32 @@ private static ConstructingObjectParser<PivotConfig, Void> createParser(boolean
                 args -> {
                     @SuppressWarnings("unchecked")
                     List<GroupConfig> groups = (List<GroupConfig>) args[0];
-                    AggregationConfig aggregationConfig = (AggregationConfig) args[1];
+
+                    // allow "aggs" and "aggregations" but require one to be specified
+                    // if somebody specifies both: throw
+                    AggregationConfig aggregationConfig = null;
+                    if (args[1] != null) {
+                        aggregationConfig = (AggregationConfig) args[1];
+                    }
+
+                    if (args[2] != null) {
+                        if (aggregationConfig != null) {
+                            throw new IllegalArgumentException("Found two aggregation definitions: [aggs] and [aggregations]");
+                        }
+                        aggregationConfig = (AggregationConfig) args[2];
+                    }
+                    if (aggregationConfig == null) {
+                        throw new IllegalArgumentException("Required [aggregations]");
+                    }
+
                     return new PivotConfig(groups, aggregationConfig);
                 });
 
         parser.declareObjectArray(constructorArg(),
                 (p, c) -> (GroupConfig.fromXContent(p, lenient)), GROUP_BY);
 
-        parser.declareObject(constructorArg(), (p, c) -> AggregationConfig.fromXContent(p, lenient), AGGREGATIONS);
+        parser.declareObject(optionalConstructorArg(), (p, c) -> AggregationConfig.fromXContent(p, lenient), AGGREGATIONS);
+        parser.declareObject(optionalConstructorArg(), (p, c) -> AggregationConfig.fromXContent(p, lenient), AGGS);
 
         return parser;
     }

x-pack/plugin/data-frame/src/test/java/org/elasticsearch/xpack/dataframe/transforms/pivot/PivotConfigTests.java

@@ -7,7 +7,9 @@
 package org.elasticsearch.xpack.dataframe.transforms.pivot;
 
 import org.elasticsearch.common.io.stream.Writeable.Reader;
+import org.elasticsearch.common.xcontent.DeprecationHandler;
 import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.xpack.dataframe.transforms.AbstractSerializingDataFrameTestCase;
 
 import java.io.IOException;
@@ -50,4 +52,63 @@ protected PivotConfig createTestInstance() {
     protected Reader<PivotConfig> instanceReader() {
         return PivotConfig::new;
     }
+
+    public void testAggsAbbreviations() throws IOException {
+        String pivotAggs = "{"
+                    + " \"group_by\": [ {"
+                    + "   \"id\": {"
+                    + "     \"terms\": {"
+                    + "       \"field\": \"id\""
+                    + "} } } ],"
+                    + " \"aggs\": {"
+                    + "   \"avg\": {"
+                    + "     \"avg\": {"
+                    + "       \"field\": \"points\""
+                    + "} } } }";
+
+        PivotConfig p1 = createPivotConfigFromString(pivotAggs);
+        String pivotAggregations = pivotAggs.replace("aggs", "aggregations");
+        assertNotEquals(pivotAggs, pivotAggregations);
+        PivotConfig p2 = createPivotConfigFromString(pivotAggregations);
+        assertEquals(p1,p2);
+    }
+
+    public void testMissingAggs() throws IOException {
+        String pivot = "{"
+                + " \"group_by\": [ {"
+                + "   \"id\": {"
+                + "     \"terms\": {"
+                + "       \"field\": \"id\""
+                + "} } } ] }";
+
+        expectThrows(IllegalArgumentException.class, () -> createPivotConfigFromString(pivot));
+    }
+
+    public void testDoubleAggs() throws IOException {
+        String pivot = "{"
+                + " \"group_by\": [ {"
+                + "   \"id\": {"
+                + "     \"terms\": {"
+                + "       \"field\": \"id\""
+                + "} } } ],"
+                + " \"aggs\": {"
+                + "   \"avg\": {"
+                + "     \"avg\": {"
+                + "       \"field\": \"points\""
+                + "} } },"
+                + " \"aggregations\": {"
+                + "   \"avg\": {"
+                + "     \"avg\": {"
+                + "       \"field\": \"points\""
+                + "} } }"
+                + "}";
+
+        expectThrows(IllegalArgumentException.class, () -> createPivotConfigFromString(pivot));
+    }
+
+    private PivotConfig createPivotConfigFromString(String json) throws IOException {
+        final XContentParser parser = XContentType.JSON.xContent().createParser(xContentRegistry(),
+                DeprecationHandler.THROW_UNSUPPORTED_OPERATION, json);
+        return PivotConfig.fromXContent(parser, false);
+    }
 }