Skip to content

Commit bc58ca8

Browse files
ShubhamPalriwalaShubhamPalriwala
authored
Test: Add Unit tests for params under event parsing (#2199)
* feat: unit tests for event params * fix: add table format and check for all 3 cases(valid,invalid,none) * fix: reoder assertions & pass entire arg at once
1 parent 264056c commit bc58ca8

File tree

1 file changed

+354
-0
lines changed

1 file changed

+354
-0
lines changed

‎pkg/events/parse/params_test.go‎

Lines changed: 354 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,354 @@
1+
package parse
2+
3+
import (
4+
"testing"
5+
6+
"github.com/aquasecurity/tracee/types/trace"
7+
"github.com/stretchr/testify/assert"
8+
)
9+
10+
func TestArgInt32Val(t *testing.T) {
11+
12+
tests := []struct {
13+
name string
14+
arg trace.Argument
15+
expectedValue int32
16+
errorMessage string
17+
}{
18+
{
19+
name: "valid_val",
20+
arg: trace.Argument{
21+
ArgMeta: trace.ArgMeta{
22+
Name: "valid_val",
23+
Type: "int",
24+
},
25+
Value: int32(1878),
26+
},
27+
expectedValue: int32(1878),
28+
},
29+
{
30+
name: "invalid_val",
31+
arg: trace.Argument{
32+
ArgMeta: trace.ArgMeta{
33+
Name: "invalid_val",
34+
Type: "int",
35+
},
36+
Value: int64(1878),
37+
},
38+
errorMessage: "argument invalid_val is not of type int32",
39+
},
40+
{
41+
name: "no_val",
42+
arg: trace.Argument{
43+
ArgMeta: trace.ArgMeta{
44+
Name: "does_not_exist_val",
45+
Type: "int",
46+
},
47+
Value: int32(1878),
48+
},
49+
errorMessage: "argument no_val not found",
50+
},
51+
}
52+
53+
for _, tt := range tests {
54+
t.Run(tt.name, func(t *testing.T) {
55+
e := trace.Event{Args: []trace.Argument{tt.arg}}
56+
val, err := ArgInt32Val(&e, tt.name)
57+
if tt.errorMessage != "" {
58+
assert.Error(t, err)
59+
assert.Equal(t, tt.errorMessage, err.Error())
60+
} else {
61+
assert.NoError(t, err)
62+
assert.Equal(t, tt.expectedValue, val)
63+
}
64+
})
65+
}
66+
}
67+
68+
func TestArgStringVal(t *testing.T) {
69+
tests := []struct {
70+
name string
71+
arg trace.Argument
72+
expectedValue string
73+
errorMessage string
74+
}{
75+
{
76+
name: "valid_val",
77+
arg: trace.Argument{
78+
ArgMeta: trace.ArgMeta{
79+
Name: "valid_val",
80+
Type: "string",
81+
},
82+
Value: "hello_tracee",
83+
},
84+
expectedValue: "hello_tracee",
85+
},
86+
{
87+
name: "invalid_val",
88+
arg: trace.Argument{
89+
ArgMeta: trace.ArgMeta{
90+
Name: "invalid_val",
91+
Type: "int",
92+
},
93+
Value: int64(1878),
94+
},
95+
errorMessage: "argument invalid_val is not of type string",
96+
},
97+
{
98+
name: "no_val",
99+
arg: trace.Argument{
100+
ArgMeta: trace.ArgMeta{
101+
Name: "does_not_exist_val",
102+
Type: "string",
103+
},
104+
Value: "hola_tracee",
105+
},
106+
errorMessage: "argument no_val not found",
107+
},
108+
}
109+
110+
for _, tt := range tests {
111+
t.Run(tt.name, func(t *testing.T) {
112+
e := trace.Event{Args: []trace.Argument{tt.arg}}
113+
val, err := ArgStringVal(&e, tt.name)
114+
if tt.errorMessage != "" {
115+
assert.Error(t, err)
116+
assert.Equal(t, tt.errorMessage, err.Error())
117+
} else {
118+
assert.NoError(t, err)
119+
assert.Equal(t, tt.expectedValue, val)
120+
}
121+
})
122+
}
123+
124+
}
125+
126+
func TestArgUint64Val(t *testing.T) {
127+
tests := []struct {
128+
name string
129+
arg trace.Argument
130+
expectedValue uint64
131+
errorMessage string
132+
}{
133+
{
134+
name: "valid_val",
135+
arg: trace.Argument{
136+
ArgMeta: trace.ArgMeta{
137+
Name: "valid_val",
138+
Type: "int",
139+
},
140+
Value: uint64(1878),
141+
},
142+
expectedValue: uint64(1878),
143+
},
144+
{
145+
name: "invalid_val",
146+
arg: trace.Argument{
147+
ArgMeta: trace.ArgMeta{
148+
Name: "invalid_val",
149+
Type: "int",
150+
},
151+
Value: uint32(1878),
152+
},
153+
errorMessage: "argument invalid_val is not of type uint64",
154+
},
155+
{
156+
name: "no_val",
157+
arg: trace.Argument{
158+
ArgMeta: trace.ArgMeta{
159+
Name: "does_not_exist_val",
160+
Type: "int",
161+
},
162+
Value: uint64(1878),
163+
},
164+
errorMessage: "argument no_val not found",
165+
},
166+
}
167+
168+
for _, tt := range tests {
169+
t.Run(tt.name, func(t *testing.T) {
170+
e := trace.Event{Args: []trace.Argument{tt.arg}}
171+
val, err := ArgUint64Val(&e, tt.name)
172+
if tt.errorMessage != "" {
173+
assert.Error(t, err)
174+
assert.Equal(t, tt.errorMessage, err.Error())
175+
} else {
176+
assert.NoError(t, err)
177+
assert.Equal(t, tt.expectedValue, val)
178+
}
179+
})
180+
}
181+
182+
}
183+
184+
func TestArgUint32Val(t *testing.T) {
185+
tests := []struct {
186+
name string
187+
arg trace.Argument
188+
expectedValue uint32
189+
errorMessage string
190+
}{
191+
{
192+
name: "valid_val",
193+
arg: trace.Argument{
194+
ArgMeta: trace.ArgMeta{
195+
Name: "valid_val",
196+
Type: "int",
197+
},
198+
Value: uint32(1878),
199+
},
200+
expectedValue: uint32(1878),
201+
},
202+
{
203+
name: "invalid_val",
204+
arg: trace.Argument{
205+
ArgMeta: trace.ArgMeta{
206+
Name: "invalid_val",
207+
Type: "int",
208+
},
209+
Value: uint64(1878),
210+
},
211+
errorMessage: "argument invalid_val is not of type uint32",
212+
},
213+
{
214+
name: "no_val",
215+
arg: trace.Argument{
216+
ArgMeta: trace.ArgMeta{
217+
Name: "does_not_exist_val",
218+
Type: "int",
219+
},
220+
Value: uint32(1878),
221+
},
222+
errorMessage: "argument no_val not found",
223+
},
224+
}
225+
226+
for _, tt := range tests {
227+
t.Run(tt.name, func(t *testing.T) {
228+
e := trace.Event{Args: []trace.Argument{tt.arg}}
229+
val, err := ArgUint32Val(&e, tt.name)
230+
if tt.errorMessage != "" {
231+
assert.Error(t, err)
232+
assert.Equal(t, tt.errorMessage, err.Error())
233+
} else {
234+
assert.NoError(t, err)
235+
assert.Equal(t, tt.expectedValue, val)
236+
}
237+
})
238+
}
239+
240+
}
241+
242+
func TestArgStringArrVal(t *testing.T) {
243+
tests := []struct {
244+
name string
245+
arg trace.Argument
246+
expectedValue []string
247+
errorMessage string
248+
}{
249+
{
250+
name: "valid_val",
251+
arg: trace.Argument{
252+
ArgMeta: trace.ArgMeta{
253+
Name: "valid_val",
254+
Type: "string",
255+
},
256+
Value: []string{"hello", "tracee", "ebpf"},
257+
},
258+
expectedValue: []string{"hello", "tracee", "ebpf"},
259+
},
260+
{
261+
name: "invalid_val",
262+
arg: trace.Argument{
263+
ArgMeta: trace.ArgMeta{
264+
Name: "invalid_val",
265+
Type: "int",
266+
},
267+
Value: int64(1878),
268+
},
269+
errorMessage: "argument invalid_val is not of type string",
270+
},
271+
{
272+
name: "no_val",
273+
arg: trace.Argument{
274+
ArgMeta: trace.ArgMeta{
275+
Name: "does_not_exist_val",
276+
Type: "string",
277+
},
278+
Value: []string{"hello", "tracee", "ebpf"},
279+
},
280+
errorMessage: "argument no_val not found",
281+
},
282+
}
283+
284+
for _, tt := range tests {
285+
t.Run(tt.name, func(t *testing.T) {
286+
e := trace.Event{Args: []trace.Argument{tt.arg}}
287+
val, err := ArgStringArrVal(&e, tt.name)
288+
if tt.errorMessage != "" {
289+
assert.Error(t, err)
290+
assert.Equal(t, tt.errorMessage, err.Error())
291+
} else {
292+
assert.NoError(t, err)
293+
assert.Equal(t, tt.expectedValue, val)
294+
}
295+
})
296+
}
297+
}
298+
299+
func TestArgUlongArrVal(t *testing.T) {
300+
tests := []struct {
301+
name string
302+
arg trace.Argument
303+
expectedValue []uint64
304+
errorMessage string
305+
}{
306+
{
307+
name: "valid_val",
308+
arg: trace.Argument{
309+
ArgMeta: trace.ArgMeta{
310+
Name: "valid_val",
311+
Type: "int",
312+
},
313+
Value: []uint64{1878, 1878, 1878},
314+
},
315+
expectedValue: []uint64{1878, 1878, 1878},
316+
},
317+
{
318+
name: "invalid_val",
319+
arg: trace.Argument{
320+
ArgMeta: trace.ArgMeta{
321+
Name: "invalid_val",
322+
Type: "int",
323+
},
324+
Value: []uint32{1878, 1878, 1878},
325+
},
326+
errorMessage: "argument invalid_val is not of type ulong array",
327+
},
328+
{
329+
name: "no_val",
330+
arg: trace.Argument{
331+
ArgMeta: trace.ArgMeta{
332+
Name: "does_not_exist_val",
333+
Type: "int",
334+
},
335+
Value: []uint64{1878, 1878, 1878},
336+
},
337+
errorMessage: "argument no_val not found",
338+
},
339+
}
340+
341+
for _, tt := range tests {
342+
t.Run(tt.name, func(t *testing.T) {
343+
e := trace.Event{Args: []trace.Argument{tt.arg}}
344+
val, err := ArgUlongArrVal(&e, tt.name)
345+
if tt.errorMessage != "" {
346+
assert.Error(t, err)
347+
assert.Equal(t, tt.errorMessage, err.Error())
348+
} else {
349+
assert.NoError(t, err)
350+
assert.Equal(t, tt.expectedValue, val)
351+
}
352+
})
353+
}
354+
}

0 commit comments

Comments
 (0)