issues/243 - Refactor integration tests to use mocked node.

.gitignore

@@ -1,5 +1,6 @@
 HELP.md
 .gradle
+assets/
 build/
 src/test/resources/deploy-accounts/nctl
 !gradle/wrapper/gradle-wrapper.jar

src/test/java/com/casper/sdk/service/AbstractJsonRpcTests.java

@@ -8,6 +8,7 @@
 import org.junit.jupiter.api.BeforeAll;
 
 import java.net.MalformedURLException;
+import java.net.URI;
 
 /**
  * Abstract class for testing json rpc methods
@@ -23,16 +24,22 @@ public enum CasperNetwork {
         MAIN_NET("65.109.54.159", 7777),
         TEST_NET("85.114.132.133", 7777),
         NCTL("127.0.0.1", 11101),
-        NCTL_SPECULATIVE("127.0.0.1", 25101);
+        NCTL_SPECULATIVE("127.0.0.1", 25101),
+        MOCK("localhost", 7777);
 
         private final String ip;
         private final int port;
+
+        public URI getUri() {
+            return URI.create("http://" + ip + ":" + port);
+        }
     }
 
     protected static CasperService casperServiceMainnet;
     protected static CasperService casperServiceTestnet;
     protected static CasperService casperServiceNctl;
     protected static CasperService speculativeCasperServiceNctl;
+    protected static CasperService casperServiceMock;
 
     @BeforeAll
     public static void setUp() throws MalformedURLException {
@@ -44,5 +51,6 @@ public static void setUp() throws MalformedURLException {
                 CasperNetwork.NCTL.getPort());
         speculativeCasperServiceNctl = CasperService.usingPeer(CasperNetwork.NCTL_SPECULATIVE.getIp(),
                 CasperNetwork.NCTL_SPECULATIVE.getPort());
+        casperServiceMock = CasperService.usingPeer(CasperNetwork.MOCK.ip, CasperNetwork.MOCK.port);
     }
 }

src/test/java/com/casper/sdk/test/MockNode.java

@@ -27,4 +27,9 @@ public void setDispatcher(final Dispatcher dispatcher) {
         mockWebServer.setDispatcher(dispatcher);
     }
 
-}
+    public RcpResponseDispatcher withRcpResponseDispatcher() {
+        final RcpResponseDispatcher whenDispatcher = new RcpResponseDispatcher();
+        setDispatcher(whenDispatcher);
+        return whenDispatcher;
+    }
+}

src/test/java/com/casper/sdk/test/RcpResponseDispatcher.java

@@ -0,0 +1,109 @@
+package com.casper.sdk.test;
+
+
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+import okhttp3.mockwebserver.Dispatcher;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.RecordedRequest;
+import okio.Buffer;
+import org.hamcrest.CustomMatcher;
+import org.hamcrest.Matcher;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author [email protected]
+ */
+public class RcpResponseDispatcher extends Dispatcher {
+
+    private static class MethodMatcher extends CustomMatcher<String> {
+        private final String method;
+
+        MethodMatcher(final String method) {
+            super("MethodMatcher");
+            this.method = method;
+        }
+
+        @Override
+        public boolean matches(final Object item) {
+            return this.method.equals(((DocumentContext) item).read("$.method", String.class));
+        }
+    }
+
+    private static class JsonBodyMatcher extends CustomMatcher<String> {
+
+        private final String jsonPath;
+        private final String expeted;
+
+        JsonBodyMatcher(final String jsonPath, final String expected) {
+            super("JsonBodyMatcher");
+            this.jsonPath = jsonPath;
+            this.expeted = expected;
+        }
+
+        @Override
+        public boolean matches(final Object item) {
+            final String actual = ((DocumentContext) item).read(this.jsonPath, String.class);
+            return this.expeted.equals(actual);
+        }
+    }
+
+    private final List<Matcher<?>> matchers = new ArrayList<>();
+    private URL resource;
+
+    @NotNull
+    @Override
+    public MockResponse dispatch(final RecordedRequest recordedRequest) {
+
+        final String body = recordedRequest.getBody().readString(StandardCharsets.UTF_8);
+        final DocumentContext ctx = JsonPath.parse(body);
+
+        for (final Matcher<?> matcher : matchers) {
+            if (!matcher.matches(ctx)) {
+                return new MockResponse().setResponseCode(404).setBody(matcher.toString());
+            }
+        }
+
+        //noinspection ConstantConditions
+        try (final InputStream in = resource.openStream();
+             final Buffer buffer = new Buffer().readFrom(in)) {
+
+            return new MockResponse().setResponseCode(200)
+                    .addHeader("Content-Type", "application/json")
+                    .setBody(buffer);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public RcpResponseDispatcher withMethod(final String method) {
+        return addMatcher(new MethodMatcher(method));
+    }
+
+    public RcpResponseDispatcher withBody(final String jsonPath, final String expected) {
+        return addMatcher(new JsonBodyMatcher(jsonPath, expected));
+    }
+
+    public RcpResponseDispatcher addMatcher(final Matcher<?> matcher) {
+        this.matchers.add(matcher);
+        return this;
+    }
+
+    public RcpResponseDispatcher thenDispatch(final URL resource) {
+        this.resource = resource;
+        return this;
+    }
+
+    public RcpResponseDispatcher clear() {
+        this.matchers.clear();
+        this.resource = null;
+        return this;
+    }
+}