162 lines
3.6 KiB
Go
162 lines
3.6 KiB
Go
package cassandra
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/scylladb/gocqlx/v3/qb"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestQueryBuilder_TableDriven(t *testing.T) {
|
|
ctx := context.Background()
|
|
db := &DB{} // 可以用 mock DB
|
|
|
|
type args struct {
|
|
cmp qb.Cmp
|
|
whereArg map[string]any
|
|
selects []string
|
|
orderCol string
|
|
order qb.Order
|
|
limit uint
|
|
setCol string
|
|
setVal any
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
wantPanic bool
|
|
wantColumns []string
|
|
wantOrderCol string
|
|
wantOrder qb.Order
|
|
wantLimit uint
|
|
wantSetCol string
|
|
wantSetVal any
|
|
}{
|
|
{
|
|
name: "where by partition key",
|
|
args: args{
|
|
cmp: qb.Eq("id"),
|
|
whereArg: map[string]any{"id": "abc"},
|
|
selects: []string{"id", "name"},
|
|
orderCol: "id",
|
|
order: qb.ASC,
|
|
limit: 1,
|
|
setCol: "name",
|
|
setVal: "Daniel",
|
|
},
|
|
wantPanic: false,
|
|
wantColumns: []string{"id", "name"},
|
|
wantOrderCol: "id",
|
|
wantOrder: qb.ASC,
|
|
wantLimit: 1,
|
|
wantSetCol: "name",
|
|
wantSetVal: "Daniel",
|
|
},
|
|
{
|
|
name: "where by sai index",
|
|
args: args{
|
|
cmp: qb.Eq("name"),
|
|
whereArg: map[string]any{"name": "daniel"},
|
|
selects: []string{"id", "name"},
|
|
orderCol: "name",
|
|
order: qb.DESC,
|
|
limit: 2,
|
|
setCol: "name",
|
|
setVal: "Jacky",
|
|
},
|
|
wantPanic: false,
|
|
wantColumns: []string{"id", "name"},
|
|
wantOrderCol: "name",
|
|
wantOrder: qb.DESC,
|
|
wantLimit: 2,
|
|
wantSetCol: "name",
|
|
wantSetVal: "Jacky",
|
|
},
|
|
{
|
|
name: "where by non-partition-non-sai",
|
|
args: args{
|
|
cmp: qb.Eq("age"),
|
|
whereArg: map[string]any{"age": 18},
|
|
selects: []string{"id", "name"},
|
|
orderCol: "age",
|
|
order: qb.ASC,
|
|
limit: 3,
|
|
setCol: "age",
|
|
setVal: 20,
|
|
},
|
|
wantPanic: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
run := func() {
|
|
q := db.Model(ctx, &MonkeyEntity{}, "my_keyspace").
|
|
Where(tc.args.cmp, tc.args.whereArg).
|
|
Select(tc.args.selects...).
|
|
OrderBy(tc.args.orderCol, tc.args.order).
|
|
Limit(tc.args.limit).
|
|
Set(tc.args.setCol, tc.args.setVal)
|
|
|
|
assert.Equal(t, tc.wantColumns, q.columns)
|
|
if len(q.orders) > 0 {
|
|
assert.Equal(t, tc.wantOrderCol, q.orders[0].Column)
|
|
assert.Equal(t, tc.wantOrder, q.orders[0].Order)
|
|
}
|
|
assert.Equal(t, tc.wantLimit, q.limit)
|
|
if len(q.sets) > 0 {
|
|
assert.Equal(t, tc.wantSetCol, q.sets[0].Col)
|
|
assert.Equal(t, tc.wantSetVal, q.sets[0].Val)
|
|
}
|
|
}
|
|
|
|
if tc.wantPanic {
|
|
assert.Panics(t, run)
|
|
} else {
|
|
assert.NotPanics(t, run)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestQuery_Select_TableDriven(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
selectCalls [][]string
|
|
wantColumns []string
|
|
}{
|
|
{
|
|
name: "select one col",
|
|
selectCalls: [][]string{{"id"}},
|
|
wantColumns: []string{"id"},
|
|
},
|
|
{
|
|
name: "select multi col in one call",
|
|
selectCalls: [][]string{{"id", "name"}},
|
|
wantColumns: []string{"id", "name"},
|
|
},
|
|
{
|
|
name: "multiple select calls append columns",
|
|
selectCalls: [][]string{{"id"}, {"name"}, {"age"}},
|
|
wantColumns: []string{"id", "name", "age"},
|
|
},
|
|
{
|
|
name: "multiple select calls with overlap",
|
|
selectCalls: [][]string{{"id"}, {"id", "name"}, {"name", "age"}},
|
|
wantColumns: []string{"id", "id", "name", "name", "age"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
q := &Query{columns: make([]string, 0)}
|
|
for _, call := range tc.selectCalls {
|
|
q = q.Select(call...)
|
|
}
|
|
assert.Equal(t, tc.wantColumns, q.columns)
|
|
})
|
|
}
|
|
}
|