write tests for delete stmt

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

query_test.go

···
 
 import (
 	"testing"
-	"time"
 
 	_ "github.com/mattn/go-sqlite3"
 )
···
 	})
 }
 
-func TestSelectIntegration_ErrorHandling(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-
-	t.Run("Invalid table name", func(t *testing.T) {
-		s := Select("*").From("nonexistent_table")
+func TestDeleteIntegration_BasicQueries(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         delete_
+		expectedRows int64
+	}{
+		{
+			name:         "Delete all users",
+			stmt:         Delete().From("users"),
+			expectedRows: 6,
+		},
+		{
+			name: "Delete active users only",
+			stmt: Delete().
+				From("users").
+				Where(Eq("active", true)),
+			expectedRows: 4,
+		},
+		{
+			name: "Select users in Engineering",
+			stmt: Delete().
+				From("users").
+				Where(Eq("department", "Engineering")),
+			expectedRows: 3,
+		},
+		{
+			name: "Delete users with age > 30",
+			stmt: Delete().
+				From("users").
+				Where(Gt("age", 30)),
+			expectedRows: 2,
+		},
+		{
+			name: "Delete users with salary between 70000 and 80000",
+			stmt: Delete().
+				From("users").
+				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),
+			expectedRows: 3,
+		},
+	}
 
-		sql, args := s.MustBuild()
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			db := setupTestDB(t)
+			defer db.Close()
 
-		_, err := db.Query(sql, args...)
-		if err == nil {
-			t.Error("Expected error for nonexistent table, got nil")
-		}
-	})
+			sql, args, err := test.stmt.Build()
+			if err != nil {
+				t.Fatalf("Failed to build query: %v", err)
+			}
 
-	t.Run("Invalid column name", func(t *testing.T) {
-		s := Select("nonexistent_column").From("users")
+			res, err := db.Exec(sql, args...)
+			if err != nil {
+				t.Fatalf("Failed to execute query: %v", err)
+			}
 
-		sql, args := s.MustBuild()
+			count, err := res.RowsAffected()
+			if err != nil {
+				t.Fatalf("Failed to execute query: %v", err)
+			}
 
-		_, err := db.Query(sql, args...)
-		if err == nil {
-			t.Error("Expected error for nonexistent column, got nil")
-		}
-	})
-}
-
-func TestSelectIntegration_PerformanceBaseline(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-
-	start := time.Now()
-	for i := range 1000 {
-		_, err := db.Exec(`
-			INSERT INTO users (name, email, department, age, active, salary)
-			VALUES (?, ?, ?, ?, ?, ?)
-		`, "User"+string(rune(i)), "user"+string(rune(i))+"@example.com", "Engineering", 25+i%15, i%2 == 0, 50000.0+float64(i*100))
-		if err != nil {
-			t.Fatalf("Failed to insert test user: %v", err)
-		}
+			if count != test.expectedRows {
+				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
+			}
+		})
 	}
-	insertTime := time.Since(start)
-	t.Logf("Inserted 1000 users in %v", insertTime)
-
-	t.Run("Simple select performance", func(t *testing.T) {
-		s := Select("name", "email").
-			From("users").
-			Where(Eq("active", true))
-
-		sql, args := s.MustBuild()
-
-		start := time.Now()
-		rows, err := db.Query(sql, args...)
-		if err != nil {
-			t.Fatalf("Failed to execute query: %v", err)
-		}
-		defer rows.Close()
-
-		count := 0
-		for rows.Next() {
-			count++
-		}
-		queryTime := time.Since(start)
-
-		t.Logf("Selected %d rows in %v", count, queryTime)
-		if queryTime > time.Millisecond*100 {
-			t.Logf("Query took longer than expected: %v", queryTime)
-		}
-	})
-
-	t.Run("Complex query performance", func(t *testing.T) {
-		s := Select("name", "department", "salary").
-			From("users").
-			Where(
-				Eq("active", true).
-					And(Gt("salary", 60000.0)).
-					Or(Eq("department", "Engineering")),
-			).
-			OrderBy("salary", Descending).
-			Limit(50)
-
-		sql, args := s.MustBuild()
-
-		start := time.Now()
-		rows, err := db.Query(sql, args...)
-		if err != nil {
-			t.Fatalf("Failed to execute query: %v", err)
-		}
-		defer rows.Close()
-
-		count := 0
-		for rows.Next() {
-			count++
-		}
-		queryTime := time.Since(start)
-
-		t.Logf("Complex query returned %d rows in %v", count, queryTime)
-		if queryTime > time.Millisecond*200 {
-			t.Logf("Complex query took longer than expected: %v", queryTime)
-		}
-	})
 }