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