tests: add helpers for TcS

Simple helpers to make easy create tests required Taranatool
centralized configuration storage.

Author: dmyger

test_helpers/main.go

@@ -33,6 +33,14 @@ type StartOpts struct {
 	// InitScript is a Lua script for tarantool to run on start.
 	InitScript string
 
+	// ConfigFile is a path to a configuration file for a Tarantool instance.
+	// Required in pair with InstanceName.
+	ConfigFile string
+
+	// InstanceName is a name of an instance to run.
+	// Required in pair with ConfigFile.
+	InstanceName string
+
 	// Listen is box.cfg listen parameter for tarantool.
 	// Use this address to connect to tarantool after configuration.
 	// https://www.tarantool.io/en/doc/latest/reference/configuration/#cfg-basic-listen
@@ -77,6 +85,32 @@ type TarantoolInstance struct {
 
 	// Dialer to check that connection established.
 	Dialer tarantool.Dialer
+
+	done    chan error
+	is_done bool
+	result  error
+}
+
+// Status checks if Tarantool instance is still running.
+// Return true if it is running, false if it is not.
+// If instance was exit and error is nil - process completed success with zero status code.
+func (t *TarantoolInstance) Status() (bool, error) {
+	if t.is_done {
+		return false, t.result
+	}
+
+	select {
+	case t.result = <-t.done:
+		t.is_done = true
+		return false, t.result
+	default:
+		return true, nil
+	}
+}
+
+func (t *TarantoolInstance) checkDone() {
+	t.done = make(chan error, 1)
+	t.done <- t.Cmd.Wait()
 }
 
 func isReady(dialer tarantool.Dialer, opts *tarantool.Opts) error {
@@ -108,7 +142,7 @@ var (
 )
 
 func init() {
-	tarantoolVersionRegexp = regexp.MustCompile(`Tarantool (?:Enterprise )?(\d+)\.(\d+)\.(\d+).*`)
+	tarantoolVersionRegexp = regexp.MustCompile(`Tarantool (Enterprise )?(\d+)\.(\d+)\.(\d+).*`)
 }
 
 // atoiUint64 parses string to uint64.
@@ -145,15 +179,15 @@ func IsTarantoolVersionLess(majorMin uint64, minorMin uint64, patchMin uint64) (
 		return true, fmt.Errorf("failed to parse output %q", out)
 	}
 
-	if major, err = atoiUint64(parsed[1]); err != nil {
+	if major, err = atoiUint64(parsed[2]); err != nil {
 		return true, fmt.Errorf("failed to parse major from output %q: %w", out, err)
 	}
 
-	if minor, err = atoiUint64(parsed[2]); err != nil {
+	if minor, err = atoiUint64(parsed[3]); err != nil {
 		return true, fmt.Errorf("failed to parse minor from output %q: %w", out, err)
 	}
 
-	if patch, err = atoiUint64(parsed[3]); err != nil {
+	if patch, err = atoiUint64(parsed[4]); err != nil {
 		return true, fmt.Errorf("failed to parse patch from output %q: %w", out, err)
 	}
 
@@ -166,6 +200,21 @@ func IsTarantoolVersionLess(majorMin uint64, minorMin uint64, patchMin uint64) (
 	}
 }
 
+// IsTarantoolEE checks if Tarantool is Enterprise edition.
+func IsTarantoolEE() (bool, error) {
+	out, err := exec.Command(getTarantoolExec(), "--version").Output()
+	if err != nil {
+		return true, err
+	}
+
+	parsed := tarantoolVersionRegexp.FindStringSubmatch(string(out))
+	if parsed == nil {
+		return true, fmt.Errorf("failed to parse output %q", out)
+	}
+
+	return parsed[1] != "", nil
+}
+
 // RestartTarantool restarts a tarantool instance for tests
 // with specifies parameters (refer to StartOpts)
 // which were specified in inst parameter.
@@ -211,6 +260,7 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 	}
 
 	inst.Cmd = exec.Command(getTarantoolExec(), startOpts.InitScript)
+	inst.Cmd.Dir = startOpts.WorkDir
 
 	inst.Cmd.Env = append(
 		os.Environ(),
@@ -219,6 +269,11 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 		fmt.Sprintf("TEST_TNT_MEMTX_USE_MVCC_ENGINE=%t", startOpts.MemtxUseMvccEngine),
 		fmt.Sprintf("TEST_TNT_AUTH_TYPE=%s", startOpts.Auth),
 	)
+	if startOpts.ConfigFile != "" && startOpts.InstanceName != "" {
+		inst.Cmd.Env = append(inst.Cmd.Env, fmt.Sprintf("TT_CONFIG=%s", startOpts.ConfigFile))
+		inst.Cmd.Env = append(inst.Cmd.Env,
+			fmt.Sprintf("TT_INSTANCE_NAME=%s", startOpts.InstanceName))
+	}
 
 	// Copy SSL certificates.
 	if startOpts.SslCertsDir != "" {
@@ -242,6 +297,8 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 	// see https://github.com/tarantool/go-tarantool/issues/136
 	time.Sleep(startOpts.WaitStart)
 
+	go inst.checkDone()
+
 	opts := tarantool.Opts{
 		Timeout:    500 * time.Millisecond,
 		SkipSchema: true,
@@ -261,7 +318,17 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 		}
 	}
 
-	return inst, err
+	if err != nil {
+		StopTarantool(inst)
+		return TarantoolInstance{}, fmt.Errorf("failed to connect Tarantool: %w", err)
+	}
+
+	working, err := inst.Status()
+	if !working || err != nil {
+		StopTarantool(inst)
+		return TarantoolInstance{}, fmt.Errorf("unexpected terminated Tarantool: %w", err)
+	}
+	return inst, nil
 }
 
 // StopTarantool stops a tarantool instance started

test_helpers/tcs/prepare.go

@@ -0,0 +1,49 @@
+package tcs
+
+import (
+	_ "embed"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/tarantool/go-tarantool/v2"
+	"github.com/tarantool/go-tarantool/v2/test_helpers"
+)
+
+const (
+	waitTimeout  = 500 * time.Millisecond
+	connectRetry = 3
+	TcsUser      = "client"
+	TcsPassword  = "secret"
+)
+
+//go:embed testdata/config.yaml
+var tcsConfig []byte
+
+func makeOpts(port int) (test_helpers.StartOpts, error) {
+	opts := test_helpers.StartOpts{}
+	dir, err := os.MkdirTemp("", "tcs_dir")
+	if err != nil {
+		return opts, err
+	}
+	os.WriteFile(filepath.Join(dir, "config.yaml"), tcsConfig, 0644)
+
+	address := fmt.Sprintf("localhost:%d", port)
+
+	opts = test_helpers.StartOpts{
+		ConfigFile:   "config.yaml",
+		WorkDir:      dir,
+		WaitStart:    waitTimeout,
+		ConnectRetry: connectRetry,
+		RetryTimeout: waitTimeout,
+		InstanceName: "master",
+		Listen:       address,
+		Dialer: tarantool.NetDialer{
+			Address:  address,
+			User:     TcsUser,
+			Password: TcsPassword,
+		},
+	}
+	return opts, nil
+}

test_helpers/tcs/tcs.go

@@ -0,0 +1,187 @@
+package tcs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"testing"
+
+	"github.com/tarantool/go-tarantool/v2"
+	"github.com/tarantool/go-tarantool/v2/test_helpers"
+)
+
+var ErrNotSupported = errors.New("required Tarantool EE 3.3+")
+var ErrNoValue = errors.New("required Value not found")
+
+// TCS is a Tarantool centralized configuration storage connection.
+type TCS struct {
+	inst test_helpers.TarantoolInstance
+	conn *tarantool.Connection
+	tb   testing.TB
+	port int
+}
+
+// dataResponse content of TcS response in data array.
+type dataResponse struct {
+	Path        string `msgpack:"path"`
+	Value       string `msgpack:"value"`
+	ModRevision int64  `msgpack:"mod_revision"`
+}
+
+func isSupported() bool {
+	if less, err := test_helpers.IsTarantoolEE(); less || err != nil {
+		return false
+	}
+	if less, err := test_helpers.IsTarantoolVersionLess(3, 3, 0); less || err != nil {
+		return false
+	}
+	return true
+
+}
+
+// findEmptyPort returns some random unused port if @port is passed with zero.
+// If @port not zero, it checks if the port is free.
+func findEmptyPort(port int) (int, error) {
+	listener, err := net.Listen("tcp4", fmt.Sprintf(":%d", port)) // Bind to port 0
+	if err != nil {
+		return 0, err
+	}
+	defer listener.Close() // Ensure the listener is closed after use
+	addr := listener.Addr().(*net.TCPAddr)
+	return addr.Port, nil // Return the assigned port
+}
+
+// Start starts a Tarantool centralized configuration storage.
+// Use `port = 0` to use any unused port.
+// Returns a Tcs instance and a cleanup function.
+func Start(port int) (TCS, error) {
+	tcs := TCS{}
+	if !isSupported() {
+		return tcs, ErrNotSupported
+	}
+	var err error
+	tcs.port, err = findEmptyPort(port)
+	if err != nil {
+		if port == 0 {
+			return tcs, fmt.Errorf("failed to detect an empty port: %w", err)
+		} else {
+			return tcs, fmt.Errorf("port %d can't be used: %w", port, err)
+		}
+	}
+	opts, err := makeOpts(tcs.port)
+	if err != nil {
+		return tcs, err
+	}
+
+	tcs.inst, err = test_helpers.StartTarantool(opts)
+	if err != nil {
+		return tcs, fmt.Errorf("failed to start Tarantool config storage: %w", err)
+	}
+
+	tcs.conn, err = tarantool.Connect(context.Background(), tcs.inst.Dialer, tarantool.Opts{})
+	if err != nil {
+		return tcs, fmt.Errorf("failed to connect to Tarantool config storage: %w", err)
+	}
+
+	return tcs, nil
+}
+
+// Start starts a Tarantool centralized configuration storage.
+// Returns a Tcs instance and a cleanup function.
+func StartTesting(tb testing.TB, port int) TCS {
+	tcs, err := Start(port)
+	if err != nil {
+		tb.Fatal(err)
+	}
+	return tcs
+}
+
+// Doer return interface for interacting with Tarantool.
+func (t *TCS) Doer() tarantool.Doer {
+	return t.conn
+}
+
+// Dialer returns a dialer to connect to Tarantool.
+func (t *TCS) Dialer() tarantool.Dialer {
+	return t.inst.Dialer
+}
+
+// Endpoints returns a list of addresses to connect.
+func (t *TCS) Endpoints() []string {
+	return []string{fmt.Sprintf("localhost:%d", t.port)}
+}
+
+// Credentials returns a user name and password to connect.
+func (t *TCS) Credentials() (string, string) {
+	return TcsUser, TcsPassword
+}
+
+// Stop stops the Tarantool centralized configuration storage.
+func (t *TCS) Stop() {
+	if t.tb != nil {
+		t.tb.Helper()
+	}
+	if t.conn != nil {
+		t.conn.Close()
+	}
+	test_helpers.StopTarantoolWithCleanup(t.inst)
+}
+
+// Put implements "config.storage.put" method.
+func (t *TCS) Put(ctx context.Context, path string, value string) error {
+	if t.tb != nil {
+		t.tb.Helper()
+	}
+	req := tarantool.NewCallRequest("config.storage.put").
+		Args([]any{path, value}).
+		Context(ctx)
+	if _, err := t.conn.Do(req).GetResponse(); err != nil {
+		return fmt.Errorf("failed save data to tarantool: %w", err)
+	}
+	return nil
+}
+
+// Delete implements "config.storage.delete" method.
+func (t *TCS) Delete(ctx context.Context, path string) error {
+	if t.tb != nil {
+		t.tb.Helper()
+	}
+	req := tarantool.NewCallRequest("config.storage.delete").
+		Args([]any{path}).
+		Context(ctx)
+	if _, err := t.conn.Do(req).GetResponse(); err != nil {
+		return fmt.Errorf("failed delete data from tarantool: %w", err)
+	}
+	return nil
+}
+
+// Get implements "config.storage.get" method.
+func (t *TCS) Get(ctx context.Context, path string) (string, error) {
+	if t.tb != nil {
+		t.tb.Helper()
+	}
+	req := tarantool.NewCallRequest("config.storage.get").
+		Args([]any{path}).
+		Context(ctx)
+
+	resp := []struct {
+		Data []dataResponse `msgpack:"data"`
+	}{}
+
+	err := t.conn.Do(req).GetTyped(&resp)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch data from tarantool: %w", err)
+	}
+	if len(resp) != 1 {
+		return "", errors.New("unexpected response from tarantool")
+	}
+	if len(resp[0].Data) == 0 {
+		return "", ErrNoValue
+	}
+	if len(resp[0].Data) != 1 {
+		return "", errors.New("to many data in response from tarantool")
+	}
+
+	return resp[0].Data[0].Value, nil
+}