Changed restmodel to use CompletableFuture from java 8

Author: jepp3

src/main/java/org/codebrewery/CrudModelInterface.java

@@ -3,6 +3,7 @@
 import com.ning.http.client.ListenableFuture;
 
 import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
 /**
@@ -26,26 +27,26 @@ public interface CrudModelInterface {
      *
      * The url will be constructed the following way baseurl + identifierValue
      */
-    void fetch(ActionCompletedInterface actionCompletedInterface) throws ExecutionException, InterruptedException;
+    CompletableFuture<RESTModel> fetch();
 
     /**
      * Destroys the single instance of the model
      *
      * The url will be constructed the following way baseurl + identifierValue
      */
-    void destroy(ActionCompletedInterface actionCompletedInterface) throws ExecutionException, InterruptedException;
+    CompletableFuture<RESTModel> destroy();
 
     /**
      * updates the resource
      *
      * The url will be constructed the following way baseurl + identifierValue
      */
-    void update(ActionCompletedInterface actionCompletedInterface) throws ExecutionException, InterruptedException, IOException;
+    CompletableFuture<RESTModel> update() throws IOException;
 
     /**
      * Creates a new resource
      *
      * The url will only consist o fthe base url
      */
-    void create(ActionCompletedInterface actionCompletedInterface) throws ExecutionException, InterruptedException, IOException;
+    CompletableFuture<RESTModel> create() throws IOException;
 }

src/main/java/org/codebrewery/RESTModel.java

@@ -1,11 +1,13 @@
 package org.codebrewery;
 
-import com.ning.http.client.AsyncCompletionHandler;
 import com.ning.http.client.AsyncHttpClient;
+import com.ning.http.client.ListenableFuture;
 import com.ning.http.client.Response;
 import org.json.simple.parser.ParseException;
 
 import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.ExecutionException;
 
 
@@ -49,13 +51,13 @@ public abstract class RESTModel implements CrudModelInterface {
 
 
 
-    protected String generateCollectionUrl() {
+    String generateCollectionUrl() {
 
         return config.getRequestBaseUrl() + "/" + resourceUrl();
 
     }
 
-    protected String generatedInstanceUrl() {
+    String generatedInstanceUrl() {
 
         return generateCollectionUrl() + "/" + identifierValue();
 
@@ -72,12 +74,11 @@ public void setConfiguration( RestModelConfiguration config ) {
      *
      * It will use the JSONConverter, that will use a ObjectMapper to resolve the different attribute names
      *
-     * @param response
      * @return
      * @throws IOException
      * @throws ParseException
      */
-    protected RESTModel convertJSONToRESTModelObject(String json) throws IOException, ParseException {
+    RESTModel convertJSONToRESTModelObject(String json) throws IOException, ParseException {
 
         return JSONConverter.unMarshall(json, this.getClass());
     }
@@ -91,58 +92,57 @@ protected RESTModel convertJSONToRESTModelObject(String json) throws IOException
      * @throws IOException
      * @throws ParseException
      */
-    protected String convertRESTModelToJSON() throws IOException {
+    String convertRESTModelToJSON() throws IOException {
 
         return JSONConverter.marshall(this);
 
     }
 
-    protected AsyncCompletionHandler getAsyncCompletionHandler(ActionCompletedInterface actions) {
+    CompletableFuture<RESTModel> wrapExecutionInCompletableFuture(ListenableFuture<Response> futureResponse) {
 
-        return new AsyncCompletionHandler(){
+        return CompletableFuture.supplyAsync(() -> {
 
-            @Override
-            public Object onCompleted(Response response) throws Exception {
+            try {
+                return convertJSONToRESTModelObject(futureResponse.get().getResponseBody());
+            } catch (IOException | ParseException | InterruptedException | ExecutionException e4) {
 
+                throw new CompletionException(e4);
 
-                actions.onDone(convertJSONToRESTModelObject(response.getResponseBody()));
-
-                return null;
             }
 
-            @Override
-            public void onThrowable(Throwable t) {
 
-                actions.onError(t);
+        });
+    }
 
-            }
-        };
 
-    }
+    ListenableFuture<Response> execute(AsyncHttpClient.BoundRequestBuilder boundRequestBuilder) {
+
+        return boundRequestBuilder.execute();
 
+    }
 
-    public void fetch(final ActionCompletedInterface actions) throws ExecutionException, InterruptedException {
+    public CompletableFuture<RESTModel> fetch()  {
 
-        new AsyncHttpClient().prepareGet(generatedInstanceUrl()).execute(getAsyncCompletionHandler(actions));
+        return wrapExecutionInCompletableFuture(execute(new AsyncHttpClient().prepareGet(generatedInstanceUrl())));
 
     }
 
-    public void destroy(final ActionCompletedInterface actions) throws ExecutionException, InterruptedException {
+    public CompletableFuture<RESTModel> destroy() {
 
-        new AsyncHttpClient().prepareDelete(generatedInstanceUrl()).execute(getAsyncCompletionHandler(actions));
+        return wrapExecutionInCompletableFuture(execute(new AsyncHttpClient().prepareDelete(generatedInstanceUrl())));
 
     }
 
-    public void update(final ActionCompletedInterface actions) throws ExecutionException, InterruptedException, IOException {
+   public CompletableFuture<RESTModel> update() throws IOException {
 
-        new AsyncHttpClient().preparePut(generatedInstanceUrl()).setBody(convertRESTModelToJSON()).execute(getAsyncCompletionHandler(actions));
+        return wrapExecutionInCompletableFuture(execute(new AsyncHttpClient().preparePut(generatedInstanceUrl()).setBody(convertRESTModelToJSON())));
 
     }
 
 
-    public void create(final ActionCompletedInterface actions) throws ExecutionException, InterruptedException, IOException {
+    public CompletableFuture<RESTModel> create() throws IOException {
 
-        new AsyncHttpClient().preparePost(generateCollectionUrl()).setBody(convertRESTModelToJSON()).execute(getAsyncCompletionHandler(actions));
+        return wrapExecutionInCompletableFuture(execute(new AsyncHttpClient().preparePost(generateCollectionUrl()).setBody(convertRESTModelToJSON())));
 
     }
 

src/test/java/org/codebrewery/MockRestModel.java

@@ -1,19 +1,26 @@
 package org.codebrewery;
 
+import com.ning.http.client.AsyncHttpClient;
+import com.ning.http.client.ListenableFuture;
+import com.ning.http.client.Response;
+import org.codehaus.jackson.annotate.JsonIgnoreProperties;
 import org.json.simple.JSONObject;
 
 import java.io.IOException;
 
 /**
  * Created by jepp3 on 2015-09-06.
  */
+@JsonIgnoreProperties({"boundRequestBuilder"})
 public class MockRestModel extends RESTModel {
 
     public final String name;
+    private AsyncHttpClient.BoundRequestBuilder boundRequestBuilder;
 
     public MockRestModel() {
         this.name = "";
     }
+
     public MockRestModel(String name) {
         this.name = name;
     }
@@ -30,5 +37,15 @@ String identifierValue() {
 
     }
 
+    @Override
+    ListenableFuture<Response> execute(AsyncHttpClient.BoundRequestBuilder boundRequestBuilder) {
+
+        this.boundRequestBuilder = boundRequestBuilder;
+        return null;
 
+    }
+    // for testing
+    public AsyncHttpClient.BoundRequestBuilder getBoundRequestBuilder() {
+        return boundRequestBuilder;
+    }
 }

src/test/java/org/codebrewery/TestAbstractRestModel.java

@@ -2,11 +2,19 @@
 
 import com.ning.http.client.AsyncCompletionHandler;
 
+import com.ning.http.client.AsyncHttpClient;
+import com.ning.http.client.Request;
+import com.ning.http.client.Response;
+import com.ning.http.client.listenable.AbstractListenableFuture;
 import org.junit.Before;
 import org.junit.Test;
 
 
 import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import static org.junit.Assert.*;
 
@@ -35,7 +43,7 @@ public void testThatGeneratingFullHttpUrlForInstanceCombinesColectionUrlWithIden
 
         String fullHttpUrl = mockModel.generatedInstanceUrl();
 
-        assertEquals("http://localhost:8081/api/dogs/identifier",fullHttpUrl);
+        assertEquals("http://localhost:8081/api/dogs/identifier", fullHttpUrl);
 
     }
 
@@ -57,70 +65,98 @@ public String getBaseUrl() {
 
 
     @Test
-    public void testThatAsyncCompletionHandlerDoesWhatItsSuposedTo() throws Exception {
+    public void testConvertRESTModelToJSON() throws IOException {
 
-        ActionCompletedInterface mockAction = new ActionCompletedInterface() {
+        String json = mockModel.convertRESTModelToJSON();
 
-            @Override
-            public void onDone(RESTModel model) {
-                    MockRestModel resp = (MockRestModel) model;
-                    assertNotNull(model);
-                    assertEquals(resp.name, "plutoTheTester");
-            }
+        assertEquals("{\"name\":\"plutoTheTester\"}",json);
 
-            @Override
-            public void onError(Throwable e) {
+    }
 
-                fail();
-            }
-        };
 
-        AsyncCompletionHandler handler = mockModel.getAsyncCompletionHandler(mockAction);
+    @Test
+    public void testThatWrapExecutionInCompletableFutureMethodReturnsValidFuture() throws Exception {
+
 
-        // invoke the handler directly
-        handler.onCompleted(new MockResponse());
+        CompletableFuture<RESTModel> handler = mockModel.wrapExecutionInCompletableFuture(new AbstractListenableFuture<Response>() {
+            @Override
+            public void done() {
 
+            }
 
-    }
+            @Override
+            public void abort(Throwable throwable) {
 
+            }
 
-    @Test
-    public void testThatAsyncCompletionHandleronERRORDoesWhatItsSuposedTo() throws Exception {
+            @Override
+            public void touch() {
 
-        ActionCompletedInterface mockAction = new ActionCompletedInterface() {
+            }
 
             @Override
-            public void onDone(RESTModel model) {
+            public boolean cancel(boolean mayInterruptIfRunning) {
+                return false;
+            }
 
-                fail();
+            @Override
+            public boolean isCancelled() {
+                return false;
             }
 
             @Override
-            public void onError(Throwable e) {
+            public boolean isDone() {
+                return false;
+            }
 
-                assertNotNull(e);
+            @Override
+            public Response get() throws InterruptedException, ExecutionException {
+                return new MockResponse();
+            }
 
+            @Override
+            public Response get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+                return null;
             }
-        };
+        });
 
-        AsyncCompletionHandler handler = mockModel.getAsyncCompletionHandler(mockAction);
+        MockRestModel resp = (MockRestModel) handler.get();
 
-        // invoke the handler directly
-        handler.onThrowable(new Exception());
+        assertEquals("plutoTheTester", resp.name);
+
+    }
+
+
+    @Test
+    public void testThatFetchReturnsRightUrl() {
+        CompletableFuture<RESTModel> future = mockModel.fetch();
+        Request request = mockModel.getBoundRequestBuilder().build();
 
+        assertEquals("http://localhost:8081/api/dogs/identifier",request.getUrl());
 
     }
 
 
     @Test
-    public void testConvertRESTModelToJSON() throws IOException {
+    public void testThatPutReturnsRightUrl() throws IOException {
+        CompletableFuture<RESTModel> future = mockModel.create();
+        Request request = mockModel.getBoundRequestBuilder().build();
 
-        String json = mockModel.convertRESTModelToJSON();
+        assertEquals("http://localhost:8081/api/dogs",request.getUrl());
 
-        assertEquals("{\"name\":\"plutoTheTester\"}",json);
+    }
+
+    @Test
+    public void testThatPostReturnsRightUrl() {
+        CompletableFuture<RESTModel> future = mockModel.destroy();
+        Request request = mockModel.getBoundRequestBuilder().build();
+
+        assertEquals("http://localhost:8081/api/dogs/identifier",request.getUrl());
 
     }
 
 
 
+
+
 }