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         rtmgr.RMRConnStatus = make(map[string]bool)
 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         rtmgr.RMRConnStatus = make(map[string]bool)
 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         rtmgr.RMRConnStatus = make(map[string]bool)
 190         data := models.E2tData{
 191                 E2TAddress: swag.String("10.101.01.1"),
 192         }
 193         err, _ := validateE2tData(&data)
 194         t.Log(err)
 195 }
 196
 197 func TestValidateE2tDatavalid(t *testing.T) {
 198         rtmgr.RMRConnStatus = make(map[string]bool)
 199         data := models.E2tData{
 200                 E2TAddress: swag.String("10.101.01.1:8098"),
 201         }
 202
 203         err, _ := validateE2tData(&data)
 204         t.Log(err)
 205
 206         _ = CreateNewE2tHandleHandlerImpl(&data)
 207
 208 }
 209
 210 func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
 211         rtmgr.RMRConnStatus = make(map[string]bool)
 212         data := models.E2tData{
 213                 E2TAddress: swag.String("10.101.01.1:8098"),
 214         }
 215
 216         // insert endpoint for testing purpose
 217         uuid := "10.101.01.1:8098"
 218         ep := &rtmgr.Endpoint{
 219                 Uuid: uuid,
 220         }
 221         rtmgr.Eps[uuid] = ep
 222
 223         err, _ := validateE2tData(&data)
 224         t.Log(err)
 225
 226         // delete endpoint for at end of test case
 227         delete(rtmgr.Eps, uuid)
 228
 229 }
 230
 231 func TestValidateDeleteE2tData(t *testing.T) {
 232
 233         rtmgr.RMRConnStatus = make(map[string]bool)
 234         // test-1
 235         data := models.E2tDeleteData{
 236                 E2TAddress: swag.String(""),
 237         }
 238
 239         err := validateDeleteE2tData(&data)
 240         if err.Error() != "E2TAddress is empty!!!" {
 241                 t.Log(err)
 242         }
 243
 244         // test-2
 245         data = models.E2tDeleteData{
 246                 E2TAddress: swag.String("10.101.01.1:8098"),
 247         }
 248
 249         err = validateDeleteE2tData(&data)
 250         if err != nil {
 251                 t.Log(err)
 252         }
 253
 254         // test-3
 255         //################ Create End Point dummy entry
 256         uuid := "10.101.01.1:8098"
 257         ep := &rtmgr.Endpoint{
 258                 Uuid: uuid,
 259         }
 260         rtmgr.Eps[uuid] = ep
 261         //#####################
 262
 263         data = models.E2tDeleteData{
 264                 E2TAddress: swag.String("10.101.01.1:8098"),
 265                 RanAssocList: models.RanE2tMap{
 266                         {E2TAddress: swag.String("10.101.01.1:8098")},
 267                 },
 268         }
 269
 270         err = validateDeleteE2tData(&data)
 271         if err != nil {
 272                 t.Log(err)
 273         }
 274
 275         // delete endpoint for at end of test case
 276         //################ Delete End Point dummy entry
 277         delete(rtmgr.Eps, uuid)
 278         //#####################
 279
 280         // test-4
 281
 282         //################ Create End Point dummy entry
 283         uuid = "10.101.01.1:9991"
 284         ep = &rtmgr.Endpoint{
 285                 Uuid: uuid,
 286         }
 287         rtmgr.Eps[uuid] = ep
 288
 289         uuid = "10.101.01.1:9992"
 290         ep = &rtmgr.Endpoint{
 291                 Uuid: uuid,
 292         }
 293         rtmgr.Eps[uuid] = ep
 294         //#####################
 295
 296         data = models.E2tDeleteData{
 297                 E2TAddress: swag.String("10.101.01:8098"),
 298                 RanAssocList: models.RanE2tMap{
 299                         {E2TAddress: swag.String("10.101.01.1:9991")},
 300                         {E2TAddress: swag.String("10.101.01.1:9992")},
 301                 },
 302         }
 303
 304         err = validateDeleteE2tData(&data)
 305         if err != nil {
 306                 t.Log(err)
 307         }
 308         //################ Delete End Point dummy entry
 309         delete(rtmgr.Eps, "10.101.01.1:9991")
 310         delete(rtmgr.Eps, "10.101.01.1:9992")
 311         //#####################
 312
 313         // test-5
 314
 315         data = models.E2tDeleteData{
 316                 E2TAddress: swag.String("10.101.01:8098"),
 317                 RanAssocList: models.RanE2tMap{
 318                         {E2TAddress: swag.String("10.101.01.19991")},
 319                 },
 320         }
 321
 322         err = validateDeleteE2tData(&data)
 323         if err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991" {
 324                 t.Log(err)
 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         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 func TestHttpInstance(t *testing.T) {
 481         sdlEngine, _ := sdl.GetSdl("file")
 482         rpeEngine, _ := rpe.GetRpe("rmrpush")
 483         sbiEngine, _ := sbi.GetSbi("rmrpush")
 484         httpinstance := NewHttpRestful()
 485         err := httpinstance.Terminate()
 486         t.Log(err)
 487         fmt.Printf("sbiEngine = %v", sbiEngine)
 488
 489         createMockPlatformComponents()
 490         //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
 491         //ts.Start()
 492         //defer ts.Close()
 493         var m sync.Mutex
 494         err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m)
 495 }
 496
 497 func TestXappCallbackWithData(t *testing.T) {
 498         data := models.XappCallbackData{
 499                 XApps:   *swag.String("[]"),
 500                 Version: *swag.Int64(1),
 501                 Event:   *swag.String("someevent"),
 502                 ID:      *swag.String("123456")}
 503         _, _ = recvXappCallbackData(&data)
 504 }
 505
 506 func TestXappCallbackNodata(t *testing.T) {
 507         //data := *models.XappCallbackData
 508         _, _ = recvXappCallbackData(nil)
 509 }
 510
 511 func TestE2TwithData(t *testing.T) {
 512         data2 := models.E2tData{
 513                 E2TAddress:  swag.String("1.2.3.4"),
 514                 RanNamelist: []string{"ran1", "ran2"},
 515         }
 516         _, _, _ = recvNewE2Tdata(&data2)
 517 }
 518
 519 func TestE2TwithNoData(t *testing.T) {
 520         _, _, _ = recvNewE2Tdata(nil)
 521 }
 522
 523 func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
 524         p := uint16(0)
 525         data := models.XappSubscriptionData{
 526                 Address:        swag.String("10.0.0.0"),
 527                 Port:           &p,
 528                 SubscriptionID: swag.Int32(1234)}
 529         _ = ProvideXappSubscriptionHandleImpl(&data)
 530 }
 531
 532 func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server {
 533         l, err := net.Listen("tcp", url)
 534         if err != nil {
 535                 fmt.Println("Failed to create listener: " + err.Error())
 536         }
 537         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 538                 if r.Method == "GET" && r.URL.String() == "/ric/v1/xapps" {
 539                         w.Header().Add("Content-Type", "application/json")
 540                         w.WriteHeader(http.StatusOK)
 541                         w.Write(g)
 542                 }
 543                 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
 544                         w.Header().Add("Content-Type", "application/json")
 545                         w.WriteHeader(http.StatusCreated)
 546                         w.Write(p)
 547                 }
 548                 if r.Method == "GET" && r.URL.String() == "/ric/v1/e2t/list" {
 549                         w.Header().Add("Content-Type", "application/json")
 550                         w.WriteHeader(http.StatusOK)
 551                         w.Write(t)
 552                 }
 553
 554         }))
 555         ts.Listener.Close()
 556         ts.Listener = l
 557         return ts
 558 }
 559
 560 func createMockSubmgrWithData(url string, t []byte) *httptest.Server {
 561         l, err := net.Listen("tcp", url)
 562         if err != nil {
 563                 fmt.Println("Failed to create listener: " + err.Error())
 564         }
 565         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 566
 567                 if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" {
 568                         w.Header().Add("Content-Type", "application/json")
 569                         w.WriteHeader(http.StatusOK)
 570                         w.Write(t)
 571                 }
 572
 573         }))
 574         ts.Listener.Close()
 575         ts.Listener = l
 576         return ts
 577 }
 578
 579 func createMockPlatformComponents() {
 580         var filename = "config.json"
 581         file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
 582         filestr := string(file)
 583         filestr = "{\"PlatformComponents\":" + filestr + "}"
 584         file = []byte(filestr)
 585         _ = ioutil.WriteFile(filename, file, 644)
 586 }
 587
 588 func TestProvideXappHandleHandlerImpl(t *testing.T) {
 589         data := models.XappCallbackData{
 590                 XApps:   *swag.String("[]"),
 591                 Version: *swag.Int64(1),
 592                 Event:   *swag.String("someevent"),
 593                 ID:      *swag.String("123456")}
 594         err := ProvideXappHandleHandlerImpl(&data)
 595
 596         //Empty XappCallbackdata
 597         data1 := models.XappCallbackData{}
 598         err = ProvideXappHandleHandlerImpl(&data1)
 599         t.Log(err)
 600 }
 601
 602 func TestValidateXappCallbackData(t *testing.T) {
 603         data := models.XappCallbackData{
 604                 XApps:   *swag.String("[]"),
 605                 Version: *swag.Int64(1),
 606                 Event:   *swag.String("someevent"),
 607                 ID:      *swag.String("123456")}
 608
 609         err := validateXappCallbackData(&data)
 610         if err != nil {
 611                 t.Error("Invalid XApp callback data: " + err.Error())
 612         }
 613 }
 614
 615 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
 616         data := models.XappCallbackData{
 617                 XApps:   *swag.String("{}"),
 618                 Version: *swag.Int64(1),
 619                 Event:   *swag.String("someevent"),
 620                 ID:      *swag.String("123456")}
 621
 622         err := validateXappCallbackData(&data)
 623         if err == nil {
 624                 t.Error("Invalid XApp callback data: " + err.Error())
 625         }
 626 }
 627
 628 func TestHttpGetXAppsInvalidData(t *testing.T) {
 629         _, err := httpGetXApps(XMURL)
 630         if err == nil {
 631                 t.Error("No XApp data received: " + err.Error())
 632         }
 633 }
 634
 635 func TestHttpGetXAppsWithValidData(t *testing.T) {
 636         var expected = 1
 637         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
 638
 639         ts.Start()
 640         defer ts.Close()
 641         xapplist, err := httpGetXApps(XMURL)
 642         if err != nil {
 643                 t.Error("Error occured: " + err.Error())
 644         } else {
 645                 if len(*xapplist) != expected {
 646                         t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
 647                 }
 648         }
 649 }
 650
 651 func TestRetrieveStartupDataTimeout(t *testing.T) {
 652         sdlEngine, _ := sdl.GetSdl("file")
 653         createMockPlatformComponents()
 654         err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 655         if err == nil {
 656                 t.Error("Cannot retrieve startup data: " + err.Error())
 657         }
 658         os.Remove("rt.json")
 659         os.Remove("config.json")
 660 }
 661
 662 func TestRetrieveStartupData(t *testing.T) {
 663         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
 664         ts.Start()
 665         defer ts.Close()
 666
 667         ts1 := createMockAppmgrWithData("127.0.0.1:8085", nil, nil, E2TListResp)
 668         ts1.Start()
 669         defer ts1.Close()
 670
 671         ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList)
 672         ts2.Start()
 673         defer ts2.Close()
 674
 675         sdlEngine, _ := sdl.GetSdl("file")
 676         var httpRestful, _ = GetNbi("httpRESTful")
 677         createMockPlatformComponents()
 678         httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 679         //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 680         /*if err != nil {
 681                 t.Error("Cannot retrieve startup data: " + err.Error())
 682         }*/
 683         os.Remove("rt.json")
 684         os.Remove("config.json")
 685 }
 686
 687 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
 688         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
 689         ts.Start()
 690         defer ts.Close()
 691         sdlEngine, _ := sdl.GetSdl("file")
 692         var httpRestful, _ = GetNbi("httpRESTful")
 693         createMockPlatformComponents()
 694         err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
 695         if err == nil {
 696                 t.Error("Cannot retrieve startup data: " + err.Error())
 697         }
 698         os.Remove("rt.json")
 699         os.Remove("config.json")
 700 }
 701
 702 func TestInvalidarguments(t *testing.T) {
 703         _ = PostSubReq("\n", "nbifinterface")
 704         _ = PostSubReq("xmurl", "\n")
 705 }
 706
 707 func TestInitEngine(t *testing.T) {
 708         initRtmgr()
 709 }
 710
 711 func TestUpdateXappSubscription(t *testing.T) {
 712         ep := make(map[string]*rtmgr.Endpoint)
 713         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}
 714
 715         rtmgr.Eps = ep
 716
 717         p := uint16(1234)
 718         xapp := models.XappElement{
 719                 Address: swag.String("10.1.1.1"),
 720                 Port:    &p,
 721         }
 722
 723         var b models.XappList
 724         b = append(b, &xapp)
 725         _ = UpdateXappSubscriptionHandleImpl(&b, 10)
 726
 727         //Test case when subscriptions already exist
 728         data := models.XappSubscriptionData{
 729                 Address:        swag.String("10.0.0.0"),
 730                 Port:           &p,
 731                 SubscriptionID: swag.Int32(12345)}
 732
 733         rtmgr.Subs = *stub.ValidSubscriptions
 734
 735         subscriptionExists(&data)
 736         addSubscription(&rtmgr.Subs, &data)
 737         _ = UpdateXappSubscriptionHandleImpl(&b, 10)
 738
 739 }
 740
 741 func TestDumpDebugdata(t *testing.T) {
 742         _, _ = DumpDebugData()
 743 }
 744
 745 func TestManagerRequest(t *testing.T) {
 746         var params xapp.RMRParams
 747         var rmrmeid xapp.RMRMeid
 748         sdlEngine, _ = sdl.GetSdl("file")
 749         sbiEngine, _ = sbi.GetSbi("rmrpush")
 750         rpeEngine, _ = rpe.GetRpe("rmrpush")
 751         rmrmeid.RanName = "gnb1"
 752         c := Control{make(chan *xapp.RMRParams)}
 753         params.Payload = []byte{1, 2, 3, 4}
 754         params.Mtype = 1234
 755         params.SubId = -1
 756         params.Meid = &rmrmeid
 757         params.Src = "sender"
 758         params.PayloadLen = 4
 759         c.handleUpdateToRoutingManagerRequest(&params)
 760 }
 761
 762 func TestRecievermr(t *testing.T) {
 763         var params xapp.RMRParams
 764         var rmrmeid xapp.RMRMeid
 765         sdlEngine, _ = sdl.GetSdl("file")
 766         sbiEngine, _ = sbi.GetSbi("rmrpush")
 767         rpeEngine, _ = rpe.GetRpe("rmrpush")
 768         rmrmeid.RanName = "gnb1"
 769
 770         params.Payload = []byte{1, 2, 3, 4}
 771         params.SubId = -1
 772         params.Meid = &rmrmeid
 773         params.Src = "sender"
 774         params.PayloadLen = 4
 775
 776         c := Control{make(chan *xapp.RMRParams)}
 777         params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
 778         c.recievermr(&params)
 779         params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"]
 780         c.recievermr(&params)
 781         params.Mtype = 1234
 782         c.recievermr(&params)
 783
 784         rtmgr.Rtmgr_ready = true
 785         params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
 786         c.recievermr(&params)
 787         time.Sleep(time.Duration(5) * time.Second)
 788 }
 789
 790 func TestAddDelRmr(t *testing.T) {
 791         sdlEngine, _ = sdl.GetSdl("file")
 792         sbiEngine, _ = sbi.GetSbi("rmrpush")
 793         rpeEngine, _ = rpe.GetRpe("rmrpush")
 794         var routelist models.Routelist
 795         mtype := uint32(1234)
 796         tendpoint := "goofle.com"
 797         listofroutes := models.AddRmrRoute{SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint}
 798         listofroutes2 := models.AddRmrRoute{SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint}
 799         listofroutes3 := models.AddRmrRoute{MessageType: &mtype, TargetEndPoint: &tendpoint}
 800         Adddelrmrroute(routelist, false)
 801         routelist = append(routelist, &listofroutes)
 802         routelist = append(routelist, &listofroutes2)
 803         routelist = append(routelist, &listofroutes3)
 804         routelist = append(routelist, &listofroutes3)
 805         Adddelrmrroute(routelist, true)
 806
 807         Adddelrmrroute(routelist, false)
 808 }
 809
 810 func TestPopulateSubscription(t *testing.T) {
 811         var sublist xfmodel.SubscriptionList
 812
 813         subdata := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp1.com:3800"}, SubscriptionID: -1, Meid: ""}
 814         subdata2 := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp2.com:3800"}, SubscriptionID: 11, Meid: ""}
 815         subdata3 := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp3.com:3800"}, SubscriptionID: 221, Meid: ""}
 816         sublist = append(sublist, &subdata)
 817         sublist = append(sublist, &subdata2)
 818         sublist = append(sublist, &subdata3)
 819
 820         PopulateSubscription(sublist)
 821
 822 }