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