Consolidate enrich list all and get by name APIs (#45705)

The get and list APIs are a single API in this commit. Whether
requesting one named policy or all policies, a list of policies is
returened. The list API code has all been removed and the GET api is
what remains, which contains much of the list response code.

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

@@ -45,10 +45,13 @@ public class EnrichIT extends ESRestHighLevelClientTestCase {
         Response getPolicyResponse = highLevelClient().getLowLevelClient().performRequest(getPolicyRequest);
         assertThat(getPolicyResponse.getHttpResponse().getStatusLine().getStatusCode(), equalTo(200));
         Map<String, Object> responseBody = toMap(getPolicyResponse);
-        assertThat(responseBody.get("type"), equalTo(putPolicyRequest.getType()));
-        assertThat(responseBody.get("indices"), equalTo(putPolicyRequest.getIndices()));
-        assertThat(responseBody.get("match_field"), equalTo(putPolicyRequest.getMatchField()));
-        assertThat(responseBody.get("enrich_fields"), equalTo(putPolicyRequest.getEnrichFields()));
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> responsePolicies = (List<Map<String, Object>>) responseBody.get("policies");
+        assertThat(responsePolicies.size(), equalTo(1));
+        assertThat(responsePolicies.get(0).get("type"), equalTo(putPolicyRequest.getType()));
+        assertThat(responsePolicies.get(0).get("indices"), equalTo(putPolicyRequest.getIndices()));
+        assertThat(responsePolicies.get(0).get("match_field"), equalTo(putPolicyRequest.getMatchField()));
+        assertThat(responsePolicies.get(0).get("enrich_fields"), equalTo(putPolicyRequest.getEnrichFields()));
     }
 
     private static Map<String, Object> toMap(Response response) throws IOException {

docs/reference/ingest/ingest-node.asciidoc

@@ -968,7 +968,6 @@ Also there are several APIs in order to manage and execute enrich policies:
 * <<get-policy-api,Get policy api>>.
 * <<delete-policy-api,Delete policy api>>.
 * <<execute-policy-api,Execute policy api>>.
-* <<list-policies-api,List policies api>>.
 
 If security is enabled then the user managing enrich policies will need to have
 the `enrich_user` builtin role. Also the user will need to have read privileges
@@ -1009,7 +1008,7 @@ Response:
 
 The get policy api allows a policy to be retrieved by id.
 
-Request"
+Request:
 
 [source,js]
 --------------------------------------------------
@@ -1023,18 +1022,27 @@ Response:
 [source,js]
 --------------------------------------------------
 {
-    "type": "exact_match",
-    "indices": ["users"],
-    "match_field": "email",
-    "enrich_fields": ["first_name", "last_name", "address", "city", "zip", "state"]
+    "policies": [
+        {
+            "name" : "my-policy",
+            "type" : "exact_match",
+            "indices" : ["users"],
+            "match_field" : "email",
+            "enrich_fields" : [
+                "first_name",
+                "last_name",
+                "address",
+                "city",
+                "zip",
+                "state"
+            ]
+        }
+    ]
 }
 --------------------------------------------------
 // TESTRESPONSE
 
-[[list-policies-api]]
-==== List Policies API
-
-The list policies api allows all policies to be returned.
+The get policy api allows all policies to be returned.
 
 Request:
 

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java

@@ -16,7 +16,11 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
 
 import java.io.IOException;
+import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
 
 public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Response> {
 
@@ -31,6 +35,8 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
 
         private String name;
 
+        public Request() { }
+
         public Request(String name) {
             this.name = name;
         }
@@ -75,34 +81,43 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
 
     public static class Response extends ActionResponse implements ToXContentObject {
 
-        private final EnrichPolicy policy;
+        private final List<EnrichPolicy.NamedPolicy> policies;
 
-        public Response(EnrichPolicy policy) {
-            this.policy = Objects.requireNonNull(policy, "policy cannot be null");
+        public Response(Map<String, EnrichPolicy> policies) {
+            Objects.requireNonNull(policies, "policies cannot be null");
+            // use a treemap to guarantee ordering in the set, then transform it to the list of named policies
+            this.policies = new TreeMap<>(policies).entrySet().stream()
+                .map(entry -> new EnrichPolicy.NamedPolicy(entry.getKey(), entry.getValue())).collect(Collectors.toList());
         }
 
         public Response(StreamInput in) throws IOException {
-            policy = new EnrichPolicy(in);
+            policies = in.readList(EnrichPolicy.NamedPolicy::new);
         }
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
-            policy.writeTo(out);
+            out.writeList(policies);
         }
 
         @Override
         public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
             builder.startObject();
             {
-                policy.toXContent(builder, params);
+                builder.startArray("policies");
+                {
+                    for (EnrichPolicy.NamedPolicy policy: policies) {
+                        policy.toXContent(builder, params);
+                    }
+                }
+                builder.endArray();
             }
             builder.endObject();
 
             return builder;
         }
 
-        public EnrichPolicy getPolicy() {
-            return policy;
+        public List<EnrichPolicy.NamedPolicy> getPolicies() {
+            return policies;
         }
 
         @Override
@@ -110,12 +125,12 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
             if (this == o) return true;
             if (o == null || getClass() != o.getClass()) return false;
             Response response = (Response) o;
-            return policy.equals(response.policy);
+            return policies.equals(response.policies);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(policy);
+            return Objects.hash(policies);
         }
     }
 }

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java

@@ -1,102 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the Elastic License;
- * you may not use this file except in compliance with the Elastic License.
- */
-package org.elasticsearch.xpack.core.enrich.action;
-
-import org.elasticsearch.action.ActionRequestValidationException;
-import org.elasticsearch.action.ActionResponse;
-import org.elasticsearch.action.ActionType;
-import org.elasticsearch.action.support.master.MasterNodeRequest;
-import org.elasticsearch.common.io.stream.StreamInput;
-import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.common.xcontent.ToXContentObject;
-import org.elasticsearch.common.xcontent.XContentBuilder;
-import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-
-public class ListEnrichPolicyAction extends ActionType<ListEnrichPolicyAction.Response> {
-
-    public static final ListEnrichPolicyAction INSTANCE = new ListEnrichPolicyAction();
-    public static final String NAME = "cluster:admin/xpack/enrich/list";
-
-    private ListEnrichPolicyAction() {
-        super(NAME, Response::new);
-    }
-
-    public static class Request extends MasterNodeRequest<ListEnrichPolicyAction.Request> {
-
-        public Request() {}
-
-        public Request(StreamInput in) throws IOException {
-            super(in);
-        }
-
-        @Override
-        public ActionRequestValidationException validate() {
-            return null;
-        }
-    }
-
-    public static class Response extends ActionResponse implements ToXContentObject {
-
-        private final List<EnrichPolicy.NamedPolicy> policies;
-
-        public Response(Map<String, EnrichPolicy> policies) {
-            Objects.requireNonNull(policies, "policies cannot be null");
-            // use a treemap to guarantee ordering in the set, then transform it to the list of named policies
-            this.policies = new TreeMap<>(policies).entrySet().stream()
-                .map(entry -> new EnrichPolicy.NamedPolicy(entry.getKey(), entry.getValue())).collect(Collectors.toList());
-        }
-
-        public Response(StreamInput in) throws IOException {
-            policies = in.readList(EnrichPolicy.NamedPolicy::new);
-        }
-
-        @Override
-        public void writeTo(StreamOutput out) throws IOException {
-            out.writeList(policies);
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject();
-            {
-                builder.startArray("policies");
-                {
-                    for (EnrichPolicy.NamedPolicy policy: policies) {
-                        policy.toXContent(builder, params);
-                    }
-                }
-                builder.endArray();
-            }
-            builder.endObject();
-
-            return builder;
-        }
-
-        public List<EnrichPolicy.NamedPolicy> getPolicies() {
-            return policies;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            Response response = (Response) o;
-            return policies.equals(response.policies);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(policies);
-        }
-    }
-}

x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java

@@ -11,7 +11,6 @@ import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction;
 import org.elasticsearch.transport.TransportRequest;
 import org.elasticsearch.xpack.core.security.authz.permission.ClusterPermission;
@@ -185,7 +184,6 @@ public class PrivilegeTests extends ESTestCase {
         verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, DeleteEnrichPolicyAction.NAME);
         verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, ExecuteEnrichPolicyAction.NAME);
         verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, GetEnrichPolicyAction.NAME);
-        verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, ListEnrichPolicyAction.NAME);
         verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, PutEnrichPolicyAction.NAME);
         verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, "cluster:admin/xpack/enrich/brand_new_api");
         verifyClusterActionDenied(ClusterPrivilegeResolver.MANAGE_ENRICH, "cluster:admin/xpack/whatever");

x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml

@@ -19,13 +19,15 @@
   - do:
       enrich.get_policy:
         name: policy-crud
-  - match: { type: exact_match }
-  - match: { indices: ["bar*"] }
-  - match: { match_field: baz }
-  - match: { enrich_fields: ["a", "b"] }
+  - length: { policies: 1 }
+  - match: { policies.0.name: policy-crud }
+  - match: { policies.0.type: exact_match }
+  - match: { policies.0.indices: ["bar*"] }
+  - match: { policies.0.match_field: baz }
+  - match: { policies.0.enrich_fields: ["a", "b"] }
 
   - do:
-      enrich.list_policy: {}
+      enrich.get_policy: {}
   - length: { policies: 1 }
   - match: { policies.0.name: policy-crud }
   - match: { policies.0.type: exact_match }

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java

@@ -38,19 +38,16 @@ import org.elasticsearch.xpack.core.XPackPlugin;
 import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.action.CoordinatorProxyAction;
 import org.elasticsearch.xpack.enrich.action.EnrichShardMultiSearchAction;
 import org.elasticsearch.xpack.enrich.action.TransportDeleteEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.action.TransportExecuteEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.action.TransportGetEnrichPolicyAction;
-import org.elasticsearch.xpack.enrich.action.TransportListEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.action.TransportPutEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.rest.RestDeleteEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.rest.RestExecuteEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.rest.RestGetEnrichPolicyAction;
-import org.elasticsearch.xpack.enrich.rest.RestListEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.rest.RestPutEnrichPolicyAction;
 
 import java.util.Collection;
@@ -113,7 +110,6 @@ public class EnrichPlugin extends Plugin implements ActionPlugin, IngestPlugin {
         return List.of(
             new ActionHandler<>(GetEnrichPolicyAction.INSTANCE, TransportGetEnrichPolicyAction.class),
             new ActionHandler<>(DeleteEnrichPolicyAction.INSTANCE, TransportDeleteEnrichPolicyAction.class),
-            new ActionHandler<>(ListEnrichPolicyAction.INSTANCE, TransportListEnrichPolicyAction.class),
             new ActionHandler<>(PutEnrichPolicyAction.INSTANCE, TransportPutEnrichPolicyAction.class),
             new ActionHandler<>(ExecuteEnrichPolicyAction.INSTANCE, TransportExecuteEnrichPolicyAction.class),
             new ActionHandler<>(CoordinatorProxyAction.INSTANCE, CoordinatorProxyAction.TransportAction.class),
@@ -132,7 +128,6 @@ public class EnrichPlugin extends Plugin implements ActionPlugin, IngestPlugin {
         return List.of(
             new RestGetEnrichPolicyAction(restController),
             new RestDeleteEnrichPolicyAction(restController),
-            new RestListEnrichPolicyAction(restController),
             new RestPutEnrichPolicyAction(restController),
             new RestExecuteEnrichPolicyAction(restController)
         );

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java

@@ -24,6 +24,7 @@ import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
 import org.elasticsearch.xpack.enrich.EnrichStore;
 
 import java.io.IOException;
+import java.util.Map;
 
 public class TransportGetEnrichPolicyAction extends TransportMasterNodeReadAction<GetEnrichPolicyAction.Request,
     GetEnrichPolicyAction.Response> {
@@ -56,11 +57,18 @@ public class TransportGetEnrichPolicyAction extends TransportMasterNodeReadActio
     protected void masterOperation(Task task, GetEnrichPolicyAction.Request request,
                                    ClusterState state,
                                    ActionListener<GetEnrichPolicyAction.Response> listener) throws Exception {
-        final EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state);
-        if (policy == null) {
-            throw new ResourceNotFoundException("Policy [{}] was not found", request.getName());
+        Map<String, EnrichPolicy> policies;
+        if (request.getName() == null || request.getName().isEmpty()) {
+            policies = EnrichStore.getPolicies(state);
+        } else {
+            EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state);
+            if (policy == null) {
+                throw new ResourceNotFoundException("Policy [{}] was not found", request.getName());
+            }
+            policies = Map.of(request.getName(), policy);
+
         }
-        listener.onResponse(new GetEnrichPolicyAction.Response(policy));
+        listener.onResponse(new GetEnrichPolicyAction.Response(policies));
     }
 
     @Override

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java

@@ -1,68 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the Elastic License;
- * you may not use this file except in compliance with the Elastic License.
- */
-package org.elasticsearch.xpack.enrich.action;
-
-import org.elasticsearch.action.ActionListener;
-import org.elasticsearch.action.support.ActionFilters;
-import org.elasticsearch.action.support.master.TransportMasterNodeAction;
-import org.elasticsearch.cluster.ClusterState;
-import org.elasticsearch.cluster.block.ClusterBlockException;
-import org.elasticsearch.cluster.block.ClusterBlockLevel;
-import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
-import org.elasticsearch.cluster.service.ClusterService;
-import org.elasticsearch.common.inject.Inject;
-import org.elasticsearch.common.io.stream.StreamInput;
-import org.elasticsearch.tasks.Task;
-import org.elasticsearch.threadpool.ThreadPool;
-import org.elasticsearch.transport.TransportService;
-import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
-import org.elasticsearch.xpack.enrich.EnrichStore;
-
-import java.io.IOException;
-import java.util.Map;
-
-public class TransportListEnrichPolicyAction
-    extends TransportMasterNodeAction<ListEnrichPolicyAction.Request, ListEnrichPolicyAction.Response> {
-
-    @Inject
-    public TransportListEnrichPolicyAction(TransportService transportService,
-                                           ClusterService clusterService,
-                                           ThreadPool threadPool,
-                                           ActionFilters actionFilters,
-                                           IndexNameExpressionResolver indexNameExpressionResolver) {
-        super(ListEnrichPolicyAction.NAME, transportService, clusterService, threadPool, actionFilters,
-            ListEnrichPolicyAction.Request::new, indexNameExpressionResolver);
-    }
-
-    @Override
-    protected String executor() {
-        return ThreadPool.Names.SAME;
-    }
-
-    @Override
-    protected ListEnrichPolicyAction.Response read(StreamInput in) throws IOException {
-        return new ListEnrichPolicyAction.Response(in);
-    }
-
-    protected ListEnrichPolicyAction.Response newResponse() {
-        throw new UnsupportedOperationException("usage of Streamable is to be replaced by Writeable");
-    }
-
-    @Override
-    protected void masterOperation(Task task, ListEnrichPolicyAction.Request request, ClusterState state,
-                                   ActionListener<ListEnrichPolicyAction.Response> listener) throws Exception {
-        Map<String, EnrichPolicy> policies = EnrichStore.getPolicies(clusterService.state());
-        listener.onResponse(new ListEnrichPolicyAction.Response(policies));
-    }
-
-    @Override
-    protected ClusterBlockException checkBlock(ListEnrichPolicyAction.Request request, ClusterState state) {
-        return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
-    }
-
-
-}

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java

@@ -18,6 +18,7 @@ public class RestGetEnrichPolicyAction extends BaseRestHandler {
 
     public RestGetEnrichPolicyAction(final RestController controller) {
         controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy/{name}", this);
+        controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy", this);
     }
 
     @Override

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestListEnrichPolicyAction.java

@@ -1,33 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the Elastic License;
- * you may not use this file except in compliance with the Elastic License.
- */
-package org.elasticsearch.xpack.enrich.rest;
-
-import org.elasticsearch.client.node.NodeClient;
-import org.elasticsearch.rest.BaseRestHandler;
-import org.elasticsearch.rest.RestController;
-import org.elasticsearch.rest.RestRequest;
-import org.elasticsearch.rest.action.RestToXContentListener;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
-
-import java.io.IOException;
-
-public class RestListEnrichPolicyAction extends BaseRestHandler {
-
-    public RestListEnrichPolicyAction(final RestController controller) {
-        controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy", this);
-    }
-
-    @Override
-    public String getName() {
-        return "list_enrich_policy";
-    }
-
-    @Override
-    protected RestChannelConsumer prepareRequest(final RestRequest restRequest, final NodeClient client) throws IOException {
-        final ListEnrichPolicyAction.Request request = new ListEnrichPolicyAction.Request();
-        return channel -> client.execute(ListEnrichPolicyAction.INSTANCE, request, new RestToXContentListener<>(channel));
-    }
-}

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java

@@ -26,7 +26,6 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
 import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction;
 
 import java.util.Collection;
@@ -67,9 +66,10 @@ public class EnrichMultiNodeIT extends ESIntegTestCase {
             client().execute(PutEnrichPolicyAction.INSTANCE, request).actionGet();
             client().execute(ExecuteEnrichPolicyAction.INSTANCE, new ExecuteEnrichPolicyAction.Request(policyName)).actionGet();
 
-            EnrichPolicy result =
-                client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicy();
-            assertThat(result, equalTo(enrichPolicy));
+            EnrichPolicy.NamedPolicy result =
+                client().execute(GetEnrichPolicyAction.INSTANCE,
+                    new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicies().get(0);
+            assertThat(result, equalTo(new EnrichPolicy.NamedPolicy(policyName, enrichPolicy)));
             String enrichIndexPrefix = EnrichPolicy.getBaseName(policyName) + "*";
             refresh(enrichIndexPrefix);
             SearchResponse searchResponse = client().search(new SearchRequest(enrichIndexPrefix)).actionGet();
@@ -77,8 +77,8 @@ public class EnrichMultiNodeIT extends ESIntegTestCase {
             assertThat(searchResponse.getHits().getTotalHits().value, equalTo((long) numDocsInSourceIndex));
         }
 
-        ListEnrichPolicyAction.Response response =
-            client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet();
+        GetEnrichPolicyAction.Response response =
+            client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet();
         assertThat(response.getPolicies().size(), equalTo(numPolicies));
 
         for (int i = 0; i < numPolicies; i++) {
@@ -86,7 +86,7 @@ public class EnrichMultiNodeIT extends ESIntegTestCase {
             client().execute(DeleteEnrichPolicyAction.INSTANCE, new DeleteEnrichPolicyAction.Request(policyName)).actionGet();
         }
 
-        response = client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet();
+        response = client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet();
         assertThat(response.getPolicies().size(), equalTo(0));
     }
 

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java

@@ -9,7 +9,7 @@ import org.elasticsearch.index.reindex.ReindexPlugin;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.ESIntegTestCase;
 import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
+import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
 import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction;
 
 import java.util.Collection;
@@ -50,8 +50,8 @@ public class EnrichRestartIT extends ESIntegTestCase {
     }
 
     private static void verifyPolicies(int numPolicies, EnrichPolicy enrichPolicy) {
-        ListEnrichPolicyAction.Response response =
-            client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet();
+        GetEnrichPolicyAction.Response response =
+            client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet();
         assertThat(response.getPolicies().size(), equalTo(numPolicies));
         for (int i = 0; i < numPolicies; i++) {
             String policyName = POLICY_NAME + i;

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java

@@ -13,22 +13,41 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
 import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
 
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies;
 import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy;
+import static org.hamcrest.core.IsEqual.equalTo;
 
 public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestCase<GetEnrichPolicyAction.Response> {
 
     @Override
     protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException {
-        EnrichPolicy policy = EnrichPolicy.fromXContent(parser);
-        return new GetEnrichPolicyAction.Response(policy);
+        Map<String, EnrichPolicy> policies = new HashMap<>();
+        assert parser.nextToken() == XContentParser.Token.START_OBJECT;
+        assert parser.nextToken() == XContentParser.Token.FIELD_NAME;
+        assert parser.currentName().equals("policies");
+        assert parser.nextToken() == XContentParser.Token.START_ARRAY;
+
+        XContentParser.Token token;
+        while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
+            assert token == XContentParser.Token.START_OBJECT;
+            EnrichPolicy.NamedPolicy policy = EnrichPolicy.NamedPolicy.fromXContent(parser);
+            policies.put(policy.getName(), policy.getPolicy());
+        }
+
+        return new GetEnrichPolicyAction.Response(policies);
     }
 
     @Override
     protected GetEnrichPolicyAction.Response createTestInstance() {
-        EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
-        return new GetEnrichPolicyAction.Response(policy);
+        Map<String, EnrichPolicy> items = new HashMap<>();
+        for (int i = 0; i < randomIntBetween(0, 3); i++) {
+            EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
+            items.put(randomAlphaOfLength(3), policy);
+        }
+        return new GetEnrichPolicyAction.Response(items);
     }
 
     @Override
@@ -40,6 +59,14 @@ public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestC
     protected void assertEqualInstances(GetEnrichPolicyAction.Response expectedInstance, GetEnrichPolicyAction.Response newInstance) {
         assertNotSame(expectedInstance, newInstance);
         // the tests shuffle around the policy query source xcontent type, so this is needed here
-        assertEqualPolicies(expectedInstance.getPolicy(), newInstance.getPolicy());
+        assertThat(expectedInstance.getPolicies().size(), equalTo(newInstance.getPolicies().size()));
+        // since the backing store is a treemap the list will be sorted so we can just check each
+        // instance is the same
+        for (int i = 0; i < expectedInstance.getPolicies().size(); i++) {
+            EnrichPolicy.NamedPolicy expected = expectedInstance.getPolicies().get(i);
+            EnrichPolicy.NamedPolicy newed = newInstance.getPolicies().get(i);
+            assertThat(expected.getName(), equalTo(newed.getName()));
+            assertEqualPolicies(expected.getPolicy(), newed.getPolicy());
+        }
     }
 }

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java

@@ -1,72 +0,0 @@
-/*
- * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
- * or more contributor license agreements. Licensed under the Elastic License;
- * you may not use this file except in compliance with the Elastic License.
- */
-package org.elasticsearch.xpack.enrich.action;
-
-import org.elasticsearch.common.io.stream.Writeable;
-import org.elasticsearch.common.xcontent.XContentParser;
-import org.elasticsearch.common.xcontent.XContentType;
-import org.elasticsearch.test.AbstractSerializingTestCase;
-import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
-import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies;
-import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy;
-import static org.hamcrest.Matchers.equalTo;
-
-public class ListEnrichPolicyActionResponseTests extends AbstractSerializingTestCase<ListEnrichPolicyAction.Response> {
-    @Override
-    protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException {
-        Map<String, EnrichPolicy> policies = new HashMap<>();
-        assert parser.nextToken() == XContentParser.Token.START_OBJECT;
-        assert parser.nextToken() == XContentParser.Token.FIELD_NAME;
-        assert parser.currentName().equals("policies");
-        assert parser.nextToken() == XContentParser.Token.START_ARRAY;
-
-        XContentParser.Token token;
-        while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-            assert token == XContentParser.Token.START_OBJECT;
-            EnrichPolicy.NamedPolicy policy = EnrichPolicy.NamedPolicy.fromXContent(parser);
-            policies.put(policy.getName(), policy.getPolicy());
-        }
-
-        return new ListEnrichPolicyAction.Response(policies);
-    }
-
-    @Override
-    protected ListEnrichPolicyAction.Response createTestInstance() {
-        Map<String, EnrichPolicy> items = new HashMap<>();
-        for (int i = 0; i < randomIntBetween(0, 3); i++) {
-            EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
-            items.put(randomAlphaOfLength(3), policy);
-        }
-        return new ListEnrichPolicyAction.Response(items);
-    }
-
-    @Override
-    protected Writeable.Reader<ListEnrichPolicyAction.Response> instanceReader() {
-        return ListEnrichPolicyAction.Response::new;
-    }
-
-    @Override
-    protected void assertEqualInstances(ListEnrichPolicyAction.Response expectedInstance, ListEnrichPolicyAction.Response newInstance) {
-        assertThat(expectedInstance.getPolicies().size(), equalTo(newInstance.getPolicies().size()));
-        for (EnrichPolicy.NamedPolicy expectedPolicy: expectedInstance.getPolicies()) {
-            // contains and indexOf cannot be used here as the query source may be represented differently, so we need to check
-            // if the name is the same and if it is, use that to ensure the policies are the same
-            Optional<EnrichPolicy.NamedPolicy> maybePolicy = newInstance.getPolicies().stream()
-                .filter(p -> p.getName().equals(expectedPolicy.getName())).findFirst();
-            assertTrue(maybePolicy.isPresent());
-            EnrichPolicy.NamedPolicy newPolicy = maybePolicy.get();
-            assertEqualPolicies(expectedPolicy.getPolicy(), newPolicy.getPolicy());
-            assertThat(expectedPolicy.getName(), equalTo(newPolicy.getName()));
-        }
-    }
-}

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyActionTests.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+package org.elasticsearch.xpack.enrich.action;
+
+import org.elasticsearch.ResourceNotFoundException;
+import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.support.ActionTestUtils;
+import org.elasticsearch.action.support.master.AcknowledgedResponse;
+import org.elasticsearch.cluster.service.ClusterService;
+import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.xpack.core.enrich.EnrichPolicy;
+import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction;
+import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction;
+import org.elasticsearch.xpack.enrich.AbstractEnrichTestCase;
+import org.junit.After;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies;
+import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+
+public class TransportGetEnrichPolicyActionTests extends AbstractEnrichTestCase {
+
+    @After
+    private void cleanupPolicies() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
+        final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
+        ActionTestUtils.execute(transportAction, null,
+            new GetEnrichPolicyAction.Request(),
+            new ActionListener<GetEnrichPolicyAction.Response>() {
+                @Override
+                public void onResponse(GetEnrichPolicyAction.Response response) {
+                    reference.set(response);
+                    latch.countDown();
+
+                }
+
+                public void onFailure(final Exception e) {
+                    fail();
+                }
+            });
+        latch.await();
+        assertNotNull(reference.get());
+        GetEnrichPolicyAction.Response response = reference.get();
+
+        for (EnrichPolicy.NamedPolicy policy: response.getPolicies()) {
+            final CountDownLatch loopLatch = new CountDownLatch(1);
+            final AtomicReference<AcknowledgedResponse> loopReference = new AtomicReference<>();
+            final TransportDeleteEnrichPolicyAction deleteAction = node().injector().getInstance(TransportDeleteEnrichPolicyAction.class);
+            ActionTestUtils.execute(deleteAction, null,
+                new DeleteEnrichPolicyAction.Request(policy.getName()),
+                new ActionListener<>() {
+                    @Override
+                    public void onResponse(AcknowledgedResponse acknowledgedResponse) {
+                        loopReference.set(acknowledgedResponse);
+                        loopLatch.countDown();
+                    }
+
+                    public void onFailure(final Exception e) {
+                        fail();
+                    }
+                });
+            loopLatch.await();
+            assertNotNull(loopReference.get());
+            assertTrue(loopReference.get().isAcknowledged());
+        }
+    }
+
+    public void testListPolicies() throws InterruptedException {
+        EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
+        ClusterService clusterService = getInstanceFromNode(ClusterService.class);
+        String name = "my-policy";
+
+        AtomicReference<Exception> error = saveEnrichPolicy(name, policy, clusterService);
+        assertThat(error.get(), nullValue());
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
+        final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
+        ActionTestUtils.execute(transportAction, null,
+            // empty or null should return the same
+            randomBoolean() ? new GetEnrichPolicyAction.Request() : new GetEnrichPolicyAction.Request(""),
+            new ActionListener<>() {
+                @Override
+                public void onResponse(GetEnrichPolicyAction.Response response) {
+                    reference.set(response);
+                    latch.countDown();
+
+                }
+
+                public void onFailure(final Exception e) {
+                    fail();
+                }
+            });
+        latch.await();
+        assertNotNull(reference.get());
+        GetEnrichPolicyAction.Response response = reference.get();
+
+        assertThat(response.getPolicies().size(), equalTo(1));
+
+        EnrichPolicy.NamedPolicy actualPolicy = response.getPolicies().get(0);
+        assertThat(name, equalTo(actualPolicy.getName()));
+        assertEqualPolicies(policy, actualPolicy.getPolicy());
+    }
+
+    public void testListEmptyPolicies() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
+        final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
+        ActionTestUtils.execute(transportAction, null,
+            new GetEnrichPolicyAction.Request(),
+            new ActionListener<GetEnrichPolicyAction.Response>() {
+                @Override
+                public void onResponse(GetEnrichPolicyAction.Response response) {
+                    reference.set(response);
+                    latch.countDown();
+
+                }
+
+                public void onFailure(final Exception e) {
+                    fail();
+                }
+            });
+        latch.await();
+        assertNotNull(reference.get());
+        GetEnrichPolicyAction.Response response = reference.get();
+
+        assertThat(response.getPolicies().size(), equalTo(0));
+    }
+
+    public void testGetPolicy() throws InterruptedException {
+        EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
+        ClusterService clusterService = getInstanceFromNode(ClusterService.class);
+        String name = "my-policy";
+
+        AtomicReference<Exception> error = saveEnrichPolicy(name, policy, clusterService);
+        assertThat(error.get(), nullValue());
+
+        // save a second one to verify the count below on GET
+        error = saveEnrichPolicy("something-else", randomEnrichPolicy(XContentType.JSON), clusterService);
+        assertThat(error.get(), nullValue());
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
+        final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
+        ActionTestUtils.execute(transportAction, null,
+            new GetEnrichPolicyAction.Request(name),
+            new ActionListener<GetEnrichPolicyAction.Response>() {
+                @Override
+                public void onResponse(GetEnrichPolicyAction.Response response) {
+                    reference.set(response);
+                    latch.countDown();
+
+                }
+
+                public void onFailure(final Exception e) {
+                    fail();
+                }
+            });
+        latch.await();
+        assertNotNull(reference.get());
+        GetEnrichPolicyAction.Response response = reference.get();
+
+        assertThat(response.getPolicies().size(), equalTo(1));
+
+        EnrichPolicy.NamedPolicy actualPolicy = response.getPolicies().get(0);
+        assertThat(name, equalTo(actualPolicy.getName()));
+        assertEqualPolicies(policy, actualPolicy.getPolicy());
+    }
+
+    public void testGetPolicyThrowsError() throws InterruptedException {
+        EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON);
+        ClusterService clusterService = getInstanceFromNode(ClusterService.class);
+        String name = "my-policy";
+
+        AtomicReference<Exception> error = saveEnrichPolicy(name, policy, clusterService);
+        assertThat(error.get(), nullValue());
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<Exception> reference = new AtomicReference<>();
+        final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
+        ActionTestUtils.execute(transportAction, null,
+            new GetEnrichPolicyAction.Request("non-exists"),
+            new ActionListener<GetEnrichPolicyAction.Response>() {
+                @Override
+                public void onResponse(GetEnrichPolicyAction.Response response) {
+                    fail();
+                }
+
+                public void onFailure(final Exception e) {
+                    reference.set(e);
+                    latch.countDown();
+                }
+            });
+        latch.await();
+        assertNotNull(reference.get());
+        assertThat(reference.get(), instanceOf(ResourceNotFoundException.class));
+        assertThat(reference.get().getMessage(),
+            equalTo("Policy [non-exists] was not found"));
+    }
+}

x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json

@@ -13,6 +13,10 @@
               "description" : "The name of the enrich policy"
             }
           }
+        },
+        {
+          "path": "/_enrich/policy",
+          "methods": [ "GET" ]
         }
       ]
     }

x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.list_policy.json

@@ -1,14 +0,0 @@
-{
-  "enrich.list_policy": {
-    "documentation": "https://www.elastic.co/guide/en/elasticsearch/reference/current/enrich-list-policy.html",
-    "stability" : "stable",
-    "url": {
-      "paths": [
-        {
-          "path": "/_enrich/policy",
-          "methods": [ "GET" ]
-        }
-      ]
-    }
-  }
-}