conn_test.go

package sqlmock

import (
	"context"
	"database/sql/driver"
	"errors"
	"io"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestConnPrepare(t *testing.T) {
	tests := []struct {
		name  string
		query string
	}{
		{
			name:  "returns_stmt_with_same_query",
			query: "SELECT id FROM users WHERE id = ?",
		},
		{
			name:  "supports_exec_statement_query",
			query: "UPDATE users SET active = ? WHERE id = ?",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			conn := &Conn{mock: NewMock()}

			// Act
			stmtRaw, err := conn.Prepare(tt.query)

			// Assert
			require.NoError(t, err)
			require.NotNil(t, stmtRaw)

			stmt, ok := stmtRaw.(*Stmt)
			require.True(t, ok)
			assert.Equal(t, tt.query, stmt.query)
			assert.Same(t, conn, stmt.conn)
		})
	}
}

func TestExtractArgs(t *testing.T) {
	tests := []struct {
		name string
		args []driver.NamedValue
		want []any
	}{
		{
			name: "returns_empty_slice_for_no_args",
			args: []driver.NamedValue{},
			want: []any{},
		},
		{
			name: "extracts_value_field_only",
			args: []driver.NamedValue{
				{Ordinal: 1, Value: int64(10)},
				{Name: "name", Ordinal: 2, Value: "alice"},
			},
			want: []any{int64(10), "alice"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Act
			got := extractArgs(tt.args)

			// Assert
			assert.Equal(t, tt.want, got)
		})
	}
}

func TestConnQueryContext(t *testing.T) {
	tests := []struct {
		name         string
		strictTx     bool
		setup        func(c *Conn, m *Mock)
		query        string
		args         []driver.NamedValue
		wantRow      []driver.Value
		wantErr      bool
		errSubstr    string
		wantHint     bool
		wantOpsAfter int
	}{
		{
			name:     "returns_rows_for_matching_expectation_in_strict_mode",
			strictTx: true,
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectQuery("SELECT id, name FROM users WHERE id = ?").
					WithArgs(int64(1)).
					WillReturnRows(NewRows([]string{"id", "name"}).AddRows(int64(1), "alice"))
			},
			query:        "SELECT id, name FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(1)}},
			wantRow:      []driver.Value{int64(1), "alice"},
			wantErr:      false,
			wantOpsAfter: 0,
		},
		{
			name: "returns_rows_without_transaction_in_default_mode",
			setup: func(c *Conn, m *Mock) {
				m.ExpectQuery("SELECT id, name FROM users WHERE id = ?").
					WithArgs(int64(2)).
					WillReturnRows(NewRows([]string{"id", "name"}).AddRows(int64(2), "bob"))
			},
			query:        "SELECT id, name FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(2)}},
			wantRow:      []driver.Value{int64(2), "bob"},
			wantErr:      false,
			wantOpsAfter: 0,
		},
		{
			name:     "returns_error_without_transaction",
			strictTx: true,
			setup: func(c *Conn, m *Mock) {
				m.ExpectQuery("SELECT 1")
			},
			query:        "SELECT 1",
			wantErr:      true,
			errSubstr:    "query without active transaction",
			wantHint:     true,
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_when_no_expectation_remaining",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
			},
			query:        "SELECT 1",
			wantErr:      true,
			errSubstr:    "no expectation remaining",
			wantOpsAfter: 0,
		},
		{
			name: "returns_error_when_next_expectation_is_not_query",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").WithArgs(true, int64(1))
			},
			query:        "SELECT id FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "got QUERY",
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_for_query_sql_mismatch",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectQuery("SELECT id FROM users WHERE id = ?").WithArgs(int64(1))
			},
			query:        "SELECT name FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "query sql mismatch",
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_for_query_args_mismatch",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectQuery("SELECT id FROM users WHERE id = ?").WithArgs(int64(1))
			},
			query:        "SELECT id FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(2)}},
			wantErr:      true,
			errSubstr:    "query args mismatch",
			wantOpsAfter: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			opts := []Option{}
			if tt.strictTx {
				opts = append(opts, WithStrictTx())
			}
			mock := NewMock(opts...)
			conn := &Conn{mock: mock}
			if tt.setup != nil {
				tt.setup(conn, mock)
			}

			// Act
			rows, err := conn.QueryContext(context.Background(), tt.query, tt.args)

			// Assert
			if tt.wantErr {
				require.Error(t, err)
				assert.Nil(t, rows)
				assert.Contains(t, err.Error(), tt.errSubstr)
				if tt.wantHint {
					assert.Contains(t, err.Error(), "Use WithStrictTx() if this should be transactional")
				}
				assert.Len(t, mock.ops, tt.wantOpsAfter)
				return
			}

			require.NoError(t, err)
			require.NotNil(t, rows)

			dest := make([]driver.Value, len(tt.wantRow))
			require.NoError(t, rows.Next(dest))
			assert.Equal(t, tt.wantRow, dest)
			require.ErrorIs(t, rows.Next(dest), io.EOF)
			require.NoError(t, rows.Close())
			assert.Len(t, mock.ops, tt.wantOpsAfter)
		})
	}
}

func TestConnExecContext(t *testing.T) {
	execErr := errors.New("exec failed")

	tests := []struct {
		name         string
		strictTx     bool
		setup        func(c *Conn, m *Mock)
		query        string
		args         []driver.NamedValue
		wantCount    int64
		wantErr      bool
		errSubstr    string
		wantHint     bool
		wantOpsAfter int
	}{
		{
			name:     "returns_result_for_matching_expectation_in_strict_mode",
			strictTx: true,
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").
					WithArgs(true, int64(1)).
					WillReturnResult(3)
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: true}, {Ordinal: 2, Value: int64(1)}},
			wantCount:    3,
			wantErr:      false,
			wantOpsAfter: 0,
		},
		{
			name: "returns_result_without_transaction_in_default_mode",
			setup: func(c *Conn, m *Mock) {
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").
					WithArgs(false, int64(2)).
					WillReturnResult(2)
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: false}, {Ordinal: 2, Value: int64(2)}},
			wantCount:    2,
			wantErr:      false,
			wantOpsAfter: 0,
		},
		{
			name: "returns_default_result_when_not_configured",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("DELETE FROM users WHERE id = ?").WithArgs(int64(1))
			},
			query:        "DELETE FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(1)}},
			wantCount:    1,
			wantErr:      false,
			wantOpsAfter: 0,
		},
		{
			name:     "returns_error_without_transaction",
			strictTx: true,
			setup: func(c *Conn, m *Mock) {
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").WithArgs(true, int64(1))
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: true}, {Ordinal: 2, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "exec without active transaction",
			wantHint:     true,
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_when_no_expectation_remaining",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: true}, {Ordinal: 2, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "no expectation remaining",
			wantOpsAfter: 0,
		},
		{
			name: "returns_error_when_next_expectation_is_not_exec",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectQuery("SELECT 1")
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: true}, {Ordinal: 2, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "got EXEC",
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_for_exec_sql_mismatch",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").WithArgs(true, int64(1))
			},
			query:        "DELETE FROM users WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "exec sql mismatch",
			wantOpsAfter: 1,
		},
		{
			name: "returns_error_for_exec_args_mismatch",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").WithArgs(true, int64(1))
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: false}, {Ordinal: 2, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "exec args mismatch",
			wantOpsAfter: 1,
		},
		{
			name: "returns_configured_exec_error",
			setup: func(c *Conn, m *Mock) {
				c.txStarted = true
				m.ExpectExec("UPDATE users SET active = ? WHERE id = ?").
					WithArgs(true, int64(1)).
					WillReturnError(execErr)
			},
			query:        "UPDATE users SET active = ? WHERE id = ?",
			args:         []driver.NamedValue{{Ordinal: 1, Value: true}, {Ordinal: 2, Value: int64(1)}},
			wantErr:      true,
			errSubstr:    "exec failed",
			wantOpsAfter: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			opts := []Option{}
			if tt.strictTx {
				opts = append(opts, WithStrictTx())
			}
			mock := NewMock(opts...)
			conn := &Conn{mock: mock}
			if tt.setup != nil {
				tt.setup(conn, mock)
			}

			// Act
			result, err := conn.ExecContext(context.Background(), tt.query, tt.args)

			// Assert
			if tt.wantErr {
				require.Error(t, err)
				assert.Nil(t, result)
				assert.Contains(t, err.Error(), tt.errSubstr)
				if tt.wantHint {
					assert.Contains(t, err.Error(), "Use WithStrictTx() if this should be transactional")
				}
				assert.Len(t, mock.ops, tt.wantOpsAfter)
				return
			}

			require.NoError(t, err)
			require.NotNil(t, result)
			affected, err := result.RowsAffected()
			require.NoError(t, err)
			assert.Equal(t, tt.wantCount, affected)
			assert.Len(t, mock.ops, tt.wantOpsAfter)
		})
	}
}

func TestConnClose(t *testing.T) {
	tests := []struct {
		name string
	}{
		{name: "returns_nil_error"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			conn := &Conn{mock: NewMock()}

			// Act
			err := conn.Close()

			// Assert
			require.NoError(t, err)
		})
	}
}

func TestConnBegin(t *testing.T) {
	beginErr := errors.New("begin failed")

	tests := []struct {
		name         string
		setup        func(m *Mock)
		wantErr      bool
		errSubstr    string
		wantTx       bool
		wantStarted  bool
		wantOpsAfter int
	}{
		{
			name: "starts_transaction_when_begin_expectation_matches",
			setup: func(m *Mock) {
				m.ExpectBegin()
			},
			wantErr:      false,
			wantTx:       true,
			wantStarted:  true,
			wantOpsAfter: 0,
		},
		{
			name: "returns_error_when_no_expectation_remaining",
			setup: func(m *Mock) {
			},
			wantErr:      true,
			errSubstr:    "no expectation remaining",
			wantTx:       false,
			wantStarted:  false,
			wantOpsAfter: 0,
		},
		{
			name: "returns_error_when_next_expectation_is_not_begin",
			setup: func(m *Mock) {
				m.ExpectQuery("SELECT 1")
			},
			wantErr:      true,
			errSubstr:    "expected QUERY, got begin",
			wantTx:       false,
			wantStarted:  false,
			wantOpsAfter: 1,
		},
		{
			name: "returns_configured_begin_error",
			setup: func(m *Mock) {
				m.ExpectBegin().WillReturnError(beginErr)
			},
			wantErr:      true,
			errSubstr:    "begin failed",
			wantTx:       false,
			wantStarted:  false,
			wantOpsAfter: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			mock := NewMock()
			if tt.setup != nil {
				tt.setup(mock)
			}
			conn := &Conn{mock: mock}

			// Act
			tx, err := conn.Begin()

			// Assert
			if tt.wantErr {
				require.Error(t, err)
				assert.Nil(t, tx)
				assert.Contains(t, err.Error(), tt.errSubstr)
				assert.Equal(t, tt.wantStarted, conn.txStarted)
				assert.Len(t, mock.ops, tt.wantOpsAfter)
				return
			}

			require.NoError(t, err)
			if tt.wantTx {
				require.NotNil(t, tx)
				_, ok := tx.(*Tx)
				require.True(t, ok)
			}
			assert.Equal(t, tt.wantStarted, conn.txStarted)
			assert.Len(t, mock.ops, tt.wantOpsAfter)
		})
	}
}

func TestConnBeginTx(t *testing.T) {
	tests := []struct {
		name         string
		setup        func(m *Mock)
		wantErr      bool
		errSubstr    string
		wantStarted  bool
		wantOpsAfter int
	}{
		{
			name: "starts_transaction_with_default_options",
			setup: func(m *Mock) {
				m.ExpectBegin()
			},
			wantErr:      false,
			wantStarted:  true,
			wantOpsAfter: 0,
		},
		{
			name: "returns_error_on_mismatch_expectation",
			setup: func(m *Mock) {
				m.ExpectCommit()
			},
			wantErr:      true,
			errSubstr:    "expected COMMIT, got begin",
			wantStarted:  false,
			wantOpsAfter: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Arrange
			mock := NewMock()
			tt.setup(mock)
			conn := &Conn{mock: mock}

			// Act
			tx, err := conn.BeginTx(context.Background(), driver.TxOptions{})

			// Assert
			if tt.wantErr {
				require.Error(t, err)
				assert.Nil(t, tx)
				assert.Contains(t, err.Error(), tt.errSubstr)
				assert.Equal(t, tt.wantStarted, conn.txStarted)
				assert.Len(t, mock.ops, tt.wantOpsAfter)
				return
			}

			require.NoError(t, err)
			require.NotNil(t, tx)
			assert.Equal(t, tt.wantStarted, conn.txStarted)
			assert.Len(t, mock.ops, tt.wantOpsAfter)
		})
	}
}