add tests for insert stmt

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

query.go

···
 type insert struct {
 	into   string
 	or     InsertOr
-	values map[string]any
+	values []struct {
+		col string
+		val any
+	}
 }
 
 type InsertOr int
···
 }
 
 func Insert() insert {
-	return insert{
-		values: make(map[string]any),
-	}
+	return insert{}
 }
 
 type InsertOpt func(s *insert)
···
 }
 
 func (s insert) Value(column string, arg any) insert {
-	s.values[column] = arg
+	s.values = append(s.values, struct {
+		col string
+		val any
+	}{
+		column, arg,
+	})
 	return s
 }
 
···
 	if s.or != None {
 		sql.WriteString("OR ")
 		sql.WriteString(s.or.String())
+		sql.WriteString(" ")
 	}
 
 	if s.into == "" {
 		return "", nil, fmt.Errorf("INTO clause is required")
 	}
-	sql.WriteString(" INTO ")
+	sql.WriteString("INTO ")
 	sql.WriteString(s.into)
 
 	if len(s.values) == 0 {
···
 
 	sql.WriteString(" (")
 
-	first := true
-	for col, val := range s.values {
-		if !first {
-			sql.WriteString(",")
-			first = !first
+	for i, v := range s.values {
+		if i != 0 {
+			sql.WriteString(", ")
 		}
 
-		sql.WriteString(col)
-		args = append(args, val)
+		sql.WriteString(v.col)
+		args = append(args, v.val)
 	}
 
 	sql.WriteString(") VALUES (")
-	sql.WriteString(strings.TrimSuffix(strings.Repeat("?,", len(s.values)), ","))
+	sql.WriteString(strings.TrimSuffix(strings.Repeat("?, ", len(s.values)), ", "))
 	sql.WriteString(")")
 
 	return sql.String(), args, nil

query_test.go

···
 		})
 	}
 }
+
+func TestInsertBuild_Success(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         insert
+		expectedSql  string
+		expectedArgs []any
+	}{
+		{
+			name:         "Simple insert",
+			stmt:         Insert().Into("users").Value("name", "John"),
+			expectedSql:  "INSERT INTO users (name) VALUES (?)",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Replace clause",
+			stmt:         Insert().Or(Replace).Into("users").Value("name", "John"),
+			expectedSql:  "INSERT OR REPLACE INTO users (name) VALUES (?)",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "More values",
+			stmt:         Insert().Into("users").Value("name", "John").Value("age", 35),
+			expectedSql:  "INSERT INTO users (name, age) VALUES (?, ?)",
+			expectedArgs: []any{"John", 35},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sql, args, err := test.stmt.Build()
+
+			if err != nil {
+				t.Errorf("Expected no error, got %v", err)
+			}
+
+			if sql != test.expectedSql {
+				t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql)
+			}
+
+			if len(args) != len(test.expectedArgs) {
+				t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args))
+			}
+
+			for i := range len(args) {
+				if args[i] != test.expectedArgs[i] {
+					t.Errorf("Expected '%v', got '%v' at index %d", test.expectedArgs[i], args[i], i)
+				}
+			}
+		})
+	}
+}