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, "310", config.GlobalRicId.Mcc)
  45         assert.Equal(t, "411", config.GlobalRicId.Mnc)
  46         assert.Equal(t, "RAN_CONNECTION_STATUS_CHANGE", config.StateChangeMessageChannel)
  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 TestEmptyRicIdFailure(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("#TestEmptyRicIdFailure - 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("#TestEmptyRicIdFailure - 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 "globalRicId":    map[string]interface{}{"mcc": "327", "mnc": "94", "ricId": ""},
 242 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 243 }
 244 buf, err := yaml.Marshal(yamlMap)
 245 if err != nil {
 246 t.Errorf("#TestEmptyRicIdFailure - failed to marshal configuration map\n")
 247 }
 248 err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 249 if err != nil {
 250 t.Errorf("#TestEmptyRicIdFailure - failed to write configuration file: %s\n", configPath)
 251 }
 252 assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is missing or empty\n",
 253 func() { ParseConfiguration() })
 254 }
 255
 256 func TestMissingRicIdFailure(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"},
 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 TestNonHexRicIdFailure(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("#TestNonHexRicIdFailure - 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("#TestNonHexRicIdFailure - 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", "ricId": "TEST1"},
 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("#TestNonHexRicIdFailure - failed to marshal configuration map\n")
 311         }
 312         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 313         if err != nil {
 314                 t.Errorf("#TestNonHexRicIdFailure - failed to write configuration file: %s\n", configPath)
 315         }
 316         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId is not hex number\n",
 317                 func() { ParseConfiguration() })
 318 }
 319
 320 func TestWrongRicIdLengthFailure(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("#TestWrongRicIdLengthFailure - 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("#TestWrongRicIdLengthFailure - 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": "AA43"},
 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("#TestWrongRicIdLengthFailure - failed to marshal configuration map\n")
 343         }
 344         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 345         if err != nil {
 346                 t.Errorf("#TestWrongRicIdLengthFailure - failed to write configuration file: %s\n", configPath)
 347         }
 348         assert.PanicsWithValue(t, "#configuration.validateRicId - ricId length should be 5 hex characters\n",
 349                 func() { ParseConfiguration() })
 350 }
 351
 352 func TestMccNotThreeDigitsFailure(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("#TestMccNotThreeDigitsFailure - 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("#TestMccNotThreeDigitsFailure - 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": "31", "mnc": "94", "ricId": "AA443"},
 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("#TestMccNotThreeDigitsFailure - failed to marshal configuration map\n")
 375         }
 376         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 377         if err != nil {
 378                 t.Errorf("#TestMccNotThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
 379         }
 380         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not 3 digits\n",
 381                 func() { ParseConfiguration() })
 382 }
 383
 384 func TestMncLengthIsGreaterThanThreeDigitsFailure(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("#TestMncLengthIsGreaterThanThreeDigitsFailure - 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("#TestMncLengthIsGreaterThanThreeDigitsFailure - 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": "310", "mnc": "6794", "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("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to marshal configuration map\n")
 407         }
 408         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 409         if err != nil {
 410                 t.Errorf("#TestMncLengthIsGreaterThanThreeDigitsFailure - failed to write configuration file: %s\n", configPath)
 411         }
 412         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not 2 or 3 digits\n",
 413                 func() { ParseConfiguration() })
 414 }
 415
 416 func TestMncLengthIsLessThanTwoDigitsFailure(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("#TestMncLengthIsLessThanTwoDigitsFailure - 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("#TestMncLengthIsLessThanTwoDigitsFailure - 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": "4", "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("#TestMncLengthIsLessThanTwoDigitsFailure - failed to marshal configuration map\n")
 439         }
 440         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 441         if err != nil {
 442                 t.Errorf("#TestMncLengthIsLessThanTwoDigitsFailure - 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 TestNegativeMncFailure(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("#TestNegativeMncFailure - 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("#TestNegativeMncFailure - 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": "-2", "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("#TestNegativeMncFailure - failed to marshal configuration map\n")
 471         }
 472         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 473         if err != nil {
 474                 t.Errorf("#TestNegativeMncFailure - failed to write configuration file: %s\n", configPath)
 475         }
 476         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is negative\n",
 477                 func() { ParseConfiguration() })
 478 }
 479
 480 func TestNegativeMccFailure(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": "-31", "mnc": "222", "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.validateMcc - mcc is negative\n",
 509                 func() { ParseConfiguration() })
 510 }
 511
 512 func TestAlphaNumericMccFailure(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("#TestAlphaNumericMccFailure - 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("#TestAlphaNumericMccFailure - 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": "1W2", "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("#TestAlphaNumericMccFailure - failed to marshal configuration map\n")
 535         }
 536         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 537         if err != nil {
 538                 t.Errorf("#TestAlphaNumericMccFailure - failed to write configuration file: %s\n", configPath)
 539         }
 540         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is not a number\n",
 541                 func() { ParseConfiguration() })
 542 }
 543
 544 func TestAlphaNumericMncFailure(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("#TestAlphaNumericMncFailure - 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("#TestAlphaNumericMncFailure - 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": "111", "mnc": "2A8", "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("#TestAlphaNumericMncFailure - failed to marshal configuration map\n")
 567         }
 568         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 569         if err != nil {
 570                 t.Errorf("#TestAlphaNumericMncFailure - failed to write configuration file: %s\n", configPath)
 571         }
 572         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is not a number\n",
 573                 func() { ParseConfiguration() })
 574 }
 575
 576 func TestMissingMmcFailure(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("#TestMissingMmcFailure - 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("#TestMissingMmcFailure - 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{}{"mnc": "94", "ricId": "AABB3"},
 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("#TestMissingMmcFailure - failed to marshal configuration map\n")
 599         }
 600         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 601         if err != nil {
 602                 t.Errorf("#TestMissingMmcFailure - failed to write configuration file: %s\n", configPath)
 603         }
 604         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is missing or empty\n",
 605                 func() { ParseConfiguration() })
 606 }
 607
 608
 609 func TestEmptyMmcFailure(t *testing.T) {
 610         configPath := "../resources/configuration.yaml"
 611         configPathTmp := "../resources/configuration.yaml_tmp"
 612         err := os.Rename(configPath, configPathTmp)
 613         if err != nil {
 614                 t.Errorf("#TestEmptyMmcFailure - failed to rename configuration file: %s\n", configPath)
 615         }
 616         defer func() {
 617                 err = os.Rename(configPathTmp, configPath)
 618                 if err != nil {
 619                         t.Errorf("#TestEmptyMmcFailure - failed to rename configuration file: %s\n", configPath)
 620                 }
 621         }()
 622         yamlMap := map[string]interface{}{
 623                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 624                 "logging": map[string]interface{}{"logLevel": "info"},
 625                 "http": map[string]interface{}{"port": 3800},
 626                 "globalRicId":    map[string]interface{}{"mcc": "", "mnc": "94", "ricId": "AABB3"},
 627                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 628         }
 629         buf, err := yaml.Marshal(yamlMap)
 630         if err != nil {
 631                 t.Errorf("#TestEmptyMmcFailure - failed to marshal configuration map\n")
 632         }
 633         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 634         if err != nil {
 635                 t.Errorf("#TestEmptyMmcFailure - failed to write configuration file: %s\n", configPath)
 636         }
 637         assert.PanicsWithValue(t, "#configuration.validateMcc - mcc is missing or empty\n",
 638                 func() { ParseConfiguration() })
 639 }
 640
 641 func TestEmptyMncFailure(t *testing.T) {
 642         configPath := "../resources/configuration.yaml"
 643         configPathTmp := "../resources/configuration.yaml_tmp"
 644         err := os.Rename(configPath, configPathTmp)
 645         if err != nil {
 646                 t.Errorf("#TestEmptyMncFailure - failed to rename configuration file: %s\n", configPath)
 647         }
 648         defer func() {
 649                 err = os.Rename(configPathTmp, configPath)
 650                 if err != nil {
 651                         t.Errorf("#TestEmptyMncFailure - failed to rename configuration file: %s\n", configPath)
 652                 }
 653         }()
 654         yamlMap := map[string]interface{}{
 655                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 656                 "logging": map[string]interface{}{"logLevel": "info"},
 657                 "http": map[string]interface{}{"port": 3800},
 658                 "globalRicId":    map[string]interface{}{"mcc": "111", "mnc": "", "ricId": "AABB3"},
 659                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 660         }
 661         buf, err := yaml.Marshal(yamlMap)
 662         if err != nil {
 663                 t.Errorf("#TestEmptyMncFailure - failed to marshal configuration map\n")
 664         }
 665         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 666         if err != nil {
 667                 t.Errorf("#TestEmptyMncFailure - failed to write configuration file: %s\n", configPath)
 668         }
 669         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is missing or empty\n",
 670                 func() { ParseConfiguration() })
 671 }
 672
 673 func TestMissingMncFailure(t *testing.T) {
 674         configPath := "../resources/configuration.yaml"
 675         configPathTmp := "../resources/configuration.yaml_tmp"
 676         err := os.Rename(configPath, configPathTmp)
 677         if err != nil {
 678                 t.Errorf("#TestMissingMncFailure - failed to rename configuration file: %s\n", configPath)
 679         }
 680         defer func() {
 681                 err = os.Rename(configPathTmp, configPath)
 682                 if err != nil {
 683                         t.Errorf("#TestMissingMncFailure - failed to rename configuration file: %s\n", configPath)
 684                 }
 685         }()
 686         yamlMap := map[string]interface{}{
 687                 "rmr":     map[string]interface{}{"port": 3801, "maxMsgSize": 4096},
 688                 "logging": map[string]interface{}{"logLevel": "info"},
 689                 "http": map[string]interface{}{"port": 3800},
 690                 "globalRicId":    map[string]interface{}{"mcc": "111", "ricId": "AABB3"},
 691                 "routingManager":    map[string]interface{}{"baseUrl": "http://localhost:8080/ric/v1/handles/"},
 692         }
 693         buf, err := yaml.Marshal(yamlMap)
 694         if err != nil {
 695                 t.Errorf("#TestMissingMncFailure - failed to marshal configuration map\n")
 696         }
 697         err = ioutil.WriteFile("../resources/configuration.yaml", buf, 0644)
 698         if err != nil {
 699                 t.Errorf("#TestMissingMncFailure - failed to write configuration file: %s\n", configPath)
 700         }
 701         assert.PanicsWithValue(t, "#configuration.validateMnc - mnc is missing or empty\n",
 702                 func() { ParseConfiguration() })
 703 }