2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
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
10 http://www.apache.org/licenses/LICENSE-2.0
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.
19 This source code is part of the near-RT RIC (RAN Intelligent Controller)
20 platform project (RICP).
22 ==================================================================================
25 Mnemonic: httprestful_test.go
26 Abstract: HTTPRestful unit tests
35 xfmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
36 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
37 "github.com/go-openapi/swag"
38 "github.com/spf13/viper"
44 "routing-manager/pkg/models"
45 "routing-manager/pkg/rpe"
46 "routing-manager/pkg/rtmgr"
47 "routing-manager/pkg/sbi"
48 "routing-manager/pkg/sdl"
49 "routing-manager/pkg/stub"
55 var BasicXAppLists = []byte(`[
57 "name":"xapp-01","status":"unknown","version":"1.2.3",
59 {"name":"xapp-01-instance-01","status":"pending","ip":"172.16.1.103","port":4555,
60 "txMessages":["ControlIndication"],
61 "rxMessages":["LoadIndication","Reset"]
63 {"name":"xapp-01-instance-02","status":"pending","ip":"10.244.1.12","port":4561,
64 "txMessages":["ControlIndication","SNStatusTransfer"],
65 "rxMessages":["LoadIndication","HandoverPreparation"]
71 var SubscriptionResp = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
73 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"]}]`)
75 var SubscriptionList = []byte(`[{"SubscriptionId":11,"Meid":"Test-Gnb","Endpoint":["127.0.0.1:4056"]}]`)
77 var InvalidSubResp = []byte(`{"Version":0, "EventType":all}`)
79 type Consumer struct{}
81 func (m Consumer) Consume(params *xapp.RMRParams) (err error) {
82 xapp.Sdl.Store("myKey", params.Payload)
87 func TestMain(m *testing.M) {
88 go xapp.RunWithParams(Consumer{}, viper.GetBool("db.waitForSdl"))
89 time.Sleep(time.Duration(5) * time.Second)
94 func TestValidateXappCallbackData_1(t *testing.T) {
95 data := models.XappCallbackData{
96 XApps: *swag.String("[]"),
97 Version: *swag.Int64(1),
98 Event: *swag.String("someevent"),
99 ID: *swag.String("123456")}
101 err := validateXappCallbackData(&data)
103 t.Error("Invalid XApp callback data: " + err.Error())
107 func TestValidateXappCallbackDataInvalid(t *testing.T) {
108 data := models.XappCallbackData{}
109 err := validateXappCallbackData(&data)
113 func TestValidateXappSubscriptionsData(t *testing.T) {
115 ep := make(map[string]*rtmgr.Endpoint)
116 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}
118 data := models.XappSubscriptionData{
119 Address: swag.String("10.1.1.1"),
121 SubscriptionID: swag.Int32(123456)}
124 err = validateXappSubscriptionData(&data)
129 data1 := models.XappSubscriptionData{
130 Address: swag.String(""),
132 SubscriptionID: swag.Int32(123456)}
133 err = validateXappSubscriptionData(&data1)
136 data2 := models.E2tData{
137 E2TAddress: swag.String(""),
139 /*err = validateE2tData(&data2)*/
141 //e2tchannel := make(chan *models.E2tData, 10)
142 _ = createNewE2tHandleHandlerImpl(&data2)
143 //defer close(e2tchannel)
145 //test case for provideXappSubscriptionHandleImp
146 //datachannel := make(chan *models.XappSubscriptionData, 10)
147 sdlEngine, _ = sdl.GetSdl("file")
148 sbiEngine, _ = sbi.GetSbi("rmrpush")
149 rpeEngine, _ = rpe.GetRpe("rmrpush")
150 _ = provideXappSubscriptionHandleImpl(&data1)
151 //defer close(datachannel)
153 //test case for deleteXappSubscriptionHandleImpl
154 _ = deleteXappSubscriptionHandleImpl(&data1)
156 data3 := models.XappSubscriptionData{
157 Address: swag.String("10.55.55.5"),
159 SubscriptionID: swag.Int32(123456)}
160 //test case for deleteXappSubscriptionHandleImpl
161 _ = deleteXappSubscriptionHandleImpl(&data3)
162 data4 := models.XappSubscriptionData{
163 Address: swag.String("1.5.5.5"),
165 SubscriptionID: swag.Int32(1236)}
166 _ = deleteXappSubscriptionHandleImpl(&data4)
170 func TestValidateE2tDataEmpty(t *testing.T) {
171 data := models.E2tData{
172 E2TAddress: swag.String(""),
174 err := validateE2tData(&data)
178 func TestValidateE2tDataDNSLookUPfails(t *testing.T) {
179 data := models.E2tData{
180 E2TAddress: swag.String("e2t.1com:1234"),
182 err := validateE2tData(&data)
186 func TestValidateE2tDataInvalid(t *testing.T) {
187 data := models.E2tData{
188 E2TAddress: swag.String("10.101.01.1"),
190 err := validateE2tData(&data)
194 func TestValidateE2tDatavalid(t *testing.T) {
195 data := models.E2tData{
196 E2TAddress: swag.String("10.101.01.1:8098"),
199 err := validateE2tData(&data)
202 _ = createNewE2tHandleHandlerImpl(&data)
206 func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
207 data := models.E2tData{
208 E2TAddress: swag.String("10.101.01.1:8098"),
211 // insert endpoint for testing purpose
212 uuid := "10.101.01.1:8098"
213 ep := &rtmgr.Endpoint{
218 err := validateE2tData(&data)
221 // delete endpoint for at end of test case
222 delete(rtmgr.Eps, uuid)
226 func TestValidateDeleteE2tData(t *testing.T) {
229 data := models.E2tDeleteData{
230 E2TAddress: swag.String(""),
233 err := validateDeleteE2tData(&data)
234 if err.Error() != "E2TAddress is empty!!!" {
239 data = models.E2tDeleteData{
240 E2TAddress: swag.String("10.101.01.1:8098"),
243 err = validateDeleteE2tData(&data)
249 //################ Create End Point dummy entry
250 uuid := "10.101.01.1:8098"
251 ep := &rtmgr.Endpoint{
255 //#####################
257 data = models.E2tDeleteData{
258 E2TAddress: swag.String("10.101.01.1:8098"),
259 RanAssocList: models.RanE2tMap{
260 {E2TAddress: swag.String("10.101.01.1:8098")},
264 err = validateDeleteE2tData(&data)
269 // delete endpoint for at end of test case
270 //################ Delete End Point dummy entry
271 delete(rtmgr.Eps, uuid)
272 //#####################
276 //################ Create End Point dummy entry
277 uuid = "10.101.01.1:9991"
278 ep = &rtmgr.Endpoint{
283 uuid = "10.101.01.1:9992"
284 ep = &rtmgr.Endpoint{
288 //#####################
290 data = models.E2tDeleteData{
291 E2TAddress: swag.String("10.101.01:8098"),
292 RanAssocList: models.RanE2tMap{
293 {E2TAddress: swag.String("10.101.01.1:9991")},
294 {E2TAddress: swag.String("10.101.01.1:9992")},
298 err = validateDeleteE2tData(&data)
302 //################ Delete End Point dummy entry
303 delete(rtmgr.Eps, "10.101.01.1:9991")
304 delete(rtmgr.Eps, "10.101.01.1:9992")
305 //#####################
309 data = models.E2tDeleteData{
310 E2TAddress: swag.String("10.101.01:8098"),
311 RanAssocList: models.RanE2tMap{
312 {E2TAddress: swag.String("10.101.01.19991")},
316 err = validateDeleteE2tData(&data)
317 if err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991" {
322 func TestValidateE2TAddressRANListData(t *testing.T) {
324 data := models.RanE2tMap{
326 E2TAddress: swag.String(""),
329 err := validateE2TAddressRANListData(data)
334 data = models.RanE2tMap{
336 E2TAddress: swag.String("10.101.01.1:8098"),
339 err = validateE2TAddressRANListData(data)
346 func TestAssociateRanToE2THandlerImpl(t *testing.T) {
348 data := models.RanE2tMap{
350 E2TAddress: swag.String("10.101.01.1:8098"),
353 err := associateRanToE2THandlerImpl(data)
358 //################ Create End Point dummy entry
359 uuid := "10.101.01.1:8098"
360 ep := &rtmgr.Endpoint{
364 //#####################
366 data = models.RanE2tMap{
368 E2TAddress: swag.String("10.101.01.1:8098"),
371 err = associateRanToE2THandlerImpl(data)
376 //################ Delete End Point dummy entry
377 delete(rtmgr.Eps, uuid)
378 //#####################
381 func TestDisassociateRanToE2THandlerImpl(t *testing.T) {
383 data := models.RanE2tMap{
385 E2TAddress: swag.String("10.101.01.1:8098"),
388 err := disassociateRanToE2THandlerImpl(data)
392 //################ Create End Point dummy entry
393 uuid := "10.101.01.1:8098"
394 ep := &rtmgr.Endpoint{
398 //#####################
400 data = models.RanE2tMap{
402 E2TAddress: swag.String("10.101.01.1:8098"),
405 err = disassociateRanToE2THandlerImpl(data)
410 //################ Delete End Point dummy entry
411 delete(rtmgr.Eps, uuid)
412 //#####################
415 func TestDeleteE2tHandleHandlerImpl(t *testing.T) {
417 data := models.E2tDeleteData{
418 E2TAddress: swag.String(""),
420 err := deleteE2tHandleHandlerImpl(&data)
425 //################ Create End Point dummy entry
426 uuid := "10.101.01.1:8098"
427 ep := &rtmgr.Endpoint{
431 //#####################
433 data = models.E2tDeleteData{
434 E2TAddress: swag.String("10.101.01.1:8098"),
436 err = deleteE2tHandleHandlerImpl(&data)
440 //################ Delete End Point dummy entry
441 delete(rtmgr.Eps, uuid)
442 //#####################
445 func TestSubscriptionExists(t *testing.T) {
447 data := models.XappSubscriptionData{
448 Address: swag.String("10.0.0.0"),
450 SubscriptionID: swag.Int32(1234)}
452 rtmgr.Subs = *stub.ValidSubscriptions
454 yes_no := subscriptionExists(&data)
455 yes_no = addSubscription(&rtmgr.Subs, &data)
456 yes_no = addSubscription(&rtmgr.Subs, &data)
457 yes_no = delSubscription(&rtmgr.Subs, &data)
458 yes_no = delSubscription(&rtmgr.Subs, &data)
462 func TestAddSubscriptions(t *testing.T) {
464 subdata := models.XappSubscriptionData{
465 Address: swag.String("10.0.0.0"),
467 SubscriptionID: swag.Int32(1234)}
469 rtmgr.Subs = *stub.ValidSubscriptions
470 yes_no := addSubscription(&rtmgr.Subs, &subdata)
474 func TestHttpInstance(t *testing.T) {
475 sdlEngine, _ := sdl.GetSdl("file")
476 rpeEngine, _ := rpe.GetRpe("rmrpush")
477 sbiEngine, _ := sbi.GetSbi("rmrpush")
478 httpinstance := NewHttpRestful()
479 err := httpinstance.Terminate()
481 fmt.Printf("sbiEngine = %v", sbiEngine)
483 createMockPlatformComponents()
484 //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
488 err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m)
491 func TestXappCallbackWithData(t *testing.T) {
492 data := models.XappCallbackData{
493 XApps: *swag.String("[]"),
494 Version: *swag.Int64(1),
495 Event: *swag.String("someevent"),
496 ID: *swag.String("123456")}
497 _, _ = recvXappCallbackData(&data)
500 func TestXappCallbackNodata(t *testing.T) {
501 //data := *models.XappCallbackData
502 _, _ = recvXappCallbackData(nil)
505 func TestE2TwithData(t *testing.T) {
506 data2 := models.E2tData{
507 E2TAddress: swag.String("1.2.3.4"),
508 RanNamelist: []string{"ran1", "ran2"},
510 _, _, _ = recvNewE2Tdata(&data2)
513 func TestE2TwithNoData(t *testing.T) {
514 _, _, _ = recvNewE2Tdata(nil)
517 func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
519 data := models.XappSubscriptionData{
520 Address: swag.String("10.0.0.0"),
522 SubscriptionID: swag.Int32(1234)}
523 _ = provideXappSubscriptionHandleImpl(&data)
526 func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server {
527 l, err := net.Listen("tcp", url)
529 fmt.Println("Failed to create listener: " + err.Error())
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)
537 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
538 w.Header().Add("Content-Type", "application/json")
539 w.WriteHeader(http.StatusCreated)
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)
554 func createMockSubmgrWithData(url string, t []byte) *httptest.Server {
555 l, err := net.Listen("tcp", url)
557 fmt.Println("Failed to create listener: " + err.Error())
559 ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
561 if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" {
562 w.Header().Add("Content-Type", "application/json")
563 w.WriteHeader(http.StatusOK)
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)
582 func TestProvideXappHandleHandlerImpl(t *testing.T) {
583 data := models.XappCallbackData{
584 XApps: *swag.String("[]"),
585 Version: *swag.Int64(1),
586 Event: *swag.String("someevent"),
587 ID: *swag.String("123456")}
588 err := provideXappHandleHandlerImpl(&data)
590 //Empty XappCallbackdata
591 data1 := models.XappCallbackData{}
592 err = provideXappHandleHandlerImpl(&data1)
596 func TestValidateXappCallbackData(t *testing.T) {
597 data := models.XappCallbackData{
598 XApps: *swag.String("[]"),
599 Version: *swag.Int64(1),
600 Event: *swag.String("someevent"),
601 ID: *swag.String("123456")}
603 err := validateXappCallbackData(&data)
605 t.Error("Invalid XApp callback data: " + err.Error())
609 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
610 data := models.XappCallbackData{
611 XApps: *swag.String("{}"),
612 Version: *swag.Int64(1),
613 Event: *swag.String("someevent"),
614 ID: *swag.String("123456")}
616 err := validateXappCallbackData(&data)
618 t.Error("Invalid XApp callback data: " + err.Error())
622 func TestHttpGetXAppsInvalidData(t *testing.T) {
623 _, err := httpGetXApps(XMURL)
625 t.Error("No XApp data received: " + err.Error())
629 func TestHttpGetXAppsWithValidData(t *testing.T) {
631 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
635 xapplist, err := httpGetXApps(XMURL)
637 t.Error("Error occured: " + err.Error())
639 if len(*xapplist) != expected {
640 t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
645 func TestRetrieveStartupDataTimeout(t *testing.T) {
646 sdlEngine, _ := sdl.GetSdl("file")
647 createMockPlatformComponents()
648 err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
650 t.Error("Cannot retrieve startup data: " + err.Error())
653 os.Remove("config.json")
656 func TestRetrieveStartupData(t *testing.T) {
657 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
661 ts1 := createMockAppmgrWithData("127.0.0.1:8080", nil, nil, E2TListResp)
665 ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList)
669 sdlEngine, _ := sdl.GetSdl("file")
670 var httpRestful, _ = GetNbi("httpRESTful")
671 createMockPlatformComponents()
672 httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
673 //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
675 t.Error("Cannot retrieve startup data: " + err.Error())
678 os.Remove("config.json")
681 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
682 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
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)
690 t.Error("Cannot retrieve startup data: " + err.Error())
693 os.Remove("config.json")
696 func TestInvalidarguments(t *testing.T) {
697 _ = PostSubReq("\n", "nbifinterface")
698 _ = PostSubReq("xmurl", "\n")
701 func TestInitEngine(t *testing.T) {
705 func TestUpdateXappSubscription(t *testing.T) {
706 ep := make(map[string]*rtmgr.Endpoint)
707 ep["dummy"] = &rtmgr.Endpoint{Uuid: "10.0.0.1:0", Name: "E2TERM", XAppType: "app1", Ip: "10.1.1.1", Port: 1234, TxMessages: []string{"", ""}, RxMessages: []string{"", ""}, Socket: nil, IsReady: true, Keepalive: true}
712 xapp := models.XappElement{
713 Address: swag.String("10.1.1.1"),
717 var b models.XappList
719 _ = updateXappSubscriptionHandleImpl(&b, 10)
721 //Test case when subscriptions already exist
722 data := models.XappSubscriptionData{
723 Address: swag.String("10.0.0.0"),
725 SubscriptionID: swag.Int32(12345)}
727 rtmgr.Subs = *stub.ValidSubscriptions
729 subscriptionExists(&data)
730 addSubscription(&rtmgr.Subs, &data)
731 _ = updateXappSubscriptionHandleImpl(&b, 10)
735 func TestDumpDebugdata(t *testing.T) {
736 _, _ = dumpDebugData()
739 func TestManagerRequest(t *testing.T) {
740 var params xapp.RMRParams
741 var rmrmeid xapp.RMRMeid
742 sdlEngine, _ = sdl.GetSdl("file")
743 sbiEngine, _ = sbi.GetSbi("rmrpush")
744 rpeEngine, _ = rpe.GetRpe("rmrpush")
745 rmrmeid.RanName = "gnb1"
746 c := Control{make(chan *xapp.RMRParams)}
747 params.Payload = []byte{1, 2, 3, 4}
750 params.Meid = &rmrmeid
751 params.Src = "sender"
752 params.PayloadLen = 4
753 c.handleUpdateToRoutingManagerRequest(¶ms)
756 func TestRecievermr(t *testing.T) {
757 var params xapp.RMRParams
758 var rmrmeid xapp.RMRMeid
759 sdlEngine, _ = sdl.GetSdl("file")
760 sbiEngine, _ = sbi.GetSbi("rmrpush")
761 rpeEngine, _ = rpe.GetRpe("rmrpush")
762 rmrmeid.RanName = "gnb1"
764 params.Payload = []byte{1, 2, 3, 4}
766 params.Meid = &rmrmeid
767 params.Src = "sender"
768 params.PayloadLen = 4
770 c := Control{make(chan *xapp.RMRParams)}
771 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
772 c.recievermr(¶ms)
773 params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"]
774 c.recievermr(¶ms)
776 c.recievermr(¶ms)
778 rtmgr.Rtmgr_ready = true
779 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
780 c.recievermr(¶ms)
781 time.Sleep(time.Duration(5) * time.Second)
784 func TestAddDelRmr(t *testing.T) {
785 sdlEngine, _ = sdl.GetSdl("file")
786 sbiEngine, _ = sbi.GetSbi("rmrpush")
787 rpeEngine, _ = rpe.GetRpe("rmrpush")
788 var routelist models.Routelist
789 mtype := uint32(1234)
790 tendpoint := "goofle.com"
791 listofroutes := models.AddRmrRoute{SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint}
792 listofroutes2 := models.AddRmrRoute{SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint}
793 listofroutes3 := models.AddRmrRoute{MessageType: &mtype, TargetEndPoint: &tendpoint}
794 adddelrmrroute(routelist, false)
795 routelist = append(routelist, &listofroutes)
796 routelist = append(routelist, &listofroutes2)
797 routelist = append(routelist, &listofroutes3)
798 routelist = append(routelist, &listofroutes3)
799 adddelrmrroute(routelist, true)
801 adddelrmrroute(routelist, false)
804 func TestPopulateSubscription(t *testing.T) {
805 var sublist xfmodel.SubscriptionList
807 subdata := xfmodel.SubscriptionData{Endpoint: []string{"xapp1.com:3800"}, SubscriptionID: -1, Meid: ""}
808 subdata2 := xfmodel.SubscriptionData{Endpoint: []string{"xapp2.com:3800"}, SubscriptionID: 11, Meid: ""}
809 subdata3 := xfmodel.SubscriptionData{Endpoint: []string{"xapp3.com:3800"}, SubscriptionID: 221, Meid: ""}
810 sublist = append(sublist, &subdata)
811 sublist = append(sublist, &subdata2)
812 sublist = append(sublist, &subdata3)
814 PopulateSubscription(sublist)