HLRC: Deactivate Watch API

client/rest-high-level/src/main/java/org/elasticsearch/client/watcher/DeactivateWatchRequest.java

@@ -28,25 +28,27 @@ public class DeactivateWatchRequest implements Validatable {
     private final String watchId;
 
     public DeactivateWatchRequest(String watchId) {
+
+        if (watchId == null) {
+            ValidationException exception = new ValidationException();
+            exception.addValidationError("watch id is missing");
+            throw exception;
+        } else if (PutWatchRequest.isValidId(watchId) == false) {
+            ValidationException exception = new ValidationException();
+            exception.addValidationError("watch id contains whitespace");
+            throw exception;
+        }
+
         this.watchId = watchId;
     }
 
     public String getWatchId() {
         return watchId;
     }
 
+     // as per discussion https://github.com/elastic/elasticsearch/pull/34192/files#r221994527, keeping validate method as a no-op relic
     @Override
     public Optional<ValidationException> validate() {
-        ValidationException exception = new ValidationException();
-
-        if (watchId == null) {
-            exception.addValidationError("watch id is missing");
-        } else if (PutWatchRequest.isValidId(watchId) == false) {
-            exception.addValidationError("watch id contains whitespace");
-        }
-
-        return exception.validationErrors().isEmpty()
-            ? Optional.empty()  // empty indicates no validation errors
-            : Optional.of(exception);
+        return Optional.empty();  // empty indicates no validation errors
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/watcher/DeactivateWatchResponse.java

@@ -28,6 +28,20 @@
 public class DeactivateWatchResponse {
     private WatchStatus status;
 
+    private static final ParseField STATUS_FIELD = new ParseField("status");
+    private static final ConstructingObjectParser<DeactivateWatchResponse, Void> PARSER
+        = new ConstructingObjectParser<>("x_pack_deactivate_watch_response", true,
+        (fields) -> new DeactivateWatchResponse((WatchStatus) fields[0]));
+    static {
+        PARSER.declareObject(ConstructingObjectParser.constructorArg(),
+            (parser, context) -> WatchStatus.parse(parser),
+            STATUS_FIELD);
+    }
+
+    public static DeactivateWatchResponse fromXContent(XContentParser parser) throws IOException {
+        return PARSER.parse(parser, null);
+    }
+
     public DeactivateWatchResponse(WatchStatus status) {
         this.status = status;
     }
@@ -48,18 +62,4 @@ public int hashCode() {
     public WatchStatus getStatus() {
         return status;
     }
-
-    private static final ParseField STATUS_FIELD = new ParseField("status");
-    private static final ConstructingObjectParser<DeactivateWatchResponse, Void> PARSER
-        = new ConstructingObjectParser<>("x_pack_deactivate_watch_response", true,
-        (fields) -> new DeactivateWatchResponse((WatchStatus) fields[0]));
-    static {
-        PARSER.declareObject(ConstructingObjectParser.constructorArg(),
-            (parser, context) -> WatchStatus.parse(parser),
-            STATUS_FIELD);
-    }
-
-    public static DeactivateWatchResponse fromXContent(XContentParser parser) throws IOException {
-        return PARSER.parse(parser, null);
-    }
 }

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

@@ -55,21 +55,19 @@ private PutWatchResponse createWatch(String watchId) throws Exception {
 
     public void testDeactivateWatch() throws Exception {
         // Deactivate a watch that exists
-        {
-            String watchId = randomAlphaOfLength(10);
-            createWatch(watchId);
-            DeactivateWatchResponse response = highLevelClient().watcher().deactivateWatch(
-                new DeactivateWatchRequest(watchId), RequestOptions.DEFAULT);
-            assertThat(response.getStatus().state().isActive(), is(false));
-        }
+        String watchId = randomAlphaOfLength(10);
+        createWatch(watchId);
+        DeactivateWatchResponse response = highLevelClient().watcher().deactivateWatch(
+            new DeactivateWatchRequest(watchId), RequestOptions.DEFAULT);
+        assertThat(response.getStatus().state().isActive(), is(false));
+    }
+    public void testDeactivateWatch404() throws Exception {
         // Deactivate a watch that does not exist
-        {
-            String watchId = randomAlphaOfLength(10);
-            ElasticsearchStatusException exception = expectThrows(ElasticsearchStatusException.class,
-                () -> highLevelClient().watcher().deactivateWatch(new DeactivateWatchRequest(watchId), RequestOptions.DEFAULT));
-            assertEquals(RestStatus.NOT_FOUND, exception.status());
+        String watchId = randomAlphaOfLength(10);
+        ElasticsearchStatusException exception = expectThrows(ElasticsearchStatusException.class,
+            () -> highLevelClient().watcher().deactivateWatch(new DeactivateWatchRequest(watchId), RequestOptions.DEFAULT));
+        assertEquals(RestStatus.NOT_FOUND, exception.status());
 
-        }
     }
 
     public void testDeleteWatch() throws Exception {

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

@@ -22,24 +22,20 @@
 import org.elasticsearch.client.ValidationException;
 import org.elasticsearch.test.ESTestCase;
 
-import java.util.Optional;
-
 import static org.hamcrest.Matchers.hasItem;
 
 public class DeactivateWatchRequestTests extends ESTestCase {
 
     public void testNullId() {
-        DeactivateWatchRequest request = new DeactivateWatchRequest(null);
-        Optional<ValidationException> actual = request.validate();
-        assertTrue(actual.isPresent());
-        assertThat(actual.get().validationErrors(), hasItem("watch id is missing"));
+        ValidationException actual = expectThrows(ValidationException.class, () -> new DeactivateWatchRequest(null));
+        assertNotNull(actual);
+        assertThat(actual.validationErrors(), hasItem("watch id is missing"));
     }
 
     public void testInvalidId() {
-        DeactivateWatchRequest request = new DeactivateWatchRequest("Watch Id with spaces");
-        Optional<ValidationException> actual = request.validate();
-        assertTrue(actual.isPresent());
-        assertThat(actual.get().validationErrors(), hasItem("watch id contains whitespace"));
+        ValidationException actual = expectThrows(ValidationException.class, () -> new DeactivateWatchRequest("Watch id has spaces"));
+        assertNotNull(actual);
+        assertThat(actual.validationErrors(), hasItem("watch id contains whitespace"));
     }
 
 }