More verbose test for complex service

e2e/complex_service_test.go

@@ -5,15 +5,17 @@ import (
 	"testing"
 
 	"github.com/mesg-foundation/engine/hash"
+	"github.com/mesg-foundation/engine/protobuf/acknowledgement"
 	pb "github.com/mesg-foundation/engine/protobuf/api"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc/metadata"
 )
 
 func testComplexService(t *testing.T) {
 	var (
-		testServiceHash hash.Hash
-		testRunnerHash  hash.Hash
+		testServiceHash  hash.Hash
+		testRunnerHash   hash.Hash
+		testInstanceHash hash.Hash
 	)
 
 	req := newTestComplexCreateServiceRequest()
@@ -26,13 +28,41 @@ func testComplexService(t *testing.T) {
 		testServiceHash = resp.Hash
 	})
 
+	stream, err := client.EventClient.Stream(context.Background(), &pb.StreamEventRequest{})
+	require.NoError(t, err)
+	acknowledgement.WaitForStreamToBeReady(stream)
+
 	t.Run("run", func(t *testing.T) {
 		resp, err := client.RunnerClient.Create(ctx, &pb.CreateRunnerRequest{
 			ServiceHash: testServiceHash,
-			Env:         []string{"FOO=1"},
+			Env:         []string{"FOO=bar"},
 		})
 		require.NoError(t, err)
 		testRunnerHash = resp.Hash
+
+		resp1, err := client.RunnerClient.Get(context.Background(), &pb.GetRunnerRequest{Hash: testRunnerHash})
+		require.NoError(t, err)
+		testInstanceHash = resp1.InstanceHash
+	})
+	t.Run("check events", func(t *testing.T) {
+		okEventsNo := 4
+		for i := 0; i < okEventsNo; {
+			ev, err := stream.Recv()
+			require.NoError(t, err)
+
+			if !ev.InstanceHash.Equal(testInstanceHash) {
+				continue
+			}
+			i++
+
+			switch ev.Key {
+			case "test_service_ready", "read_env_ok",
+				"access_volumes_from_ok", "ping_dependencie_ok":
+				t.Logf("recieved event %s ", ev.Key)
+			default:
+				t.Fatalf("failed on event %s", ev.Key)
+			}
+		}
 	})
 
 	t.Run("delete", func(t *testing.T) {

e2e/definition_test.go

@@ -96,47 +96,22 @@ func newTestComplexCreateServiceRequest() *pb.CreateServiceRequest {
 			{
 				Key:     "busybox",
 				Image:   "busybox",
-				Volumes: []string{"/tmp"},
+				Volumes: []string{"/volume-test"},
 			},
 		},
 		Configuration: service.Service_Configuration{
 			VolumesFrom: []string{"busybox"},
 			Env:         []string{"FOO"},
 		},
-		Tasks: []*service.Service_Task{
-			{
-				Key: "foo",
-				Inputs: []*service.Service_Parameter{
-					{
-						Key:  "o",
-						Type: "Object",
-						Object: []*service.Service_Parameter{
-							{
-								Key:  "msg",
-								Type: "String",
-							},
-						},
-					},
-				},
-			},
-		},
 		Events: []*service.Service_Event{
-			{
-				Key: "foo",
-				Data: []*service.Service_Parameter{
-					{
-						Key:  "o",
-						Type: "Object",
-						Object: []*service.Service_Parameter{
-							{
-								Key:  "msg",
-								Type: "String",
-							},
-						},
-					},
-				},
-			},
+			{Key: "test_service_ready"},
+			{Key: "read_env_ok"},
+			{Key: "read_env_error"},
+			{Key: "access_volumes_from_ok"},
+			{Key: "access_volumes_from_error"},
+			{Key: "ping_dependencie_ok"},
+			{Key: "ping_dependencie_error"},
 		},
-		Source: "QmRarLspkiAUL7nQiTfA2DGTusVpY7JUB33Qm9poq56ris",
+		Source: "QmfVR9mrKrhwxJ2uUtGPCKVv6rdrYrRLRMJnEXpYEDDRC4",
 	}
 }

e2e/testdata/test-complex-service/main.go

@@ -4,13 +4,12 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"net"
 	"os"
 	"time"
 
-	"github.com/mesg-foundation/engine/execution"
 	"github.com/mesg-foundation/engine/hash"
 	pb "github.com/mesg-foundation/engine/protobuf/api"
-	types "github.com/mesg-foundation/engine/protobuf/types"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/keepalive"
 )
@@ -21,24 +20,6 @@ const (
 	envMesgInstanceHash = "MESG_INSTANCE_HASH"
 )
 
-var response = &types.Struct{
-	Fields: map[string]*types.Value{
-		"o": &types.Value{
-			Kind: &types.Value_StructValue{
-				StructValue: &types.Struct{
-					Fields: map[string]*types.Value{
-						"msg": &types.Value{
-							Kind: &types.Value_StringValue{
-								StringValue: "bar",
-							},
-						},
-					},
-				},
-			},
-		},
-	},
-}
-
 // Client is a client to connect to all mesg exposed API.
 type Client struct {
 	// all clients registered by mesg server.
@@ -83,6 +64,15 @@ func New() (*Client, error) {
 	}, nil
 }
 
+func (c *Client) SendEvent(key string) {
+	if _, err := c.EventClient.Create(context.Background(), &pb.CreateEventRequest{
+		InstanceHash: c.InstanceHash,
+		Key:          key,
+	}); err != nil {
+		log.Fatal(err)
+	}
+}
+
 func main() {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 
@@ -92,48 +82,23 @@ func main() {
 	}
 	log.Printf("connect to %s\n", os.Getenv(envMesgEndpoint))
 
-	stream, err := client.ExecutionClient.Stream(context.Background(), &pb.StreamExecutionRequest{
-		Filter: &pb.StreamExecutionRequest_Filter{
-			Statuses:     []execution.Status{execution.Status_InProgress},
-			InstanceHash: client.InstanceHash,
-		},
-	})
-	if err != nil {
-		log.Fatal(err)
+	client.SendEvent("test_service_ready")
+
+	if os.Getenv("FOO") == "bar" {
+		client.SendEvent("read_env_ok")
+	} else {
+		client.SendEvent("read_env_error")
 	}
-	log.Printf("create a stream\n")
 
-	if _, err := client.EventClient.Create(context.Background(), &pb.CreateEventRequest{
-		InstanceHash: client.InstanceHash,
-		Key:          "test_service_ready",
-	}); err != nil {
-		log.Fatal(err)
+	if _, err := os.Stat("/volume-test"); err == nil {
+		client.SendEvent("access_volumes_from_ok")
+	} else {
+		client.SendEvent("access_volumes_from_error")
 	}
 
-	for {
-		exec, err := stream.Recv()
-		if err != nil {
-			log.Fatal(err)
-		}
-		log.Printf("recieve exeuction %s %s\n", exec.TaskKey, exec.Hash)
-
-		req := &pb.UpdateExecutionRequest{
-			Hash: exec.Hash,
-			Result: &pb.UpdateExecutionRequest_Outputs{
-				Outputs: response,
-			},
-		}
-
-		if _, err := client.ExecutionClient.Update(context.Background(), req); err != nil {
-			log.Fatal(err)
-		}
-
-		if _, err := client.EventClient.Create(context.Background(), &pb.CreateEventRequest{
-			InstanceHash: exec.InstanceHash,
-			Key:          exec.TaskKey,
-			Data:         response,
-		}); err != nil {
-			log.Fatal(err)
-		}
+	if _, err := net.LookupHost("busybox"); err == nil {
+		client.SendEvent("ping_dependencie_ok")
+	} else {
+		client.SendEvent("ping_dependencie_error")
 	}
 }

e2e/testdata/test-complex-service/mesg.yml

@@ -11,22 +11,16 @@ dependencies:
   busybox:
     image: busybox
     volumes:
-      - /tmp
-
-tasks:
-  foo:
-    inputs:
-      o:
-        type: Object
-        object:
-          msg:
-            type: String
+      - /volume-test
 
 events:
-  foo:
-    data:
-      o:
-        type: Object
-        object:
-          msg:
-            type: String
+  test_service_ready:
+
+  read_env_ok:
+  read_env_error:
+
+  access_volumes_from_ok:
+  access_volumes_from_error:
+
+  ping_dependencie_ok:
+  ping_dependencie_error:

sdk/service/backend.go

@@ -129,7 +129,7 @@ func (s *Backend) Exists(request cosmostypes.Request, hash hash.Hash) (bool, err
 
 // Hash returns the hash of a service request.
 func (s *Backend) Hash(serviceRequest *api.CreateServiceRequest) hash.Hash {
-	return api.TransformCreateReqToService(serviceRequest).Hash
+	return hash.Dump(api.TransformCreateReqToService(serviceRequest))
 }
 
 // List returns all services.