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