temporary commit

* preemptive checking for empty connection
* hide constructors for schema and etc
* redo (minify) API for box.session.su (simplify it)
* added mock tests to check API

Author: bigbes

box/box.go

@@ -12,6 +12,12 @@ type Box struct {
 
 // New returns a new instance of the box structure, which implements the Box interface.
 func New(conn tarantool.Doer) *Box {
+	if conn == nil {
+		// Check if the provided Tarantool connection is nil, and if it is, panic with an error message.
+		// panic early helps to catch and fix nil pointer issues in the code.
+		panic("tarantool connection cannot be nil")
+	}
+
 	return &Box{
 		conn: conn, // Assigns the provided Tarantool connection.
 	}
@@ -20,7 +26,7 @@ func New(conn tarantool.Doer) *Box {
 // Schema returns a new Schema instance, providing access to schema-related operations.
 // It uses the connection from the Box instance to communicate with Tarantool.
 func (b *Box) Schema() *Schema {
-	return NewSchema(b.conn)
+	return newSchema(b.conn)
 }
 
 // Info retrieves the current information of the Tarantool instance.

box/box_test.go

@@ -1,49 +1,86 @@
-package box
+package box_test
 
 import (
+	"context"
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
+	"github.com/tarantool/go-tarantool/v2/box"
 	"github.com/tarantool/go-tarantool/v2/test_helpers"
 )
 
 func TestNew(t *testing.T) {
 	t.Parallel()
 
-	// Create a box instance with a nil connection. This should lead to a panic later.
-	b := New(nil)
+	// Create a box instance with a nil connection. This should lead to a panic.
+	require.Panics(t, func() { box.New(nil) })
+}
+
+func TestMocked(t *testing.T) {
+	t.Run("Box.Info", func(t *testing.T) {
+		t.Parallel()
 
-	// Ensure the box instance is not nil (which it shouldn't be), but this is not meaningful
-	// since we will panic when we call the Info method with the nil connection.
-	require.NotNil(t, b)
+		data := []interface{}{
+			map[string]interface{}{
+				"version":     "1.0.0",
+				"id":          nil,
+				"ro":          false,
+				"uuid":        "uuid",
+				"pid":         456,
+				"status":      "status",
+				"lsn":         123,
+				"replication": nil,
+			},
+		}
+		mock := test_helpers.NewMockDoer(t,
+			test_helpers.NewMockResponse(t, data),
+		)
+		b := box.New(&mock)
 
-	// We expect a panic because we are passing a nil connection (nil Doer) to the By function.
-	// The library does not control this zone, and the nil connection would cause a runtime error
-	// when we attempt to call methods (like Info) on it.
-	// This test ensures that such an invalid state is correctly handled by causing a panic,
-	// as it's outside the library's responsibility.
-	require.Panics(t, func() {
+		info, err := b.Info()
+		require.NoError(t, err)
 
-		// Calling Info on a box with a nil connection will result in a panic, since the underlying
-		// connection (Doer) cannot perform the requested action (it's nil).
-		_, _ = b.Info()
+		assert.Equal(t, "1.0.0", info.Version)
+		assert.Equal(t, 456, info.PID)
 	})
-}
 
-func TestNew_Schema_PassesDoer(t *testing.T) {
-	t.Parallel()
+	t.Run("Box.Schema.User.Info", func(t *testing.T) {
+		t.Parallel()
 
-	doer := test_helpers.NewMockDoer(t)
+		data := []interface{}{
+			[]interface{}{
+				[]interface{}{"read,write,execute", "universe", ""},
+			},
+		}
+		mock := test_helpers.NewMockDoer(t,
+			test_helpers.NewMockResponse(t, data),
+		)
+		b := box.New(&mock)
 
-	b := New(&doer)
-	schemaObject := b.Schema()
-	assert.Equal(t, &doer, schemaObject.conn)
+		privs, err := b.Schema().User().Info(context.Background(), "username")
+		require.NoError(t, err)
 
-	userSchemaObject := b.Schema().User()
-	assert.Equal(t, &doer, userSchemaObject.conn)
+		assert.Equal(t, []box.Privilege{
+			{
+				Permissions: []box.Permission{box.PermissionRead, box.PermissionWrite, box.PermissionExecute},
+				Type:        box.PrivilegeUniverse,
+				Name:        "",
+			},
+		}, privs)
+	})
+
+	t.Run("Box.Session.Su", func(t *testing.T) {
+		t.Parallel()
 
-	sessionObject := b.Session()
-	assert.Equal(t, &doer, sessionObject.conn)
+		mock := test_helpers.NewMockDoer(t,
+			test_helpers.NewMockResponse(t, []interface{}{}),
+			errors.New("user not found or supplied credentials are invalid"),
+		)
+		b := box.New(&mock)
+
+		err := b.Session().Su(context.Background(), "admin")
+		require.NoError(t, err)
+	})
 }

box/schema.go

@@ -8,10 +8,10 @@ type Schema struct {
 	conn tarantool.Doer // Connection interface for interacting with Tarantool.
 }
 
-// NewSchema creates a new Schema instance with the provided Tarantool connection.
+// newSchema creates a new Schema instance with the provided Tarantool connection.
 // It initializes a Schema object that can be used for schema-related operations
 // such as managing users, tables, and other schema elements in the Tarantool instance.
-func NewSchema(conn tarantool.Doer) *Schema {
+func newSchema(conn tarantool.Doer) *Schema {
 	return &Schema{conn: conn} // Pass the connection to the Schema.
 }
 

box/schema_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func TestSchemaNotNil(t *testing.T) {
-	b := NewSchema(nil)
+	b := newSchema(nil)
 	require.NotNil(t, b)
 	require.NotNil(t, b.User())
 }
@@ -23,15 +23,15 @@ func TestSchemaConnectionsEquality(t *testing.T) {
 	}
 
 	for _, tCase := range tCases {
-		sch := NewSchema(tCase)
+		sch := newSchema(tCase)
 		require.Equal(t, tCase, sch.conn)
 		require.Equal(t, tCase, sch.User().conn)
 	}
 }
 
 func TestSchemaNilConnectionPanics(t *testing.T) {
 	ctx := context.Background()
-	b := NewSchema(nil)
+	b := newSchema(nil)
 
 	require.Panics(t, func() {
 		_, _ = b.User().Info(ctx, "panic-on")

box/schema_user.go

@@ -378,8 +378,11 @@ func (uer *UserInfoResponse) DecodeMsgpack(d *msgpack.Decoder) error {
 	rawArr := make([][][3]string, 0)
 
 	err := d.Decode(&rawArr)
-	if err != nil {
+	switch {
+	case err != nil:
 		return err
+	case len(rawArr) != 1:
+		return fmt.Errorf("protocol violation; expected 1 array, got %d", len(rawArr))
 	}
 
 	privileges := make([]Privilege, len(rawArr[0]))

box/session.go

@@ -12,14 +12,14 @@ type Session struct {
 	conn tarantool.Doer // Connection interface for interacting with Tarantool.
 }
 
-// NewSession creates a new Session instance, taking a Tarantool connection as an argument.
-func NewSession(conn tarantool.Doer) *Session {
+// newSession creates a new Session instance, taking a Tarantool connection as an argument.
+func newSession(conn tarantool.Doer) *Session {
 	return &Session{conn: conn} // Pass the connection to the Session structure.
 }
 
 // Session method returns a new Session object associated with the Box instance.
 func (b *Box) Session() *Session {
-	return NewSession(b.conn)
+	return newSession(b.conn)
 }
 
 // SessionSuRequest struct wraps a Tarantool call request specifically for session switching.
@@ -48,17 +48,18 @@ func NewSessionSuRequest(username string, execute ...any) (SessionSuRequest, err
 }
 
 // Su method is used to switch the session to the specified username.
-// It sends the request to Tarantool and returns a future response or an error.
-func (s *Session) Su(ctx context.Context, username string,
-	execute ...any) (*tarantool.Future, error) {
+// It sends the request to Tarantool and returns an error.
+func (s *Session) Su(ctx context.Context, username string) error {
 	// Create a request and send it to Tarantool.
-	req, err := NewSessionSuRequest(username, execute...)
+	req, err := NewSessionSuRequest(username)
 	if err != nil {
-		return nil, err // Return any errors encountered while creating the request.
+		return err // Return any errors encountered while creating the request.
 	}
 
 	req.Context(ctx) // Attach the context to the request for cancellation and timeout.
 
 	// Execute the request and return the future response, or an error.
-	return s.conn.Do(req), nil
+	fut := s.conn.Do(req)
+	_, err = fut.GetResponse()
+	return err
 }

box/session_test.go

@@ -1,19 +1,20 @@
 package box
 
 import (
+	th "github.com/tarantool/go-tarantool/v2/test_helpers"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
 func TestBox_Session(t *testing.T) {
-	b := New(nil)
+	b := New(th.Ptr(th.NewMockDoer(t)))
 	require.NotNil(t, b.Session())
 }
 
 func TestNewSession(t *testing.T) {
 	require.NotPanics(t, func() {
-		NewSession(nil)
+		newSession(nil)
 	})
 }
 

box/tarantool_test.go

@@ -478,11 +478,9 @@ func TestBox_Sugar_Schema_UserGrant_WithSu(t *testing.T) {
 	startPrivilages, err := b.Schema().User().Info(ctx, username)
 	require.NoError(t, err)
 
-	future, err := b.Session().Su(ctx, "admin")
+	err = b.Session().Su(ctx, "admin")
 	require.NoError(t, err)
 
-	_, err = future.Get()
-
 	require.NoError(t, err, "default user in super group")
 
 	newPrivilege := box.Privilege{
@@ -565,11 +563,9 @@ func TestSchemaUser_Revoke_WithSu(t *testing.T) {
 	startPrivileges, err := b.Schema().User().Info(ctx, username)
 	require.NoError(t, err)
 
-	future, err := b.Session().Su(ctx, "admin")
+	err = b.Session().Su(ctx, "admin")
 	require.NoError(t, err)
 
-	_, err = future.Get()
-
 	require.NoError(t, err, "dialer user in super group")
 
 	require.NotEmpty(t, startPrivileges)
@@ -614,9 +610,8 @@ func TestSchemaUser_Revoke_NonExistsPermission(t *testing.T) {
 	startPrivileges, err := b.Schema().User().Info(ctx, username)
 	require.NoError(t, err)
 
-	future, err := b.Session().Su(ctx, "admin")
+	err = b.Session().Su(ctx, "admin")
 	require.NoError(t, err)
-	_, err = future.Get()
 
 	require.NoError(t, err, "dialer user in super group")
 
@@ -637,18 +632,6 @@ func TestSchemaUser_Revoke_NonExistsPermission(t *testing.T) {
 	require.Error(t, err)
 }
 
-func TestSession_Su_WithCall(t *testing.T) {
-	ctx := context.TODO()
-
-	conn, err := tarantool.Connect(ctx, dialer, tarantool.Opts{})
-	require.NoError(t, err)
-
-	b := box.New(conn)
-
-	_, err = b.Session().Su(ctx, "admin", "echo", 1, 2)
-	require.Error(t, err, "unsupported now")
-}
-
 func TestSession_Su_AdminPermissions(t *testing.T) {
 	ctx := context.TODO()
 
@@ -657,7 +640,7 @@ func TestSession_Su_AdminPermissions(t *testing.T) {
 
 	b := box.New(conn)
 
-	_, err = b.Session().Su(ctx, "admin")
+	err = b.Session().Su(ctx, "admin")
 	require.NoError(t, err)
 }
 

test_helpers/doer.go

@@ -67,3 +67,7 @@ func (doer *MockDoer) Do(req tarantool.Request) *tarantool.Future {
 
 	return fut
 }
+
+func Ptr[T any](val T) *T {
+	return &val
+}