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
  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
 126 func TestvalidateE2tData(t *testing.T) {
 127         data := models.E2tData{
 128                 E2TAddress: swag.String(""),
 129         }
 130         err := validateE2tData(&data)
 131         t.Log(err)
 132 }
 133
 134 func TestSubscriptionExists(t *testing.T) {
 135         p := uint16(0)
 136         data := models.XappSubscriptionData{
 137                 Address:        swag.String("10.0.0.0"),
 138                 Port:           &p,
 139                 SubscriptionID: swag.Int32(1234)}
 140
 141         rtmgr.Subs = *stub.ValidSubscriptions
 142
 143         yes_no := subscriptionExists(&data)
 144         yes_no = addSubscription(&rtmgr.Subs, &data)
 145         yes_no = addSubscription(&rtmgr.Subs, &data)
 146         yes_no = delSubscription(&rtmgr.Subs, &data)
 147         yes_no = delSubscription(&rtmgr.Subs, &data)
 148         t.Log(yes_no)
 149 }
 150
 151 func TestaddSubscriptions(t *testing.T) {
 152         p := uint16(1)
 153         subdata := models.XappSubscriptionData{
 154                 Address:        swag.String("10.0.0.0"),
 155                 Port:           &p,
 156                 SubscriptionID: swag.Int32(1234)}
 157
 158         rtmgr.Subs = *stub.ValidSubscriptions
 159         yes_no := addSubscription(&rtmgr.Subs, &subdata)
 160         t.Log(yes_no)
 161 }
 162
 163 func TestHttpInstance(t *testing.T) {
 164         sdlEngine, _ := sdl.GetSdl("file")
 165         rpeEngine, _ := rpe.GetRpe("rmrpush")
 166         httpinstance := NewHttpRestful()
 167         err := httpinstance.Terminate()
 168         t.Log(err)
 169
 170         triggerSBI := make(chan bool)
 171         createMockPlatformComponents()
 172         //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
 173         //ts.Start()
 174         //defer ts.Close()
 175         err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine, rpeEngine, triggerSBI)
 176 }
 177
 178 func TestXappCallbackDataChannelwithdata(t *testing.T) {
 179         data := models.XappCallbackData{
 180                 XApps:   *swag.String("[]"),
 181                 Version: *swag.Int64(1),
 182                 Event:   *swag.String("someevent"),
 183                 ID:      *swag.String("123456")}
 184         datach := make(chan *models.XappCallbackData, 1)
 185         go func() { _, _ = recvXappCallbackData(datach) }()
 186         defer close(datach)
 187         datach <- &data
 188 }
 189 func TestXappCallbackDataChannelNodata(t *testing.T) {
 190         datach := make(chan *models.XappCallbackData, 1)
 191         go func() { _, _ = recvXappCallbackData(datach) }()
 192         defer close(datach)
 193 }
 194
 195 func TestE2TChannelwithData(t *testing.T) {
 196         data2 := models.E2tData{
 197                 E2TAddress: swag.String(""),
 198         }
 199         dataChannel := make(chan *models.E2tData, 10)
 200         go func() { _, _ = recvNewE2Tdata(dataChannel) }()
 201         defer close(dataChannel)
 202         dataChannel <- &data2
 203 }
 204
 205 func TestE2TChannelwithNoData(t *testing.T) {
 206         dataChannel := make(chan *models.E2tData, 10)
 207         go func() { _, _ = recvNewE2Tdata(dataChannel) }()
 208         defer close(dataChannel)
 209 }
 210
 211 func TestprovideXappSubscriptionHandleImpl(t *testing.T) {
 212         p := uint16(0)
 213         data := models.XappSubscriptionData{
 214                 Address:        swag.String("10.0.0.0"),
 215                 Port:           &p,
 216                 SubscriptionID: swag.Int32(1234)}
 217         datachannel := make(chan *models.XappSubscriptionData, 10)
 218         go func() { _ = provideXappSubscriptionHandleImpl(datachannel, &data) }()
 219         defer close(datachannel)
 220         datachannel <- &data
 221
 222         //subdel test
 223 }
 224
 225 func TestdeleteXappSubscriptionHandleImpl(t *testing.T) {
 226         p := uint16(1)
 227         subdeldata := models.XappSubscriptionData{
 228                 Address:        swag.String("10.0.0.0"),
 229                 Port:           &p,
 230                 SubscriptionID: swag.Int32(1234)}
 231         subdelchannel := make(chan *models.XappSubscriptionData, 10)
 232         go func() { _ = deleteXappSubscriptionHandleImpl(subdelchannel, &subdeldata) }()
 233         defer close(subdelchannel)
 234         subdelchannel <- &subdeldata
 235 }
 236
 237 func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
 238         l, err := net.Listen("tcp", url)
 239         if err != nil {
 240                 fmt.Println("Failed to create listener: " + err.Error())
 241         }
 242         ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 243                 if r.Method == "GET" && r.URL.String() == "/ric/v1/xapps" {
 244                         w.Header().Add("Content-Type", "application/json")
 245                         w.WriteHeader(http.StatusOK)
 246                         w.Write(g)
 247                 }
 248                 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
 249                         w.Header().Add("Content-Type", "application/json")
 250                         w.WriteHeader(http.StatusCreated)
 251                         w.Write(p)
 252                 }
 253
 254         }))
 255         ts.Listener.Close()
 256         ts.Listener = l
 257         return ts
 258 }
 259
 260 func createMockPlatformComponents() {
 261         var filename = "config.json"
 262         file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
 263         filestr := string(file)
 264         filestr = "{\"PlatformComponents\":" + filestr + "}"
 265         file = []byte(filestr)
 266         _ = ioutil.WriteFile(filename, file, 644)
 267 }
 268
 269 func TestRecvXappCallbackData(t *testing.T) {
 270         data := models.XappCallbackData{
 271                 XApps:   *swag.String("[]"),
 272                 Version: *swag.Int64(1),
 273                 Event:   *swag.String("any"),
 274                 ID:      *swag.String("123456"),
 275         }
 276
 277         ch := make(chan *models.XappCallbackData)
 278         defer close(ch)
 279         httpRestful := NewHttpRestful()
 280         go func() { ch <- &data }()
 281         time.Sleep(1 * time.Second)
 282         t.Log(string(len(ch)))
 283         xappList, err := httpRestful.RecvXappCallbackData(ch)
 284         if err != nil {
 285                 t.Error("Receive failed: " + err.Error())
 286         } else {
 287                 if xappList == nil {
 288                         t.Error("Expected an XApp notification list")
 289                 } else {
 290                         t.Log("whatever")
 291                 }
 292         }
 293 }
 294
 295 func TestProvideXappHandleHandlerImpl(t *testing.T) {
 296         datach := make(chan *models.XappCallbackData, 10)
 297         defer close(datach)
 298         data := models.XappCallbackData{
 299                 XApps:   *swag.String("[]"),
 300                 Version: *swag.Int64(1),
 301                 Event:   *swag.String("someevent"),
 302                 ID:      *swag.String("123456")}
 303         var httpRestful, _ = GetNbi("httpRESTful")
 304         err := httpRestful.(*HttpRestful).ProvideXappHandleHandlerImpl(datach, &data)
 305         if err != nil {
 306                 t.Error("Error occured: " + err.Error())
 307         } else {
 308                 recv := <-datach
 309                 if recv == nil {
 310                         t.Error("Something gone wrong: " + err.Error())
 311                 } else {
 312                         if recv != &data {
 313                                 t.Error("Malformed data on channel")
 314                         }
 315                 }
 316         }
 317 }
 318
 319 func TestValidateXappCallbackData(t *testing.T) {
 320         data := models.XappCallbackData{
 321                 XApps:   *swag.String("[]"),
 322                 Version: *swag.Int64(1),
 323                 Event:   *swag.String("someevent"),
 324                 ID:      *swag.String("123456")}
 325
 326         err := validateXappCallbackData(&data)
 327         if err != nil {
 328                 t.Error("Invalid XApp callback data: " + err.Error())
 329         }
 330 }
 331
 332 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
 333         data := models.XappCallbackData{
 334                 XApps:   *swag.String("{}"),
 335                 Version: *swag.Int64(1),
 336                 Event:   *swag.String("someevent"),
 337                 ID:      *swag.String("123456")}
 338
 339         err := validateXappCallbackData(&data)
 340         if err == nil {
 341                 t.Error("Invalid XApp callback data: " + err.Error())
 342         }
 343 }
 344
 345 func TestHttpGetXAppsInvalidData(t *testing.T) {
 346         _, err := httpGetXApps(XMURL)
 347         if err == nil {
 348                 t.Error("No XApp data received: " + err.Error())
 349         }
 350 }
 351
 352 func TestHttpGetXAppsWithValidData(t *testing.T) {
 353         var expected = 1
 354         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
 355
 356         ts.Start()
 357         defer ts.Close()
 358         xapplist, err := httpGetXApps(XMURL)
 359         if err != nil {
 360                 t.Error("Error occured: " + err.Error())
 361         } else {
 362                 if len(*xapplist) != expected {
 363                         t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
 364                 }
 365         }
 366 }
 367 func TestRetrieveStartupDataTimeout(t *testing.T) {
 368         sdlEngine, _ := sdl.GetSdl("file")
 369         createMockPlatformComponents()
 370         err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 371         if err == nil {
 372                 t.Error("Cannot retrieve startup data: " + err.Error())
 373         }
 374         os.Remove("rt.json")
 375         os.Remove("config.json")
 376 }
 377
 378 func TestRetrieveStartupData(t *testing.T) {
 379         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp)
 380         ts.Start()
 381         defer ts.Close()
 382         sdlEngine, _ := sdl.GetSdl("file")
 383         var httpRestful, _ = GetNbi("httpRESTful")
 384         createMockPlatformComponents()
 385         err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 386         //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 387         if err != nil {
 388                 t.Error("Cannot retrieve startup data: " + err.Error())
 389         }
 390         os.Remove("rt.json")
 391         os.Remove("config.json")
 392 }
 393
 394 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
 395         ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp)
 396         ts.Start()
 397         defer ts.Close()
 398         sdlEngine, _ := sdl.GetSdl("file")
 399         var httpRestful, _ = GetNbi("httpRESTful")
 400         createMockPlatformComponents()
 401         err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
 402         if err == nil {
 403                 t.Error("Cannot retrieve startup data: " + err.Error())
 404         }
 405         os.Remove("rt.json")
 406         os.Remove("config.json")
 407 }
 408
 409 func TestrecvXappCallbackData(t *testing.T) {
 410         data := models.E2tData{
 411                 E2TAddress: swag.String("123456")}
 412
 413         var err error
 414
 415         e2tch := make(chan *models.E2tData)
 416         go func() { e2tch <- &data }()
 417         time.Sleep(1 * time.Second)
 418         t.Log(string(len(e2tch)))
 419         defer close(e2tch)
 420
 421         var httpRestful, _ = GetNbi("httpRESTful")
 422         _, err = httpRestful.(*HttpRestful).RecvNewE2Tdata(e2tch)
 423         t.Log(err)
 424 }