Beginning of e2e test

Author: cschleiden

backend/sqlite/sqlite_test.go

@@ -13,3 +13,10 @@ func Test_SqliteBackend(t *testing.T) {
 		return NewInMemoryBackend(backend.WithStickyTimeout(0))
 	}, nil)
 }
+
+func Test_EndToEndSqliteBackend(t *testing.T) {
+	test.EndToEndBackendTest(t, func() backend.Backend {
+		// Disable sticky workflow behavior for the test execution
+		return NewInMemoryBackend(backend.WithStickyTimeout(0))
+	}, nil)
+}

backend/test/e2e.go

@@ -0,0 +1,112 @@
+package test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/cschleiden/go-workflows/backend"
+	"github.com/cschleiden/go-workflows/client"
+	"github.com/cschleiden/go-workflows/worker"
+	"github.com/cschleiden/go-workflows/workflow"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+func EndToEndBackendTest(t *testing.T, setup func() backend.Backend, teardown func(b backend.Backend)) {
+	tests := []struct {
+		name           string
+		workflow       interface{}
+		workflowInputs []interface{}
+		f              func(t *testing.T, ctx context.Context, c client.Client, w worker.Worker)
+	}{
+		{
+			name: "SimpleWorkflow",
+			f: func(t *testing.T, ctx context.Context, c client.Client, w worker.Worker) {
+				wf := func(ctx workflow.Context, msg string) (string, error) {
+					return msg + " world", nil
+				}
+				register(t, ctx, w, []interface{}{wf}, nil)
+
+				output, err := runWorkflowWithResult[string](t, ctx, c, wf, "hello")
+
+				require.Equal(t, "hello world", output)
+				require.NoError(t, err)
+			},
+		},
+		{
+			name: "UnregisteredWorkflow",
+			f: func(t *testing.T, ctx context.Context, c client.Client, w worker.Worker) {
+				wf := func(ctx workflow.Context, msg string) (string, error) {
+					return msg + " world", nil
+				}
+				register(t, ctx, w, nil, nil)
+
+				output, err := runWorkflowWithResult[string](t, ctx, c, wf, "hello")
+
+				require.Nil(t, output)
+				require.Error(t, err)
+			},
+		},
+		{
+			name: "UnregisteredActivity",
+			f: func(t *testing.T, ctx context.Context, c client.Client, w worker.Worker) {
+				a := func(context.Context) error { return nil }
+				wf := func(ctx workflow.Context) (int, error) {
+					return workflow.ExecuteActivity[int](ctx, workflow.DefaultActivityOptions, a).Get(ctx)
+				}
+				register(t, ctx, w, nil, []interface{}{wf})
+
+				output, err := runWorkflowWithResult[int](t, ctx, c, wf)
+
+				require.Zero(t, output)
+				require.ErrorContains(t, err, "activity not found")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := setup()
+			ctx := context.Background()
+
+			c := client.New(b)
+			w := worker.New(b, &worker.DefaultWorkerOptions)
+
+			tt.f(t, ctx, c, w)
+
+			w.Stop()
+
+			if teardown != nil {
+				teardown(b)
+			}
+		})
+	}
+}
+
+func register(t *testing.T, ctx context.Context, w worker.Worker, workflows []interface{}, activities []interface{}) {
+	for _, wf := range workflows {
+		require.NoError(t, w.RegisterWorkflow(wf))
+	}
+
+	for _, a := range activities {
+		require.NoError(t, w.RegisterActivity(a))
+	}
+
+	err := w.Start(ctx)
+	require.NoError(t, err)
+}
+
+func runWorkflow(t *testing.T, ctx context.Context, c client.Client, wf interface{}, inputs ...interface{}) *workflow.Instance {
+	instance, err := c.CreateWorkflowInstance(ctx, client.WorkflowInstanceOptions{
+		InstanceID: uuid.NewString(),
+	}, wf, "hello")
+	require.NoError(t, err)
+
+	return instance
+}
+
+func runWorkflowWithResult[T any](t *testing.T, ctx context.Context, c client.Client, wf interface{}, inputs ...interface{}) (T, error) {
+	instance := runWorkflow(t, ctx, c, wf, inputs...)
+	return client.GetWorkflowResult[T](ctx, c, instance, time.Second*10)
+}