1 package logcfg
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 assertapi "github.com/stretchr/testify/assert"
8 corev1 "k8s.io/api/core/v1"
9 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
10
11 "edge-infra.dev/pkg/edge/api/graph/mapper"
12 )
13
14 const (
15 clusterTestString = "cluster: WARN"
16 fluentTestString = "namespace:fluent-operator: alert"
17 kubeTestString = "namespace:kube-system: ALERT"
18 prometheusTestString = "namespace:prometheus: EMERGENCY"
19
20 clusterTestStringNoLevel = "cluster: "
21 prometheusTestStringNoLevel = "namespace:prometheus: "
22 fluentTestStringNoLevel = "namespace:fluent-operator: "
23 kubeTestStringNoLevel = "namespace:kube-system: "
24 )
25
26 func TestFromLogLeveLsConfigMap(t *testing.T) {
27 assert := assertapi.New(t)
28
29 cfg := getLogLevelConfigMap()
30
31 logLevel := FromConfigMap(cfg)
32
33 assert.Contains(logLevel.LogLevels, clusterTestString)
34 assert.Contains(logLevel.LogLevels, fluentTestString)
35 assert.Contains(logLevel.LogLevels, prometheusTestString)
36 assert.Contains(logLevel.LogLevels, kubeTestString)
37 }
38
39 func TestToLogLeveLsConfigMap(t *testing.T) {
40 assert := assertapi.New(t)
41
42
43 logLevel := getLogLevel()
44 cfg := logLevel.ToConfigMap()
45
46 assert.Contains(cfg.Data[LogLevelDataFieldName], clusterTestString)
47 assert.Contains(cfg.Data[LogLevelDataFieldName], fluentTestString)
48 assert.Contains(cfg.Data[LogLevelDataFieldName], prometheusTestString)
49 assert.Contains(cfg.Data[LogLevelDataFieldName], kubeTestString)
50 }
51
52 func TestBuildLogLevelConfigMap(t *testing.T) {
53 assert := assertapi.New(t)
54 jsonBlob := `[{"namespace":"fluent-operator","level":"alert"},{"namespace":"kube-system","level":"ALERT"},{"namespace":"prometheus","level":"EMERGENCY"}]`
55
56 namespaceLogLevels, err := mapper.JSONtoNLL(jsonBlob)
57 assert.NoError(err)
58
59 cfg, err := BuildLogLevelConfigMap("WARN", namespaceLogLevels)
60 assert.NoError(err)
61 assert.NotNil(cfg)
62 assert.NoError(ValidateConfigMap(cfg))
63
64 assert.Contains(cfg.Data[LogLevelDataFieldName], clusterTestString)
65 assert.Contains(cfg.Data[LogLevelDataFieldName], fluentTestString)
66 assert.Contains(cfg.Data[LogLevelDataFieldName], prometheusTestString)
67 assert.Contains(cfg.Data[LogLevelDataFieldName], kubeTestString)
68 }
69
70 func TestNewValidLogLevelConfigMap(t *testing.T) {
71 assert := assertapi.New(t)
72 cfg := getLogLevelConfigMap()
73 logLevel, err := New(cfg)
74 assert.NoError(err)
75 assert.Contains(logLevel.LogLevels, clusterTestString)
76 assert.Contains(logLevel.LogLevels, fluentTestString)
77 assert.Contains(logLevel.LogLevels, prometheusTestString)
78 assert.Contains(logLevel.LogLevels, kubeTestString)
79 }
80
81 func TestNewInvalidLogLeveLsConfigMap(t *testing.T) {
82 assert := assertapi.New(t)
83 cfg := getLogLevelConfigMap()
84 delete(cfg.Data, LogLevelDataFieldName)
85 logLevel, err := New(cfg)
86 assert.Error(err)
87 assert.Nil(logLevel)
88 }
89
90 func TestIsLogLevelConfigMap(t *testing.T) {
91 assert := assertapi.New(t)
92
93 expected := getLogLevelConfigMap()
94 IsLogLevelConfigMap := IsLogLevelConfigMap(expected.ObjectMeta.Name, expected.ObjectMeta.Namespace)
95
96 assert.True(IsLogLevelConfigMap)
97 }
98
99 func TestFieldsRequired(t *testing.T) {
100 assert := assertapi.New(t)
101 cfg := &corev1.ConfigMap{}
102 err := ValidateConfigMap(cfg)
103 assert.Error(err)
104 allFields := "log-level configmap invalid, value(s) not provided: " +
105 "log-levels"
106 assert.Equal(err.Error(), allFields)
107 }
108
109 func TestCreateMultilineString(t *testing.T) {
110
111
112 correctTests := map[string]struct {
113 description string
114 cluster string
115 namespaceJSON string
116 expected string
117 }{
118 "no-namespace": {
119 description: "Should only have cluster",
120 cluster: "WARN",
121 namespaceJSON: "[]",
122 expected: clusterTestString + "\n",
123 },
124 "single-namespace": {
125 description: "Should only have one cluster and namespace",
126 cluster: "WARN",
127 namespaceJSON: `[{"namespace":"prometheus","level":"EMERGENCY"}]`,
128 expected: clusterTestString + "\n" + prometheusTestString + "\n",
129 },
130 "multi-namespace": {
131 description: "Should only have one cluster and 3 namespace",
132 cluster: "WARN",
133 namespaceJSON: `[{"namespace":"fluent-operator","level":"alert"},{"namespace":"kube-system","level":"ALERT"},{"namespace":"prometheus","level":"EMERGENCY"}]`,
134 expected: clusterTestString + "\n" + fluentTestString + "\n" + kubeTestString + "\n" + prometheusTestString + "\n",
135 },
136 }
137
138 for testName, test := range correctTests {
139 namespaceLogLevels, err := mapper.JSONtoNLL(test.namespaceJSON)
140 assert.NoError(t, err)
141
142 returnVal, err := CreateMultilineString(test.cluster, namespaceLogLevels)
143 assert.NoError(t, err)
144
145 if returnVal != test.expected {
146 t.Errorf("%s test was \n%s,\n but was expected to be \n%s", testName, returnVal, test.expected)
147 }
148 }
149
150 noLevelTest := map[string]struct {
151 description string
152 cluster string
153 namespaceJSON string
154 expected string
155 }{
156 "no-namespace-noLevel": {
157 description: "Should only have cluster with no level",
158 cluster: "",
159 namespaceJSON: "[]",
160 expected: clusterTestStringNoLevel + "\n",
161 },
162 "only-namespace-noLevel": {
163 description: "Should only have one namespace with no level",
164 namespaceJSON: `[{"namespace":"prometheus","level":""}]`,
165 expected: clusterTestStringNoLevel + "\n" + prometheusTestStringNoLevel + "\n",
166 },
167 "single-namespace-noLevel": {
168 description: "Should have no levels for cluster and one namespace",
169 cluster: "WARN",
170 namespaceJSON: `[{"namespace":"prometheus","level":""}]`,
171 expected: clusterTestString + "\n" + prometheusTestStringNoLevel + "\n",
172 },
173 "multi-namespace-noLevel": {
174 description: "Should have no levels for cluster and 3 namespace",
175 namespaceJSON: `[{"namespace":"fluent-operator","level":""},{"namespace":"kube-system","level":""},{"namespace":"prometheus","level":""}]`,
176 expected: clusterTestStringNoLevel + "\n" + fluentTestStringNoLevel + "\n" + kubeTestStringNoLevel + "\n" + prometheusTestStringNoLevel + "\n",
177 },
178 "multi-namespace-1-NoLevel": {
179 description: "Should have levels for cluster and 2 namespace, but not 1 namespace",
180 cluster: "WARN",
181 namespaceJSON: `[{"namespace":"fluent-operator","level":"alert"},{"namespace":"kube-system","level":"ALERT"},{"namespace":"prometheus","level":""}]`,
182 expected: clusterTestString + "\n" + fluentTestString + "\n" + kubeTestString + "\n" + prometheusTestStringNoLevel + "\n",
183 },
184 "multi-namespace-2-NoLevel": {
185 description: "Should have levels for cluster and 2 namespace, but not 1 namespace",
186 cluster: "WARN",
187 namespaceJSON: `[{"namespace":"fluent-operator","level":"alert"},{"namespace":"kube-system","level":""},{"namespace":"prometheus","level":""}]`,
188 expected: clusterTestString + "\n" + fluentTestString + "\n" + kubeTestStringNoLevel + "\n" + prometheusTestStringNoLevel + "\n",
189 },
190 "multi-namespace-3-noLevel": {
191 description: "Should have cluster and no levels for 3 namespace",
192 cluster: "WARN",
193 namespaceJSON: `[{"namespace":"fluent-operator","level":""},{"namespace":"kube-system","level":""},{"namespace":"prometheus","level":""}]`,
194 expected: clusterTestString + "\n" + fluentTestStringNoLevel + "\n" + kubeTestStringNoLevel + "\n" + prometheusTestStringNoLevel + "\n",
195 },
196 }
197
198 for testName, test := range noLevelTest {
199 namespaceLogLevels, err := mapper.JSONtoNLL(test.namespaceJSON)
200 assert.NoError(t, err)
201
202 returnVal, err := CreateMultilineString(test.cluster, namespaceLogLevels)
203 assert.NoError(t, err)
204
205 if returnVal != test.expected {
206 t.Errorf("%s test was \n%s,\n but was expected to be \n%s", testName, returnVal, test.expected)
207 }
208 }
209 }
210
211
212 func getLogLevel() *LogLevelData {
213 jsonBlob := `[{"namespace":"fluent-operator","level":"alert"},{"namespace":"kube-system","level":"ALERT"},{"namespace":"prometheus","level":"EMERGENCY"}]`
214
215 namespaceLogLevels, _ := mapper.JSONtoNLL(jsonBlob)
216
217 levels, _ := CreateMultilineString("WARN", namespaceLogLevels)
218
219 return &LogLevelData{
220 LogLevels: levels,
221 }
222 }
223
224 func getLogLevelConfigMap() *corev1.ConfigMap {
225
226 ll := getLogLevel()
227 return &corev1.ConfigMap{
228 TypeMeta: v1.TypeMeta{
229 Kind: "ConfigMap",
230 APIVersion: v1.SchemeGroupVersion.String(),
231 },
232 ObjectMeta: v1.ObjectMeta{
233 Name: LogLevelConfigMapName,
234 Namespace: LogLevelConfigMapNS,
235 },
236 Data: map[string]string{
237 LogLevelDataFieldName: ll.LogLevels,
238 },
239 }
240 }
241
View as plain text