box: added logic for working with Tarantool schema

Implemented the `box.Schema()` method that returns a `Schema`
object for schema-related operations

Author: maksim.konovalov

CHANGELOG.md

@@ -11,6 +11,8 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 ### Added
 
 - Extend box with replication information (#427).
+- Implemented all box.schema.user operations requests and sugar interface (#426).
+- Implemented box.session.su request and sugar interface only for current session granting (#426).
 
 ### Changed
 

box/box.go

@@ -17,6 +17,12 @@ 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)
+}
+
 // Info retrieves the current information of the Tarantool instance.
 // It calls the "box.info" function and parses the result into the Info structure.
 func (b *Box) Info() (Info, error) {

box/example_test.go

@@ -18,7 +18,7 @@ import (
 	"github.com/tarantool/go-tarantool/v2/box"
 )
 
-func Example() {
+func ExampleBox_Info() {
 	dialer := tarantool.NetDialer{
 		Address:  "127.0.0.1:3013",
 		User:     "test",
@@ -58,3 +58,129 @@ func Example() {
 	fmt.Printf("Box info uuids are equal")
 	fmt.Printf("Current box info: %+v\n", resp.Info)
 }
+
+func ExampleSchemaUser_Exists() {
+	dialer := tarantool.NetDialer{
+		Address:  "127.0.0.1:3013",
+		User:     "test",
+		Password: "test",
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+	client, err := tarantool.Connect(ctx, dialer, tarantool.Opts{})
+	cancel()
+	if err != nil {
+		log.Fatalf("Failed to connect: %s", err)
+	}
+
+	// You can use UserExistsRequest type and call it directly.
+	fut := client.Do(box.NewUserExistsRequest("user"))
+
+	resp := &box.UserExistsResponse{}
+
+	err = fut.GetTyped(resp)
+	if err != nil {
+		log.Fatalf("Failed get box schema user exists with error: %s", err)
+	}
+
+	// Or use simple User implementation.
+	b := box.New(client)
+	exists, err := b.Schema().User().Exists(ctx, "user")
+	if err != nil {
+		log.Fatalf("Failed get box schema user exists with error: %s", err)
+	}
+
+	if exists != resp.Exists {
+		log.Fatalf("Box schema users exists are not equal")
+	}
+
+	fmt.Printf("Box schema users exists are equal")
+	fmt.Printf("Current exists state: %+v\n", exists)
+}
+
+func ExampleSchemaUser_Create() {
+	// Connect to Tarantool.
+	dialer := tarantool.NetDialer{
+		Address:  "127.0.0.1:3013",
+		User:     "test",
+		Password: "test",
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+	client, err := tarantool.Connect(ctx, dialer, tarantool.Opts{})
+	cancel()
+	if err != nil {
+		log.Fatalf("Failed to connect: %s", err)
+	}
+
+	// Create SchemaUser.
+	schemaUser := box.NewSchemaUser(client)
+
+	// Create a new user.
+	username := "new_user"
+	options := box.UserCreateOptions{
+		IfNotExists: true,
+		Password:    "secure_password",
+	}
+	err = schemaUser.Create(ctx, username, options)
+	if err != nil {
+		log.Fatalf("Failed to create user: %s", err)
+	}
+
+	fmt.Printf("User '%s' created successfully\n", username)
+}
+
+func ExampleSchemaUser_Drop() {
+	// Connect to Tarantool.
+	dialer := tarantool.NetDialer{
+		Address:  "127.0.0.1:3013",
+		User:     "test",
+		Password: "test",
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+	client, err := tarantool.Connect(ctx, dialer, tarantool.Opts{})
+	cancel()
+	if err != nil {
+		log.Fatalf("Failed to connect: %s", err)
+	}
+
+	// Create SchemaUser.
+	schemaUser := box.NewSchemaUser(client)
+
+	// Drop an existing user.
+	username := "new_user"
+	options := box.UserDropOptions{
+		IfExists: true,
+	}
+	err = schemaUser.Drop(ctx, username, options)
+	if err != nil {
+		log.Fatalf("Failed to drop user: %s", err)
+	}
+
+	fmt.Printf("User '%s' dropped successfully\n", username)
+}
+
+func ExampleSchemaUser_Password() {
+	// Connect to Tarantool.
+	dialer := tarantool.NetDialer{
+		Address:  "127.0.0.1:3013",
+		User:     "test",
+		Password: "test",
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+	client, err := tarantool.Connect(ctx, dialer, tarantool.Opts{})
+	cancel()
+	if err != nil {
+		log.Fatalf("Failed to connect: %s", err)
+	}
+
+	// Create SchemaUser.
+	schemaUser := box.NewSchemaUser(client)
+
+	// Get the password hash.
+	password := "my-password"
+	passwordHash, err := schemaUser.Password(ctx, password)
+	if err != nil {
+		log.Fatalf("Failed to get password hash: %s", err)
+	}
+
+	fmt.Printf("Password '%s' hash: %s\n", password, passwordHash)
+}

box/info.go

@@ -112,18 +112,14 @@ func (ir *InfoResponse) DecodeMsgpack(d *msgpack.Decoder) error {
 // InfoRequest represents a request to retrieve information about the Tarantool instance.
 // It implements the tarantool.Request interface.
 type InfoRequest struct {
-	baseRequest
-}
-
-// Body method is used to serialize the request's body.
-// It is part of the tarantool.Request interface implementation.
-func (i InfoRequest) Body(res tarantool.SchemaResolver, enc *msgpack.Encoder) error {
-	return i.impl.Body(res, enc)
+	*tarantool.CallRequest // Underlying Tarantool call request.
 }
 
 // NewInfoRequest returns a new empty info request.
 func NewInfoRequest() InfoRequest {
-	req := InfoRequest{}
-	req.impl = newCall("box.info")
-	return req
+	callReq := tarantool.NewCallRequest("box.info")
+
+	return InfoRequest{
+		callReq,
+	}
 }

box/request.go

@@ -0,0 +1,21 @@
+package box
+
+import "github.com/tarantool/go-tarantool/v2"
+
+// Schema represents the schema-related operations in Tarantool.
+// It holds a connection to interact with the Tarantool instance.
+type Schema struct {
+	conn tarantool.Doer // Connection interface for interacting with Tarantool.
+}
+
+// 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 {
+	return &Schema{conn: conn} // Pass the connection to the Schema.
+}
+
+// User returns a new SchemaUser instance, allowing schema-related user operations.
+func (s *Schema) User() *SchemaUser {
+	return NewSchemaUser(s.conn)
+}

box/schema.go

@@ -0,0 +1,45 @@
+package box
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tarantool/go-tarantool/v2"
+	"github.com/tarantool/go-tarantool/v2/test_helpers"
+)
+
+func TestNewSchema(t *testing.T) {
+	ctx := context.Background()
+
+	// Create a schema instance with a nil connection. This should lead to a panic later.
+	b := NewSchema(nil)
+
+	// Ensure the schema is not nil (which it shouldn't be), but this is not meaningful
+	// since we will panic when we call the schema methods with the nil connection.
+	t.Run("internal sugar sub-objects not panics", func(t *testing.T) {
+		require.NotNil(t, b)
+		require.NotNil(t, b.User())
+	})
+
+	t.Run("check that connections are equal", func(t *testing.T) {
+		var tCases []tarantool.Doer
+		for i := 0; i < 10; i++ {
+
+			doer := test_helpers.NewMockDoer(t)
+			tCases = append(tCases, &doer)
+		}
+
+		for _, tCase := range tCases {
+			sch := NewSchema(tCase)
+			require.Equal(t, tCase, sch.conn)
+			require.Equal(t, tCase, sch.User().conn)
+		}
+	})
+
+	t.Run("nil conn panics", func(t *testing.T) {
+		require.Panics(t, func() {
+			_, _ = b.User().Info(ctx, "panic-on")
+		})
+	})
+}

box/schema_test.go

@@ -0,0 +1,191 @@
+package box
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tarantool/go-tarantool/v2"
+	"github.com/vmihailenco/msgpack/v5"
+	"github.com/vmihailenco/msgpack/v5/msgpcode"
+)
+
+func TestNewSchemaUser(t *testing.T) {
+	// Create a schema user instance with a nil connection. This should lead to a panic later.
+	su := NewSchemaUser(nil)
+
+	// Ensure the schema user is not nil (which it shouldn't be), but this is not meaningful
+	// since we will panic when we call some method with the nil connection.
+	require.NotNil(t, su)
+
+	// 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() {
+		// Calling Exists on a schema user with a nil connection will result in a panic,
+		// since the underlying connection (Doer) cannot perform the requested action (it's nil).
+		_, _ = su.Exists(context.TODO(), "test")
+	})
+}
+
+func TestUserExistsResponse_DecodeMsgpack(t *testing.T) {
+	tCases := map[bool]func() *bytes.Buffer{
+		true: func() *bytes.Buffer {
+			buf := bytes.NewBuffer(nil)
+			buf.WriteByte(msgpcode.FixedArrayLow | byte(1))
+			buf.WriteByte(msgpcode.True)
+
+			return buf
+		},
+		false: func() *bytes.Buffer {
+			buf := bytes.NewBuffer(nil)
+			buf.WriteByte(msgpcode.FixedArrayLow | byte(1))
+			buf.WriteByte(msgpcode.False)
+
+			return buf
+		},
+	}
+
+	for tCaseBool, tCaseBuf := range tCases {
+		tCaseBool := tCaseBool
+		tCaseBuf := tCaseBuf()
+
+		t.Run(fmt.Sprintf("case: %t", tCaseBool), func(t *testing.T) {
+			t.Parallel()
+
+			resp := UserExistsResponse{}
+
+			require.NoError(t, resp.DecodeMsgpack(msgpack.NewDecoder(tCaseBuf)))
+			require.Equal(t, tCaseBool, resp.Exists)
+		})
+	}
+
+}
+
+func TestUserPasswordResponse_DecodeMsgpack(t *testing.T) {
+	tCases := []string{
+		"test",
+		"$tr0ng_pass",
+	}
+
+	for _, tCase := range tCases {
+		tCase := tCase
+
+		t.Run(tCase, func(t *testing.T) {
+			t.Parallel()
+			buf := bytes.NewBuffer(nil)
+			buf.WriteByte(msgpcode.FixedArrayLow | byte(1))
+
+			bts, err := msgpack.Marshal(tCase)
+			require.NoError(t, err)
+			buf.Write(bts)
+
+			resp := UserPasswordResponse{}
+
+			err = resp.DecodeMsgpack(msgpack.NewDecoder(buf))
+			require.NoError(t, err)
+			require.Equal(t, tCase, resp.Hash)
+		})
+	}
+
+}
+
+func FuzzUserPasswordResponse_DecodeMsgpack(f *testing.F) {
+	f.Fuzz(func(t *testing.T, orig string) {
+		buf := bytes.NewBuffer(nil)
+		buf.WriteByte(msgpcode.FixedArrayLow | byte(1))
+
+		bts, err := msgpack.Marshal(orig)
+		require.NoError(t, err)
+		buf.Write(bts)
+
+		resp := UserPasswordResponse{}
+
+		err = resp.DecodeMsgpack(msgpack.NewDecoder(buf))
+		require.NoError(t, err)
+		require.Equal(t, orig, resp.Hash)
+	})
+}
+
+func TestNewUserExistsRequest(t *testing.T) {
+	t.Parallel()
+
+	req := UserExistsRequest{}
+
+	require.NotPanics(t, func() {
+		req = NewUserExistsRequest("test")
+	})
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}
+
+func TestNewUserCreateRequest(t *testing.T) {
+	t.Parallel()
+
+	req := UserCreateRequest{}
+
+	require.NotPanics(t, func() {
+		req = NewUserCreateRequest("test", UserCreateOptions{})
+	})
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}
+
+func TestNewUserDropRequest(t *testing.T) {
+	t.Parallel()
+
+	req := UserDropRequest{}
+
+	require.NotPanics(t, func() {
+		req = NewUserDropRequest("test", UserDropOptions{})
+	})
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}
+
+func TestNewUserPasswordRequest(t *testing.T) {
+	t.Parallel()
+
+	req := UserPasswordRequest{}
+
+	require.NotPanics(t, func() {
+		req = NewUserPasswordRequest("test")
+	})
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}
+
+func TestNewUserPasswdRequest(t *testing.T) {
+	t.Parallel()
+
+	var err error
+	req := UserPasswdRequest{}
+
+	require.NotPanics(t, func() {
+		req, err = NewUserPasswdRequest("test")
+		require.NoError(t, err)
+	})
+
+	_, err = NewUserPasswdRequest()
+	require.Errorf(t, err, "invalid arguments count")
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}
+
+func TestNewUserInfoRequest(t *testing.T) {
+	t.Parallel()
+
+	var err error
+	req := UserInfoRequest{}
+
+	require.NotPanics(t, func() {
+		req = NewUserInfoRequest("test")
+		require.NoError(t, err)
+	})
+
+	require.Implements(t, (*tarantool.Request)(nil), req)
+}

box/schema_user.go

@@ -0,0 +1,64 @@
+package box
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/tarantool/go-tarantool/v2"
+)
+
+// Session struct represents a connection session to Tarantool.
+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 {
+	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)
+}
+
+// SessionSuRequest struct wraps a Tarantool call request specifically for session switching.
+type SessionSuRequest struct {
+	*tarantool.CallRequest // Underlying Tarantool call request.
+}
+
+// NewSessionSuRequest creates a new SessionSuRequest for switching session to a specified username.
+// It returns an error if any execute functions are provided, as they are not supported now.
+func NewSessionSuRequest(username string, execute ...any) (SessionSuRequest, error) {
+	args := []interface{}{username} // Create args slice with the username.
+
+	// Check if any execute functions were provided and return an error if so.
+	if len(execute) > 0 {
+		return SessionSuRequest{},
+			fmt.Errorf("user functions call inside su command is unsupported now," +
+				" because Tarantool needs functions signature instead of name")
+	}
+
+	// Create a new call request for the box.session.su method with the given args.
+	callReq := tarantool.NewCallRequest("box.session.su").Args(args)
+
+	return SessionSuRequest{
+		callReq, // Return the new SessionSuRequest containing the call request.
+	}, nil
+}
+
+// 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) {
+	// Create a request and send it to Tarantool.
+	req, err := NewSessionSuRequest(username, execute...)
+	if err != nil {
+		return nil, 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
+}

box/schema_user_test.go

@@ -0,0 +1,26 @@
+package box
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBox_Session(t *testing.T) {
+	b := New(nil)
+	require.NotNil(t, b.Session())
+}
+
+func TestNewSession(t *testing.T) {
+	require.NotPanics(t, func() {
+		NewSession(nil)
+	})
+}
+
+func TestNewSessionSuRequest(t *testing.T) {
+	_, err := NewSessionSuRequest("admin", 1, 2, 3)
+	require.Error(t, err, "error should be occurred, because of tarantool signature requires")
+
+	_, err = NewSessionSuRequest("admin")
+	require.NoError(t, err)
+}

box/session.go

@@ -4,8 +4,10 @@ box.cfg{
     work_dir = os.getenv("TEST_TNT_WORK_DIR"),
 }
 
+box.schema.space.create('space1')
+
 box.schema.user.create('test', { password = 'test' , if_not_exists = true })
-box.schema.user.grant('test', 'execute', 'universe', nil, { if_not_exists = true })
+box.schema.user.grant('test', 'super', nil, nil, { if_not_exists = true })
 
 -- Set listen only when every other thing is configured.
 box.cfg{