mock_test.go

package gocassa

import (
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
)

type user struct {
	Pk1  int
	Pk2  int
	Ck1  int
	Ck2  int
	Name string
}

type point struct {
	Time time.Time
	Id   int
	User string
	X    float64
	Y    float64
}

func TestRunMockSuite(t *testing.T) {
	suite.Run(t, new(MockSuite))
}

type MockSuite struct {
	suite.Suite
	*require.Assertions
	tbl     Table
	ks      KeySpace
	mapTbl  MapTable
	mmapTbl MultimapTable
	tsTbl   TimeSeriesTable
	mtsTbl  MultiTimeSeriesTable
}

func (s *MockSuite) SetupTest() {
	s.ks = NewMockKeySpace()
	s.Assertions = require.New(s.T())
	s.tbl = s.ks.Table("users", user{}, Keys{
		PartitionKeys:     []string{"Pk1", "Pk2"},
		ClusteringColumns: []string{"Ck1", "Ck2"},
	})

	s.mapTbl = s.ks.MapTable("users", "Pk1", user{})
	s.mmapTbl = s.ks.MultimapTable("users", "Pk1", "Pk2", user{})
	s.tsTbl = s.ks.TimeSeriesTable("points", "Time", "Id", 1*time.Minute, point{})
	s.mtsTbl = s.ks.MultiTimeSeriesTable("points", "User", "Time", "Id", 1*time.Minute, point{})
}

// Table tests
func (s *MockSuite) TestTableEmpty() {
	var result []user
	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 1)).Read(&result).Run())
	s.Equal(0, len(result))
}

func (s *MockSuite) TestTableRead() {
	u1, u2, u3, u4 := s.insertUsers()

	var users []user
	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1)).Read(&users).Run())
	s.Equal([]user{u1, u3, u4}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 2)).Read(&users).Run())
	s.Equal([]user{u2}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), In("Pk2", 1, 2)).Read(&users).Run())
	s.Equal([]user{u1, u3, u4, u2}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1)).Read(&users).Run())
	s.Equal([]user{u1, u4}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 1)).Read(&users).Run())
	s.Equal([]user{u1}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), GT("Ck1", 1)).Read(&users).Run())
	s.Equal([]user{u3}, users)

	s.NoError(s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), LT("Ck2", 2)).Read(&users).Run())
	s.Equal([]user{u1}, users)

	var u user
	op1 := s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 1)).ReadOne(&u)
	s.NoError(op1.Run())
	s.Equal(u1, u)

	op2 := s.tbl.Where(Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 2)).ReadOne(&u)
	s.NoError(op2.Run())
	s.Equal(u4, u)

	s.NoError(op1.Add(op2).Run())
}

func (s *MockSuite) TestTableUpdate() {
	s.insertUsers()

	relations := []Relation{Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 2)}

	s.NoError(s.tbl.Where(relations...).Update(map[string]interface{}{
		"Name": "x",
	}).Run())

	var u user
	s.NoError(s.tbl.Where(relations...).ReadOne(&u).Run())
	s.Equal("x", u.Name)

	relations = []Relation{Eq("Pk1", 1), In("Pk2", 1, 2), Eq("Ck1", 1), Eq("Ck2", 1)}

	s.NoError(s.tbl.Where(relations...).Update(map[string]interface{}{
		"Name": "y",
	}).Run())

	var users []user
	s.NoError(s.tbl.Where(relations...).Read(&users).Run())
	for _, u := range users {
		s.Equal("y", u.Name)
	}
}

func (s *MockSuite) TestTableDeleteOne() {
	s.insertUsers()

	relations := []Relation{Eq("Pk1", 1), Eq("Pk2", 1), Eq("Ck1", 1), Eq("Ck2", 2)}
	s.NoError(s.tbl.Where(relations...).Delete().Run())

	var users []user
	s.NoError(s.tbl.Where(relations...).Read(&users).Run())
	s.Empty(users)
}

func (s *MockSuite) TestTableDeleteWithIn() {
	s.insertUsers()

	relations := []Relation{Eq("Pk1", 1), In("Pk2", 1, 2), Eq("Ck1", 1), Eq("Ck2", 1)}
	s.NoError(s.tbl.Where(relations...).Delete().Run())

	var users []user
	s.NoError(s.tbl.Where(relations...).Read(&users).Run())
	s.Empty(users)
}

// MapTable tests
func (s *MockSuite) TestMapTableRead() {
	s.insertUsers()
	var u user
	s.NoError(s.mapTbl.Read(1, &u).Run())
	s.Equal("Jane", u.Name)
	s.Error(s.mapTbl.Read(42, &u).Run())
}

func (s *MockSuite) TestMapTableMultiRead() {
	s.insertUsers()
	var users []user
	s.NoError(s.mapTbl.MultiRead([]interface{}{1, 2}, &users).Run())
	s.Len(users, 2)
	s.Equal("Jane", users[0].Name)
	s.Equal("Jill", users[1].Name)
}

func (s *MockSuite) TestMapTableUpdate() {
	s.insertUsers()
	s.NoError(s.mapTbl.Update(1, map[string]interface{}{
		"Name": "foo",
	}).Run())
	var u user
	s.NoError(s.mapTbl.Read(1, &u).Run())
	s.Equal("foo", u.Name)
}

func (s *MockSuite) TestMapTableDelete() {
	s.insertUsers()
	s.NoError(s.mapTbl.Delete(1).Run())
	var user user
	s.Equal(RowNotFoundError{}, s.mapTbl.Read(1, &user).Run())
}

// MultiMapTable tests
func (s *MockSuite) TestMultiMapTableRead() {
	s.insertUsers()

	var u user
	s.NoError(s.mmapTbl.Read(1, 1, &u).Run())
	s.Equal("Jane", u.Name)
	s.NoError(s.mmapTbl.Read(1, 2, &u).Run())
	s.Equal("Joe", u.Name)
}

func (s *MockSuite) TestMultiMapTableMultiRead() {
	s.insertUsers()
	var users []user
	s.NoError(s.mmapTbl.MultiRead(1, []interface{}{1, 2}, &users).Run())
	s.Len(users, 2)
	s.Equal("Jane", users[0].Name)
	s.Equal("Joe", users[1].Name)
}

func (s *MockSuite) TestMultiMapTableList() {
	s.insertUsers()
	var users []user

	// Offset 0, limit 10
	s.NoError(s.mmapTbl.List(1, 0, 10, &users).Run())
	s.Len(users, 2)
	s.Equal("Jane", users[0].Name)
	s.Equal("Joe", users[1].Name)

	// Offset 1, limit 1
	s.NoError(s.mmapTbl.List(1, 1, 1, &users).Run())
	s.Len(users, 1)
	s.Equal("Jane", users[0].Name)

	// Offset 2, limit 1
	s.NoError(s.mmapTbl.List(1, 2, 1, &users).Run())
	s.Len(users, 1)
	s.Equal("Joe", users[0].Name)
}

func (s *MockSuite) TestMultiMapTableUpdate() {
	s.insertUsers()

	s.NoError(s.mmapTbl.Update(1, 2, map[string]interface{}{
		"Name": "foo",
	}).Run())
	var u user
	s.NoError(s.mmapTbl.Read(1, 2, &u).Run())
	s.Equal("foo", u.Name)
}

func (s *MockSuite) TestMultiMapTableDelete() {
	s.insertUsers()
	s.NoError(s.mmapTbl.Delete(1, 2).Run())
	var u user
	s.Equal(RowNotFoundError{}, s.mmapTbl.Read(1, 2, &u).Run())
}

func (s *MockSuite) TestMultiMapTableDeleteAll() {
	s.insertUsers()
	s.NoError(s.mmapTbl.DeleteAll(1).Run())
	var users []user
	s.Empty(users)
}

// TimeSeriesTable tests
func (s *MockSuite) TestTimeSeriesTableRead() {
	points := s.insertPoints()

	var p point
	s.NoError(s.tsTbl.Read(points[0].Time, points[0].Id, &p).Run())
	s.Equal(points[0], p)
}

func (s *MockSuite) TestTimeSeriesTableList() {
	points := s.insertPoints()

	// First two points
	var ps []point
	s.NoError(s.tsTbl.List(points[0].Time, points[1].Time, &ps).Run())
	s.Len(ps, 2)
	s.Equal(points[0], ps[0])
	s.Equal(points[1], ps[1])

	// Last two points
	s.NoError(s.tsTbl.List(points[1].Time, points[2].Time, &ps).Run())
	s.Len(ps, 2)
	s.Equal(points[1], ps[0])
	s.Equal(points[2], ps[1])
}

func (s *MockSuite) TestTimeSeriesTableUpdate() {
	points := s.insertPoints()

	s.NoError(s.tsTbl.Update(points[0].Time, points[0].Id, map[string]interface{}{
		"X": 42.0,
		"Y": 43.0,
	}).Run())
	var p point
	s.NoError(s.tsTbl.Read(points[0].Time, points[0].Id, &p).Run())
	s.Equal(42.0, p.X)
	s.Equal(43.0, p.Y)
}

func (s *MockSuite) TestTimeSeriesTableDelete() {
	points := s.insertPoints()

	var p point
	s.NoError(s.tsTbl.Delete(points[0].Time, points[0].Id).Run())
	s.Equal(RowNotFoundError{}, s.tsTbl.Read(points[0].Time, points[0].Id, &p).Run())
}

// MultiTimeSeriesTable tests
func (s *MockSuite) TestMultiTimeSeriesTableRead() {
	points := s.insertPoints()

	var p point
	s.NoError(s.mtsTbl.Read("John", points[0].Time, points[0].Id, &p).Run())
	s.Equal(points[0], p)
}

func (s *MockSuite) TestMultiTimeSeriesTableList() {
	points := s.insertPoints()

	var ps []point
	s.NoError(s.mtsTbl.List("John", points[0].Time, points[2].Time, &ps).Run())
	s.Len(ps, 2)
	s.Equal(points[0], ps[0])
	s.Equal(points[2], ps[1])

	s.NoError(s.mtsTbl.List("Jane", points[0].Time, points[2].Time, &ps).Run())
	s.Len(ps, 1)
	s.Equal(points[1], ps[0])
}

func (s *MockSuite) TestMultiTimeSeriesTableUpdate() {
	points := s.insertPoints()

	s.NoError(s.mtsTbl.Update("John", points[0].Time, points[0].Id, map[string]interface{}{
		"X": 42.0,
	}).Run())

	var p point
	s.NoError(s.mtsTbl.Read("John", points[0].Time, points[0].Id, &p).Run())
	s.Equal(42.0, p.X)
}

func (s *MockSuite) TestMultiTimeSeriesTableDelete() {
	points := s.insertPoints()

	s.NoError(s.mtsTbl.Delete("John", points[0].Time, points[0].Id).Run())

	var p point
	s.Equal(RowNotFoundError{}, s.mtsTbl.Read("John", points[0].Time, points[0].Id, &p).Run())
}

func (s *MockSuite) TestNoop() {
	s.insertUsers()
	var users []user
	op := Noop()
	op = op.Add(s.mapTbl.MultiRead([]interface{}{1, 2}, &users))
	s.NoError(op.Run())
	s.Len(users, 2)
	s.Equal("Jane", users[0].Name)
	s.Equal("Jill", users[1].Name)
}

// Helper functions
func (s *MockSuite) insertPoints() []point {
	points := []point{
		point{
			Time: s.parseTime("2015-04-01 15:41:00"),
			Id:   1,
			User: "John",
			X:    1.1,
			Y:    1.2,
		},
		point{
			Time: s.parseTime("2015-04-01 15:41:05"),
			Id:   2,
			User: "Jane",
			X:    5.1,
			Y:    5.2,
		},
		point{
			Time: s.parseTime("2015-04-01 15:41:10"),
			Id:   3,
			User: "John",
			X:    1.1,
			Y:    1.3,
		},
	}

	for _, p := range points {
		s.NoError(s.tsTbl.Set(p).Run())
		s.NoError(s.mtsTbl.Set(p).Run())
	}

	return points
}

func (s *MockSuite) insertUsers() (user, user, user, user) {
	u1 := user{
		Pk1:  1,
		Pk2:  1,
		Ck1:  1,
		Ck2:  1,
		Name: "John",
	}
	u2 := user{
		Pk1:  1,
		Pk2:  2,
		Ck1:  1,
		Ck2:  1,
		Name: "Joe",
	}
	u3 := user{
		Pk1:  1,
		Pk2:  1,
		Ck1:  2,
		Ck2:  1,
		Name: "Josh",
	}
	u4 := user{
		Pk1:  1,
		Pk2:  1,
		Ck1:  1,
		Ck2:  2,
		Name: "Jane",
	}
	u5 := user{
		Pk1:  2,
		Pk2:  1,
		Ck1:  1,
		Ck2:  1,
		Name: "Jill",
	}

	for _, u := range []user{u1, u2, u3, u4, u5} {
		s.NoError(s.tbl.Set(u).Run())
		s.NoError(s.mapTbl.Set(u).Run())
		s.NoError(s.mmapTbl.Set(u).Run())
	}

	return u1, u2, u3, u4
}

func (s *MockSuite) parseTime(value string) time.Time {
	t, err := time.Parse("2006-01-02 15:04:05", value)
	s.NoError(err)
	return t
}