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