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