generate default test namespace

main.go

@@ -9,14 +9,15 @@ import (
 	"log"
 	"os"
 
-	_ "github.com/DataDog/temporalite/internal/common/persistence/sql/sqlplugin/sqlite" // needed to load sqlite plugin
-	"github.com/DataDog/temporalite/internal/liteconfig"
-	"github.com/DataDog/temporalite/server"
 	"github.com/urfave/cli/v2"
 	"go.temporal.io/server/common/headers"
 	tlog "go.temporal.io/server/common/log"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+
+	_ "github.com/DataDog/temporalite/internal/common/persistence/sql/sqlplugin/sqlite" // needed to load sqlite plugin
+	"github.com/DataDog/temporalite/internal/liteconfig"
+	"github.com/DataDog/temporalite/server"
 )
 
 var (

server/server.go

@@ -10,7 +10,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/DataDog/temporalite/internal/liteconfig"
 	enumspb "go.temporal.io/api/enums/v1"
 	"go.temporal.io/api/workflowservice/v1"
 	"go.temporal.io/sdk/client"
@@ -19,6 +18,8 @@ import (
 	"go.temporal.io/server/common/dynamicconfig"
 	"go.temporal.io/server/temporal"
 	"google.golang.org/grpc"
+
+	"github.com/DataDog/temporalite/internal/liteconfig"
 )
 
 type Server struct {

server/server_test.go

@@ -6,49 +6,34 @@ package server_test
 
 import (
 	"context"
-	"os"
 	"testing"
 	"time"
 
-	"github.com/DataDog/temporalite/internal/examples/helloworld"
-	"github.com/DataDog/temporalite/server"
-	"github.com/DataDog/temporalite/server/temporaltest"
 	"go.temporal.io/sdk/client"
 	"go.temporal.io/sdk/worker"
-)
 
-var ts *server.Server
+	"github.com/DataDog/temporalite/internal/examples/helloworld"
+	"github.com/DataDog/temporalite/server/temporaltest"
+)
 
-func TestMain(m *testing.M) {
-	s := temporaltest.NewServer(server.WithNamespaces("default"))
-	defer s.Stop()
+func BenchmarkRunWorkflow(b *testing.B) {
+	ts := temporaltest.NewServer()
+	c := ts.Client()
+	defer ts.Stop()
 
-	ts = s
+	w := worker.New(c, "example", worker.Options{})
+	helloworld.RegisterWorkflowsAndActivities(w)
 
-	code := m.Run()
-	os.Exit(code)
-}
+	if err := w.Start(); err != nil {
+		panic(err)
+	}
+	defer w.Stop()
 
-func BenchmarkRunWorkflow(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		func(b *testing.B) {
 			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 			defer cancel()
 
-			c, err := ts.NewClient(ctx, "default")
-			if err != nil {
-				b.Fatal(err)
-			}
-			defer c.Close()
-
-			w := worker.New(c, "example", worker.Options{})
-			helloworld.RegisterWorkflowsAndActivities(w)
-
-			if err := w.Start(); err != nil {
-				panic(err)
-			}
-			defer w.Stop()
-
 			wfr, err := c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{TaskQueue: "example"}, helloworld.Greet, "world")
 			if err != nil {
 				b.Fatal(err)

server/temporaltest/server.go

@@ -5,28 +5,87 @@
 package temporaltest
 
 import (
-	"github.com/DataDog/temporalite/server"
-	tlog "go.temporal.io/server/common/log"
+	"context"
+	"fmt"
+	"math/rand"
+	"time"
+
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/server/common/log"
 	"go.uber.org/zap"
+
+	"github.com/DataDog/temporalite/server"
 )
 
-func NewServer(opts ...server.Option) *server.Server {
-	opts = append(opts, 
+type TestServer struct {
+	server               *server.Server
+	defaultTestNamespace string
+	defaultClient        client.Client
+	clients              []client.Client
+}
+
+// Client returns a Temporal client configured for making requests to the server.
+// It is configured to use a pre-registered test namespace and will
+// be closed on TestServer.Stop.
+func (ts *TestServer) Client() client.Client {
+	if ts.defaultClient == nil {
+		ts.defaultClient = ts.NewClientWithOptions(client.Options{})
+	}
+	return ts.defaultClient
+}
+
+// NewClientWithOptions returns a Temporal client configured for making requests to the server.
+// If no namespace option is set it will use a pre-registered test namespace.
+// The returned client will be closed on TestServer.Stop.
+func (ts *TestServer) NewClientWithOptions(opts client.Options) client.Client {
+	if opts.Namespace == "" {
+		opts.Namespace = ts.defaultTestNamespace
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	c, err := ts.server.NewClientWithOptions(ctx, opts)
+	if err != nil {
+		panic(fmt.Errorf("error creating client: %w", err))
+	}
+
+	ts.clients = append(ts.clients, c)
+
+	return c
+}
+
+// Stop closes test clients and shuts down the server.
+func (ts *TestServer) Stop() {
+	for _, c := range ts.clients {
+		c.Close()
+	}
+	ts.server.Stop()
+}
+
+func NewServer() *TestServer {
+	rand.Seed(time.Now().UnixNano())
+	testNamespace := fmt.Sprintf("temporaltest-%d", rand.Intn(999999))
+
+	s, err := server.New(
+		server.WithNamespaces(testNamespace),
 		server.WithPersistenceDisabled(),
-                server.WithFrontendPort(0),
-                server.WithDynamicPorts(),
-                server.WithLogger(tlog.NewZapLogger(zap.NewNop())),	
+		server.WithFrontendPort(0),
+		server.WithDynamicPorts(),
+		server.WithLogger(log.NewZapLogger(zap.NewNop())),
 	)
-	s, err := server.New(opts...)
 	if err != nil {
-		panic(err)
+		panic(fmt.Errorf("error creating server: %w", err))
 	}
 
 	go func() {
 		if err := s.Start(); err != nil {
-			panic(err)
+			panic(fmt.Errorf("error starting server: %w", err))
 		}
 	}()
 
-	return s
+	return &TestServer{
+		server:               s,
+		defaultTestNamespace: testNamespace,
+	}
 }

server/temporaltest/server_test.go

@@ -9,28 +9,18 @@ import (
 	"testing"
 	"time"
 
-	"github.com/DataDog/temporalite/internal/examples/helloworld"
-	"github.com/DataDog/temporalite/server"
-	"github.com/DataDog/temporalite/server/temporaltest"
-
 	"go.temporal.io/sdk/client"
 	"go.temporal.io/sdk/worker"
+
+	"github.com/DataDog/temporalite/internal/examples/helloworld"
+	"github.com/DataDog/temporalite/server/temporaltest"
 )
 
 func TestNewServer(t *testing.T) {
-	// Create test Temporal server
-	srv := temporaltest.NewServer(server.WithNamespaces("default"))
-	defer srv.Stop()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// Get a new client
-	c, err := srv.NewClient(ctx, "default")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
+	// Create test Temporal server and client
+	ts := temporaltest.NewServer()
+	c := ts.Client()
+	defer ts.Stop()
 
 	w := worker.New(c, "example", worker.Options{})
 	helloworld.RegisterWorkflowsAndActivities(w)
@@ -40,6 +30,9 @@ func TestNewServer(t *testing.T) {
 	}
 	defer w.Stop()
 
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
 	wfr, err := c.ExecuteWorkflow(ctx, client.StartWorkflowOptions{TaskQueue: "example"}, helloworld.Greet, "world")
 	if err != nil {
 		t.Fatal(err)