[FAB-16745] Remove SDK from integration tests

- Remove the use of the SDK to setup fabric
- Use the script.sh in the cli container
  for the channel, and cc install etc.
- Use Java ProcessBuilder to then issue
  peer exec/peer chaincode invoke calls in
  the cli container

- This change is remove dependency on the SDK
  and focus on the tests that do exist
- Will move to Cucumber in due course

Change-Id: I0a6529a0bf3e324e432622f8ada35a2d2ec18829
Signed-off-by: Matthew B. White <[email protected]>

Author: mbwhite

.gitignore

@@ -37,4 +37,9 @@ nbdist/
 
 local-config.yaml
 gradle.properties
-.vscode/
+.vscode/
+
+# The local repos for the chaincode
+
+fabric-chaincode-example-sacc/repository
+fabric-chaincode-example-sbe/repository

fabric-chaincode-example-sbe/src/main/java/org/hyperledger/fabric/example/EndorsementCC.java

@@ -32,6 +32,7 @@ public class EndorsementCC extends ChaincodeBase {
             functions.put("getval", EndorsementCC.class.getMethod("getVal", ChaincodeStub.class));
             functions.put("cc2cc", EndorsementCC.class.getMethod("invokeCC", ChaincodeStub.class));
         } catch (NoSuchMethodException e) {
+            e.printStackTrace();
             _logger.error(e);
         }
     }
@@ -44,6 +45,7 @@ public Response init(ChaincodeStub stub) {
             _logger.info("Init done");
             return newSuccessResponse();
         } catch (Throwable e) {
+            e.printStackTrace();
             return newErrorResponse(e);
         }
     }
@@ -59,6 +61,7 @@ public Response invoke(ChaincodeStub stub) {
             }
             return newErrorResponse("Unknown function " + funcName);
         } catch (Throwable e) {
+            e.printStackTrace();
             return newErrorResponse(e);
         }
     }
@@ -189,13 +192,16 @@ public Response setVal(ChaincodeStub stub) {
 
             if ("pub".equals(parameters.get(0))) {
                 stub.putStringState("pub", parameters.get(1));
+                _logger.info("Put state "+parameters.get(1));
             } else if ("priv".equals(parameters.get(0))) {
                 stub.putPrivateData("col", "priv", parameters.get(1));
+                _logger.info("Put Private  "+parameters.get(1));
             } else {
                 return newErrorResponse("Unknown key specified");
             }
             return newSuccessResponse(new byte[]{});
         } catch (Throwable e) {
+            e.printStackTrace();
             return newErrorResponse(e);
         }
     }
@@ -209,13 +215,16 @@ public Response getVal(ChaincodeStub stub) {
             }
 
             if ("pub".equals(parameters.get(0))) {
+                _logger.info(stub.getState("pub"));
                 return newSuccessResponse(stub.getState("pub"));
             } else if ("priv".equals(parameters.get(0))) {
+                _logger.info("get privateData" +stub.getPrivateData("col", "priv"));
                 return newSuccessResponse(stub.getPrivateData("col", "priv"));
             } else {
                 return newErrorResponse("Unknown key specified");
             }
         } catch (Throwable e) {
+            e.printStackTrace();
             return newErrorResponse(e);
         }
     }

fabric-chaincode-integration-test/build.gradle

@@ -3,7 +3,22 @@ dependencies {
     testCompile 'org.testcontainers:testcontainers:1.7.1'
     testCompile 'org.hyperledger.fabric-sdk-java:fabric-sdk-java:1.4.1'
     compile project(':fabric-chaincode-shim')
+    implementation group: 'org.json', name: 'json', version: '20180813'
 }
 
 build.dependsOn project(':fabric-chaincode-docker').buildImage
 
+ test {
+    // Always run tests, even when nothing changed.
+    dependsOn 'cleanTest'
+    
+    // Show test results.
+    testLogging {
+        events "passed", "skipped", "failed"
+        showExceptions true
+        showCauses true
+        showStandardStreams true
+        exceptionFormat "full"
+        
+    }
+ }

fabric-chaincode-integration-test/src/test/java/org/hyperleder/fabric/shim/integration/Command.java

@@ -0,0 +1,119 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package org.hyperleder.fabric.shim.integration;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class Command {
+
+    protected List<String> cmd;
+    protected Map<String, String> env;
+
+    Command(List<String> cmd) {
+        this.cmd = cmd;
+        this.env = new HashMap<>();
+
+    }
+
+    class Result {
+        ArrayList<String> stdout;
+        ArrayList<String> stderr;
+        int exitcode;
+    }
+
+    /**
+     * Run but don't suppress the output being printed directly
+     */
+    public Result run() {
+        return this.run(false);
+    }
+
+    /**
+     * Run the command, and process the output to arrays for later parsing and checking
+     * 
+     * @param quiet true if the output should NOT be printed directly to System.out/System.err
+     */
+    public Result run(boolean quiet) {
+
+        ProcessBuilder processBuilder = new ProcessBuilder(cmd);
+        processBuilder.environment().putAll(env);
+        final Result result = new Result();
+
+        System.out.println("Running:" + this.toString());
+        try {
+            Process process = processBuilder.start();
+
+            CompletableFuture<ArrayList<String>> soutFut = readOutStream(process.getInputStream(),quiet?null:System.out);
+            CompletableFuture<ArrayList<String>> serrFut = readOutStream(process.getErrorStream(),quiet?null:System.err);
+
+            CompletableFuture<Result> resultFut = soutFut.thenCombine(serrFut, (stdout, stderr) -> {
+                 // print to current stderr the stderr of process and return the stdout
+                result.stderr = stderr;
+                result.stdout = stdout;
+                return result;
+             });
+
+            result.exitcode = process.waitFor();
+            // get stdout once ready, blocking
+            resultFut.get();
+
+        } catch (IOException | InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+            result.exitcode = -1;
+        }
+
+        return result;
+    }
+
+    /**
+     * Collect the information from the executed process and add them to a result object
+     * 
+     * @param is
+     * @param stream
+     * @return Completable Future with the array list of the stdout/sstderr
+     */
+    CompletableFuture<ArrayList<String>> readOutStream(InputStream is, PrintStream stream) {
+        return CompletableFuture.supplyAsync(() -> {
+            try (InputStreamReader isr = new InputStreamReader(is); BufferedReader br = new BufferedReader(isr);) {
+                ArrayList<String> res = new ArrayList<String>();
+                String inputLine;
+                while ((inputLine = br.readLine()) != null) {
+                    if (stream!=null) stream.println(inputLine);
+                    res.add(inputLine);
+                }
+                return res;
+            } catch (Throwable e) {
+                throw new RuntimeException("problem with executing program", e);
+            }
+        });
+    }
+
+    public String toString() {
+        return "[" + String.join(" ", cmd) + "]";
+    }
+
+    static public class Builder<T extends Command> implements Cloneable {
+        public Builder<T> duplicate() {
+            try {
+                return (Builder<T>) this.clone();
+            } catch (CloneNotSupportedException e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+    }
+}

fabric-chaincode-integration-test/src/test/java/org/hyperleder/fabric/shim/integration/Docker.java

@@ -0,0 +1,77 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+package org.hyperleder.fabric.shim.integration;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Represents the 'peer' cli command
+ * 
+ * 
+ *
+ */
+public class Docker extends Command {
+
+    public static DockerBuilder newBuilder(){
+        return new DockerBuilder();
+    }
+
+    static public class DockerBuilder implements Cloneable {
+        boolean exec;
+        String container;
+        String script;
+
+        public DockerBuilder duplicate() {
+            try {
+                return (DockerBuilder) this.clone();
+            } catch (CloneNotSupportedException e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+        
+        public DockerBuilder script(String script){
+            this.script = script;
+            return this;
+        }
+
+        public DockerBuilder container(String container){
+            this.container = container;
+            return this;
+        }
+
+        public DockerBuilder exec(){
+            this.exec = true;
+            return this;
+        }        
+        public Docker build(){
+
+            ArrayList<String> list = new ArrayList<>();
+            list.add("docker");
+            if(exec){
+                list.add("exec");
+
+            }
+            
+            if (container == null || container.isEmpty()){
+                throw new RuntimeException("container should be set");
+            }
+            list.add(container);
+            
+            if (script == null || script.isEmpty()){
+                throw new RuntimeException("script should be set");
+            }
+            list.add(script);
+
+            
+            return new Docker(list);
+        }
+    }
+       
+    Docker(List<String> cmd) {
+       super(cmd);
+    }
+
+}

fabric-chaincode-integration-test/src/test/java/org/hyperleder/fabric/shim/integration/DockerCompose.java

@@ -0,0 +1,74 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+package org.hyperleder.fabric.shim.integration;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Represents the 'peer' cli command
+ * 
+ * 
+ *
+ */
+public class DockerCompose extends Command {
+
+    public static DockerComposeBuilder newBuilder(){
+        return new DockerComposeBuilder();
+    }
+    
+    static public class DockerComposeBuilder extends Command.Builder<DockerCompose>{
+        String composeFile;
+
+        boolean up = true;
+        boolean detach = false;
+
+        public DockerComposeBuilder file(String composeFile){
+            this.composeFile = composeFile;
+            return this;
+        }
+        
+        public DockerComposeBuilder duplicate() {
+            return (DockerComposeBuilder) super.duplicate();
+        }
+
+        public DockerComposeBuilder up(){
+            this.up = true;
+            return this;
+        }
+        
+        public DockerComposeBuilder detach(){
+            this.detach = true;
+            return this;
+        }
+        
+        public DockerComposeBuilder down(){
+            this.up = false;
+            return this;
+        }
+      
+        public DockerCompose build(){
+
+            ArrayList<String> list = new ArrayList<>();
+            list.add("docker-compose");
+            if (composeFile!=null && !composeFile.isEmpty()) {
+                list.add("-f");
+                list.add(composeFile);
+            }
+            list.add(up?"up":"down");
+            if (detach){
+                list.add("-d");
+            }
+            
+
+            return new DockerCompose(list);
+        }
+    }
+       
+    DockerCompose(List<String> cmd) {
+       super(cmd);
+       super.env.put("COMPOSE_PROJECT_NAME","first-network");
+    }
+    
+}