Add support for Check-And-Set option to DELETE operation (#178)

* Add eclipse project files to .gitignore

* Add support for Check-And-Set option to DELETE operation.

.gitignore

@@ -14,3 +14,6 @@ gradle/gradlew
 gradle/gradlew.bat
 gradle/gradle
 src/gradle
+.classpath
+.project
+.settings

src/main/java/com/orbitz/consul/KeyValueClient.java

@@ -7,6 +7,7 @@
 import com.orbitz.consul.model.ConsulResponse;
 import com.orbitz.consul.model.kv.Value;
 import com.orbitz.consul.model.session.SessionInfo;
+import com.orbitz.consul.option.DeleteOptions;
 import com.orbitz.consul.option.ImmutablePutOptions;
 import com.orbitz.consul.option.PutOptions;
 import com.orbitz.consul.option.QueryOptions;
@@ -275,7 +276,7 @@ public List<String> getKeys(String key) {
      * @param key The key to delete.
      */
     public void deleteKey(String key) {
-        handle(api.deleteValue(trimLeadingSlash(key)));
+        deleteKey(key, DeleteOptions.BLANK);
     }
 
     /**
@@ -286,7 +287,22 @@ public void deleteKey(String key) {
      * @param key The key to delete.
      */
     public void deleteKeys(String key) {
-        handle(api.deleteValues(trimLeadingSlash(key), ImmutableMap.of("recurse", "true")));
+        deleteKey(key, DeleteOptions.RECURSE);
+    }
+
+    /**
+     * Deletes a specified key.
+     *
+     * DELETE /v1/kv/{key}
+     *
+     * @param key The key to delete.
+     * @param deleteOptions DELETE options (e.g. recurse, cas)
+     */
+    public void deleteKey(String key, DeleteOptions deleteOptions) {
+        checkArgument(StringUtils.isNotEmpty(key), "Key must be defined");
+        Map<String, Object> query = deleteOptions.toQuery();
+
+        handle(api.deleteValues(trimLeadingSlash(key), query));
     }
 
     /**
@@ -365,11 +381,8 @@ Call<Boolean> putValue(@Path("key") String key,
                                @Body RequestBody data,
                                @QueryMap Map<String, Object> query);
 
-        @DELETE("kv/{key}")
-        Call<Void> deleteValue(@Path("key") String key);
-
         @DELETE("kv/{key}")
         Call<Void> deleteValues(@Path("key") String key,
-                                @QueryMap Map<String, String> query);
+                                @QueryMap Map<String, Object> query);
     }
 }

src/main/java/com/orbitz/consul/option/DeleteOptions.java

@@ -0,0 +1,39 @@
+package com.orbitz.consul.option;
+
+import static com.orbitz.consul.option.Options.optionallyAdd;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.immutables.value.Value;
+
+import com.google.common.base.Optional;
+
+@Value.Immutable
+public abstract class DeleteOptions implements ParamAdder {
+
+	public static final DeleteOptions BLANK = ImmutableDeleteOptions.builder().build();
+	public static final DeleteOptions RECURSE = ImmutableDeleteOptions.builder().recurse(true).build();
+
+	public abstract Optional<Long> getCas();
+
+	public abstract Optional<Boolean> getRecurse();
+
+	@Value.Derived
+	public boolean isRecurse() {
+		return getRecurse().isPresent();
+	}
+
+	@Override
+	public Map<String, Object> toQuery() {
+		final Map<String, Object> result = new HashMap<>();
+
+		if (isRecurse()) {
+			result.put("recurse", "");
+		}
+
+		optionallyAdd(result, "cas", getCas());
+
+		return result;
+	}
+}

src/test/java/com/orbitz/consul/KeyValueTests.java

@@ -6,6 +6,8 @@
 import com.orbitz.consul.model.kv.Value;
 import com.orbitz.consul.model.session.ImmutableSession;
 import com.orbitz.consul.model.session.SessionCreatedResponse;
+import com.orbitz.consul.option.ImmutableDeleteOptions;
+import com.orbitz.consul.option.ImmutableDeleteOptions.Builder;
 import com.orbitz.consul.option.QueryOptions;
 import org.junit.Test;
 
@@ -125,6 +127,51 @@ public void shouldDeleteRecursively() throws Exception {
 
     }
 
+    @Test
+    public void shouldDeleteCas() throws Exception {
+        KeyValueClient keyValueClient = client.keyValueClient();
+        String key = UUID.randomUUID().toString();
+        final String value = UUID.randomUUID().toString();
+
+        /**
+         * Update the value twice and remember the value at each step
+         */
+        keyValueClient.putValue(key, value);
+
+        final Optional<Value> valueAfter1stPut = keyValueClient.getValue(key);
+        assertTrue(valueAfter1stPut.isPresent());
+        assertTrue(valueAfter1stPut.get().getValueAsString().isPresent());
+
+        keyValueClient.putValue(key, UUID.randomUUID().toString());
+
+        final Optional<Value> valueAfter2ndPut = keyValueClient.getValue(key);
+        assertTrue(valueAfter2ndPut.isPresent());
+        assertTrue(valueAfter2ndPut.get().getValueAsString().isPresent());
+
+        /**
+         * Trying to delete the key once with the older lock, which should not
+         * work
+         */
+        final Builder deleteOptionsBuilderWithOlderLock = ImmutableDeleteOptions.builder();
+        deleteOptionsBuilderWithOlderLock.cas(valueAfter1stPut.get().getModifyIndex());
+        final ImmutableDeleteOptions deleteOptionsWithOlderLock = deleteOptionsBuilderWithOlderLock.build();
+
+        keyValueClient.deleteKey(key, deleteOptionsWithOlderLock);
+
+        assertTrue(keyValueClient.getValueAsString(key).isPresent());
+
+        /**
+         * Deleting the key with the most recent lock, which should work
+         */
+        final Builder deleteOptionsBuilderWithLatestLock = ImmutableDeleteOptions.builder();
+        deleteOptionsBuilderWithLatestLock.cas(valueAfter2ndPut.get().getModifyIndex());
+        final ImmutableDeleteOptions deleteOptionsWithLatestLock = deleteOptionsBuilderWithLatestLock.build();
+
+        keyValueClient.deleteKey(key, deleteOptionsWithLatestLock);
+
+        assertFalse(keyValueClient.getValueAsString(key).isPresent());
+    }
+
     @Test
     public void acquireAndReleaseLock() throws Exception {
         KeyValueClient keyValueClient = client.keyValueClient();