sqlmock_test.go

package sqlmock

import (
	"sync"
	"testing"

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

func TestNew(t *testing.T) {
	// Arrange
	db, mock, err := NewWithOptions(WithStrictTx())
	require.NoError(t, err)
	require.NotNil(t, db)
	require.NotNil(t, mock)
	require.True(t, mock.strictTx)
	t.Cleanup(func() {
		require.NoError(t, db.Close())
	})

	tests := []struct {
		name string
		run  func(t *testing.T, mock *Mock)
	}{
		{
			name: "returns_error_for_query_without_transaction_in_strict_mode",
			run: func(t *testing.T, mock *Mock) {
				// Arrange
				const query = "SELECT id FROM users WHERE id = ?"

				// Act
				rows, err := db.Query(query, int64(999))

				// Assert
				require.Error(t, err)
				assert.Nil(t, rows)
				assert.Contains(t, err.Error(), "query without active transaction")
				require.NoError(t, mock.ExpectationsWereMet())
			},
		},
		{
			name: "creates_working_db_for_expected_query_in_transaction",
			run: func(t *testing.T, mock *Mock) {
				// Arrange
				const query = "SELECT id, name FROM users WHERE id = ?"
				mock.ExpectBegin()
				mock.ExpectQuery(query).
					WithArgs(int64(7)).
					WillReturnRows(NewRows([]string{"id", "name"}).AddRows(int64(7), "Alice"))
				mock.ExpectCommit()

				tx, err := db.Begin()
				require.NoError(t, err)

				// Act
				var id int64
				var name string
				err = tx.QueryRow(query, int64(7)).Scan(&id, &name)

				// Assert
				require.NoError(t, err)
				assert.Equal(t, int64(7), id)
				assert.Equal(t, "Alice", name)
				require.NoError(t, tx.Commit())
				require.NoError(t, mock.ExpectationsWereMet())
			},
		},
		{
			name: "returns_error_for_exec_without_transaction_in_strict_mode",
			run: func(t *testing.T, mock *Mock) {
				// Arrange
				const query = "UPDATE users SET active = ? WHERE id = ?"

				// Act
				result, err := db.Exec(query, true, int64(7))

				// Assert
				require.Error(t, err)
				assert.Nil(t, result)
				assert.Contains(t, err.Error(), "exec without active transaction")
				require.NoError(t, mock.ExpectationsWereMet())
			},
		},
		{
			name: "creates_working_db_for_expected_exec_in_transaction",
			run: func(t *testing.T, mock *Mock) {
				// Arrange
				const query = "UPDATE users SET active = ? WHERE id = ?"
				mock.ExpectBegin()
				mock.ExpectExec(query).WithArgs(true, int64(7)).WillReturnResult(1)
				mock.ExpectCommit()

				tx, err := db.Begin()
				require.NoError(t, err)

				// Act
				result, err := tx.Exec(query, true, int64(7))

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

				affected, err := result.RowsAffected()
				require.NoError(t, err)
				assert.Equal(t, int64(1), affected)
				require.NoError(t, tx.Commit())
				require.NoError(t, mock.ExpectationsWereMet())
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.run(t, mock)
		})
	}

	t.Run("allows_multiple_new_calls", func(t *testing.T) {
		// Arrange
		db1, mock1, err := New()
		require.NoError(t, err)
		require.NotNil(t, db1)
		require.NotNil(t, mock1)
		t.Cleanup(func() {
			require.NoError(t, db1.Close())
		})

		db2, mock2, err := NewWithOptions(WithStrictTx())
		require.NoError(t, err)
		require.NotNil(t, db2)
		require.NotNil(t, mock2)
		require.True(t, mock2.strictTx)
		t.Cleanup(func() {
			require.NoError(t, db2.Close())
		})

		const query = "SELECT id FROM users WHERE id = ?"
		mock1.ExpectQuery(query).
			WithArgs(int64(1)).
			WillReturnRows(NewRows([]string{"id"}).AddRows(int64(1)))

		// Act
		var id int64
		err = db1.QueryRow(query, int64(1)).Scan(&id)

		// Assert
		require.NoError(t, err)
		assert.Equal(t, int64(1), id)
		require.NoError(t, mock1.ExpectationsWereMet())
	})

	t.Run("supports_parallel_new_calls", func(t *testing.T) {
		const workers = 8
		var wg sync.WaitGroup
		errCh := make(chan error, workers)

		for i := 0; i < workers; i++ {
			wg.Add(1)

			go func() {
				defer wg.Done()

				db, mock, err := NewWithOptions(WithStrictTx())
				if err != nil {
					errCh <- err
					return
				}
				defer db.Close()

				if mock == nil {
					errCh <- assert.AnError
					return
				}

				if err := mock.ExpectationsWereMet(); err != nil {
					errCh <- err
					return
				}
			}()
		}

		wg.Wait()
		close(errCh)

		for err := range errCh {
			require.NoError(t, err)
		}
	})
}