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
  21 package configuration
  22
  23 import (
  24         "github.com/stretchr/testify/assert"
  25         "gopkg.in/yaml.v2"
  26         "io/ioutil"
  27         "os"
  28         "testing"
  29 )
  30
  31 func TestParseConfigurationSuccess(t *testing.T) {
  32         config := ParseConfiguration()
  33         assert.Equal(t, 3800, config.Http.Port)
  34         assert.Equal(t, 3801, config.Rmr.Port)
  35         assert.Equal(t, 65536, config.Rmr.MaxMsgSize)
  36         assert.Equal(t, "info", config.Logging.LogLevel)
  37         assert.Equal(t, 100, config.NotificationResponseBuffer)
  38         assert.Equal(t, 5, config.BigRedButtonTimeoutSec)
  39         assert.Equal(t, 4500, config.KeepAliveResponseTimeoutMs)
  40         assert.Equal(t, 1500, config.KeepAliveDelayMs)
  41         assert.Equal(t, 15000, config.E2TInstanceDeletionTimeoutMs)
  42         assert.NotNil(t, config.GlobalRicId)
  43         assert.Equal(t, "AACCE", config.GlobalRicId.RicId)
  44         assert.Equal(t, "026", config.GlobalRicId.Mcc)
  45         assert.Equal(t, "09", config.GlobalRicId.Mnc)
  46 }
  47
  48 func TestStringer(t *testing.T) {
  49         config := ParseConfiguration().String()
  50         assert.NotEmpty(t, config)
  51 }
  52
  53 func TestParseConfigurationFileNotFoundFailure(t *testing.T) {
  54         configPath := "../resources/configuration.yaml"
  55         configPathTmp := "../resources/configuration.yaml_tmp"
  56         err := os.Rename(configPath, configPathTmp)
  57         if err != nil {
  58                 t.Errorf("#TestParseConfigurationFileNotFoundFailure - failed to rename configuration file: %s\n", configPath)
  59         }
  60         defer func() {
  61                 err = os.Rename(configPathTmp, configPath)
  62                 if err != nil {
  63                         t.Errorf("#TestParseConfigurationFileNotFoundFailure - failed to rename configuration file: %s\n", configPath)
  64                 }
  65         }()
  66         assert.Panics(t, func() { ParseConfiguration() })
  67 }
  68
  69 func TestRmrConfigNotFoundFailure(t *testing.T) {
  70         configPath := "../resources/configuration.yaml"
  71         configPathTmp := "../resources/configuration.yaml_tmp"
  72         err := os.Rename(configPath, configPathTmp)
  73         if err != nil {
  74                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
  75         }
  76         defer func() {
  77                 err = os.Rename(configPathTmp, configPath)
  78                 if err != nil {
  79                         t.Errorf("#TestRmrConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
  80                 }
  81         }()
  82         yamlMap := map[string]interface{}{
  83                 "logging": map[string]interface{}{"logLevel": "info"},
  84                 "http":    map[string]interface{}{"port": 3800},
  85                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
  86                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
  87         }
  88         buf, err := yaml.Marshal(yamlMap)
  89         if err != nil {
  90                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to marshal configuration map\n")
  91         }
  92         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
  93         if err != nil {
  94                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
  95         }
  96         assert.PanicsWithValue(t, "#configuration.populateRmrConfig - failed to populate RMR configuration: The entry 'rmr' not found\n", func() { ParseConfiguration() })
  97 }
  98
  99 func TestLoggingConfigNotFoundFailure(t *testing.T) {
 100         configPath := "../resources/configuration.yaml"
 101         configPathTmp := "../resources/configuration.yaml_tmp"
 102         err := os.Rename(configPath, configPathTmp)
 103         if err != nil {
 104                 t.Errorf("#TestLoggingConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 105         }
 106         defer func() {
 107                 err = os.Rename(configPathTmp, configPath)
 108                 if err != nil {
 109                         t.Errorf("#TestLoggingConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 110                 }
 111         }()
 112         yamlMap := map[string]interface{}{
 113                 "rmr":  map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 114                 "http": map[string]interface{}{"port": 3800},
 115                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 116                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
 117         }
 118         buf, err := yaml.Marshal(yamlMap)
 119         if err != nil {
 120                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to marshal configuration map\n")
 121         }
 122         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 123         if err != nil {
 124                 t.Errorf("#TestRmrConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
 125         }
 126         assert.PanicsWithValue(t, "#configuration.populateLoggingConfig - failed to populate logging configuration: The entry 'logging' not found\n",
 127                 func() { ParseConfiguration() })
 128 }
 129
 130 func TestHttpConfigNotFoundFailure(t *testing.T) {
 131         configPath := "../resources/configuration.yaml"
 132         configPathTmp := "../resources/configuration.yaml_tmp"
 133         err := os.Rename(configPath, configPathTmp)
 134         if err != nil {
 135                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 136         }
 137         defer func() {
 138                 err = os.Rename(configPathTmp, configPath)
 139                 if err != nil {
 140                         t.Errorf("#TestHttpConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 141                 }
 142         }()
 143         yamlMap := map[string]interface{}{
 144                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 145                 "logging": map[string]interface{}{"logLevel": "info"},
 146                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 147                 "globalRicId":    map[string]interface{}{"plmnId": "131014", "ricNearRtId": "556670"},
 148         }
 149         buf, err := yaml.Marshal(yamlMap)
 150         if err != nil {
 151                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to marshal configuration map\n")
 152         }
 153         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 154         if err != nil {
 155                 t.Errorf("#TestHttpConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
 156         }
 157         assert.PanicsWithValue(t, "#configuration.populateHttpConfig - failed to populate HTTP configuration: The entry 'http' not found\n",
 158                 func() { ParseConfiguration() })
 159 }
 160
 161 func TestRoutingManagerConfigNotFoundFailure(t *testing.T) {
 162         configPath := "../resources/configuration.yaml"
 163         configPathTmp := "../resources/configuration.yaml_tmp"
 164         err := os.Rename(configPath, configPathTmp)
 165         if err != nil {
 166                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 167         }
 168         defer func() {
 169                 err = os.Rename(configPathTmp, configPath)
 170                 if err != nil {
 171                         t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 172                 }
 173         }()
 174         yamlMap := map[string]interface{}{
 175                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 176                 "logging": map[string]interface{}{"logLevel": "info"},
 177                 "http": map[string]interface{}{"port": 3800},
 178                 "globalRicId":    map[string]interface{}{"mcc": 327, "mnc": 94, "ricId": "AACCE"},
 179         }
 180         buf, err := yaml.Marshal(yamlMap)
 181         if err != nil {
 182                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to marshal configuration map\n")
 183         }
 184         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 185         if err != nil {
 186                 t.Errorf("#TestRoutingManagerConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
 187         }
 188         assert.PanicsWithValue(t, "#configuration.populateRoutingManagerConfig - failed to populate Routing Manager configuration: The entry 'routingManager' not found\n",
 189                 func() { ParseConfiguration() })
 190 }
 191
 192 func TestGlobalRicIdConfigNotFoundFailure(t *testing.T) {
 193         configPath := "../resources/configuration.yaml"
 194         configPathTmp := "../resources/configuration.yaml_tmp"
 195         err := os.Rename(configPath, configPathTmp)
 196         if err != nil {
 197                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 198         }
 199         defer func() {
 200                 err = os.Rename(configPathTmp, configPath)
 201                 if err != nil {
 202                         t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to rename configuration file: %s\n", configPath)
 203                 }
 204         }()
 205         yamlMap := map[string]interface{}{
 206                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 207                 "logging": map[string]interface{}{"logLevel": "info"},
 208                 "http": map[string]interface{}{"port": 3800},
 209                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 210         }
 211         buf, err := yaml.Marshal(yamlMap)
 212         if err != nil {
 213                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to marshal configuration map\n")
 214         }
 215         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 216         if err != nil {
 217                 t.Errorf("#TestGlobalRicIdConfigNotFoundFailure - failed to write configuration file: %s\n", configPath)
 218         }
 219         assert.PanicsWithValue(t, "#configuration.validateGlobalRicIdConfig - failed to populate Global RicId configuration: The entry 'globalRicId' not found\n",
 220                 func() { ParseConfiguration() })
 221 }
 222
 223 func TestEmptyRicIdFailure(t *testing.T) {
 224 configPath := "../resources/configuration.yaml"
 225 configPathTmp := "../resources/configuration.yaml_tmp"
 226 err := os.Rename(configPath, configPathTmp)
 227 if err != nil {
 228 t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
 229 }
 230 defer func() {
 231 err = os.Rename(configPathTmp, configPath)
 232 if err != nil {
 233 t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
 234 }
 235 }()
 236 yamlMap := map[string]interface{}{
 237 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 238 "logging": map[string]interface{}{"logLevel": "info"},
 239 "http": map[string]interface{}{"port": 3800},
 240 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": ""},
 241 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 242 }
 243 buf, err := yaml.Marshal(yamlMap)
 244 if err != nil {
 245 t.Errorf("#TestEmptyRicIdFailure - failed to marshal configuration map\n")
 246 }
 247 err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 248 if err != nil {
 249 t.Errorf("#TestEmptyRicIdFailure - failed to write configuration file: %s\n", configPath)
 250 }
 251 assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is emtpy or missing\n",
 252 func() { ParseConfiguration() })
 253 }
 254
 255 func TestMissingRicIdFailure(t *testing.T) {
 256         configPath := "../resources/configuration.yaml"
 257         configPathTmp := "../resources/configuration.yaml_tmp"
 258         err := os.Rename(configPath, configPathTmp)
 259         if err != nil {
 260                 t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
 261         }
 262         defer func() {
 263                 err = os.Rename(configPathTmp, configPath)
 264                 if err != nil {
 265                         t.Errorf("#TestEmptyRicIdFailure - failed to rename configuration file: %s\n", configPath)
 266                 }
 267         }()
 268         yamlMap := map[string]interface{}{
 269                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 270                 "logging": map[string]interface{}{"logLevel": "info"},
 271                 "http": map[string]interface{}{"port": 3800},
 272                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94"},
 273                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 274         }
 275         buf, err := yaml.Marshal(yamlMap)
 276         if err != nil {
 277                 t.Errorf("#TestEmptyRicIdFailure - failed to marshal configuration map\n")
 278         }
 279         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 280         if err != nil {
 281                 t.Errorf("#TestEmptyRicIdFailure - failed to write configuration file: %s\n", configPath)
 282         }
 283         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is emtpy or missing\n",
 284                 func() { ParseConfiguration() })
 285 }
 286
 287 func TestNonHexRicIdFailure(t *testing.T) {
 288         configPath := "../resources/configuration.yaml"
 289         configPathTmp := "../resources/configuration.yaml_tmp"
 290         err := os.Rename(configPath, configPathTmp)
 291         if err != nil {
 292                 t.Errorf("#TestNonHexRicIdFailure - failed to rename configuration file: %s\n", configPath)
 293         }
 294         defer func() {
 295                 err = os.Rename(configPathTmp, configPath)
 296                 if err != nil {
 297                         t.Errorf("#TestNonHexRicIdFailure - failed to rename configuration file: %s\n", configPath)
 298                 }
 299         }()
 300         yamlMap := map[string]interface{}{
 301                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 302                 "logging": map[string]interface{}{"logLevel": "info"},
 303                 "http": map[string]interface{}{"port": 3800},
 304                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": "TEST1"},
 305                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 306         }
 307         buf, err := yaml.Marshal(yamlMap)
 308         if err != nil {
 309                 t.Errorf("#TestNonHexRicIdFailure - failed to marshal configuration map\n")
 310         }
 311         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 312         if err != nil {
 313                 t.Errorf("#TestNonHexRicIdFailure - failed to write configuration file: %s\n", configPath)
 314         }
 315         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is not hex number\n",
 316                 func() { ParseConfiguration() })
 317 }
 318
 319 func TestWrongRicIdLengthFailure(t *testing.T) {
 320         configPath := "../resources/configuration.yaml"
 321         configPathTmp := "../resources/configuration.yaml_tmp"
 322         err := os.Rename(configPath, configPathTmp)
 323         if err != nil {
 324                 t.Errorf("#TestWrongRicIdLengthFailure - failed to rename configuration file: %s\n", configPath)
 325         }
 326         defer func() {
 327                 err = os.Rename(configPathTmp, configPath)
 328                 if err != nil {
 329                         t.Errorf("#TestWrongRicIdLengthFailure - failed to rename configuration file: %s\n", configPath)
 330                 }
 331         }()
 332         yamlMap := map[string]interface{}{
 333                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 334                 "logging": map[string]interface{}{"logLevel": "info"},
 335                 "http": map[string]interface{}{"port": 3800},
 336                 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": "AA43"},
 337                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 338         }
 339         buf, err := yaml.Marshal(yamlMap)
 340         if err != nil {
 341                 t.Errorf("#TestWrongRicIdLengthFailure - failed to marshal configuration map\n")
 342         }
 343         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 344         if err != nil {
 345                 t.Errorf("#TestWrongRicIdLengthFailure - failed to write configuration file: %s\n", configPath)
 346         }
 347         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId length should be 5 hex characters\n",
 348                 func() { ParseConfiguration() })
 349 }
 350
 351 func TestMccNotThreeDigitsFailure(t *testing.T) {
 352         configPath := "../resources/configuration.yaml"
 353         configPathTmp := "../resources/configuration.yaml_tmp"
 354         err := os.Rename(configPath, configPathTmp)
 355         if err != nil {
 356                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
 357         }
 358         defer func() {
 359                 err = os.Rename(configPathTmp, configPath)
 360                 if err != nil {
 361                         t.Errorf("#TestMccNotThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
 362                 }
 363         }()
 364         yamlMap := map[string]interface{}{
 365                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 366                 "logging": map[string]interface{}{"logLevel": "info"},
 367                 "http": map[string]interface{}{"port": 3800},
 368                 "globalRicId":    map[string]interface{}{"mcc": "31", "mnc": "94", "ricId": "AA443"},
 369                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 370         }
 371         buf, err := yaml.Marshal(yamlMap)
 372         if err != nil {
 373                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to marshal configuration map\n")
 374         }
 375         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 376         if err != nil {
 377                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
 378         }
 379         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not 3 digits\n",
 380                 func() { ParseConfiguration() })
 381 }
 382
 383 func TestMncLengthIsGreaterThanThreeDigitsFailure(t *testing.T) {
 384         configPath := "../resources/configuration.yaml"
 385         configPathTmp := "../resources/configuration.yaml_tmp"
 386         err := os.Rename(configPath, configPathTmp)
 387         if err != nil {
 388                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
 389         }
 390         defer func() {
 391                 err = os.Rename(configPathTmp, configPath)
 392                 if err != nil {
 393                         t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to rename configuration file: %s\n", configPath)
 394                 }
 395         }()
 396         yamlMap := map[string]interface{}{
 397                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 398                 "logging": map[string]interface{}{"logLevel": "info"},
 399                 "http": map[string]interface{}{"port": 3800},
 400                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "6794", "ricId": "AA443"},
 401                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 402         }
 403         buf, err := yaml.Marshal(yamlMap)
 404         if err != nil {
 405                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to marshal configuration map\n")
 406         }
 407         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 408         if err != nil {
 409                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
 410         }
 411         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not 2 or 3 digits\n",
 412                 func() { ParseConfiguration() })
 413 }
 414
 415 func TestMncLengthIsLessThanTwoDigitsFailure(t *testing.T) {
 416         configPath := "../resources/configuration.yaml"
 417         configPathTmp := "../resources/configuration.yaml_tmp"
 418         err := os.Rename(configPath, configPathTmp)
 419         if err != nil {
 420                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to rename configuration file: %s\n", configPath)
 421         }
 422         defer func() {
 423                 err = os.Rename(configPathTmp, configPath)
 424                 if err != nil {
 425                         t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to rename configuration file: %s\n", configPath)
 426                 }
 427         }()
 428         yamlMap := map[string]interface{}{
 429                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 430                 "logging": map[string]interface{}{"logLevel": "info"},
 431                 "http": map[string]interface{}{"port": 3800},
 432                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "4", "ricId": "AA443"},
 433                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 434         }
 435         buf, err := yaml.Marshal(yamlMap)
 436         if err != nil {
 437                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to marshal configuration map\n")
 438         }
 439         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 440         if err != nil {
 441                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - failed to write configuration file: %s\n", configPath)
 442         }
 443         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not 2 or 3 digits\n",
 444                 func() { ParseConfiguration() })
 445 }
 446
 447 func TestNegativeMncFailure(t *testing.T) {
 448         configPath := "../resources/configuration.yaml"
 449         configPathTmp := "../resources/configuration.yaml_tmp"
 450         err := os.Rename(configPath, configPathTmp)
 451         if err != nil {
 452                 t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
 453         }
 454         defer func() {
 455                 err = os.Rename(configPathTmp, configPath)
 456                 if err != nil {
 457                         t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
 458                 }
 459         }()
 460         yamlMap := map[string]interface{}{
 461                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 462                 "logging": map[string]interface{}{"logLevel": "info"},
 463                 "http": map[string]interface{}{"port": 3800},
 464                 "globalRicId":    map[string]interface{}{"mcc": "310", "mnc": "-2", "ricId": "AA443"},
 465                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 466         }
 467         buf, err := yaml.Marshal(yamlMap)
 468         if err != nil {
 469                 t.Errorf("#TestNegativeMncFailure - failed to marshal configuration map\n")
 470         }
 471         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 472         if err != nil {
 473                 t.Errorf("#TestNegativeMncFailure - failed to write configuration file: %s\n", configPath)
 474         }
 475         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is negative\n",
 476                 func() { ParseConfiguration() })
 477 }
 478
 479 func TestNegativeMccFailure(t *testing.T) {
 480         configPath := "../resources/configuration.yaml"
 481         configPathTmp := "../resources/configuration.yaml_tmp"
 482         err := os.Rename(configPath, configPathTmp)
 483         if err != nil {
 484                 t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
 485         }
 486         defer func() {
 487                 err = os.Rename(configPathTmp, configPath)
 488                 if err != nil {
 489                         t.Errorf("#TestNegativeMncFailure - failed to rename configuration file: %s\n", configPath)
 490                 }
 491         }()
 492         yamlMap := map[string]interface{}{
 493                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 494                 "logging": map[string]interface{}{"logLevel": "info"},
 495                 "http": map[string]interface{}{"port": 3800},
 496                 "globalRicId":    map[string]interface{}{"mcc": "-31", "mnc": "222", "ricId": "AA443"},
 497                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 498         }
 499         buf, err := yaml.Marshal(yamlMap)
 500         if err != nil {
 501                 t.Errorf("#TestNegativeMncFailure - failed to marshal configuration map\n")
 502         }
 503         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 504         if err != nil {
 505                 t.Errorf("#TestNegativeMncFailure - failed to write configuration file: %s\n", configPath)
 506         }
 507         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is negative\n",
 508                 func() { ParseConfiguration() })
 509 }
 510
 511 func TestAlphaNumericMccFailure(t *testing.T) {
 512         configPath := "../resources/configuration.yaml"
 513         configPathTmp := "../resources/configuration.yaml_tmp"
 514         err := os.Rename(configPath, configPathTmp)
 515         if err != nil {
 516                 t.Errorf("#TestAlphaNumericMccFailure - failed to rename configuration file: %s\n", configPath)
 517         }
 518         defer func() {
 519                 err = os.Rename(configPathTmp, configPath)
 520                 if err != nil {
 521                         t.Errorf("#TestAlphaNumericMccFailure - failed to rename configuration file: %s\n", configPath)
 522                 }
 523         }()
 524         yamlMap := map[string]interface{}{
 525                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 526                 "logging": map[string]interface{}{"logLevel": "info"},
 527                 "http": map[string]interface{}{"port": 3800},
 528                 "globalRicId":    map[string]interface{}{"mcc": "1W2", "mnc": "222", "ricId": "AA443"},
 529                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 530         }
 531         buf, err := yaml.Marshal(yamlMap)
 532         if err != nil {
 533                 t.Errorf("#TestAlphaNumericMccFailure - failed to marshal configuration map\n")
 534         }
 535         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 536         if err != nil {
 537                 t.Errorf("#TestAlphaNumericMccFailure - failed to write configuration file: %s\n", configPath)
 538         }
 539         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not a number\n",
 540                 func() { ParseConfiguration() })
 541 }
 542
 543 func TestAlphaNumericMncFailure(t *testing.T) {
 544         configPath := "../resources/configuration.yaml"
 545         configPathTmp := "../resources/configuration.yaml_tmp"
 546         err := os.Rename(configPath, configPathTmp)
 547         if err != nil {
 548                 t.Errorf("#TestAlphaNumericMncFailure - failed to rename configuration file: %s\n", configPath)
 549         }
 550         defer func() {
 551                 err = os.Rename(configPathTmp, configPath)
 552                 if err != nil {
 553                         t.Errorf("#TestAlphaNumericMncFailure - failed to rename configuration file: %s\n", configPath)
 554                 }
 555         }()
 556         yamlMap := map[string]interface{}{
 557                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 558                 "logging": map[string]interface{}{"logLevel": "info"},
 559                 "http": map[string]interface{}{"port": 3800},
 560                 "globalRicId":    map[string]interface{}{"mcc": "111", "mnc": "2A8", "ricId": "AA443"},
 561                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 562         }
 563         buf, err := yaml.Marshal(yamlMap)
 564         if err != nil {
 565                 t.Errorf("#TestAlphaNumericMncFailure - failed to marshal configuration map\n")
 566         }
 567         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 568         if err != nil {
 569                 t.Errorf("#TestAlphaNumericMncFailure - failed to write configuration file: %s\n", configPath)
 570         }
 571         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not a number\n",
 572                 func() { ParseConfiguration() })
 573 }
 574
 575 func TestMissingMmcFailure(t *testing.T) {
 576         configPath := "../resources/configuration.yaml"
 577         configPathTmp := "../resources/configuration.yaml_tmp"
 578         err := os.Rename(configPath, configPathTmp)
 579         if err != nil {
 580                 t.Errorf("#TestMissingMmcFailure - failed to rename configuration file: %s\n", configPath)
 581         }
 582         defer func() {
 583                 err = os.Rename(configPathTmp, configPath)
 584                 if err != nil {
 585                         t.Errorf("#TestMissingMmcFailure - failed to rename configuration file: %s\n", configPath)
 586                 }
 587         }()
 588         yamlMap := map[string]interface{}{
 589                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 590                 "logging": map[string]interface{}{"logLevel": "info"},
 591                 "http": map[string]interface{}{"port": 3800},
 592                 "globalRicId":    map[string]interface{}{"mnc": "94", "ricId": "AABB3"},
 593                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 594         }
 595         buf, err := yaml.Marshal(yamlMap)
 596         if err != nil {
 597                 t.Errorf("#TestMissingMmcFailure - failed to marshal configuration map\n")
 598         }
 599         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 600         if err != nil {
 601                 t.Errorf("#TestMissingMmcFailure - failed to write configuration file: %s\n", configPath)
 602         }
 603         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is emtpy or missing\n",
 604                 func() { ParseConfiguration() })
 605 }
 606
 607
 608 func TestEmptyMmcFailure(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("#TestEmptyMmcFailure - 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("#TestEmptyMmcFailure - 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{}{"mcc": "", "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("#TestEmptyMmcFailure - failed to marshal configuration map\n")
 631         }
 632         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 633         if err != nil {
 634                 t.Errorf("#TestEmptyMmcFailure - failed to write configuration file: %s\n", configPath)
 635         }
 636         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is emtpy or missing\n",
 637                 func() { ParseConfiguration() })
 638 }
 639
 640 func TestEmptyMncFailure(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("#TestEmptyMncFailure - 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("#TestEmptyMncFailure - 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": "111", "mnc": "", "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("#TestEmptyMncFailure - failed to marshal configuration map\n")
 663         }
 664         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 665         if err != nil {
 666                 t.Errorf("#TestEmptyMncFailure - failed to write configuration file: %s\n", configPath)
 667         }
 668         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is emtpy or missing\n",
 669                 func() { ParseConfiguration() })
 670 }
 671
 672 func TestMissingMncFailure(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("#TestMissingMncFailure - 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("#TestMissingMncFailure - 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", "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("#TestMissingMncFailure - failed to marshal configuration map\n")
 695         }
 696         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 697         if err != nil {
 698                 t.Errorf("#TestMissingMncFailure - failed to write configuration file: %s\n", configPath)
 699         }
 700         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is emtpy or missing\n",
 701                 func() { ParseConfiguration() })
 702 }