Improve unit test coverage
[ric-plt/e2mgr.git] / E2Manager / configuration / configuration_test.go
1 //
2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 //      http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16
17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 //  platform project (RICP).
19
20 package configuration
21
22 import (
23         "github.com/stretchr/testify/assert"
24         "gopkg.in/yaml.v2"
25         "io/ioutil"
26         "os"
27         "testing"
28 )
29
30 func TestParseConfigurationSuccess(t *testing.T) {
31         config := ParseConfiguration()
32         assert.Equal(t, 3800, config.Http.Port)
33         assert.Equal(t, 3801, config.Rmr.Port)
34         assert.Equal(t, 65536, config.Rmr.MaxMsgSize)
35         assert.Equal(t, "info", config.Logging.LogLevel)
36         assert.Equal(t, 100, config.NotificationResponseBuffer)
37         assert.Equal(t, 5, config.BigRedButtonTimeoutSec)
38         assert.Equal(t, 4500, config.KeepAliveResponseTimeoutMs)
39         assert.Equal(t, 1500, config.KeepAliveDelayMs)
40         assert.Equal(t, 15000, config.E2TInstanceDeletionTimeoutMs)
41         assert.NotNil(t, config.GlobalRicId)
42         assert.Equal(t, "AACCE", config.GlobalRicId.RicId)
43         assert.Equal(t, "310", config.GlobalRicId.Mcc)
44         assert.Equal(t, "411", config.GlobalRicId.Mnc)
45         assert.Equal(t, "RAN_CONNECTION_STATUS_CHANGE", config.RnibWriter.StateChangeMessageChannel)
46         assert.Equal(t, "RAN_MANIPULATION", config.RnibWriter.RanManipulationMessageChannel)
47 }
48
49 func TestStringer(t *testing.T) {
50         config := ParseConfiguration().String()
51         assert.NotEmpty(t, config)
52 }
53
54 func TestParseConfigurationFileNotFoundFailure(t *testing.T) {
55         configPath := "../resources/configuration.yaml"
56         configPathTmp := "../resources/configuration.yaml_tmp"
57         err := os.Rename(configPath, configPathTmp)
58         if err != nil {
59                 t.Errorf("#TestParseConfigurationFileNotFoundFailure - failed to rename configuration file: %s\n", configPath)
60         }
61         defer func() {
62                 err = os.Rename(configPathTmp, configPath)
63                 if err != nil {
64                         t.Errorf("#TestParseConfigurationFileNotFoundFailure - failed to rename configuration file: %s\n", configPath)
65                 }
66         }()
67         assert.Panics(t, func() { ParseConfiguration() })
68 }
69
70 func TestRmrConfigNotFoundFailure(t *testing.T) {
71         configPath := "../resources/configuration.yaml"
72         configPathTmp := "../resources/configuration.yaml_tmp"
73         err := os.Rename(configPath, configPathTmp)
74         if err != nil {
75                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
76         }
77         defer func() {
78                 err = os.Rename(configPathTmp, configPath)
79                 if err != nil {
80                         t.Errorf("#TestRmrConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
81                 }
82         }()
83         yamlMap := map[string]interface{}{
84                 "logging":        map[string]interface{}{"logLevel": "info"},
85                 "http":           map[string]interface{}{"port": 3800},
86                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
87                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
88         }
89         buf, err := yaml.Marshal(yamlMap)
90         if err != nil {
91                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to marshal configuration map\n")
92         }
93         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
94         if err != nil {
95                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
96         }
97         assert.PanicsWithValue(t, "#configuration.populateRmrConfig - failed to populate RMR configuration: The entry 'rmr' not found\n", func() { ParseConfiguration() })
98 }
99
100 func TestLoggingConfigNotFoundFailure(t *testing.T) {
101         configPath := "../resources/configuration.yaml"
102         configPathTmp := "../resources/configuration.yaml_tmp"
103         err := os.Rename(configPath, configPathTmp)
104         if err != nil {
105                 t.Errorf("#TestLoggingConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
106         }
107         defer func() {
108                 err = os.Rename(configPathTmp, configPath)
109                 if err != nil {
110                         t.Errorf("#TestLoggingConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
111                 }
112         }()
113         yamlMap := map[string]interface{}{
114                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
115                 "http":           map[string]interface{}{"port": 3800},
116                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
117                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
118         }
119         buf, err := yaml.Marshal(yamlMap)
120         if err != nil {
121                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to marshal configuration map\n")
122         }
123         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
124         if err != nil {
125                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
126         }
127         assert.PanicsWithValue(t, "#configuration.populateLoggingConfig - failed to populate logging configuration: The entry 'logging' not found\n",
128                 func() { ParseConfiguration() })
129 }
130
131 func TestHttpConfigNotFoundFailure(t *testing.T) {
132         configPath := "../resources/configuration.yaml"
133         configPathTmp := "../resources/configuration.yaml_tmp"
134         err := os.Rename(configPath, configPathTmp)
135         if err != nil {
136                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
137         }
138         defer func() {
139                 err = os.Rename(configPathTmp, configPath)
140                 if err != nil {
141                         t.Errorf("#TestHttpConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
142                 }
143         }()
144         yamlMap := map[string]interface{}{
145                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
146                 "logging":        map[string]interface{}{"logLevel": "info"},
147                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
148                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
149         }
150         buf, err := yaml.Marshal(yamlMap)
151         if err != nil {
152                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to marshal configuration map\n")
153         }
154         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
155         if err != nil {
156                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
157         }
158         assert.PanicsWithValue(t, "#configuration.populateHttpConfig - failed to populate HTTP configuration: The entry 'http' not found\n",
159                 func() { ParseConfiguration() })
160 }
161
162 func TestRoutingManagerConfigNotFoundFailure(t *testing.T) {
163         configPath := "../resources/configuration.yaml"
164         configPathTmp := "../resources/configuration.yaml_tmp"
165         err := os.Rename(configPath, configPathTmp)
166         if err != nil {
167                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
168         }
169         defer func() {
170                 err = os.Rename(configPathTmp, configPath)
171                 if err != nil {
172                         t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
173                 }
174         }()
175         yamlMap := map[string]interface{}{
176                 "rmr":         map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
177                 "logging":     map[string]interface{}{"logLevel": "info"},
178                 "http":        map[string]interface{}{"port": 3800},
179                 "globalRicId": map[string]interface{}{"mcc": 327, "mnc": 94, "ricId": "AACCE"},
180         }
181         buf, err := yaml.Marshal(yamlMap)
182         if err != nil {
183                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to marshal configuration map\n")
184         }
185         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
186         if err != nil {
187                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
188         }
189         assert.PanicsWithValue(t, "#configuration.populateRoutingManagerConfig - failed to populate Routing Manager configuration: The entry 'routingManager' not found\n",
190                 func() { ParseConfiguration() })
191 }
192
193 func TestGlobalRicIdConfigNotFoundFailure(t *testing.T) {
194         configPath := "../resources/configuration.yaml"
195         configPathTmp := "../resources/configuration.yaml_tmp"
196         err := os.Rename(configPath, configPathTmp)
197         if err != nil {
198                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
199         }
200         defer func() {
201                 err = os.Rename(configPathTmp, configPath)
202                 if err != nil {
203                         t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
204                 }
205         }()
206         yamlMap := map[string]interface{}{
207                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
208                 "logging":        map[string]interface{}{"logLevel": "info"},
209                 "http":           map[string]interface{}{"port": 3800},
210                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
211         }
212         buf, err := yaml.Marshal(yamlMap)
213         if err != nil {
214                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to marshal configuration map\n")
215         }
216         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
217         if err != nil {
218                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
219         }
220         assert.PanicsWithValue(t, "#configuration.validateGlobalRicIdConfig - failed to populate Global RicId configuration: The entry 'globalRicId' not found\n",
221                 func() { ParseConfiguration() })
222 }
223
224 func TestRnibWriterConfigNotFoundFailure(t *testing.T) {
225         configPath := "../resources/configuration.yaml"
226         configPathTmp := "../resources/configuration.yaml_tmp"
227         err := os.Rename(configPath, configPathTmp)
228         if err != nil {
229                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
230         }
231         defer func() {
232                 err = os.Rename(configPathTmp, configPath)
233                 if err != nil {
234                         t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
235                 }
236         }()
237         yamlMap := map[string]interface{}{
238                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
239                 "logging":        map[string]interface{}{"logLevel": "info"},
240                 "http":           map[string]interface{}{"port": 3800},
241                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
242                 "globalRicId": map[string]interface{}{"mcc": 327, "mnc": 94, "ricId": "AACCE"},
243         }
244         buf, err := yaml.Marshal(yamlMap)
245         if err != nil {
246                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to marshal configuration map\n")
247         }
248         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
249         if err != nil {
250                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
251         }
252         assert.PanicsWithValue(t, "#configuration.populateRnibWriterConfig - failed to populate Rnib Writer configuration: The entry 'rnibWriter' not found\n",
253                 func() { ParseConfiguration() })
254 }
255
256 func TestEmptyRicIdFailure(t *testing.T) {
257         configPath := "../resources/configuration.yaml"
258         configPathTmp := "../resources/configuration.yaml_tmp"
259         err := os.Rename(configPath, configPathTmp)
260         if err != nil {
261                 t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
262         }
263         defer func() {
264                 err = os.Rename(configPathTmp, configPath)
265                 if err != nil {
266                         t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
267                 }
268         }()
269         yamlMap := map[string]interface{}{
270                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
271                 "logging":        map[string]interface{}{"logLevel": "info"},
272                 "http":           map[string]interface{}{"port": 3800},
273                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": ""},
274                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
275         }
276         buf, err := yaml.Marshal(yamlMap)
277         if err != nil {
278                 t.Errorf("#TestEmptyRicIdFailure - failed to marshal configuration map\n")
279         }
280         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
281         if err != nil {
282                 t.Errorf("#TestEmptyRicIdFailure - failed to write configuration file: %s\n", configPath)
283         }
284         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is missing or empty\n",
285                 func() { ParseConfiguration() })
286 }
287
288 func TestMissingRicIdFailure(t *testing.T) {
289         configPath := "../resources/configuration.yaml"
290         configPathTmp := "../resources/configuration.yaml_tmp"
291         err := os.Rename(configPath, configPathTmp)
292         if err != nil {
293                 t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
294         }
295         defer func() {
296                 err = os.Rename(configPathTmp, configPath)
297                 if err != nil {
298                         t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
299                 }
300         }()
301         yamlMap := map[string]interface{}{
302                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
303                 "logging":        map[string]interface{}{"logLevel": "info"},
304                 "http":           map[string]interface{}{"port": 3800},
305                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94"},
306                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
307         }
308         buf, err := yaml.Marshal(yamlMap)
309         if err != nil {
310                 t.Errorf("#TestEmptyRicIdFailure - failed to marshal configuration map\n")
311         }
312         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
313         if err != nil {
314                 t.Errorf("#TestEmptyRicIdFailure - failed to write configuration file: %s\n", configPath)
315         }
316         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is missing or empty\n",
317                 func() { ParseConfiguration() })
318 }
319
320 func TestNonHexRicIdFailure(t *testing.T) {
321         configPath := "../resources/configuration.yaml"
322         configPathTmp := "../resources/configuration.yaml_tmp"
323         err := os.Rename(configPath, configPathTmp)
324         if err != nil {
325                 t.Errorf("#TestNonHexRicIdFailure - failed to rename configuration file: %s\n", configPath)
326         }
327         defer func() {
328                 err = os.Rename(configPathTmp, configPath)
329                 if err != nil {
330                         t.Errorf("#TestNonHexRicIdFailure - failed to rename configuration file: %s\n", configPath)
331                 }
332         }()
333         yamlMap := map[string]interface{}{
334                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
335                 "logging":        map[string]interface{}{"logLevel": "info"},
336                 "http":           map[string]interface{}{"port": 3800},
337                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": "TEST1"},
338                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
339         }
340         buf, err := yaml.Marshal(yamlMap)
341         if err != nil {
342                 t.Errorf("#TestNonHexRicIdFailure - failed to marshal configuration map\n")
343         }
344         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
345         if err != nil {
346                 t.Errorf("#TestNonHexRicIdFailure - failed to write configuration file: %s\n", configPath)
347         }
348         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is not hex number\n",
349                 func() { ParseConfiguration() })
350 }
351
352 func TestWrongRicIdLengthFailure(t *testing.T) {
353         configPath := "../resources/configuration.yaml"
354         configPathTmp := "../resources/configuration.yaml_tmp"
355         err := os.Rename(configPath, configPathTmp)
356         if err != nil {
357                 t.Errorf("#TestWrongRicIdLengthFailure - failed to rename configuration file: %s\n", configPath)
358         }
359         defer func() {
360                 err = os.Rename(configPathTmp, configPath)
361                 if err != nil {
362                         t.Errorf("#TestWrongRicIdLengthFailure - failed to rename configuration file: %s\n", configPath)
363                 }
364         }()
365         yamlMap := map[string]interface{}{
366                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
367                 "logging":        map[string]interface{}{"logLevel": "info"},
368                 "http":           map[string]interface{}{"port": 3800},
369                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": "AA43"},
370                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
371         }
372         buf, err := yaml.Marshal(yamlMap)
373         if err != nil {
374                 t.Errorf("#TestWrongRicIdLengthFailure - failed to marshal configuration map\n")
375         }
376         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
377         if err != nil {
378                 t.Errorf("#TestWrongRicIdLengthFailure - failed to write configuration file: %s\n", configPath)
379         }
380         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId length should be 5 hex characters\n",
381                 func() { ParseConfiguration() })
382 }
383
384 func TestMccNotThreeDigitsFailure(t *testing.T) {
385         configPath := "../resources/configuration.yaml"
386         configPathTmp := "../resources/configuration.yaml_tmp"
387         err := os.Rename(configPath, configPathTmp)
388         if err != nil {
389                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
390         }
391         defer func() {
392                 err = os.Rename(configPathTmp, configPath)
393                 if err != nil {
394                         t.Errorf("#TestMccNotThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
395                 }
396         }()
397         yamlMap := map[string]interface{}{
398                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
399                 "logging":        map[string]interface{}{"logLevel": "info"},
400                 "http":           map[string]interface{}{"port": 3800},
401                 "globalRicId":    map[string]interface{}{"mcc": "31", "mnc": "94", "ricId": "AA443"},
402                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
403         }
404         buf, err := yaml.Marshal(yamlMap)
405         if err != nil {
406                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to marshal configuration map\n")
407         }
408         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
409         if err != nil {
410                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
411         }
412         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not 3 digits\n",
413                 func() { ParseConfiguration() })
414 }
415
416 func TestMncLengthIsGreaterThanThreeDigitsFailure(t *testing.T) {
417         configPath := "../resources/configuration.yaml"
418         configPathTmp := "../resources/configuration.yaml_tmp"
419         err := os.Rename(configPath, configPathTmp)
420         if err != nil {
421                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
422         }
423         defer func() {
424                 err = os.Rename(configPathTmp, configPath)
425                 if err != nil {
426                         t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
427                 }
428         }()
429         yamlMap := map[string]interface{}{
430                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
431                 "logging":        map[string]interface{}{"logLevel": "info"},
432                 "http":           map[string]interface{}{"port": 3800},
433                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "6794", "ricId": "AA443"},
434                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
435         }
436         buf, err := yaml.Marshal(yamlMap)
437         if err != nil {
438                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to marshal configuration map\n")
439         }
440         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
441         if err != nil {
442                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
443         }
444         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not 2 or 3 digits\n",
445                 func() { ParseConfiguration() })
446 }
447
448 func TestMncLengthIsLessThanTwoDigitsFailure(t *testing.T) {
449         configPath := "../resources/configuration.yaml"
450         configPathTmp := "../resources/configuration.yaml_tmp"
451         err := os.Rename(configPath, configPathTmp)
452         if err != nil {
453                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to rename configuration file: %s\n", configPath)
454         }
455         defer func() {
456                 err = os.Rename(configPathTmp, configPath)
457                 if err != nil {
458                         t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to rename configuration file: %s\n", configPath)
459                 }
460         }()
461         yamlMap := map[string]interface{}{
462                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
463                 "logging":        map[string]interface{}{"logLevel": "info"},
464                 "http":           map[string]interface{}{"port": 3800},
465                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "4", "ricId": "AA443"},
466                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
467         }
468         buf, err := yaml.Marshal(yamlMap)
469         if err != nil {
470                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to marshal configuration map\n")
471         }
472         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
473         if err != nil {
474                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to write configuration file: %s\n", configPath)
475         }
476         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not 2 or 3 digits\n",
477                 func() { ParseConfiguration() })
478 }
479
480 func TestNegativeMncFailure(t *testing.T) {
481         configPath := "../resources/configuration.yaml"
482         configPathTmp := "../resources/configuration.yaml_tmp"
483         err := os.Rename(configPath, configPathTmp)
484         if err != nil {
485                 t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
486         }
487         defer func() {
488                 err = os.Rename(configPathTmp, configPath)
489                 if err != nil {
490                         t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
491                 }
492         }()
493         yamlMap := map[string]interface{}{
494                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
495                 "logging":        map[string]interface{}{"logLevel": "info"},
496                 "http":           map[string]interface{}{"port": 3800},
497                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "-2", "ricId": "AA443"},
498                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
499         }
500         buf, err := yaml.Marshal(yamlMap)
501         if err != nil {
502                 t.Errorf("#TestNegativeMncFailure - failed to marshal configuration map\n")
503         }
504         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
505         if err != nil {
506                 t.Errorf("#TestNegativeMncFailure - failed to write configuration file: %s\n", configPath)
507         }
508         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is negative\n",
509                 func() { ParseConfiguration() })
510 }
511
512 func TestNegativeMccFailure(t *testing.T) {
513         configPath := "../resources/configuration.yaml"
514         configPathTmp := "../resources/configuration.yaml_tmp"
515         err := os.Rename(configPath, configPathTmp)
516         if err != nil {
517                 t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
518         }
519         defer func() {
520                 err = os.Rename(configPathTmp, configPath)
521                 if err != nil {
522                         t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
523                 }
524         }()
525         yamlMap := map[string]interface{}{
526                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
527                 "logging":        map[string]interface{}{"logLevel": "info"},
528                 "http":           map[string]interface{}{"port": 3800},
529                 "globalRicId":    map[string]interface{}{"mcc": "-31", "mnc": "222", "ricId": "AA443"},
530                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
531         }
532         buf, err := yaml.Marshal(yamlMap)
533         if err != nil {
534                 t.Errorf("#TestNegativeMncFailure - failed to marshal configuration map\n")
535         }
536         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
537         if err != nil {
538                 t.Errorf("#TestNegativeMncFailure - failed to write configuration file: %s\n", configPath)
539         }
540         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is negative\n",
541                 func() { ParseConfiguration() })
542 }
543
544 func TestAlphaNumericMccFailure(t *testing.T) {
545         configPath := "../resources/configuration.yaml"
546         configPathTmp := "../resources/configuration.yaml_tmp"
547         err := os.Rename(configPath, configPathTmp)
548         if err != nil {
549                 t.Errorf("#TestAlphaNumericMccFailure - failed to rename configuration file: %s\n", configPath)
550         }
551         defer func() {
552                 err = os.Rename(configPathTmp, configPath)
553                 if err != nil {
554                         t.Errorf("#TestAlphaNumericMccFailure - failed to rename configuration file: %s\n", configPath)
555                 }
556         }()
557         yamlMap := map[string]interface{}{
558                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
559                 "logging":        map[string]interface{}{"logLevel": "info"},
560                 "http":           map[string]interface{}{"port": 3800},
561                 "globalRicId":    map[string]interface{}{"mcc": "1W2", "mnc": "222", "ricId": "AA443"},
562                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
563         }
564         buf, err := yaml.Marshal(yamlMap)
565         if err != nil {
566                 t.Errorf("#TestAlphaNumericMccFailure - failed to marshal configuration map\n")
567         }
568         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
569         if err != nil {
570                 t.Errorf("#TestAlphaNumericMccFailure - failed to write configuration file: %s\n", configPath)
571         }
572         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not a number\n",
573                 func() { ParseConfiguration() })
574 }
575
576 func TestAlphaNumericMncFailure(t *testing.T) {
577         configPath := "../resources/configuration.yaml"
578         configPathTmp := "../resources/configuration.yaml_tmp"
579         err := os.Rename(configPath, configPathTmp)
580         if err != nil {
581                 t.Errorf("#TestAlphaNumericMncFailure - failed to rename configuration file: %s\n", configPath)
582         }
583         defer func() {
584                 err = os.Rename(configPathTmp, configPath)
585                 if err != nil {
586                         t.Errorf("#TestAlphaNumericMncFailure - failed to rename configuration file: %s\n", configPath)
587                 }
588         }()
589         yamlMap := map[string]interface{}{
590                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
591                 "logging":        map[string]interface{}{"logLevel": "info"},
592                 "http":           map[string]interface{}{"port": 3800},
593                 "globalRicId":    map[string]interface{}{"mcc": "111", "mnc": "2A8", "ricId": "AA443"},
594                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
595         }
596         buf, err := yaml.Marshal(yamlMap)
597         if err != nil {
598                 t.Errorf("#TestAlphaNumericMncFailure - failed to marshal configuration map\n")
599         }
600         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
601         if err != nil {
602                 t.Errorf("#TestAlphaNumericMncFailure - failed to write configuration file: %s\n", configPath)
603         }
604         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not a number\n",
605                 func() { ParseConfiguration() })
606 }
607
608 func TestMissingMmcFailure(t *testing.T) {
609         configPath := "../resources/configuration.yaml"
610         configPathTmp := "../resources/configuration.yaml_tmp"
611         err := os.Rename(configPath, configPathTmp)
612         if err != nil {
613                 t.Errorf("#TestMissingMmcFailure - failed to rename configuration file: %s\n", configPath)
614         }
615         defer func() {
616                 err = os.Rename(configPathTmp, configPath)
617                 if err != nil {
618                         t.Errorf("#TestMissingMmcFailure - failed to rename configuration file: %s\n", configPath)
619                 }
620         }()
621         yamlMap := map[string]interface{}{
622                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
623                 "logging":        map[string]interface{}{"logLevel": "info"},
624                 "http":           map[string]interface{}{"port": 3800},
625                 "globalRicId":    map[string]interface{}{"mnc": "94", "ricId": "AABB3"},
626                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
627         }
628         buf, err := yaml.Marshal(yamlMap)
629         if err != nil {
630                 t.Errorf("#TestMissingMmcFailure - failed to marshal configuration map\n")
631         }
632         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
633         if err != nil {
634                 t.Errorf("#TestMissingMmcFailure - failed to write configuration file: %s\n", configPath)
635         }
636         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is missing or empty\n",
637                 func() { ParseConfiguration() })
638 }
639
640 func TestEmptyMmcFailure(t *testing.T) {
641         configPath := "../resources/configuration.yaml"
642         configPathTmp := "../resources/configuration.yaml_tmp"
643         err := os.Rename(configPath, configPathTmp)
644         if err != nil {
645                 t.Errorf("#TestEmptyMmcFailure - failed to rename configuration file: %s\n", configPath)
646         }
647         defer func() {
648                 err = os.Rename(configPathTmp, configPath)
649                 if err != nil {
650                         t.Errorf("#TestEmptyMmcFailure - failed to rename configuration file: %s\n", configPath)
651                 }
652         }()
653         yamlMap := map[string]interface{}{
654                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
655                 "logging":        map[string]interface{}{"logLevel": "info"},
656                 "http":           map[string]interface{}{"port": 3800},
657                 "globalRicId":    map[string]interface{}{"mcc": "", "mnc": "94", "ricId": "AABB3"},
658                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
659         }
660         buf, err := yaml.Marshal(yamlMap)
661         if err != nil {
662                 t.Errorf("#TestEmptyMmcFailure - failed to marshal configuration map\n")
663         }
664         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
665         if err != nil {
666                 t.Errorf("#TestEmptyMmcFailure - failed to write configuration file: %s\n", configPath)
667         }
668         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is missing or empty\n",
669                 func() { ParseConfiguration() })
670 }
671
672 func TestEmptyMncFailure(t *testing.T) {
673         configPath := "../resources/configuration.yaml"
674         configPathTmp := "../resources/configuration.yaml_tmp"
675         err := os.Rename(configPath, configPathTmp)
676         if err != nil {
677                 t.Errorf("#TestEmptyMncFailure - failed to rename configuration file: %s\n", configPath)
678         }
679         defer func() {
680                 err = os.Rename(configPathTmp, configPath)
681                 if err != nil {
682                         t.Errorf("#TestEmptyMncFailure - failed to rename configuration file: %s\n", configPath)
683                 }
684         }()
685         yamlMap := map[string]interface{}{
686                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
687                 "logging":        map[string]interface{}{"logLevel": "info"},
688                 "http":           map[string]interface{}{"port": 3800},
689                 "globalRicId":    map[string]interface{}{"mcc": "111", "mnc": "", "ricId": "AABB3"},
690                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
691         }
692         buf, err := yaml.Marshal(yamlMap)
693         if err != nil {
694                 t.Errorf("#TestEmptyMncFailure - failed to marshal configuration map\n")
695         }
696         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
697         if err != nil {
698                 t.Errorf("#TestEmptyMncFailure - failed to write configuration file: %s\n", configPath)
699         }
700         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is missing or empty\n",
701                 func() { ParseConfiguration() })
702 }
703
704 func TestMissingMncFailure(t *testing.T) {
705         configPath := "../resources/configuration.yaml"
706         configPathTmp := "../resources/configuration.yaml_tmp"
707         err := os.Rename(configPath, configPathTmp)
708         if err != nil {
709                 t.Errorf("#TestMissingMncFailure - failed to rename configuration file: %s\n", configPath)
710         }
711         defer func() {
712                 err = os.Rename(configPathTmp, configPath)
713                 if err != nil {
714                         t.Errorf("#TestMissingMncFailure - failed to rename configuration file: %s\n", configPath)
715                 }
716         }()
717         yamlMap := map[string]interface{}{
718                 "rmr":            map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
719                 "logging":        map[string]interface{}{"logLevel": "info"},
720                 "http":           map[string]interface{}{"port": 3800},
721                 "globalRicId":    map[string]interface{}{"mcc": "111", "ricId": "AABB3"},
722                 "routingManager": map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
723         }
724         buf, err := yaml.Marshal(yamlMap)
725         if err != nil {
726                 t.Errorf("#TestMissingMncFailure - failed to marshal configuration map\n")
727         }
728         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
729         if err != nil {
730                 t.Errorf("#TestMissingMncFailure - failed to write configuration file: %s\n", configPath)
731         }
732         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is missing or empty\n",
733                 func() { ParseConfiguration() })
734 }