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