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