write tests for scanner

Signed-off-by: oppiliappan <[e-mail]>

query_test.go

···
 package norm
 
 import (
-	"database/sql"
 	"testing"
 	"time"
 
···
 }
 
 func TestComplexExpressions(t *testing.T) {
-	// Test chained logical operations
 	age := Eq("age", 25)
 	status := Eq("status", "active")
 	score := Gt("score", 100)
···
 }
 
 func TestSelectAPI(t *testing.T) {
-	// Test fluent API chaining
 	s := Select("*").
 		From("users").
 		Where(Eq("id", 1)).
···
 func TestSelectBuild_Success(t *testing.T) {
 	tests := []struct {
 		name         string
-		builder      func() select_
+		stmt         select_
 		expectedSql  string
 		expectedArgs []any
 	}{
 		{
-			name: "Simple select",
-			builder: func() select_ {
-				return Select("name", "age").From("users")
-			},
+			name:         "Simple select",
+			stmt:         Select("name", "age").From("users"),
 			expectedSql:  "SELECT name, age FROM users",
 			expectedArgs: nil,
 		},
 		{
 			name: "Select with where",
-			builder: func() select_ {
-				return Select("*").
-					From("users").
-					Where(Eq("active", true))
-			},
+			stmt: Select("*").
+				From("users").
+				Where(Eq("active", true)),
 			expectedSql:  "SELECT * FROM users WHERE (active) = (?)",
 			expectedArgs: []any{true},
 		},
 		{
 			name: "Select with order by",
-			builder: func() select_ {
-				return Select("name").
-					From("users").
-					OrderBy("name", Ascending)
-			},
+			stmt: Select("name").
+				From("users").
+				OrderBy("name", Ascending),
 			expectedSql:  "SELECT name FROM users ORDER BY name asc",
 			expectedArgs: nil,
 		},
 		{
 			name: "Select with multiple order by",
-			builder: func() select_ {
-				return Select("name", "age").
-					From("users").
-					OrderBy("name", Ascending).
-					OrderBy("age", Descending)
-			},
+			stmt: Select("name", "age").
+				From("users").
+				OrderBy("name", Ascending).
+				OrderBy("age", Descending),
 			expectedSql:  "SELECT name, age FROM users ORDER BY name asc, age desc",
 			expectedArgs: nil,
 		},
 		{
 			name: "Select with group by",
-			builder: func() select_ {
-				return Select("department", "COUNT(*)").
-					From("users").
-					GroupBy("department")
-			},
+			stmt: Select("department", "COUNT(*)").
+				From("users").
+				GroupBy("department"),
 			expectedSql:  "SELECT department, COUNT(*) FROM users GROUP BY department",
 			expectedArgs: nil,
 		},
 		{
 			name: "Select with limit",
-			builder: func() select_ {
-				return Select("*").
-					From("users").
-					Limit(5)
-			},
+			stmt: Select("*").
+				From("users").
+				Limit(5),
 			expectedSql:  "SELECT * FROM users LIMIT 5",
 			expectedArgs: nil,
 		},
 		{
 			name: "Complex select",
-			builder: func() select_ {
-				return Select("name", "age", "department").
-					From("users").
-					Where(Eq("active", true).And(Gt("age", 18))).
-					GroupBy("department").
-					OrderBy("name", Ascending).
-					Limit(10)
-			},
+			stmt: Select("name", "age", "department").
+				From("users").
+				Where(Eq("active", true).And(Gt("age", 18))).
+				GroupBy("department").
+				OrderBy("name", Ascending).
+				Limit(10),
 			expectedSql:  "SELECT name, age, department FROM users WHERE ((active) = (?)) and ((age) > (?)) GROUP BY department ORDER BY name asc LIMIT 10",
 			expectedArgs: []any{true, 18},
 		},
···
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			s := test.builder()
-			sql, args, err := s.Build()
+			sql, args, err := test.stmt.Build()
 
 			if err != nil {
 				t.Errorf("Expected no error, got %v", err)
···
 func TestSelectBuild_Errors(t *testing.T) {
 	tests := []struct {
 		name          string
-		builder       func() select_
+		stmt          select_
 		expectedError string
 	}{
 		{
-			name: "No columns",
-			builder: func() select_ {
-				return Select()
-			},
+			name:          "No columns",
+			stmt:          Select(),
 			expectedError: "result columns empty",
 		},
 		{
-			name: "No from clause",
-			builder: func() select_ {
-				return Select("name")
-			},
+			name:          "No from clause",
+			stmt:          Select("name"),
 			expectedError: "FROM clause is required",
 		},
 		{
 			name: "Invalid limit",
-			builder: func() select_ {
-				return Select("name").
-					From("users").
-					Limit(0)
-			},
+			stmt: Select("name").
+				From("users").
+				Limit(0),
 			expectedError: "LIMIT must be positive, got 0",
 		},
 		{
 			name: "Negative limit",
-			builder: func() select_ {
-				return Select("name").
-					From("users").
-					Limit(-5)
-			},
+			stmt: Select("name").
+				From("users").
+				Limit(-5),
 			expectedError: "LIMIT must be positive, got -5",
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			s := test.builder()
-			sql, args, err := s.Build()
+			sql, args, err := test.stmt.Build()
 
 			if err == nil {
 				t.Error("Expected error, got nil")
···
 	}
 }
 
-// setupTestDB creates an in-memory SQLite database with test data
-func setupTestDB(t *testing.T) *sql.DB {
-	db, err := sql.Open("sqlite3", ":memory:")
-	if err != nil {
-		t.Fatalf("Failed to open database: %v", err)
-	}
-
-	// Create users table
-	_, err = db.Exec(`
-		CREATE TABLE users (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			name TEXT NOT NULL,
-			age INTEGER NOT NULL,
-			email TEXT UNIQUE NOT NULL,
-			department TEXT,
-			active BOOLEAN DEFAULT TRUE,
-			salary REAL,
-			created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-		)
-	`)
-	if err != nil {
-		t.Fatalf("Failed to create users table: %v", err)
-	}
-
-	// Create departments table
-	_, err = db.Exec(`
-		CREATE TABLE departments (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			name TEXT NOT NULL,
-			budget REAL
-		)
-	`)
-	if err != nil {
-		t.Fatalf("Failed to create departments table: %v", err)
-	}
-
-	// Insert test data
-	users := []struct {
-		name, email, department string
-		age                     int
-		active                  bool
-		salary                  float64
-	}{
-		{"John Doe", "[e-mail]", "Engineering", 30, true, 75000.0},
-		{"Jane Smith", "[e-mail]", "Marketing", 25, true, 65000.0},
-		{"Bob Johnson", "[e-mail]", "Engineering", 35, false, 80000.0},
-		{"Alice Brown", "[e-mail]", "Sales", 28, true, 70000.0},
-		{"Charlie Wilson", "[e-mail]", "Engineering", 32, true, 85000.0},
-		{"Diana Prince", "[e-mail]", "Marketing", 29, false, 68000.0},
-	}
-
-	for _, user := range users {
-		_, err = db.Exec(`
-			INSERT INTO users (name, email, department, age, active, salary)
-			VALUES (?, ?, ?, ?, ?, ?)
-		`, user.name, user.email, user.department, user.age, user.active, user.salary)
-		if err != nil {
-			t.Fatalf("Failed to insert user %s: %v", user.name, err)
-		}
-	}
-
-	// Insert departments
-	departments := []struct {
-		name   string
-		budget float64
-	}{
-		{"Engineering", 500000.0},
-		{"Marketing", 300000.0},
-		{"Sales", 400000.0},
-	}
-
-	for _, dept := range departments {
-		_, err = db.Exec(`
-			INSERT INTO departments (name, budget)
-			VALUES (?, ?)
-		`, dept.name, dept.budget)
-		if err != nil {
-			t.Fatalf("Failed to insert department %s: %v", dept.name, err)
-		}
-	}
-
-	return db
-}
-
 func TestSelectIntegration_BasicQueries(t *testing.T) {
 	db := setupTestDB(t)
 	defer db.Close()
 
 	tests := []struct {
 		name         string
-		builder      func() select_
+		stmt         select_
 		expectedRows int
 	}{
 		{
-			name: "Select all users",
-			builder: func() select_ {
-				return Select("*").From("users")
-			},
+			name:         "Select all users",
+			stmt:         Select("*").From("users"),
 			expectedRows: 6,
 		},
 		{
 			name: "Select active users only",
-			builder: func() select_ {
-				return Select("name", "email").
-					From("users").
-					Where(Eq("active", true))
-			},
+			stmt: Select("name", "email").
+				From("users").
+				Where(Eq("active", true)),
 			expectedRows: 4,
 		},
 		{
 			name: "Select users in Engineering",
-			builder: func() select_ {
-				return Select("name", "age").
-					From("users").
-					Where(Eq("department", "Engineering"))
-			},
+			stmt: Select("name", "age").
+				From("users").
+				Where(Eq("department", "Engineering")),
 			expectedRows: 3,
 		},
 		{
 			name: "Select users with age > 30",
-			builder: func() select_ {
-				return Select("name", "age").
-					From("users").
-					Where(Gt("age", 30))
-			},
+			stmt: Select("name", "age").
+				From("users").
+				Where(Gt("age", 30)),
 			expectedRows: 2,
 		},
 		{
 			name: "Select users with salary between 70000 and 80000",
-			builder: func() select_ {
-				return Select("name", "salary").
-					From("users").
-					Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0)))
-			},
+			stmt: Select("name", "salary").
+				From("users").
+				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),
 			expectedRows: 3,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			s := test.builder()
-			sql, args, err := s.Build()
+			sql, args, err := test.stmt.Build()
 			if err != nil {
 				t.Fatalf("Failed to build query: %v", err)
 			}
···
 			t.Fatalf("Expected 6 results, got %d", len(results))
 		}
 
-		// First result should be from Engineering (alphabetically first) with highest age
 		if results[0].department != "Engineering" {
 			t.Errorf("Expected first result to be from Engineering, got %s", results[0].department)
 		}
···
 			t.Errorf("Expected 3 departments, got %d", len(results))
 		}
 
-		// Engineering should have the most users (3)
 		if results[0].department != "Engineering" || results[0].count != 3 {
 			t.Errorf("Expected Engineering with 3 users first, got %s with %d users", results[0].department, results[0].count)
 		}
···
 			t.Errorf("Expected 2 results, got %d", len(results))
 		}
 
-		// Should get Charlie Wilson (85000) and John Doe (75000)
 		if results[0].salary != 85000.0 {
 			t.Errorf("Expected highest salary to be 85000, got %f", results[0].salary)
 		}
···
 	db := setupTestDB(t)
 	defer db.Close()
 
-	// Add more test data for performance testing
 	start := time.Now()
-	for i := 0; i < 1000; i++ {
+	for i := range 1000 {
 		_, err := db.Exec(`
 			INSERT INTO users (name, email, department, age, active, salary)
 			VALUES (?, ?, ?, ?, ?, ?)

scanner.go

···
 
 func (s *Scanner[T]) Scan() iter.Seq[T] {
 	return func(yield func(T) bool) {
-		defer s.rows.Close()
-
 		for s.rows.Next() {
 			var data T
 			elem := reflect.ValueOf(&data).Elem()
···
 		}
 	}
 }
+
+func (s *Scanner[T]) Close() error {
+	return s.rows.Close()
+}

scanner_test.go

···
+package norm
+
+import (
+	"database/sql"
+	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type User struct {
+	ID         int
+	Name       string
+	Age        int
+	Email      string
+	Department sql.NullString
+	Active     bool
+	Salary     sql.NullFloat64
+	CreatedAt  time.Time
+}
+
+type UserBasic struct {
+	ID    int
+	Name  string
+	Email string
+}
+
+type Department struct {
+	ID     int
+	Name   string
+	Budget float64
+}
+
+type SimpleStruct struct {
+	Value int
+}
+
+func TestScannerWithDepartments(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, budget FROM departments ORDER BY id")
+	if err != nil {
+		t.Fatalf("Failed to query departments: %v", err)
+	}
+
+	scanner := NewScanner[Department](rows)
+	defer scanner.Close()
+	var departments []Department
+
+	for dept := range scanner.Scan() {
+		departments = append(departments, dept)
+	}
+
+	if len(departments) != 3 {
+		t.Errorf("Expected 3 departments, got %d", len(departments))
+	}
+
+	d1 := departments[0]
+	if d1.ID != 1 || d1.Name != "Engineering" || d1.Budget != 500000.0 {
+		t.Errorf("Engineering department data incorrect: %+v", d1)
+	}
+
+	d2 := departments[1]
+	if d2.ID != 2 || d2.Name != "Marketing" || d2.Budget != 300000.0 {
+		t.Errorf("Marketing department data incorrect: %+v", d2)
+	}
+}
+
+func TestScannerBasicFunctionality(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users ORDER BY id")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+	defer scanner.Close()
+	var users []UserBasic
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+	}
+
+	if len(users) != 6 {
+		t.Errorf("Expected 6 users, got %d", len(users))
+	}
+
+	if users[0].ID != 1 || users[0].Name != "John Doe" || users[0].Email != "[e-mail]" {
+		t.Errorf("Expected first user to be John Doe, got %+v", users[0])
+	}
+
+	if users[5].Name != "Diana Prince" || users[5].Email != "[e-mail]" {
+		t.Errorf("Expected last user to be Diana Prince, got %+v", users[5])
+	}
+}
+
+func TestScannerWithAllFields(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, age, email, department, active, salary, created_at FROM users ORDER BY id")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[User](rows)
+	defer scanner.Close()
+	var users []User
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+	}
+
+	if len(users) != 6 {
+		t.Errorf("Expected 6 users, got %d", len(users))
+	}
+
+	u1 := users[0]
+	if u1.ID != 1 || u1.Name != "John Doe" || u1.Age != 30 || u1.Email != "[e-mail]" || !u1.Active {
+		t.Errorf("User 1 basic data incorrect: %+v", u1)
+	}
+	if !u1.Department.Valid || u1.Department.String != "Engineering" {
+		t.Errorf("User 1 department incorrect: %v", u1.Department)
+	}
+	if !u1.Salary.Valid || u1.Salary.Float64 != 75000.0 {
+		t.Errorf("User 1 salary incorrect: %v", u1.Salary)
+	}
+
+	u3 := users[2]
+	if u3.Name != "Bob Johnson" || u3.Active {
+		t.Errorf("User 3 should be inactive Bob Johnson: %+v", u3)
+	}
+
+	if u1.CreatedAt.IsZero() {
+		t.Error("User 1 created_at should not be zero")
+	}
+}
+
+func TestScannerWithErrorHandler(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users LIMIT 1")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	var capturedError error
+	scanner := NewScanner(rows, OnScannerError[SimpleStruct](func(err error) {
+		capturedError = err
+	}))
+	defer scanner.Close()
+
+	var results []SimpleStruct
+	for result := range scanner.Scan() {
+		results = append(results, result)
+	}
+
+	if capturedError == nil {
+		t.Error("Expected an error to be captured, but none was")
+	}
+
+	if len(results) != 0 {
+		t.Errorf("Expected 0 results due to scan error, got %d", len(results))
+	}
+}
+
+func TestScannerEarlyTermination(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users ORDER BY id")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+	defer scanner.Close()
+	var users []UserBasic
+	count := 0
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+		count++
+		if count == 1 {
+			break
+		}
+	}
+
+	if len(users) != 1 {
+		t.Errorf("Expected 1 user due to early termination, got %d", len(users))
+	}
+
+	if users[0].ID != 1 || users[0].Name != "John Doe" {
+		t.Errorf("Expected first user to be John Doe, got %+v", users[0])
+	}
+}
+
+func TestScannerEmptyResults(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users WHERE id = 999")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+	defer scanner.Close()
+	var users []UserBasic
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+	}
+
+	if len(users) != 0 {
+		t.Errorf("Expected 0 users from empty query, got %d", len(users))
+	}
+}
+
+func TestScannerMultipleIterations(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users ORDER BY id LIMIT 1")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+	defer scanner.Close()
+	seq := scanner.Scan()
+
+	var users1 []UserBasic
+	for user := range seq {
+		users1 = append(users1, user)
+	}
+
+	var users2 []UserBasic
+	for user := range seq {
+		users2 = append(users2, user)
+	}
+
+	if len(users1) != 1 {
+		t.Errorf("Expected 1 user from first iteration, got %d", len(users1))
+	}
+
+	if len(users2) != 0 {
+		t.Errorf("Expected 0 users from second iteration, got %d", len(users2))
+	}
+}
+
+func TestScannerWithNilErrorHandler(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users LIMIT 1")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+	defer scanner.Close()
+	var users []UserBasic
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+	}
+
+	if len(users) != 1 {
+		t.Errorf("Expected 1 user, got %d", len(users))
+	}
+}
+
+func TestScannerResourceCleanup(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, email FROM users")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[UserBasic](rows)
+
+	for user := range scanner.Scan() {
+		_ = user
+		break
+	}
+
+	scanner.Close()
+	if err := rows.Err(); err != nil {
+		t.Errorf("Expected no error, got %s", err)
+	}
+}
+
+func TestScannerFilterByDepartment(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	rows, err := db.Query("SELECT id, name, age, email, department, active, salary, created_at FROM users WHERE department = 'Engineering' ORDER BY id")
+	if err != nil {
+		t.Fatalf("Failed to query users: %v", err)
+	}
+
+	scanner := NewScanner[User](rows)
+	defer scanner.Close()
+	var users []User
+
+	for user := range scanner.Scan() {
+		users = append(users, user)
+	}
+
+	if len(users) != 3 {
+		t.Errorf("Expected 3 Engineering users, got %d", len(users))
+	}
+
+	for i, user := range users {
+		if !user.Department.Valid || user.Department.String != "Engineering" {
+			t.Errorf("User %d should be from Engineering: %+v", i, user)
+		}
+	}
+
+	expectedNames := []string{"John Doe", "Bob Johnson", "Charlie Wilson"}
+	for i, user := range users {
+		if user.Name != expectedNames[i] {
+			t.Errorf("Expected user %d to be %s, got %s", i, expectedNames[i], user.Name)
+		}
+	}
+}

test_util.go

···
+package norm
+
+import (
+	"database/sql"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+// setupTestDB creates an in-memory SQLite database with test data
+func setupTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+
+	// Create users table
+	_, err = db.Exec(`
+		CREATE TABLE users (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			name TEXT NOT NULL,
+			age INTEGER NOT NULL,
+			email TEXT UNIQUE NOT NULL,
+			department TEXT,
+			active BOOLEAN DEFAULT TRUE,
+			salary REAL,
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+		)
+	`)
+	if err != nil {
+		t.Fatalf("Failed to create users table: %v", err)
+	}
+
+	// Create departments table
+	_, err = db.Exec(`
+		CREATE TABLE departments (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			name TEXT NOT NULL,
+			budget REAL
+		)
+	`)
+	if err != nil {
+		t.Fatalf("Failed to create departments table: %v", err)
+	}
+
+	// Insert test data
+	users := []struct {
+		name, email, department string
+		age                     int
+		active                  bool
+		salary                  float64
+	}{
+		{"John Doe", "[e-mail]", "Engineering", 30, true, 75000.0},
+		{"Jane Smith", "[e-mail]", "Marketing", 25, true, 65000.0},
+		{"Bob Johnson", "[e-mail]", "Engineering", 35, false, 80000.0},
+		{"Alice Brown", "[e-mail]", "Sales", 28, true, 70000.0},
+		{"Charlie Wilson", "[e-mail]", "Engineering", 32, true, 85000.0},
+		{"Diana Prince", "[e-mail]", "Marketing", 29, false, 68000.0},
+	}
+
+	for _, user := range users {
+		_, err = db.Exec(`
+			INSERT INTO users (name, email, department, age, active, salary)
+			VALUES (?, ?, ?, ?, ?, ?)
+		`, user.name, user.email, user.department, user.age, user.active, user.salary)
+		if err != nil {
+			t.Fatalf("Failed to insert user %s: %v", user.name, err)
+		}
+	}
+
+	// Insert departments
+	departments := []struct {
+		name   string
+		budget float64
+	}{
+		{"Engineering", 500000.0},
+		{"Marketing", 300000.0},
+		{"Sales", 400000.0},
+	}
+
+	for _, dept := range departments {
+		_, err = db.Exec(`
+			INSERT INTO departments (name, budget)
+			VALUES (?, ?)
+		`, dept.name, dept.budget)
+		if err != nil {
+			t.Fatalf("Failed to insert department %s: %v", dept.name, err)
+		}
+	}
+
+	return db
+}