1 package in_toto
2
3 import (
4 "os"
5 "reflect"
6 "sort"
7 "testing"
8 )
9
10 func TestSet(t *testing.T) {
11 testSet := NewSet()
12 if testSet.Has("a") {
13 t.Errorf("not added element 'a' in set %s", testSet.Slice())
14 }
15 testSet.Add("a")
16 if !testSet.Has("a") {
17 t.Errorf("added element 'a' not in set %s", testSet.Slice())
18 }
19 testSet.Add("a")
20 setLen := len(testSet)
21 if setLen != 1 {
22 t.Errorf("expected len 1, got %v for set %s", setLen, testSet.Slice())
23 }
24 testSet.Remove("a")
25 if testSet.Has("a") {
26 t.Errorf("removed element 'a' in set %s", testSet.Slice())
27 }
28
29 testSet.Remove("a")
30 }
31
32 func TestSetIntersection(t *testing.T) {
33 testSet1 := NewSet("a", "b", "c")
34 testSet2 := NewSet("b", "c", "d")
35 expected := NewSet("b", "c")
36 res := testSet1.Intersection(testSet2)
37
38 if !reflect.DeepEqual(res, expected) {
39 t.Errorf("expected %s, got %s", expected.Slice(), res.Slice())
40 }
41 }
42
43 func TestSetDifference(t *testing.T) {
44 testSet1 := NewSet("a", "b", "c")
45 testSet2 := NewSet("b", "c", "d")
46 expected := NewSet("a")
47 res := testSet1.Difference(testSet2)
48
49 if !reflect.DeepEqual(res, expected) {
50 t.Errorf("expected %s, got %s", expected.Slice(), res.Slice())
51 }
52 }
53
54 func TestSetSlice(t *testing.T) {
55 testSet := NewSet("a", "b", "c")
56 expected := []string{"a", "b", "c"}
57
58 res := testSet.Slice()
59 sort.Strings(res)
60 if !reflect.DeepEqual(res, expected) {
61 t.Errorf("expected: %s, got: %s", expected, res)
62 }
63 }
64
65 func TestSetFilter(t *testing.T) {
66 cases := []struct {
67 name string
68 pattern string
69 base, expected Set
70 }{
71 {"match foo", "foo", NewSet("foo", "foobar", "bar"), NewSet("foo")},
72 {"match with wildcard", "foo*", NewSet("foo", "foobar", "bar"), NewSet("foo", "foobar")},
73 {"no match", "foo", NewSet("bar"), NewSet()},
74 {"no match (due to invalid pattern)", "[", NewSet("["), NewSet()},
75 }
76
77 for _, tc := range cases {
78 t.Run(tc.name, func(t *testing.T) {
79 res := tc.base.Filter(tc.pattern)
80 if !reflect.DeepEqual(res, tc.expected) {
81 t.Errorf("expected: %s, got: %s", tc.expected.Slice(), res.Slice())
82 }
83 })
84 }
85 }
86
87 func TestInterfaceKeyStrings(t *testing.T) {
88 expected := []string{"a", "b", "c"}
89 testMap := map[string]interface{}{"a": nil, "b": nil, "c": nil}
90 res := InterfaceKeyStrings(testMap)
91 sort.Strings(res)
92 if !reflect.DeepEqual(res, expected) {
93 t.Errorf("expected: %s, got: %s", expected, res)
94 }
95 }
96
97 func TestSubsetCheck(t *testing.T) {
98 tables := []struct {
99 subset []string
100 superset Set
101 result bool
102 }{
103 {[]string{"sha256"}, NewSet("sha256", "sha512"), true},
104 {[]string{"sha512"}, NewSet("sha256"), false},
105 {[]string{"sha256", "sha512"}, NewSet("sha128", "sha256", "sha512"), true},
106 {[]string{"sha256", "sha512", "sha384"}, NewSet("sha128"), false},
107 }
108 for _, table := range tables {
109 result := table.superset.IsSubSet(NewSet(table.subset...))
110 if table.result != result {
111 t.Errorf("result mismatch for: %#v, %#v, got: %t, should have got: %t", table.subset, table.superset, result, table.result)
112 }
113 }
114 }
115
116 func TestIsWritable(t *testing.T) {
117 notWritable, err := os.MkdirTemp("", "")
118 if err != nil {
119 t.Error(err)
120 }
121 writable, err := os.MkdirTemp("", "")
122 if err != nil {
123 t.Error(err)
124 }
125
126 err = os.Chmod(notWritable, os.FileMode(0000))
127 if err != nil {
128 t.Error(err)
129 }
130
131 err = isWritable(notWritable)
132 if err == nil {
133 t.Errorf("%s should be not writable, but is writable", notWritable)
134 }
135
136 err = isWritable(writable)
137 if err != nil {
138 t.Errorf("%s should be writable, but it is not writable", writable)
139 }
140 }
141
View as plain text