pkg/nbi/httprestful_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17
  18
  19    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20    platform project (RICP).
  21
  22 ==================================================================================
  23 */
  24 /*
  25   Mnemonic:     httprestful_test.go
  26   Abstract:     HTTPRestful unit tests
  27   Date:         15 May 2019
  28 */
  29
  30 package nbi
  31
  32 import (
  33         "encoding/json"
  34         "fmt"
  35         "io/ioutil"
  36         "net"
  37         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  38         "net/http"
  39         "net/http/httptest"
  40         "os"
  41         "routing-manager/pkg/models"
  42         "routing-manager/pkg/rpe"
  43         "routing-manager/pkg/rtmgr"
  44         "routing-manager/pkg/sdl"
  45         "routing-manager/pkg/sbi"
  46         "routing-manager/pkg/stub"
  47         "testing"
  48         "sync"
  49         "github.com/go-openapi/swag"
  50         "github.com/spf13/viper"
  51         "time"
  52 )
  53
  54 var BasicXAppLists = []byte(`[
  55  {
  56  "name":"xapp-01","status":"unknown","version":"1.2.3",
  57     "instances":[
  58         {"name":"xapp-01-instance-01","status":"pending","ip":"172.16.1.103","port":4555,
  59             "txMessages":["ControlIndication"],
  60             "rxMessages":["LoadIndication","Reset"]
  61         },
  62         {"name":"xapp-01-instance-02","status":"pending","ip":"10.244.1.12","port":4561,
  63             "txMessages":["ControlIndication","SNStatusTransfer"],
  64             "rxMessages":["LoadIndication","HandoverPreparation"]
  65         }
  66     ]
  67 }
  68 ]`)
  69
  70 var SubscriptionResp = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
  71
  72 var E2TListResp = []byte(`[{"e2tAddress":"127.0.0.1:0","ranNames":["RanM0","RanN0"]},{"e2tAddress":"127.0.0.1:1","ranNames":["RanM1","RanN1"]},{"e2tAddress":"127.0.0.1:2","ranNames":["RanM2","RanN2"]},{"e2tAddress":"127.0.0.1:3","ranNames":["RanM3","RanN3"]}]`)
  73
  74 var SubscriptionList = []byte(`[{"SubscriptionId":11,"Meid":"Test-Gnb","Endpoint":["127.0.0.1:4056"]}]`)
  75
  76 var InvalidSubResp = []byte(`{"Version":0, "EventType":all}`)
  77
  78 type Consumer struct{}
  79
  80 func (m Consumer) Consume(params *xapp.RMRParams) (err error) {
  81         xapp.Sdl.Store("myKey", params.Payload)
  82         return nil
  83 }
  84
  85 // Test cases
  86 func TestMain(m *testing.M) {
  87         go xapp.RunWithParams(Consumer{}, viper.GetBool("db.waitForSdl"))
  88         time.Sleep(time.Duration(5) * time.Second)
  89         code := m.Run()
  90         os.Exit(code)
  91 }
  92
  93
  94 func TestValidateXappCallbackData_1(t *testing.T) {
  95         data := models.XappCallbackData{
  96                 XApps:   *swag.String("[]"),
  97                 Version: *swag.Int64(1),
  98                 Event:   *swag.String("someevent"),
  99                 ID:      *swag.String("123456")}
 100
 101         err := validateXappCallbackData(&data)
 102         if err != nil {
 103                 t.Error("Invalid XApp callback data: " + err.Error())
 104         }
 105 }
 106
 107 func TestValidateXappCallbackDataInvalid (t *testing.T) {
 108         data := models.XappCallbackData{}
 109         err := validateXappCallbackData(&data)
 110         t.Log(err)
 111 }
 112
 113
 114 func TestValidateXappSubscriptionsData(t *testing.T) {
 115
 116         ep := make(map[string]*rtmgr.Endpoint)
 117         ep["dummy"] = &rtmgr.Endpoint{Uuid: "10.0.0.1:0", Name: "E2TERM", XAppType: "app1", Ip: "", Port: 0, TxMessages: []string{"", ""}, RxMessages: []string{"", ""}, Socket: nil, IsReady: true, Keepalive: true}
 118         p := uint16(1234)
 119         data := models.XappSubscriptionData{
 120                 Address:        swag.String("10.1.1.1"),
 121                 Port:           &p,
 122                 SubscriptionID: swag.Int32(123456)}
 123
 124         var err error
 125         err = validateXappSubscriptionData(&data)
 126         t.Log(err)
 127
 128         rtmgr.Eps = ep
 129         p = uint16(0)
 130         data1 := models.XappSubscriptionData{
 131                 Address:        swag.String(""),
 132                 Port:           &p,
 133                 SubscriptionID: swag.Int32(123456)}
 134         err = validateXappSubscriptionData(&data1)
 135
 136         //Validate E2tData
 137         data2 := models.E2tData{
 138                 E2TAddress: swag.String(""),
 139         }
 140         /*err = validateE2tData(&data2)*/
 141
 142         //e2tchannel := make(chan *models.E2tData, 10)
 143         _ = createNewE2tHandleHandlerImpl(&data2)
 144         //defer close(e2tchannel)
 145
 146         //test case for provideXappSubscriptionHandleImp
 147         //datachannel := make(chan *models.XappSubscriptionData, 10)
 148         sdlEngine, _ = sdl.GetSdl("file")
 149         sbiEngine, _ =  sbi.GetSbi("rmrpush")
 150         rpeEngine, _ = rpe.GetRpe ("rmrpush")
 151         _ = provideXappSubscriptionHandleImpl( &data1)
 152         //defer close(datachannel)
 153
 154         //test case for deleteXappSubscriptionHandleImpl
 155         _ = deleteXappSubscriptionHandleImpl(&data1)
 156
 157         data3 := models.XappSubscriptionData{
 158                 Address:        swag.String("10.55.55.5"),
 159                 Port:           &p,
 160                 SubscriptionID: swag.Int32(123456)}
 161         //test case for deleteXappSubscriptionHandleImpl
 162         _ = deleteXappSubscriptionHandleImpl(&data3)
 163         data4 := models.XappSubscriptionData{
 164                 Address:        swag.String("1.5.5.5"),
 165                 Port:           &p,
 166                 SubscriptionID: swag.Int32(1236)}
 167         _ = deleteXappSubscriptionHandleImpl(&data4)
 168
 169 }
 170
 171 func TestValidateE2tDataEmpty(t *testing.T) {
 172         data := models.E2tData{
 173                 E2TAddress: swag.String(""),
 174         }
 175         err := validateE2tData(&data)
 176         t.Log(err)
 177 }
 178
 179 func TestValidateE2tDataDNSLookUPfails(t *testing.T) {
 180         data := models.E2tData{
 181                 E2TAddress: swag.String("e2t.1com:1234"),
 182         }
 183         err := validateE2tData(&data)
 184         t.Log(err)
 185 }
 186
 187 func TestValidateE2tDataInvalid(t *testing.T) {
 188         data := models.E2tData{
 189                 E2TAddress: swag.String("10.101.01.1"),
 190         }
 191         err := validateE2tData(&data)
 192         t.Log(err)
 193 }
 194
 195 func TestValidateE2tDatavalid(t *testing.T) {
 196         data := models.E2tData{
 197                 E2TAddress: swag.String("10.101.01.1:8098"),
 198         }
 199
 200
 201         err := validateE2tData(&data)
 202         t.Log(err)
 203
 204         _ = createNewE2tHandleHandlerImpl(&data)
 205
 206 }
 207
 208 func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
 209         data := models.E2tData{
 210                 E2TAddress: swag.String("10.101.01.1:8098"),
 211         }
 212
 213         // insert endpoint for testing purpose
 214         uuid := "10.101.01.1:8098"
 215         ep := &rtmgr.Endpoint{
 216                 Uuid:       uuid,
 217         }
 218         rtmgr.Eps[uuid] = ep
 219
 220         err := validateE2tData(&data)
 221         t.Log(err)
 222
 223         // delete endpoint for at end of test case
 224     delete(rtmgr.Eps, uuid);
 225
 226 }
 227
 228
 229 func TestValidateDeleteE2tData(t *testing.T) {
 230
 231 // test-1
 232         data := models.E2tDeleteData{
 233                 E2TAddress: swag.String(""),
 234         }
 235
 236         err := validateDeleteE2tData(&data)
 237         if (err.Error() != "E2TAddress is empty!!!") {
 238                 t.Log(err)
 239         }
 240
 241
 242 // test-2
 243         data = models.E2tDeleteData{
 244                 E2TAddress: swag.String("10.101.01.1:8098"),
 245         }
 246
 247         err = validateDeleteE2tData(&data)
 248         if (err != nil ) {
 249                 t.Log(err)
 250         }
 251
 252 // test-3
 253 //################ Create End Point dummy entry
 254         uuid := "10.101.01.1:8098"
 255         ep := &rtmgr.Endpoint{
 256                 Uuid:       uuid,
 257         }
 258         rtmgr.Eps[uuid] = ep
 259 //#####################
 260
 261         data = models.E2tDeleteData{
 262                 E2TAddress: swag.String("10.101.01.1:8098"),
 263                 RanAssocList: models.RanE2tMap{
 264                         {E2TAddress: swag.String("10.101.01.1:8098")},
 265                 },
 266         }
 267
 268         err = validateDeleteE2tData(&data)
 269         if (err != nil ) {
 270                 t.Log(err)
 271         }
 272
 273         // delete endpoint for at end of test case
 274 //################ Delete End Point dummy entry
 275     delete(rtmgr.Eps, uuid);
 276 //#####################
 277
 278 // test-4
 279
 280 //################ Create End Point dummy entry
 281         uuid = "10.101.01.1:9991"
 282         ep = &rtmgr.Endpoint{
 283                 Uuid:       uuid,
 284         }
 285         rtmgr.Eps[uuid] = ep
 286
 287         uuid = "10.101.01.1:9992"
 288         ep = &rtmgr.Endpoint{
 289                 Uuid:       uuid,
 290         }
 291         rtmgr.Eps[uuid] = ep
 292 //#####################
 293
 294         data = models.E2tDeleteData{
 295                 E2TAddress: swag.String("10.101.01:8098"),
 296                 RanAssocList: models.RanE2tMap{
 297                         {E2TAddress: swag.String("10.101.01.1:9991")},
 298                         {E2TAddress: swag.String("10.101.01.1:9992")},
 299                 },
 300         }
 301
 302         err = validateDeleteE2tData(&data)
 303         if (err != nil ) {
 304                 t.Log(err)
 305         }
 306 //################ Delete End Point dummy entry
 307     delete(rtmgr.Eps, "10.101.01.1:9991")
 308     delete(rtmgr.Eps, "10.101.01.1:9992")
 309 //#####################
 310
 311 // test-5
 312
 313         data = models.E2tDeleteData{
 314                 E2TAddress: swag.String("10.101.01:8098"),
 315                 RanAssocList: models.RanE2tMap{
 316                         {E2TAddress: swag.String("10.101.01.19991")},
 317                 },
 318         }
 319
 320         err = validateDeleteE2tData(&data)
 321         if ( err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991") {
 322                 t.Log(err)
 323         }
 324 }
 325
 326
 327 func TestValidateE2TAddressRANListData(t *testing.T) {
 328
 329         data := models.RanE2tMap{
 330                                 {
 331                                         E2TAddress: swag.String(""),
 332                         },
 333         }
 334         err := validateE2TAddressRANListData(data)
 335         if (err != nil ) {
 336                 t.Log(err)
 337         }
 338
 339         data = models.RanE2tMap{
 340                                 {
 341                                         E2TAddress: swag.String("10.101.01.1:8098"),
 342                         },
 343         }
 344         err = validateE2TAddressRANListData(data)
 345         if (err != nil ) {
 346                 t.Log(err)
 347         }
 348
 349 }
 350
 351 func TestAssociateRanToE2THandlerImpl(t *testing.T) {
 352
 353         data := models.RanE2tMap{
 354                                 {
 355                                         E2TAddress: swag.String("10.101.01.1:8098"),
 356                         },
 357         }
 358         err := associateRanToE2THandlerImpl( data)
 359         if (err != nil ) {
 360                 t.Log(err)
 361         }
 362
 363 //################ Create End Point dummy entry
 364         uuid := "10.101.01.1:8098"
 365         ep := &rtmgr.Endpoint{
 366                 Uuid:       uuid,
 367         }
 368         rtmgr.Eps[uuid] = ep
 369 //#####################
 370
 371         data = models.RanE2tMap{
 372                                 {
 373                                         E2TAddress: swag.String("10.101.01.1:8098"),
 374                         },
 375         }
 376         err = associateRanToE2THandlerImpl(data)
 377         if (err != nil ) {
 378                 t.Log(err)
 379         }
 380
 381 //################ Delete End Point dummy entry
 382     delete(rtmgr.Eps, uuid);
 383 //#####################
 384 }
 385
 386 func TestDisassociateRanToE2THandlerImpl(t *testing.T) {
 387
 388
 389         data := models.RanE2tMap{
 390                                 {
 391                                         E2TAddress: swag.String("10.101.01.1:8098"),
 392                         },
 393         }
 394         err := disassociateRanToE2THandlerImpl(data)
 395         if (err != nil ) {
 396                 t.Log(err)
 397         }
 398 //################ Create End Point dummy entry
 399         uuid := "10.101.01.1:8098"
 400         ep := &rtmgr.Endpoint{
 401                 Uuid:       uuid,
 402         }
 403         rtmgr.Eps[uuid] = ep
 404 //#####################
 405
 406         data = models.RanE2tMap{
 407                                 {
 408                                         E2TAddress: swag.String("10.101.01.1:8098"),
 409                         },
 410         }
 411         err = disassociateRanToE2THandlerImpl(data)
 412         if (err != nil ) {
 413                 t.Log(err)
 414         }
 415
 416 //################ Delete End Point dummy entry
 417     delete(rtmgr.Eps, uuid);
 418 //#####################
 419 }
 420
 421 func TestDeleteE2tHandleHandlerImpl(t *testing.T) {
 422
 423         data := models.E2tDeleteData{
 424                 E2TAddress: swag.String(""),
 425         }
 426         err := deleteE2tHandleHandlerImpl(&data)
 427         if (err != nil ) {
 428                 t.Log(err)
 429         }
 430
 431 //################ Create End Point dummy entry
 432         uuid := "10.101.01.1:8098"
 433         ep := &rtmgr.Endpoint{
 434                 Uuid:       uuid,
 435         }
 436         rtmgr.Eps[uuid] = ep
 437 //#####################
 438
 439         data = models.E2tDeleteData{
 440                 E2TAddress: swag.String("10.101.01.1:8098"),
 441         }
 442         err = deleteE2tHandleHandlerImpl(&data)
 443         if (err != nil ) {
 444                 t.Log(err)
 445         }
 446 //################ Delete End Point dummy entry
 447     delete(rtmgr.Eps, uuid);
 448 //#####################
 449 }
 450
 451 func TestSubscriptionExists(t *testing.T) {
 452         p := uint16(0)
 453         data := models.XappSubscriptionData{
 454                 Address:        swag.String("10.0.0.0"),
 455                 Port:           &p,
 456                 SubscriptionID: swag.Int32(1234)}
 457
 458         rtmgr.Subs = *stub.ValidSubscriptions
 459
 460         yes_no := subscriptionExists(&data)
 461         yes_no = addSubscription(&rtmgr.Subs, &data)
 462         yes_no = addSubscription(&rtmgr.Subs, &data)
 463         yes_no = delSubscription(&rtmgr.Subs, &data)
 464         yes_no = delSubscription(&rtmgr.Subs, &data)
 465         t.Log(yes_no)
 466 }
 467
 468 func TestAddSubscriptions(t *testing.T) {
 469         p := uint16(1)
 470         subdata := models.XappSubscriptionData{
 471                 Address:        swag.String("10.0.0.0"),
 472                 Port:           &p,
 473                 SubscriptionID: swag.Int32(1234)}
 474
 475         rtmgr.Subs = *stub.ValidSubscriptions
 476         yes_no := addSubscription(&rtmgr.Subs, &subdata)
 477         t.Log(yes_no)
 478 }
 479
 480
 481 func TestHttpInstance(t *testing.T) {
 482         sdlEngine, _ := sdl.GetSdl("file")
 483         rpeEngine, _ := rpe.GetRpe("rmrpush")
 484         sbiEngine,_ :=  sbi.GetSbi("rmrpush")
 485         httpinstance := NewHttpRestful()
 486         err := httpinstance.Terminate()
 487         t.Log(err)
 488         fmt.Printf("sbiEngine = %v",sbiEngine)
 489
 490         createMockPlatformComponents()
 491         //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
 492         //ts.Start()
 493         //defer ts.Close()
 494         var m sync.Mutex
 495         err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m)
 496 }
 497
 498 func TestXappCallbackWithData(t *testing.T) {
 499         data := models.XappCallbackData{
 500                 XApps:   *swag.String("[]"),
 501                 Version: *swag.Int64(1),
 502                 Event:   *swag.String("someevent"),
 503                 ID:      *swag.String("123456")}
 504          _, _ = recvXappCallbackData(&data)
 505 }
 506
 507 func TestXappCallbackNodata(t *testing.T) {
 508         //data := *models.XappCallbackData
 509          _, _ = recvXappCallbackData(nil)
 510 }
 511
 512 func TestE2TwithData(t *testing.T) {
 513         data2 := models.E2tData{
 514                 E2TAddress: swag.String("1.2.3.4"),
 515                 RanNamelist: []string{"ran1","ran2"},
 516         }
 517          _, _,_ = recvNewE2Tdata(&data2)
 518 }
 519
 520 func TestE2TwithNoData(t *testing.T) {
 521          _, _,_ = recvNewE2Tdata(nil)
 522 }
 523
 524 func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
 525         p := uint16(0)
 526         data := models.XappSubscriptionData{
 527                 Address:        swag.String("10.0.0.0"),
 528                 Port:           &p,
 529                 SubscriptionID: swag.Int32(1234)}
 530          _ = provideXappSubscriptionHandleImpl(&data)
 531 }
 532
 533 func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server {
 534         l, err := net.Listen("tcp", url)
 535         if err != nil {
 536                 fmt.Println("Failed to create listener: " + err.Error())
 537         }
 538         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 539                 if r.Method == "GET" && r.URL.String() == "/ric/v1/xapps" {
 540                         w.Header().Add("Content-Type", "application/json")
 541                         w.WriteHeader(http.StatusOK)
 542                         w.Write(g)
 543                 }
 544                 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
 545                         w.Header().Add("Content-Type", "application/json")
 546                         w.WriteHeader(http.StatusCreated)
 547                         w.Write(p)
 548                 }
 549                 if r.Method == "GET" && r.URL.String() == "/ric/v1/e2t/list" {
 550                         w.Header().Add("Content-Type", "application/json")
 551                         w.WriteHeader(http.StatusOK)
 552                         w.Write(t)
 553                 }
 554
 555         }))
 556         ts.Listener.Close()
 557         ts.Listener = l
 558         return ts
 559 }
 560
 561 func createMockSubmgrWithData(url string, t []byte) *httptest.Server {
 562         l, err := net.Listen("tcp", url)
 563         if err != nil {
 564                 fmt.Println("Failed to create listener: " + err.Error())
 565         }
 566         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 567
 568                 if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" {
 569                         w.Header().Add("Content-Type", "application/json")
 570                         w.WriteHeader(http.StatusOK)
 571                         w.Write(t)
 572                 }
 573
 574         }))
 575         ts.Listener.Close()
 576         ts.Listener = l
 577         return ts
 578 }
 579
 580 func createMockPlatformComponents() {
 581         var filename = "config.json"
 582         file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
 583         filestr := string(file)
 584         filestr = "{\"PlatformComponents\":" + filestr + "}"
 585         file = []byte(filestr)
 586         _ = ioutil.WriteFile(filename, file, 644)
 587 }
 588
 589 func TestProvideXappHandleHandlerImpl(t *testing.T) {
 590         data := models.XappCallbackData{
 591                 XApps:   *swag.String("[]"),
 592                 Version: *swag.Int64(1),
 593                 Event:   *swag.String("someevent"),
 594                 ID:      *swag.String("123456")}
 595         err := provideXappHandleHandlerImpl( &data)
 596
 597         //Empty XappCallbackdata
 598         data1 := models.XappCallbackData{}
 599         err = provideXappHandleHandlerImpl(&data1)
 600         t.Log(err)
 601 }
 602
 603 func TestValidateXappCallbackData(t *testing.T) {
 604         data := models.XappCallbackData{
 605                 XApps:   *swag.String("[]"),
 606                 Version: *swag.Int64(1),
 607                 Event:   *swag.String("someevent"),
 608                 ID:      *swag.String("123456")}
 609
 610         err := validateXappCallbackData(&data)
 611         if err != nil {
 612                 t.Error("Invalid XApp callback data: " + err.Error())
 613         }
 614 }
 615
 616 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
 617         data := models.XappCallbackData{
 618                 XApps:   *swag.String("{}"),
 619                 Version: *swag.Int64(1),
 620                 Event:   *swag.String("someevent"),
 621                 ID:      *swag.String("123456")}
 622
 623         err := validateXappCallbackData(&data)
 624         if err == nil {
 625                 t.Error("Invalid XApp callback data: " + err.Error())
 626         }
 627 }
 628
 629 func TestHttpGetXAppsInvalidData(t *testing.T) {
 630         _, err := httpGetXApps(XMURL)
 631         if err == nil {
 632                 t.Error("No XApp data received: " + err.Error())
 633         }
 634 }
 635
 636 func TestHttpGetXAppsWithValidData(t *testing.T) {
 637         var expected = 1
 638         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
 639
 640         ts.Start()
 641         defer ts.Close()
 642         xapplist, err := httpGetXApps(XMURL)
 643         if err != nil {
 644                 t.Error("Error occured: " + err.Error())
 645         } else {
 646                 if len(*xapplist) != expected {
 647                         t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
 648                 }
 649         }
 650 }
 651
 652
 653 func TestRetrieveStartupDataTimeout(t *testing.T) {
 654         sdlEngine, _ := sdl.GetSdl("file")
 655         createMockPlatformComponents()
 656         err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 657         if err == nil {
 658                 t.Error("Cannot retrieve startup data: " + err.Error())
 659         }
 660         os.Remove("rt.json")
 661         os.Remove("config.json")
 662 }
 663
 664 func TestRetrieveStartupData(t *testing.T) {
 665         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
 666         ts.Start()
 667         defer ts.Close()
 668
 669         ts1 := createMockAppmgrWithData("127.0.0.1:8080", nil, nil, E2TListResp)
 670         ts1.Start()
 671         defer ts1.Close()
 672
 673         ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList)
 674         ts2.Start()
 675         defer ts2.Close()
 676
 677         sdlEngine, _ := sdl.GetSdl("file")
 678         var httpRestful, _ = GetNbi("httpRESTful")
 679         createMockPlatformComponents()
 680         httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 681         //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 682         /*if err != nil {
 683                 t.Error("Cannot retrieve startup data: " + err.Error())
 684         }*/
 685         os.Remove("rt.json")
 686         os.Remove("config.json")
 687 }
 688
 689 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
 690         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
 691         ts.Start()
 692         defer ts.Close()
 693         sdlEngine, _ := sdl.GetSdl("file")
 694         var httpRestful, _ = GetNbi("httpRESTful")
 695         createMockPlatformComponents()
 696         err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 697         if err == nil {
 698                 t.Error("Cannot retrieve startup data: " + err.Error())
 699         }
 700         os.Remove("rt.json")
 701         os.Remove("config.json")
 702 }
 703
 704 func TestInvalidarguments(t *testing.T) {
 705         _ = PostSubReq("\n","nbifinterface")
 706         _ = PostSubReq("xmurl","\n")
 707 }
 708
 709 func TestInitEngine(t *testing.T) {
 710         initRtmgr()
 711 }
 712
 713 func TestUpdateXappSubscription(t *testing.T) {
 714         ep := make(map[string]*rtmgr.Endpoint)
 715         ep["dummy"] = &rtmgr.Endpoint{Uuid: "10.0.0.1:0", Name: "E2TERM", XAppType: "app1", Ip: "10.1.1.1", Port: 1234, TxMessages: []string{"", ""}, RxMessages: []string{"", ""}, Socket: nil, IsReady: true, Keepalive: true}
 716
 717         rtmgr.Eps = ep
 718
 719
 720         p := uint16(1234)
 721         xapp := models.XappElement{
 722                 Address:        swag.String("10.1.1.1"),
 723                 Port:           &p,
 724         }
 725
 726         var b models.XappList
 727         b = append(b,&xapp)
 728         _ = updateXappSubscriptionHandleImpl(&b, 10)
 729
 730         //Test case when subscriptions already exist
 731         data := models.XappSubscriptionData{
 732                 Address:        swag.String("10.0.0.0"),
 733                 Port:           &p,
 734                 SubscriptionID: swag.Int32(12345)}
 735
 736         rtmgr.Subs = *stub.ValidSubscriptions
 737
 738         subscriptionExists(&data)
 739         addSubscription(&rtmgr.Subs, &data)
 740         _ = updateXappSubscriptionHandleImpl(&b, 10)
 741
 742
 743 }
 744
 745 func TestDumpDebugdata(t *testing.T) {
 746         _,_ = dumpDebugData()
 747 }
 748
 749 func TestManagerRequest(t *testing.T) {
 750         var params xapp.RMRParams
 751         var rmrmeid xapp.RMRMeid
 752         sdlEngine, _ = sdl.GetSdl("file")
 753         sbiEngine, _ =  sbi.GetSbi("rmrpush")
 754         rpeEngine, _ = rpe.GetRpe ("rmrpush")
 755         rmrmeid.RanName = "gnb1"
 756         c := Control{make(chan *xapp.RMRParams)}
 757         params.Payload = []byte{1, 2,3,4}
 758         params.Mtype = 1234
 759         params.SubId = -1
 760         params.Meid = &rmrmeid
 761         params.Src = "sender"
 762         params.PayloadLen = 4
 763         c.handleUpdateToRoutingManagerRequest(&params)
 764 }
 765
 766 func TestRecievermr(t *testing.T) {
 767         var params xapp.RMRParams
 768         var rmrmeid xapp.RMRMeid
 769         sdlEngine, _ = sdl.GetSdl("file")
 770         sbiEngine, _ =  sbi.GetSbi("rmrpush")
 771         rpeEngine, _ = rpe.GetRpe ("rmrpush")
 772         rmrmeid.RanName = "gnb1"
 773
 774         params.Payload = []byte{1, 2,3,4}
 775         params.SubId = -1
 776         params.Meid = &rmrmeid
 777         params.Src = "sender"
 778         params.PayloadLen = 4
 779
 780         c := Control{make(chan *xapp.RMRParams)}
 781         params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
 782         c.recievermr(&params)
 783         params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"]
 784         c.recievermr(&params)
 785         params.Mtype = 1234
 786         c.recievermr(&params)
 787
 788         rtmgr.Rtmgr_ready = true
 789         params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
 790         c.recievermr(&params)
 791 }
 792
 793 func TestAddDelRmr(t *testing.T) {
 794         sdlEngine, _ = sdl.GetSdl("file")
 795         sbiEngine, _ =  sbi.GetSbi("rmrpush")
 796         rpeEngine, _ = rpe.GetRpe ("rmrpush")
 797         var routelist models.Routelist
 798         mtype := uint32(1234)
 799         tendpoint := "goofle.com"
 800         listofroutes := models.AddRmrRoute { SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint}
 801         listofroutes2 := models.AddRmrRoute { SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint}
 802         listofroutes3 := models.AddRmrRoute { MessageType: &mtype, TargetEndPoint: &tendpoint}
 803         adddelrmrroute(routelist,false)
 804         routelist = append(routelist,&listofroutes)
 805         routelist = append(routelist,&listofroutes2)
 806         routelist = append(routelist,&listofroutes3)
 807         routelist = append(routelist,&listofroutes3)
 808         adddelrmrroute(routelist,true)
 809
 810         adddelrmrroute(routelist,false)
 811 }