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