diff --git a/store/tests/reminders_test.go b/store/tests/reminders_test.go index 28aefa612..fbeb430ed 100644 --- a/store/tests/reminders_test.go +++ b/store/tests/reminders_test.go @@ -2,9 +2,12 @@ package tests import ( "context" + "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/system/types" _ "github.com/joho/godotenv/autoload" "github.com/stretchr/testify/require" + "strings" "testing" "time" ) @@ -12,22 +15,52 @@ import ( func testReminders(t *testing.T, s remindersStore) { var ( ctx = context.Background() - req = require.New(t) - //err error - reminder *types.Reminder + makeNew = func(nn ...string) *types.Reminder { + // minimum data set for new user + name := strings.Join(nn, "") + thisID := id.Next() + return &types.Reminder{ + ID: thisID, + Resource: "resource+" + name, + AssignedTo: thisID, + CreatedAt: time.Now(), + AssignedAt: time.Now(), + } + } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Reminder) { + req := require.New(t) + req.NoError(s.TruncateReminders(ctx)) + reminder := makeNew() + req.NoError(s.CreateReminder(ctx, reminder)) + return req, reminder + } + + truncAndFill = func(t *testing.T, l int) (*require.Assertions, types.ReminderSet) { + req := require.New(t) + req.NoError(s.TruncateReminders(ctx)) + + set := make([]*types.Reminder, l) + + for i := 0; i < l; i++ { + set[i] = makeNew(string(rand.Bytes(10))) + } + + req.NoError(s.CreateReminder(ctx, set...)) + return req, set + } + ) t.Run("create", func(t *testing.T) { - reminder = &types.Reminder{ - ID: 42, - CreatedAt: time.Now(), - AssignedAt: time.Now(), - } - req.NoError(s.CreateReminder(ctx, reminder)) + req := require.New(t) + req.NoError(s.CreateReminder(ctx, makeNew())) }) t.Run("lookup by ID", func(t *testing.T) { + req, reminder := truncAndCreate(t) + fetched, err := s.LookupReminderByID(ctx, reminder.ID) req.NoError(err) req.Equal(reminder.ID, fetched.ID) @@ -37,22 +70,70 @@ func testReminders(t *testing.T, s remindersStore) { }) t.Run("update", func(t *testing.T) { - reminder = &types.Reminder{ - ID: 42, - CreatedAt: time.Now(), - AssignedAt: time.Now(), - } + req, reminder := truncAndCreate(t) req.NoError(s.UpdateReminder(ctx, reminder)) }) t.Run("search", func(t *testing.T) { - set, _, err := s.SearchReminders(ctx, types.ReminderFilter{}) - req.NoError(err) - req.Len(set, 1) - }) + t.Run("by ID", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) - t.Run("search by *", func(t *testing.T) { - t.Skip("not implemented") + set, f, err := s.SearchReminders(ctx, types.ReminderFilter{ReminderID: []uint64{prefill[0].ID}}) + req.NoError(err) + req.Equal([]uint64{prefill[0].ID}, f.ReminderID) + req.Len(set, 1) + }) + + t.Run("by resource", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + set, _, err := s.SearchReminders(ctx, types.ReminderFilter{Resource: prefill[0].Resource}) + req.NoError(err) + req.Len(set, 1) + }) + + t.Run("by assigned to", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + set, f, err := s.SearchReminders(ctx, types.ReminderFilter{AssignedTo: prefill[0].AssignedTo}) + req.NoError(err) + req.Equal(prefill[0].AssignedTo, f.AssignedTo) + req.Len(set, 1) + }) + + t.Run("by dismissed", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + prefill[0].DismissedAt = &(prefill[0].CreatedAt) + s.UpdateReminder(ctx, prefill[0]) + + set, _, err := s.SearchReminders(ctx, types.ReminderFilter{ExcludeDismissed: true}) + req.NoError(err) + req.Len(set, 4) + }) + + t.Run("by scheduled", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + prefill[0].RemindAt = &(prefill[0].CreatedAt) + s.UpdateReminder(ctx, prefill[0]) + + set, _, err := s.SearchReminders(ctx, types.ReminderFilter{ScheduledOnly: true}) + req.NoError(err) + req.Len(set, 1) + }) + + t.Run("with check", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + set, _, err := s.SearchReminders(ctx, types.ReminderFilter{ + Check: func(user *types.Reminder) (bool, error) { + // simple check that matches with the first user from prefill + return user.ID == prefill[0].ID, nil + }, + }) + req.NoError(err) + req.Len(set, 1) + req.Equal(prefill[0].ID, set[0].ID) + }) }) t.Run("ordered search", func(t *testing.T) { diff --git a/store/tests/roles_test.go b/store/tests/roles_test.go index 5463a8fe4..6011b47e8 100644 --- a/store/tests/roles_test.go +++ b/store/tests/roles_test.go @@ -2,9 +2,13 @@ package tests import ( "context" + "github.com/cortezaproject/corteza-server/pkg/rh" + "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/system/types" _ "github.com/joho/godotenv/autoload" "github.com/stretchr/testify/require" + "strings" "testing" "time" ) @@ -12,70 +16,143 @@ import ( func testRoles(t *testing.T, s rolesStore) { var ( ctx = context.Background() - req = require.New(t) - //err error - role *types.Role + makeNew = func(nn ...string) *types.Role { + name := strings.Join(nn, "") + return &types.Role{ + ID: id.Next(), + CreatedAt: time.Now(), + Name: "RoleCRUD+" + name, + Handle: "rolecrud+" + name, + } + } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Role) { + req := require.New(t) + req.NoError(s.TruncateRoles(ctx)) + role := makeNew() + req.NoError(s.CreateRole(ctx, role)) + return req, role + } + + truncAndFill = func(t *testing.T, l int) (*require.Assertions, types.RoleSet) { + req := require.New(t) + req.NoError(s.TruncateRoles(ctx)) + + set := make([]*types.Role, l) + + for i := 0; i < l; i++ { + set[i] = makeNew(string(rand.Bytes(10))) + } + + req.NoError(s.CreateRole(ctx, set...)) + return req, set + } ) t.Run("create", func(t *testing.T) { - role = &types.Role{ - ID: 42, - CreatedAt: time.Now(), - Name: "RoleCRUD", - Handle: "rolecrud", - } - role.ArchivedAt = &role.CreatedAt - req.NoError(s.CreateRole(ctx, role)) + req := require.New(t) + req.NoError(s.CreateRole(ctx, makeNew())) }) t.Run("lookup by ID", func(t *testing.T) { + req, role := truncAndCreate(t) + fetched, err := s.LookupRoleByID(ctx, role.ID) req.NoError(err) req.Equal(role.Name, fetched.Name) req.Equal(role.Handle, fetched.Handle) req.Equal(role.ID, fetched.ID) - req.NotNil(fetched.ArchivedAt) req.NotNil(fetched.CreatedAt) req.Nil(fetched.UpdatedAt) req.Nil(fetched.DeletedAt) }) t.Run("update", func(t *testing.T) { - role = &types.Role{ - ID: 42, - CreatedAt: time.Now(), - Name: "RoleCRUD+2", - Handle: "rolecrud+2", - } + req, role := truncAndCreate(t) req.NoError(s.UpdateRole(ctx, role)) }) t.Run("lookup by handle", func(t *testing.T) { + req, role := truncAndCreate(t) + fetched, err := s.LookupRoleByHandle(ctx, role.Handle) req.NoError(err) req.Equal(role.ID, fetched.ID) }) t.Run("search", func(t *testing.T) { - set, f, err := s.SearchRoles(ctx, types.RoleFilter{RoleID: []uint64{role.ID}}) - req.NoError(err) - req.Equal([]uint64{role.ID}, f.RoleID) - req.Len(set, 1) - //req.Equal(set[0].ID, role.ID) + t.Run("by ID", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + set, f, err := s.SearchRoles(ctx, types.RoleFilter{RoleID: []uint64{prefill[0].ID}}) + req.NoError(err) + req.Equal([]uint64{prefill[0].ID}, f.RoleID) + req.Len(set, 1) + }) + + t.Run("by query", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + set, _, err := s.SearchRoles(ctx, types.RoleFilter{Query: prefill[0].Handle}) + req.NoError(err) + req.Len(set, 1) + }) + + t.Run("by state", func(t *testing.T) { + t.Run("by deleted", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + prefill[0].DeletedAt = &(prefill[0].CreatedAt) + s.UpdateRole(ctx, prefill[0]) + + set, _, err := s.SearchRoles(ctx, types.RoleFilter{Deleted: rh.FilterStateExcluded}) + req.NoError(err) + req.Len(set, 4) + + set, _, err = s.SearchRoles(ctx, types.RoleFilter{Deleted: rh.FilterStateInclusive}) + req.NoError(err) + req.Len(set, 5) + + set, _, err = s.SearchRoles(ctx, types.RoleFilter{Deleted: rh.FilterStateExclusive}) + req.NoError(err) + req.Len(set, 1) + }) + + t.Run("by archived", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + prefill[0].ArchivedAt = &(prefill[0].CreatedAt) + s.UpdateRole(ctx, prefill[0]) + + set, _, err := s.SearchRoles(ctx, types.RoleFilter{Archived: rh.FilterStateExcluded}) + req.NoError(err) + req.Len(set, 4) + + set, _, err = s.SearchRoles(ctx, types.RoleFilter{Archived: rh.FilterStateInclusive}) + req.NoError(err) + req.Len(set, 5) + + set, _, err = s.SearchRoles(ctx, types.RoleFilter{Archived: rh.FilterStateExclusive}) + req.NoError(err) + req.Len(set, 1) + }) + }) + + t.Run("with check", func(t *testing.T) { + req, prefill := truncAndFill(t, 5) + + set, _, err := s.SearchRoles(ctx, types.RoleFilter{ + Check: func(role *types.Role) (bool, error) { + return role.ID == prefill[0].ID, nil + }, + }) + req.NoError(err) + req.Len(set, 1) + req.Equal(prefill[0].ID, set[0].ID) + }) }) - t.Run("search", func(t *testing.T) { - set, f, err := s.SearchRoles(ctx, types.RoleFilter{Name: role.Name}) - req.NoError(err) - req.Len(set, 1) - - _ = f // dummy - }) - - t.Run("search by *", func(t *testing.T) { - t.Skip("not implemented") - }) t.Run("ordered search", func(t *testing.T) { t.Skip("not implemented")