GET v1/users is now actually pretty darn cool

common/where.go

@@ -15,17 +15,58 @@ func (w *WhereClause) Where(clause, passedParam string, allowedValues ...string)
 	if len(allowedValues) != 0 && !contains(allowedValues, passedParam) {
 		return w
 	}
-	// checks passed, if string is empty add "WHERE"
+	w.addWhere()
+	w.Clause += clause
+	w.Params = append(w.Params, passedParam)
+	return w
+}
+
+func (w *WhereClause) addWhere() {
+	// if string is empty add "WHERE", else add AND
 	if w.Clause == "" {
 		w.Clause += "WHERE "
 	} else {
 		w.Clause += " AND "
 	}
-	w.Clause += clause
-	w.Params = append(w.Params, passedParam)
+}
+
+// In generates an IN clause.
+// initial is the initial part, e.g. "users.id".
+// Fields are the possible values.
+// Sample output: users.id IN ('1', '2', '3')
+func (w *WhereClause) In(initial string, fields ...string) *WhereClause {
+	if len(fields) == 0 {
+		return w
+	}
+	w.addWhere()
+	w.Clause += initial + " IN (" + generateQuestionMarks(len(fields)) + ")"
+	fieldsInterfaced := make([]interface{}, 0, len(fields))
+	for _, i := range fields {
+		fieldsInterfaced = append(fieldsInterfaced, interface{}(i))
+	}
+	w.Params = append(w.Params, fieldsInterfaced...)
 	return w
 }
 
+func generateQuestionMarks(x int) (qm string) {
+	for i := 0; i < x-1; i++ {
+		qm += "?, "
+	}
+	if x > 0 {
+		qm += "?"
+	}
+	return qm
+}
+
+// ClauseSafe returns the clause, always containing something. If w.Clause is
+// empty, it returns "WHERE 1".
+func (w *WhereClause) ClauseSafe() string {
+	if w.Clause == "" {
+		return "WHERE 1"
+	}
+	return w.Clause
+}
+
 // Where is the same as WhereClause.Where, but creates a new WhereClause.
 func Where(clause, passedParam string, allowedValues ...string) *WhereClause {
 	w := new(WhereClause)

common/where_test.go

@@ -0,0 +1,96 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_generateQuestionMarks(t *testing.T) {
+	type args struct {
+		x int
+	}
+	tests := []struct {
+		name   string
+		args   args
+		wantQm string
+	}{
+		{"-1", args{-1}, ""},
+		{"0", args{0}, ""},
+		{"1", args{1}, "?"},
+		{"2", args{2}, "?, ?"},
+	}
+	for _, tt := range tests {
+		if gotQm := generateQuestionMarks(tt.args.x); gotQm != tt.wantQm {
+			t.Errorf("%q. generateQuestionMarks() = %v, want %v", tt.name, gotQm, tt.wantQm)
+		}
+	}
+}
+
+func TestWhereClause_In(t *testing.T) {
+	type args struct {
+		initial string
+		fields  []interface{}
+	}
+	tests := []struct {
+		name   string
+		fields *WhereClause
+		args   args
+		want   *WhereClause
+	}{
+		{
+			"simple",
+			&WhereClause{},
+			args{"users.id", []interface{}{"1", "2", "3"}},
+			&WhereClause{"WHERE users.id IN (?, ?, ?)", []interface{}{"1", "2", "3"}},
+		},
+		{
+			"withExisting",
+			Where("users.username = ?", "Howl").Where("users.xd > ?", "6"),
+			args{"users.id", []interface{}{"1"}},
+			&WhereClause{
+				"WHERE users.username = ? AND users.xd > ? AND users.id IN (?)",
+				[]interface{}{"Howl", "6", "1"},
+			},
+		},
+	}
+	for _, tt := range tests {
+		w := tt.fields
+		if got := w.In(tt.args.initial, tt.args.fields...); !reflect.DeepEqual(got, tt.want) {
+			t.Errorf("%q. WhereClause.In() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestWhere(t *testing.T) {
+	type args struct {
+		clause        string
+		passedParam   string
+		allowedValues []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want *WhereClause
+	}{
+		{
+			"simple",
+			args{"users.id = ?", "5", nil},
+			&WhereClause{"WHERE users.id = ?", []interface{}{"5"}},
+		},
+		{
+			"allowed",
+			args{"users.id = ?", "5", []string{"1", "3", "5"}},
+			&WhereClause{"WHERE users.id = ?", []interface{}{"5"}},
+		},
+		{
+			"notAllowed",
+			args{"users.id = ?", "5", []string{"0"}},
+			&WhereClause{},
+		},
+	}
+	for _, tt := range tests {
+		if got := Where(tt.args.clause, tt.args.passedParam, tt.args.allowedValues...); !reflect.DeepEqual(got, tt.want) {
+			t.Errorf("%q. Where() = %#v, want %#v", tt.name, got, tt.want)
+		}
+	}
+}