func TestSaveUpdates(t *testing.T) {
setup(t)
p := &Person{Name: "John", Age: 31}
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
expected := &Person{}
if err := rebecca.Get(p.ID, expected); err != nil {
t.Fatal(err)
}
expected.Name = "John Smith"
if err := rebecca.Save(expected); err != nil {
t.Fatal(err)
}
actual := &Person{}
if err := rebecca.Get(p.ID, actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func TestAll(t *testing.T) {
setup(t)
p1 := &Post{Title: "Post 1", Content: "Content 1", CreatedAt: time.Now()}
p2 := &Post{Title: "Post 2", Content: "Content 2", CreatedAt: time.Now()}
p3 := &Post{Title: "Post 3", Content: "Content 3", CreatedAt: time.Now()}
p4 := &Post{Title: "Post 4", Content: "Content 4", CreatedAt: time.Now()}
posts := []*Post{p1, p2, p3, p4}
for _, p := range posts {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
expected := []Post{*p1, *p2, *p3, *p4}
actual := []Post{}
if err := rebecca.All(&actual); err != nil {
t.Fatal(err)
}
if !equalPosts(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func TestRemove(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "James", Age: 11}
p4 := &Person{Name: "Monika", Age: 12}
people := []*Person{p1, p2, p3, p4}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
if err := rebecca.Remove(p3); err != nil {
t.Fatal(err)
}
expected := []Person{*p1, *p2, *p4}
actual := []Person{}
if err := rebecca.All(&actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func TestFirst(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "James", Age: 11}
p4 := &Person{Name: "Monika", Age: 12}
people := []*Person{p1, p2, p3, p4}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
expected := p2
actual := &Person{}
if err := rebecca.First(actual, "age > $1", 10); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
expected = p1
actual = &Person{}
if err := rebecca.First(actual, "age < $1", 15); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func ExampleSave() {
// Lets first define our model:
type Person struct {
// the table name is people
rebecca.ModelMetadata `tablename:"people"`
// ID is of type int, in database it is mapped to `id` and it is a primary
// key.
// Name is of type string, in database it is mapped to `name`.
// Age is of type int, in database it is mapped to `age`.
ID int `rebecca:"id" rebecca_primary:"true"`
Name string `rebecca:"name"`
Age int `rebecca:"age"`
}
// And now, lets create new record:
person := &Person{Name: "John", Age: 28}
// And finally, lets save it to the database
if err := rebecca.Save(person); err != nil {
panic(err)
}
// At this point, record was saved to database as a new record and its ID
// field was updated accordingly.
fmt.Print(person)
// Now lets modify our record:
person.Name = "John Smith"
// And save it
if err := rebecca.Save(person); err != nil {
panic(err)
}
// At this point, original record was update with new data.
fmt.Print(person)
}
func TestOrder(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "Bruce", Age: 33}
p4 := &Person{Name: "James", Age: 11}
p5 := &Person{Name: "Monika", Age: 12}
p6 := &Person{Name: "Peter", Age: 21}
people := []*Person{p1, p2, p3, p4, p5, p6}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
ctx := &rebecca.Context{Order: "age DESC"}
expected := []Person{*p3, *p2, *p6, *p5, *p4, *p1}
actual := []Person{}
if err := ctx.All(&actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
expected = []Person{*p6, *p5, *p4, *p1}
actual = []Person{}
if err := ctx.Where(&actual, "age <= $1", 21); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
expectedOne := p5
actualOne := &Person{}
if err := ctx.First(actualOne, "age < $1", 21); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actualOne, expectedOne) {
t.Errorf("Expected %+v to equal %+v", actualOne, expectedOne)
}
}
func TestSaveCreates(t *testing.T) {
setup(t)
expected := &Person{Name: "John", Age: 31}
if err := rebecca.Save(expected); err != nil {
t.Fatal(err)
}
actual := &Person{}
if err := rebecca.Get(actual, expected.ID); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func TestGroup(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "Bruce", Age: 27}
p4 := &Person{Name: "James", Age: 11}
p5 := &Person{Name: "Monika", Age: 11}
p6 := &Person{Name: "Peter", Age: 21}
p7 := &Person{Name: "Brad", Age: 11}
people := []*Person{p1, p2, p3, p4, p5, p6, p7}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
type PersonByAge struct {
rebecca.ModelMetadata `tablename:"people"`
Age int `rebecca:"age" rebecca_primary:"true"`
Count int `rebecca:"count(distinct(id))"`
}
ctx := rebecca.Context{Group: "age"}
expected := []PersonByAge{
{Age: 9, Count: 1},
{Age: 11, Count: 3},
{Age: 21, Count: 1},
{Age: 27, Count: 2},
}
actual := []PersonByAge{}
if err := ctx.All(&actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
}
func TestSkip(t *testing.T) {
setup(t)
p1 := &Person{Name: "John", Age: 9}
p2 := &Person{Name: "Sarah", Age: 27}
p3 := &Person{Name: "Bruce", Age: 33}
p4 := &Person{Name: "James", Age: 11}
p5 := &Person{Name: "Monika", Age: 12}
p6 := &Person{Name: "Peter", Age: 21}
people := []*Person{p1, p2, p3, p4, p5, p6}
for _, p := range people {
if err := rebecca.Save(p); err != nil {
t.Fatal(err)
}
}
examples := map[string]struct {
ctx *rebecca.Context
}{
"when using Skip option it works": {
ctx: &rebecca.Context{Skip: 2},
},
"when using Offset option it should be the same": {
ctx: &rebecca.Context{Offset: 2},
},
}
for _, e := range examples {
ctx := e.ctx
expected := []Person{*p3, *p4, *p5, *p6}
actual := []Person{}
if err := ctx.All(&actual); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
expected = []Person{*p5, *p6}
actual = []Person{}
if err := ctx.Where(&actual, "age > $1", 11); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actual, expected) {
t.Errorf("Expected %+v to equal %+v", actual, expected)
}
expectedOne := p4
actualOne := &Person{}
if err := ctx.First(&actualOne, "age > $1", 10); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(actualOne, expectedOne) {
t.Errorf("Expected %+v to equal %+v", actualOne, expectedOne)
}
}
}