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