1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package tests
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/filter"
"github.com/cortezaproject/corteza-server/pkg/id"
"github.com/cortezaproject/corteza-server/pkg/rand"
"github.com/cortezaproject/corteza-server/store"
"github.com/cortezaproject/corteza-server/system/types"
_ "github.com/joho/godotenv/autoload"
"github.com/stretchr/testify/require"
"strings"
"testing"
"time"
)
func testRoles(t *testing.T, s store.Roles) {
var (
ctx = context.Background()
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) {
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.CreatedAt)
req.Nil(fetched.UpdatedAt)
req.Nil(fetched.DeletedAt)
})
t.Run("update", func(t *testing.T) {
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) {
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("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: filter.StateExcluded})
req.NoError(err)
req.Len(set, 4)
set, _, err = s.SearchRoles(ctx, types.RoleFilter{Deleted: filter.StateInclusive})
req.NoError(err)
req.Len(set, 5)
set, _, err = s.SearchRoles(ctx, types.RoleFilter{Deleted: filter.StateExclusive})
req.NoError(err)
req.Len(set, 1)
})
t.Run("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: filter.StateExcluded})
req.NoError(err)
req.Len(set, 4)
set, _, err = s.SearchRoles(ctx, types.RoleFilter{Archived: filter.StateInclusive})
req.NoError(err)
req.Len(set, 5)
set, _, err = s.SearchRoles(ctx, types.RoleFilter{Archived: filter.StateExclusive})
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("ordered search", func(t *testing.T) {
t.Skip("not implemented")
})
}