139 lines
2.5 KiB
Go
139 lines
2.5 KiB
Go
package mdb
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestDBList(t *testing.T) {
|
|
db := NewTestDBPrimary(t, t.TempDir())
|
|
|
|
var (
|
|
user1 = User{
|
|
ID: NewID(),
|
|
Name: "User1",
|
|
Email: "user1@gmail.com",
|
|
}
|
|
|
|
user2 = User{
|
|
ID: NewID(),
|
|
Name: "User2",
|
|
Email: "user2@gmail.com",
|
|
}
|
|
|
|
user3 = User{
|
|
ID: NewID(),
|
|
Name: "User3",
|
|
Email: "user3@gmail.com",
|
|
}
|
|
user1Data = make([]UserDataItem, 10)
|
|
user2Data = make([]UserDataItem, 4)
|
|
user3Data = make([]UserDataItem, 8)
|
|
)
|
|
|
|
err := db.Update(func(tx *Snapshot) error {
|
|
if err := db.Users.Insert(tx, &user1); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := db.Users.Insert(tx, &user2); err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := range user1Data {
|
|
user1Data[i] = UserDataItem{
|
|
ID: NewID(),
|
|
UserID: user1.ID,
|
|
Name: fmt.Sprintf("Name1: %d", i),
|
|
Data: fmt.Sprintf("Data: %d", i),
|
|
}
|
|
|
|
if err := db.UserData.Insert(tx, &user1Data[i]); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := range user2Data {
|
|
user2Data[i] = UserDataItem{
|
|
ID: NewID(),
|
|
UserID: user2.ID,
|
|
Name: fmt.Sprintf("Name2: %d", i),
|
|
Data: fmt.Sprintf("Data: %d", i),
|
|
}
|
|
|
|
if err := db.UserData.Insert(tx, &user2Data[i]); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := range user3Data {
|
|
user3Data[i] = UserDataItem{
|
|
ID: NewID(),
|
|
UserID: user3.ID,
|
|
Name: fmt.Sprintf("Name3: %d", i),
|
|
Data: fmt.Sprintf("Data: %d", i),
|
|
}
|
|
|
|
if err := db.UserData.Insert(tx, &user3Data[i]); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
type TestCase struct {
|
|
Name string
|
|
Args ListArgs[UserDataItem]
|
|
Expected []UserDataItem
|
|
}
|
|
|
|
cases := []TestCase{
|
|
{
|
|
Name: "User1 all",
|
|
Args: ListArgs[UserDataItem]{
|
|
After: &UserDataItem{
|
|
UserID: user1.ID,
|
|
},
|
|
While: func(item *UserDataItem) bool {
|
|
return item.UserID == user1.ID
|
|
},
|
|
},
|
|
Expected: user1Data,
|
|
}, {
|
|
Name: "User1 limited",
|
|
Args: ListArgs[UserDataItem]{
|
|
After: &UserDataItem{
|
|
UserID: user1.ID,
|
|
},
|
|
While: func(item *UserDataItem) bool {
|
|
return item.UserID == user1.ID
|
|
},
|
|
Limit: 4,
|
|
},
|
|
Expected: user1Data[:4],
|
|
},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.Name, func(t *testing.T) {
|
|
tx := db.Snapshot()
|
|
l := db.UserData.ByName.List(tx, tc.Args, nil)
|
|
if len(l) != len(tc.Expected) {
|
|
t.Fatal(tc.Name, l)
|
|
}
|
|
|
|
for i := range l {
|
|
if !reflect.DeepEqual(*l[i], tc.Expected[i]) {
|
|
t.Fatal(tc.Name, l)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|