dev: Add comprehensive unit tests for internal/query package to increase coverage (#1899)

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: asmyasnikov <[email protected]>
Co-authored-by: Aleksey Myasnikov <[email protected]>

Author: Copilot

internal/query/config/config_test.go

@@ -0,0 +1,130 @@
+package config
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ydb-platform/ydb-go-sdk/v3/trace"
+)
+
+func TestNew(t *testing.T) {
+	t.Run("DefaultConfig", func(t *testing.T) {
+		cfg := New()
+		require.NotNil(t, cfg)
+		require.Equal(t, DefaultPoolMaxSize, cfg.PoolLimit())
+		require.Equal(t, DefaultSessionCreateTimeout, cfg.SessionCreateTimeout())
+		require.Equal(t, DefaultSessionDeleteTimeout, cfg.SessionDeleteTimeout())
+		require.NotNil(t, cfg.Trace())
+		require.False(t, cfg.AllowImplicitSessions())
+		require.Equal(t, uint64(0), cfg.PoolSessionUsageLimit())
+		require.Equal(t, time.Duration(0), cfg.PoolSessionUsageTTL())
+		require.Equal(t, time.Duration(0), cfg.SessionIdleTimeToLive())
+		require.False(t, cfg.LazyTx())
+	})
+
+	t.Run("WithPoolLimit", func(t *testing.T) {
+		cfg := New(WithPoolLimit(100))
+		require.Equal(t, 100, cfg.PoolLimit())
+	})
+
+	t.Run("WithPoolLimitZero", func(t *testing.T) {
+		cfg := New(WithPoolLimit(0))
+		require.Equal(t, DefaultPoolMaxSize, cfg.PoolLimit())
+	})
+
+	t.Run("WithPoolLimitNegative", func(t *testing.T) {
+		cfg := New(WithPoolLimit(-1))
+		require.Equal(t, DefaultPoolMaxSize, cfg.PoolLimit())
+	})
+
+	t.Run("WithSessionPoolSessionUsageLimit-Uint64", func(t *testing.T) {
+		cfg := New(WithSessionPoolSessionUsageLimit(uint64(50)))
+		require.Equal(t, uint64(50), cfg.PoolSessionUsageLimit())
+	})
+
+	t.Run("WithSessionPoolSessionUsageLimit-Duration", func(t *testing.T) {
+		cfg := New(WithSessionPoolSessionUsageLimit(5 * time.Minute))
+		require.Equal(t, 5*time.Minute, cfg.PoolSessionUsageTTL())
+	})
+
+	t.Run("WithSessionCreateTimeout", func(t *testing.T) {
+		cfg := New(WithSessionCreateTimeout(2 * time.Second))
+		require.Equal(t, 2*time.Second, cfg.SessionCreateTimeout())
+	})
+
+	t.Run("WithSessionCreateTimeoutZero", func(t *testing.T) {
+		cfg := New(WithSessionCreateTimeout(0))
+		require.Equal(t, time.Duration(0), cfg.SessionCreateTimeout())
+	})
+
+	t.Run("WithSessionDeleteTimeout", func(t *testing.T) {
+		cfg := New(WithSessionDeleteTimeout(1 * time.Second))
+		require.Equal(t, 1*time.Second, cfg.SessionDeleteTimeout())
+	})
+
+	t.Run("WithSessionDeleteTimeoutZero", func(t *testing.T) {
+		cfg := New(WithSessionDeleteTimeout(0))
+		require.Equal(t, DefaultSessionDeleteTimeout, cfg.SessionDeleteTimeout())
+	})
+
+	t.Run("WithSessionIdleTimeToLive", func(t *testing.T) {
+		cfg := New(WithSessionIdleTimeToLive(10 * time.Minute))
+		require.Equal(t, 10*time.Minute, cfg.SessionIdleTimeToLive())
+	})
+
+	t.Run("WithSessionIdleTimeToLiveZero", func(t *testing.T) {
+		cfg := New(WithSessionIdleTimeToLive(0))
+		require.Equal(t, time.Duration(0), cfg.SessionIdleTimeToLive())
+	})
+
+	t.Run("AllowImplicitSessions", func(t *testing.T) {
+		cfg := New(AllowImplicitSessions())
+		require.True(t, cfg.AllowImplicitSessions())
+	})
+
+	t.Run("WithLazyTx", func(t *testing.T) {
+		cfg := New(WithLazyTx(true))
+		require.True(t, cfg.LazyTx())
+	})
+
+	t.Run("WithTrace", func(t *testing.T) {
+		tr := &trace.Query{
+			OnSessionCreate: func(info trace.QuerySessionCreateStartInfo) func(info trace.QuerySessionCreateDoneInfo) {
+				return func(info trace.QuerySessionCreateDoneInfo) {}
+			},
+		}
+		cfg := New(WithTrace(tr))
+		require.NotNil(t, cfg.Trace())
+	})
+
+	t.Run("NilOption", func(t *testing.T) {
+		cfg := New(nil)
+		require.NotNil(t, cfg)
+	})
+
+	t.Run("MultipleOptions", func(t *testing.T) {
+		cfg := New(
+			WithPoolLimit(200),
+			WithSessionCreateTimeout(3*time.Second),
+			WithSessionDeleteTimeout(2*time.Second),
+			AllowImplicitSessions(),
+			WithLazyTx(true),
+		)
+		require.Equal(t, 200, cfg.PoolLimit())
+		require.Equal(t, 3*time.Second, cfg.SessionCreateTimeout())
+		require.Equal(t, 2*time.Second, cfg.SessionDeleteTimeout())
+		require.True(t, cfg.AllowImplicitSessions())
+		require.True(t, cfg.LazyTx())
+	})
+}
+
+func TestDefaults(t *testing.T) {
+	cfg := defaults()
+	require.NotNil(t, cfg)
+	require.Equal(t, DefaultPoolMaxSize, cfg.poolLimit)
+	require.Equal(t, DefaultSessionCreateTimeout, cfg.sessionCreateTimeout)
+	require.Equal(t, DefaultSessionDeleteTimeout, cfg.sessionDeleteTimeout)
+	require.NotNil(t, cfg.trace)
+}

internal/query/errors_test.go

@@ -0,0 +1,75 @@
+package query
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestErrors(t *testing.T) {
+	t.Run("errNilClient", func(t *testing.T) {
+		require.NotNil(t, errNilClient)
+		require.Contains(t, errNilClient.Error(), "table client is not initialized")
+	})
+
+	t.Run("ErrTransactionRollingBack", func(t *testing.T) {
+		require.NotNil(t, ErrTransactionRollingBack)
+		require.Contains(t, ErrTransactionRollingBack.Error(), "the transaction is rolling back")
+	})
+
+	t.Run("errWrongNextResultSetIndex", func(t *testing.T) {
+		require.NotNil(t, errWrongNextResultSetIndex)
+		require.Equal(t, "wrong result set index", errWrongNextResultSetIndex.Error())
+	})
+
+	t.Run("errWrongResultSetIndex", func(t *testing.T) {
+		require.NotNil(t, errWrongResultSetIndex)
+		require.Equal(t, "critical violation of the logic - wrong result set index", errWrongResultSetIndex.Error())
+	})
+
+	t.Run("errMoreThanOneRow", func(t *testing.T) {
+		require.NotNil(t, errMoreThanOneRow)
+		require.Equal(t, "unexpected more than one row in result set", errMoreThanOneRow.Error())
+	})
+
+	t.Run("errMoreThanOneResultSet", func(t *testing.T) {
+		require.NotNil(t, errMoreThanOneResultSet)
+		require.Equal(t, "unexpected more than one result set", errMoreThanOneResultSet.Error())
+	})
+
+	t.Run("errNoResultSets", func(t *testing.T) {
+		require.NotNil(t, errNoResultSets)
+		require.Equal(t, "no result sets", errNoResultSets.Error())
+	})
+
+	t.Run("errNilOption", func(t *testing.T) {
+		require.NotNil(t, errNilOption)
+		require.Equal(t, "nil option", errNilOption.Error())
+	})
+
+	t.Run("ErrOptionNotForTxExecute", func(t *testing.T) {
+		require.NotNil(t, ErrOptionNotForTxExecute)
+		require.Equal(t, "option is not for execute on transaction", ErrOptionNotForTxExecute.Error())
+	})
+
+	t.Run("errExecuteOnCompletedTx", func(t *testing.T) {
+		require.NotNil(t, errExecuteOnCompletedTx)
+		require.Equal(t, "execute on completed transaction", errExecuteOnCompletedTx.Error())
+	})
+
+	t.Run("errSessionClosed", func(t *testing.T) {
+		require.NotNil(t, errSessionClosed)
+		require.Equal(t, "session is closed", errSessionClosed.Error())
+	})
+
+	t.Run("ErrorsAreUnique", func(t *testing.T) {
+		// Verify that error variables are distinct
+		require.False(t, errors.Is(errNilClient, ErrTransactionRollingBack))
+		require.False(t, errors.Is(errWrongNextResultSetIndex, errWrongResultSetIndex))
+		require.False(t, errors.Is(errMoreThanOneRow, errMoreThanOneResultSet))
+		require.False(t, errors.Is(errNoResultSets, errNilOption))
+		require.False(t, errors.Is(ErrOptionNotForTxExecute, errExecuteOnCompletedTx))
+		require.False(t, errors.Is(errExecuteOnCompletedTx, errSessionClosed))
+	})
+}

internal/query/options/execute_test.go

@@ -7,6 +7,7 @@ import (
 	"google.golang.org/grpc"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/params"
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/stats"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/tx"
 )
 
@@ -166,3 +167,66 @@ func must[T any](v T, err error) T {
 
 	return v
 }
+
+func TestResponsePartLimitSizeBytes(t *testing.T) {
+	settings := ExecuteSettings(
+		WithTxControl(tx.NewControl(tx.WithTxID(""))),
+		WithResponsePartLimitSizeBytes(1024),
+	)
+	require.Equal(t, int64(1024), settings.ResponsePartLimitSizeBytes())
+}
+
+func TestLabel(t *testing.T) {
+	settings := defaultExecuteSettings()
+	require.Equal(t, "undefined", settings.Label())
+}
+
+func TestStatsModeApplyWithCallback(t *testing.T) {
+	called := false
+	callback := func(stats.QueryStats) {
+		called = true
+	}
+	settings := ExecuteSettings(
+		WithTxControl(tx.NewControl(tx.WithTxID(""))),
+		WithStatsMode(StatsModeBasic, callback),
+	)
+	require.Equal(t, StatsModeBasic, settings.StatsMode())
+	require.NotNil(t, settings.StatsCallback())
+	// Verify callback works
+	settings.StatsCallback()(nil)
+	require.True(t, called)
+}
+
+func TestRetryOpts(t *testing.T) {
+	settings := defaultExecuteSettings()
+	require.Nil(t, settings.RetryOpts())
+}
+
+func TestStatsCallback(t *testing.T) {
+	settings := defaultExecuteSettings()
+	require.Nil(t, settings.StatsCallback())
+}
+
+func TestStatsMode(t *testing.T) {
+	t.Run("StatsModeNone", func(t *testing.T) {
+		settings := ExecuteSettings(
+			WithTxControl(tx.NewControl(tx.WithTxID(""))),
+			StatsModeNone,
+		)
+		require.Equal(t, StatsModeNone, settings.StatsMode())
+	})
+
+	t.Run("StatsModeBasic", func(t *testing.T) {
+		settings := ExecuteSettings(
+			WithTxControl(tx.NewControl(tx.WithTxID(""))),
+			StatsModeBasic,
+		)
+		require.Equal(t, StatsModeBasic, settings.StatsMode())
+	})
+}
+
+func TestThisOptionIsNotForExecuteOnTx(t *testing.T) {
+	txCtrl := (*txControlOption)(tx.NewControl(tx.WithTxID("test")))
+	// Should not panic
+	txCtrl.thisOptionIsNotForExecuteOnTx()
+}

internal/query/session_status_test.go

@@ -0,0 +1,109 @@
+package query
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestStatusString(t *testing.T) {
+	tests := []struct {
+		name     string
+		status   Status
+		expected string
+	}{
+		{
+			name:     "StatusUnknown",
+			status:   StatusUnknown,
+			expected: "Unknown",
+		},
+		{
+			name:     "StatusIdle",
+			status:   StatusIdle,
+			expected: "Idle",
+		},
+		{
+			name:     "StatusInUse",
+			status:   StatusInUse,
+			expected: "InUse",
+		},
+		{
+			name:     "StatusClosing",
+			status:   StatusClosing,
+			expected: "Closing",
+		},
+		{
+			name:     "StatusClosed",
+			status:   StatusClosed,
+			expected: "Closed",
+		},
+		{
+			name:     "StatusError",
+			status:   StatusError,
+			expected: "Error",
+		},
+		{
+			name:     "InvalidStatus",
+			status:   Status(999),
+			expected: "Unknown999",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.status.String()
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestIsAlive(t *testing.T) {
+	tests := []struct {
+		name     string
+		status   Status
+		expected bool
+	}{
+		{
+			name:     "StatusUnknown",
+			status:   StatusUnknown,
+			expected: true,
+		},
+		{
+			name:     "StatusIdle",
+			status:   StatusIdle,
+			expected: true,
+		},
+		{
+			name:     "StatusInUse",
+			status:   StatusInUse,
+			expected: true,
+		},
+		{
+			name:     "StatusClosing",
+			status:   StatusClosing,
+			expected: false,
+		},
+		{
+			name:     "StatusClosed",
+			status:   StatusClosed,
+			expected: false,
+		},
+		{
+			name:     "StatusError",
+			status:   StatusError,
+			expected: false,
+		},
+		{
+			name:     "CustomStatusValue",
+			status:   Status(100),
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsAlive(tt.status)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}