1 package rulesengine
2
3 import (
4 "errors"
5 "testing"
6
7 "github.com/stretchr/testify/assert"
8
9 "edge-infra.dev/pkg/lib/uuid"
10 )
11
12 func TestValidateCommandPayload(t *testing.T) {
13 t.Parallel()
14 tests := map[string]struct {
15 payload ValidateCommandPayload
16 expectedErr error
17 }{
18 "Success": {
19 ValidateCommandPayload{
20 Command: Command{
21 Name: "ls",
22 Type: "command",
23 },
24 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
25 Target: Target{BannerID: uuid.New().UUID},
26 },
27 nil,
28 },
29 "Fail on missing Command Type": {
30 ValidateCommandPayload{
31 Command: Command{
32 Name: "ls",
33 Type: "",
34 },
35 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
36 Target: Target{BannerID: uuid.New().UUID},
37 },
38 errors.New("command type was empty"),
39 },
40 "Success on unknown command type": {
41 ValidateCommandPayload{
42 Command: Command{
43 Name: "ls",
44 Type: "unknownCommandType",
45 },
46 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
47 Target: Target{BannerID: uuid.New().UUID},
48 },
49
50 nil,
51 },
52 "Fail no target": {
53 ValidateCommandPayload{
54 Command: Command{
55 Name: "ls",
56 Type: "command",
57 },
58 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
59 },
60 ErrInvalidBannerID,
61 },
62 "Success no UserID": {
63 ValidateCommandPayload{
64 Command: Command{
65 Name: "ls",
66 Type: "command",
67 },
68 Identity: Identity{EAroles: []string{}},
69 Target: Target{BannerID: uuid.New().UUID},
70 },
71 nil,
72 },
73 "Fail bad target": {
74 ValidateCommandPayload{
75 Command: Command{
76 Name: "ls",
77 Type: "command",
78 },
79 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
80 Target: Target{BannerID: "not a uuid"},
81 },
82 ErrInvalidBannerID,
83 },
84 "Fail no command": {
85 ValidateCommandPayload{
86 Identity: Identity{UserID: "user@ncr.com", EAroles: []string{}},
87 Target: Target{BannerID: uuid.New().UUID},
88 },
89 ErrInvalidCommandNil,
90 },
91 }
92 for name, tc := range tests {
93 tc := tc
94 t.Run(name, func(t *testing.T) {
95 t.Parallel()
96 err := tc.payload.Validate()
97 assert.Equal(t, tc.expectedErr, err)
98 })
99 }
100 }
101
102 func TestPostRuleValidation(t *testing.T) {
103 t.Parallel()
104
105 tests := map[string]struct {
106 rule WriteRule
107 returnError bool
108 }{
109 "No Errors": {
110 rule: WriteRule{"a", []string{"b"}},
111 returnError: false,
112 },
113 "No Errors Multiple entries": {
114 rule: WriteRule{"a", []string{"b", "c"}},
115 returnError: false,
116 },
117 "No command": {
118 rule: WriteRule{"", []string{"b"}},
119 returnError: true,
120 },
121 "Empty Privilege List": {
122 rule: WriteRule{"a", []string{}},
123 returnError: true,
124 },
125 "Empty entry in Privilege List": {
126 rule: WriteRule{"a", []string{""}},
127 returnError: true,
128 },
129 "Empty 2nd entry in Privilege List": {
130 rule: WriteRule{"a", []string{"b", ""}},
131 returnError: true,
132 },
133 }
134
135 for name, tc := range tests {
136 tc := tc
137 t.Run(name, func(t *testing.T) {
138 t.Parallel()
139
140 if tc.returnError {
141 assert.Error(t, tc.rule.Validate())
142 } else {
143 assert.NoError(t, tc.rule.Validate())
144 }
145 })
146 }
147 }
148
149 func TestPostRulesValidation(t *testing.T) {
150 t.Parallel()
151
152 tests := map[string]struct {
153 rule WriteRules
154 noErr bool
155 expErr string
156 }{
157 "Empty list": {
158 rule: WriteRules{},
159 expErr: "empty rules list",
160 },
161 "No List": {
162 rule: nil,
163 expErr: "empty rules list",
164 },
165 "Invalid rule": {
166 rule: WriteRules{WriteRule{}},
167 expErr: "invalid rule at 0: empty command name",
168 },
169 "Valid rules": {
170 rule: WriteRules{WriteRule{"a", []string{"b"}}},
171 noErr: true,
172 },
173 }
174
175 for name, tc := range tests {
176 tc := tc
177 t.Run(name, func(t *testing.T) {
178 t.Parallel()
179
180 err := tc.rule.Validate()
181
182 if tc.noErr {
183 assert.NoError(t, err)
184 return
185 }
186
187 assert.EqualError(t, err, tc.expErr)
188 })
189 }
190 }
191
192 func TestRuleSetsValidate(t *testing.T) {
193 t.Parallel()
194 tests := map[string]struct {
195 ruleSets RuleSets
196 assertErr assert.ErrorAssertionFunc
197 }{
198 "Empty rule sets": {
199 ruleSets: RuleSets{},
200 assertErr: ErrorEqualMsg("empty rules list"),
201 },
202 "Invalid rule set": {
203 ruleSets: RuleSets{
204 RuleSet{Privilege: "privilege", Commands: []string{"command1", ""}},
205 },
206 assertErr: ErrorEqualMsg("invalid rule at 0: empty command name in array at 1"),
207 },
208 "Multiple invalid rulesets": {
209 ruleSets: RuleSets{
210 RuleSet{Privilege: "privilege", Commands: []string{"command1", ""}},
211 RuleSet{Privilege: "privilege", Commands: []string{"command1", ""}},
212 },
213 assertErr: ErrorEqualMsg("invalid rule at 0: empty command name in array at 1\ninvalid rule at 1: empty command name in array at 1"),
214 },
215 "Valid rule sets": {
216 ruleSets: RuleSets{
217 RuleSet{Privilege: "privilege1", Commands: []string{"command1", "command2"}},
218 RuleSet{Privilege: "privilege2", Commands: []string{"command3", "command4"}},
219 },
220 assertErr: assert.NoError,
221 },
222 "Too many rules": {
223 ruleSets: func() RuleSets {
224 ruleSets := make(RuleSets, 501)
225 for i := 0; i < 501; i++ {
226 ruleSets[i] = RuleSet{Privilege: "privilege", Commands: []string{"command"}}
227 }
228 return ruleSets
229 }(),
230 assertErr: ErrorEqualMsg("total number of commands in rules 501 exceeds max 500"),
231 },
232 }
233
234 for name, tc := range tests {
235 tc := tc
236 t.Run(name, func(t *testing.T) {
237 t.Parallel()
238 err := tc.ruleSets.Validate()
239 tc.assertErr(t, err)
240 })
241 }
242 }
243
244 func TestPostPrivilegePayloadValidate(t *testing.T) {
245 t.Parallel()
246
247 tests := map[string]struct {
248 payload PostPrivilegePayload
249 assertErr assert.ErrorAssertionFunc
250 }{
251 "Empty name": {
252 payload: PostPrivilegePayload{Name: ""},
253 assertErr: ErrorEqualMsg("empty privilege name"),
254 },
255 "Valid name": {
256 payload: PostPrivilegePayload{Name: "name"},
257 assertErr: assert.NoError,
258 },
259 }
260
261 for name, tc := range tests {
262 tc := tc
263 t.Run(name, func(t *testing.T) {
264 t.Parallel()
265 err := tc.payload.Validate()
266 tc.assertErr(t, err)
267 })
268 }
269 }
270
271 func TestPostCommandPayloadValidate(t *testing.T) {
272 t.Parallel()
273
274 tests := map[string]struct {
275 payload PostCommandPayload
276 assertErr assert.ErrorAssertionFunc
277 }{
278 "Empty command": {
279 payload: PostCommandPayload{Name: ""},
280 assertErr: ErrorEqualMsg("empty command name"),
281 },
282 "Valid command": {
283 payload: PostCommandPayload{Name: "command"},
284 assertErr: assert.NoError,
285 },
286 }
287
288 for name, tc := range tests {
289 tc := tc
290 t.Run(name, func(t *testing.T) {
291 t.Parallel()
292 err := tc.payload.Validate()
293 tc.assertErr(t, err)
294 })
295 }
296 }
297
View as plain text