Add e2e tests using the light client daemon of Cosmos

e2e/api_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"io/ioutil"
 	"net/http"
@@ -28,7 +29,10 @@ var (
 	cdc    = app.MakeCodec()
 )
 
-const lcdEndpoint = "http://127.0.0.1:1317/"
+const (
+	lcdEndpoint        = "http://127.0.0.1:1317/"
+	lcdPostContentType = "application/json"
+)
 
 func lcdGet(t *testing.T, path string, ptr interface{}) {
 	resp, err := http.Get(lcdEndpoint + path)
@@ -38,7 +42,24 @@ func lcdGet(t *testing.T, path string, ptr interface{}) {
 	require.NoError(t, err)
 	cosResp := rest.ResponseWithHeight{}
 	require.NoError(t, cdc.UnmarshalJSON(body, &cosResp))
-	require.NoError(t, cdc.UnmarshalJSON(cosResp.Result, ptr))
+	if len(cosResp.Result) > 0 {
+		require.NoError(t, cdc.UnmarshalJSON(cosResp.Result, ptr))
+	}
+}
+
+func lcdPost(t *testing.T, path string, req interface{}, ptr interface{}) {
+	reqBody, err := cdc.MarshalJSON(req)
+	require.NoError(t, err)
+	resp, err := http.Post(lcdEndpoint+path, lcdPostContentType, bytes.NewReader(reqBody))
+	require.NoError(t, err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	require.NoError(t, err)
+	cosResp := rest.ResponseWithHeight{}
+	require.NoError(t, cdc.UnmarshalJSON(body, &cosResp))
+	if len(cosResp.Result) > 0 {
+		require.NoError(t, cdc.UnmarshalJSON(cosResp.Result, ptr))
+	}
 }
 
 func TestAPI(t *testing.T) {

e2e/execution_test.go

@@ -177,9 +177,16 @@ func testExecution(t *testing.T) {
 	})
 
 	t.Run("list", func(t *testing.T) {
-		resp, err := client.ExecutionClient.List(context.Background(), &pb.ListExecutionRequest{})
-		require.NoError(t, err)
-		require.Len(t, resp.Executions, 2)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.ExecutionClient.List(context.Background(), &pb.ListExecutionRequest{})
+			require.NoError(t, err)
+			require.Len(t, resp.Executions, 2)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			execs := make([]*execution.Execution, 0)
+			lcdGet(t, "execution/list", &execs)
+			require.Len(t, execs, 2)
+		})
 	})
 
 	t.Run("many executions in parallel", func(t *testing.T) {

e2e/instance_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/mesg-foundation/engine/hash"
+	"github.com/mesg-foundation/engine/instance"
 	pb "github.com/mesg-foundation/engine/protobuf/api"
 	"github.com/stretchr/testify/require"
 )
@@ -13,18 +14,34 @@ var testInstanceHash hash.Hash
 
 func testInstance(t *testing.T) {
 	t.Run("get", func(t *testing.T) {
-		resp, err := client.InstanceClient.Get(context.Background(), &pb.GetInstanceRequest{Hash: testInstanceHash})
-		require.NoError(t, err)
-		require.Equal(t, testInstanceHash, resp.Hash)
-		require.Equal(t, testServiceHash, resp.ServiceHash)
-		require.Equal(t, hash.Dump([]string{"BAR=3", "FOO=1", "REQUIRED=4"}), resp.EnvHash)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.InstanceClient.Get(context.Background(), &pb.GetInstanceRequest{Hash: testInstanceHash})
+			require.NoError(t, err)
+			require.Equal(t, testInstanceHash, resp.Hash)
+			require.Equal(t, testServiceHash, resp.ServiceHash)
+			require.Equal(t, hash.Dump([]string{"BAR=3", "FOO=1", "REQUIRED=4"}), resp.EnvHash)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var inst *instance.Instance
+			lcdGet(t, "instance/get/"+testInstanceHash.String(), &inst)
+			require.Equal(t, testInstanceHash, inst.Hash)
+			require.Equal(t, testServiceHash, inst.ServiceHash)
+			require.Equal(t, hash.Dump([]string{"BAR=3", "FOO=1", "REQUIRED=4"}), inst.EnvHash)
+		})
 	})
 
 	t.Run("list", func(t *testing.T) {
 		t.Run("with nil filter", func(t *testing.T) {
-			resp, err := client.InstanceClient.List(context.Background(), &pb.ListInstanceRequest{})
-			require.NoError(t, err)
-			require.Len(t, resp.Instances, 1)
+			t.Run("grpc", func(t *testing.T) {
+				resp, err := client.InstanceClient.List(context.Background(), &pb.ListInstanceRequest{})
+				require.NoError(t, err)
+				require.Len(t, resp.Instances, 1)
+			})
+			t.Run("lcd", func(t *testing.T) {
+				insts := make([]*instance.Instance, 0)
+				lcdGet(t, "instance/list", &insts)
+				require.Len(t, insts, 1)
+			})
 		})
 		t.Run("do not match service", func(t *testing.T) {
 			resp, err := client.InstanceClient.List(context.Background(), &pb.ListInstanceRequest{

e2e/process_test.go

@@ -54,15 +54,27 @@ func testProcess(t *testing.T) {
 	})
 
 	t.Run("get", func(t *testing.T) {
-		p, err := client.ProcessClient.Get(context.Background(), &pb.GetProcessRequest{Hash: testProcessHash})
-		require.NoError(t, err)
-		require.True(t, p.Equal(&process.Process{
-			Hash:  p.Hash,
-			Name:  req.Name,
-			Nodes: req.Nodes,
-			Edges: req.Edges,
-		}))
-		processHash = p.Hash
+		t.Run("grpc", func(t *testing.T) {
+			p, err := client.ProcessClient.Get(context.Background(), &pb.GetProcessRequest{Hash: testProcessHash})
+			require.NoError(t, err)
+			require.True(t, p.Equal(&process.Process{
+				Hash:  p.Hash,
+				Name:  req.Name,
+				Nodes: req.Nodes,
+				Edges: req.Edges,
+			}))
+			processHash = p.Hash
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var p *process.Process
+			lcdGet(t, "process/get/"+testProcessHash.String(), &p)
+			require.True(t, p.Equal(&process.Process{
+				Hash:  p.Hash,
+				Name:  req.Name,
+				Nodes: req.Nodes,
+				Edges: req.Edges,
+			}))
+		})
 	})
 
 	t.Run("check ownership creation", func(t *testing.T) {
@@ -91,9 +103,16 @@ func testProcess(t *testing.T) {
 	})
 
 	t.Run("list", func(t *testing.T) {
-		ps, err := client.ProcessClient.List(context.Background(), &pb.ListProcessRequest{})
-		require.NoError(t, err)
-		require.Len(t, ps.Processes, 1)
+		t.Run("grpc", func(t *testing.T) {
+			ps, err := client.ProcessClient.List(context.Background(), &pb.ListProcessRequest{})
+			require.NoError(t, err)
+			require.Len(t, ps.Processes, 1)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			ps := make([]*process.Process, 0)
+			lcdGet(t, "process/list", &ps)
+			require.Len(t, ps, 1)
+		})
 	})
 
 	t.Run("delete", func(t *testing.T) {

e2e/runner_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/mesg-foundation/engine/hash"
 	"github.com/mesg-foundation/engine/protobuf/acknowledgement"
 	pb "github.com/mesg-foundation/engine/protobuf/api"
+	"github.com/mesg-foundation/engine/runner"
 	"github.com/stretchr/testify/require"
 )
 
@@ -35,27 +36,50 @@ func testRunner(t *testing.T) {
 	})
 
 	t.Run("get", func(t *testing.T) {
-		resp, err := client.RunnerClient.Get(context.Background(), &pb.GetRunnerRequest{Hash: testRunnerHash})
-		require.NoError(t, err)
-		require.Equal(t, testRunnerHash, resp.Hash)
-		testInstanceHash = resp.InstanceHash
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.RunnerClient.Get(context.Background(), &pb.GetRunnerRequest{Hash: testRunnerHash})
+			require.NoError(t, err)
+			require.Equal(t, testRunnerHash, resp.Hash)
+			testInstanceHash = resp.InstanceHash
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var r *runner.Runner
+			lcdGet(t, "runner/get/"+testRunnerHash.String(), &r)
+			require.Equal(t, testRunnerHash, r.Hash)
+		})
 	})
 
 	// TODO: need to test the filters
 	t.Run("list", func(t *testing.T) {
-		resp, err := client.RunnerClient.List(context.Background(), &pb.ListRunnerRequest{})
-		require.NoError(t, err)
-		require.Len(t, resp.Runners, 1)
-		require.Equal(t, testInstanceHash, resp.Runners[0].InstanceHash)
-		require.Equal(t, testRunnerHash, resp.Runners[0].Hash)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.RunnerClient.List(context.Background(), &pb.ListRunnerRequest{})
+			require.NoError(t, err)
+			require.Len(t, resp.Runners, 1)
+			require.Equal(t, testInstanceHash, resp.Runners[0].InstanceHash)
+			require.Equal(t, testRunnerHash, resp.Runners[0].Hash)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			rs := make([]*runner.Runner, 0)
+			lcdGet(t, "runner/list", &rs)
+			require.Len(t, rs, 1)
+			require.Equal(t, testInstanceHash, rs[0].InstanceHash)
+			require.Equal(t, testRunnerHash, rs[0].Hash)
+		})
 	})
 }
 
 func testDeleteRunner(t *testing.T) {
 	_, err := client.RunnerClient.Delete(context.Background(), &pb.DeleteRunnerRequest{Hash: testRunnerHash})
 	require.NoError(t, err)
 
-	resp, err := client.RunnerClient.List(context.Background(), &pb.ListRunnerRequest{})
-	require.NoError(t, err)
-	require.Len(t, resp.Runners, 0)
+	t.Run("grpc", func(t *testing.T) {
+		resp, err := client.RunnerClient.List(context.Background(), &pb.ListRunnerRequest{})
+		require.NoError(t, err)
+		require.Len(t, resp.Runners, 0)
+	})
+	t.Run("lcd", func(t *testing.T) {
+		rs := make([]*runner.Runner, 0)
+		lcdGet(t, "runner/list", &rs)
+		require.Len(t, rs, 0)
+	})
 }

e2e/service_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/mesg-foundation/engine/hash"
 	"github.com/mesg-foundation/engine/ownership"
 	pb "github.com/mesg-foundation/engine/protobuf/api"
+	"github.com/mesg-foundation/engine/service"
 	"github.com/stretchr/testify/require"
 )
 
@@ -22,43 +23,73 @@ func testService(t *testing.T) {
 	})
 
 	t.Run("get", func(t *testing.T) {
-		service, err := client.ServiceClient.Get(context.Background(), &pb.GetServiceRequest{Hash: testServiceHash})
-		require.NoError(t, err)
-		require.Equal(t, testServiceHash, service.Hash)
+		t.Run("grpc", func(t *testing.T) {
+			service, err := client.ServiceClient.Get(context.Background(), &pb.GetServiceRequest{Hash: testServiceHash})
+			require.NoError(t, err)
+			require.Equal(t, testServiceHash, service.Hash)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var s *service.Service
+			lcdGet(t, "service/get/"+testServiceHash.String(), &s)
+			require.Equal(t, testServiceHash, s.Hash)
+		})
 	})
 
 	t.Run("list", func(t *testing.T) {
-		resp, err := client.ServiceClient.List(context.Background(), &pb.ListServiceRequest{})
-		require.NoError(t, err)
-		require.Len(t, resp.Services, 1)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.ServiceClient.List(context.Background(), &pb.ListServiceRequest{})
+			require.NoError(t, err)
+			require.Len(t, resp.Services, 1)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			ss := make([]*service.Service, 0)
+			lcdGet(t, "service/list", &ss)
+			require.Len(t, ss, 1)
+		})
 	})
 
 	t.Run("exists", func(t *testing.T) {
-		resp, err := client.ServiceClient.Exists(context.Background(), &pb.ExistsServiceRequest{Hash: testServiceHash})
-		require.NoError(t, err)
-		require.True(t, resp.Exists)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.ServiceClient.Exists(context.Background(), &pb.ExistsServiceRequest{Hash: testServiceHash})
+			require.NoError(t, err)
+			require.True(t, resp.Exists)
 
-		resp, err = client.ServiceClient.Exists(context.Background(), &pb.ExistsServiceRequest{Hash: hash.Int(1)})
-		require.NoError(t, err)
-		require.False(t, resp.Exists)
+			resp, err = client.ServiceClient.Exists(context.Background(), &pb.ExistsServiceRequest{Hash: hash.Int(1)})
+			require.NoError(t, err)
+			require.False(t, resp.Exists)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var exist bool
+			lcdGet(t, "service/exist/"+testServiceHash.String(), &exist)
+			require.True(t, exist)
+			lcdGet(t, "service/exist/"+hash.Int(1).String(), &exist)
+			require.False(t, exist)
+		})
 	})
 
 	t.Run("hash", func(t *testing.T) {
-		resp, err := client.ServiceClient.Hash(context.Background(), req)
-		require.NoError(t, err)
-		require.Equal(t, testServiceHash, resp.Hash)
+		t.Run("grpc", func(t *testing.T) {
+			resp, err := client.ServiceClient.Hash(context.Background(), req)
+			require.NoError(t, err)
+			require.Equal(t, testServiceHash, resp.Hash)
+		})
+		t.Run("lcd", func(t *testing.T) {
+			var hash hash.Hash
+			lcdPost(t, "service/hash", req, &hash)
+			require.Equal(t, testServiceHash, hash)
+		})
 	})
 
 	t.Run("check ownership creation", func(t *testing.T) {
-		t.Run("lcd", func(t *testing.T) {
+		t.Run("grpc", func(t *testing.T) {
 			ownerships, err := client.OwnershipClient.List(context.Background(), &pb.ListOwnershipRequest{})
 			require.NoError(t, err)
 			require.Len(t, ownerships.Ownerships, 1)
 			require.NotEmpty(t, ownerships.Ownerships[0].Owner)
 			require.Equal(t, ownership.Ownership_Service, ownerships.Ownerships[0].Resource)
 			require.Equal(t, testServiceHash, ownerships.Ownerships[0].ResourceHash)
 		})
-		t.Run("grpc", func(t *testing.T) {
+		t.Run("lcd", func(t *testing.T) {
 			ownerships := make([]*ownership.Ownership, 0)
 			lcdGet(t, "ownership/list", &ownerships)
 			require.Len(t, ownerships, 1)