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
37 "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
41 "routing-manager/pkg/models"
42 "routing-manager/pkg/rpe"
43 "routing-manager/pkg/rtmgr"
44 "routing-manager/pkg/sdl"
45 "routing-manager/pkg/sbi"
46 "routing-manager/pkg/stub"
49 "github.com/go-openapi/swag"
50 "github.com/spf13/viper"
54 var BasicXAppLists = []byte(`[
56 "name":"xapp-01","status":"unknown","version":"1.2.3",
58 {"name":"xapp-01-instance-01","status":"pending","ip":"172.16.1.103","port":4555,
59 "txMessages":["ControlIndication"],
60 "rxMessages":["LoadIndication","Reset"]
62 {"name":"xapp-01-instance-02","status":"pending","ip":"10.244.1.12","port":4561,
63 "txMessages":["ControlIndication","SNStatusTransfer"],
64 "rxMessages":["LoadIndication","HandoverPreparation"]
70 var SubscriptionResp = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
72 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"]}]`)
74 var SubscriptionList = []byte(`[{"SubscriptionId":11,"Meid":"Test-Gnb","Endpoint":["127.0.0.1:4056"]}]`)
76 var InvalidSubResp = []byte(`{"Version":0, "EventType":all}`)
78 type Consumer struct{}
80 func (m Consumer) Consume(params *xapp.RMRParams) (err error) {
81 xapp.Sdl.Store("myKey", params.Payload)
86 func TestMain(m *testing.M) {
87 go xapp.RunWithParams(Consumer{}, viper.GetBool("db.waitForSdl"))
88 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)
114 func TestValidateXappSubscriptionsData(t *testing.T) {
116 ep := make(map[string]*rtmgr.Endpoint)
117 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}
119 data := models.XappSubscriptionData{
120 Address: swag.String("10.1.1.1"),
122 SubscriptionID: swag.Int32(123456)}
125 err = validateXappSubscriptionData(&data)
130 data1 := models.XappSubscriptionData{
131 Address: swag.String(""),
133 SubscriptionID: swag.Int32(123456)}
134 err = validateXappSubscriptionData(&data1)
137 data2 := models.E2tData{
138 E2TAddress: swag.String(""),
140 /*err = validateE2tData(&data2)*/
142 //e2tchannel := make(chan *models.E2tData, 10)
143 _ = createNewE2tHandleHandlerImpl(&data2)
144 //defer close(e2tchannel)
146 //test case for provideXappSubscriptionHandleImp
147 //datachannel := make(chan *models.XappSubscriptionData, 10)
148 sdlEngine, _ = sdl.GetSdl("file")
149 sbiEngine, _ = sbi.GetSbi("rmrpush")
150 rpeEngine, _ = rpe.GetRpe ("rmrpush")
151 _ = provideXappSubscriptionHandleImpl( &data1)
152 //defer close(datachannel)
154 //test case for deleteXappSubscriptionHandleImpl
155 _ = deleteXappSubscriptionHandleImpl(&data1)
157 data3 := models.XappSubscriptionData{
158 Address: swag.String("10.55.55.5"),
160 SubscriptionID: swag.Int32(123456)}
161 //test case for deleteXappSubscriptionHandleImpl
162 _ = deleteXappSubscriptionHandleImpl(&data3)
163 data4 := models.XappSubscriptionData{
164 Address: swag.String("1.5.5.5"),
166 SubscriptionID: swag.Int32(1236)}
167 _ = deleteXappSubscriptionHandleImpl(&data4)
171 func TestValidateE2tDataEmpty(t *testing.T) {
172 data := models.E2tData{
173 E2TAddress: swag.String(""),
175 err := validateE2tData(&data)
179 func TestValidateE2tDataDNSLookUPfails(t *testing.T) {
180 data := models.E2tData{
181 E2TAddress: swag.String("e2t.1com:1234"),
183 err := validateE2tData(&data)
187 func TestValidateE2tDataInvalid(t *testing.T) {
188 data := models.E2tData{
189 E2TAddress: swag.String("10.101.01.1"),
191 err := validateE2tData(&data)
195 func TestValidateE2tDatavalid(t *testing.T) {
196 data := models.E2tData{
197 E2TAddress: swag.String("10.101.01.1:8098"),
201 err := validateE2tData(&data)
204 _ = createNewE2tHandleHandlerImpl(&data)
208 func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
209 data := models.E2tData{
210 E2TAddress: swag.String("10.101.01.1:8098"),
213 // insert endpoint for testing purpose
214 uuid := "10.101.01.1:8098"
215 ep := &rtmgr.Endpoint{
220 err := validateE2tData(&data)
223 // delete endpoint for at end of test case
224 delete(rtmgr.Eps, uuid);
229 func TestValidateDeleteE2tData(t *testing.T) {
232 data := models.E2tDeleteData{
233 E2TAddress: swag.String(""),
236 err := validateDeleteE2tData(&data)
237 if (err.Error() != "E2TAddress is empty!!!") {
243 data = models.E2tDeleteData{
244 E2TAddress: swag.String("10.101.01.1:8098"),
247 err = validateDeleteE2tData(&data)
253 //################ Create End Point dummy entry
254 uuid := "10.101.01.1:8098"
255 ep := &rtmgr.Endpoint{
259 //#####################
261 data = models.E2tDeleteData{
262 E2TAddress: swag.String("10.101.01.1:8098"),
263 RanAssocList: models.RanE2tMap{
264 {E2TAddress: swag.String("10.101.01.1:8098")},
268 err = validateDeleteE2tData(&data)
273 // delete endpoint for at end of test case
274 //################ Delete End Point dummy entry
275 delete(rtmgr.Eps, uuid);
276 //#####################
280 //################ Create End Point dummy entry
281 uuid = "10.101.01.1:9991"
282 ep = &rtmgr.Endpoint{
287 uuid = "10.101.01.1:9992"
288 ep = &rtmgr.Endpoint{
292 //#####################
294 data = models.E2tDeleteData{
295 E2TAddress: swag.String("10.101.01:8098"),
296 RanAssocList: models.RanE2tMap{
297 {E2TAddress: swag.String("10.101.01.1:9991")},
298 {E2TAddress: swag.String("10.101.01.1:9992")},
302 err = validateDeleteE2tData(&data)
306 //################ Delete End Point dummy entry
307 delete(rtmgr.Eps, "10.101.01.1:9991")
308 delete(rtmgr.Eps, "10.101.01.1:9992")
309 //#####################
313 data = models.E2tDeleteData{
314 E2TAddress: swag.String("10.101.01:8098"),
315 RanAssocList: models.RanE2tMap{
316 {E2TAddress: swag.String("10.101.01.19991")},
320 err = validateDeleteE2tData(&data)
321 if ( err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991") {
327 func TestValidateE2TAddressRANListData(t *testing.T) {
329 data := models.RanE2tMap{
331 E2TAddress: swag.String(""),
334 err := validateE2TAddressRANListData(data)
339 data = models.RanE2tMap{
341 E2TAddress: swag.String("10.101.01.1:8098"),
344 err = validateE2TAddressRANListData(data)
351 func TestAssociateRanToE2THandlerImpl(t *testing.T) {
353 data := models.RanE2tMap{
355 E2TAddress: swag.String("10.101.01.1:8098"),
358 err := associateRanToE2THandlerImpl( data)
363 //################ Create End Point dummy entry
364 uuid := "10.101.01.1:8098"
365 ep := &rtmgr.Endpoint{
369 //#####################
371 data = models.RanE2tMap{
373 E2TAddress: swag.String("10.101.01.1:8098"),
376 err = associateRanToE2THandlerImpl(data)
381 //################ Delete End Point dummy entry
382 delete(rtmgr.Eps, uuid);
383 //#####################
386 func TestDisassociateRanToE2THandlerImpl(t *testing.T) {
389 data := models.RanE2tMap{
391 E2TAddress: swag.String("10.101.01.1:8098"),
394 err := disassociateRanToE2THandlerImpl(data)
398 //################ Create End Point dummy entry
399 uuid := "10.101.01.1:8098"
400 ep := &rtmgr.Endpoint{
404 //#####################
406 data = models.RanE2tMap{
408 E2TAddress: swag.String("10.101.01.1:8098"),
411 err = disassociateRanToE2THandlerImpl(data)
416 //################ Delete End Point dummy entry
417 delete(rtmgr.Eps, uuid);
418 //#####################
421 func TestDeleteE2tHandleHandlerImpl(t *testing.T) {
423 data := models.E2tDeleteData{
424 E2TAddress: swag.String(""),
426 err := deleteE2tHandleHandlerImpl(&data)
431 //################ Create End Point dummy entry
432 uuid := "10.101.01.1:8098"
433 ep := &rtmgr.Endpoint{
437 //#####################
439 data = models.E2tDeleteData{
440 E2TAddress: swag.String("10.101.01.1:8098"),
442 err = deleteE2tHandleHandlerImpl(&data)
446 //################ Delete End Point dummy entry
447 delete(rtmgr.Eps, uuid);
448 //#####################
451 func TestSubscriptionExists(t *testing.T) {
453 data := models.XappSubscriptionData{
454 Address: swag.String("10.0.0.0"),
456 SubscriptionID: swag.Int32(1234)}
458 rtmgr.Subs = *stub.ValidSubscriptions
460 yes_no := subscriptionExists(&data)
461 yes_no = addSubscription(&rtmgr.Subs, &data)
462 yes_no = addSubscription(&rtmgr.Subs, &data)
463 yes_no = delSubscription(&rtmgr.Subs, &data)
464 yes_no = delSubscription(&rtmgr.Subs, &data)
468 func TestAddSubscriptions(t *testing.T) {
470 subdata := models.XappSubscriptionData{
471 Address: swag.String("10.0.0.0"),
473 SubscriptionID: swag.Int32(1234)}
475 rtmgr.Subs = *stub.ValidSubscriptions
476 yes_no := addSubscription(&rtmgr.Subs, &subdata)
481 func TestHttpInstance(t *testing.T) {
482 sdlEngine, _ := sdl.GetSdl("file")
483 rpeEngine, _ := rpe.GetRpe("rmrpush")
484 sbiEngine,_ := sbi.GetSbi("rmrpush")
485 httpinstance := NewHttpRestful()
486 err := httpinstance.Terminate()
488 fmt.Printf("sbiEngine = %v",sbiEngine)
490 createMockPlatformComponents()
491 //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
495 err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m)
498 func TestXappCallbackWithData(t *testing.T) {
499 data := models.XappCallbackData{
500 XApps: *swag.String("[]"),
501 Version: *swag.Int64(1),
502 Event: *swag.String("someevent"),
503 ID: *swag.String("123456")}
504 _, _ = recvXappCallbackData(&data)
507 func TestXappCallbackNodata(t *testing.T) {
508 //data := *models.XappCallbackData
509 _, _ = recvXappCallbackData(nil)
512 func TestE2TwithData(t *testing.T) {
513 data2 := models.E2tData{
514 E2TAddress: swag.String("1.2.3.4"),
515 RanNamelist: []string{"ran1","ran2"},
517 _, _,_ = recvNewE2Tdata(&data2)
520 func TestE2TwithNoData(t *testing.T) {
521 _, _,_ = recvNewE2Tdata(nil)
524 func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
526 data := models.XappSubscriptionData{
527 Address: swag.String("10.0.0.0"),
529 SubscriptionID: swag.Int32(1234)}
530 _ = provideXappSubscriptionHandleImpl(&data)
533 func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server {
534 l, err := net.Listen("tcp", url)
536 fmt.Println("Failed to create listener: " + err.Error())
538 ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
539 if r.Method == "GET" && r.URL.String() == "/ric/v1/xapps" {
540 w.Header().Add("Content-Type", "application/json")
541 w.WriteHeader(http.StatusOK)
544 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
545 w.Header().Add("Content-Type", "application/json")
546 w.WriteHeader(http.StatusCreated)
549 if r.Method == "GET" && r.URL.String() == "/ric/v1/e2t/list" {
550 w.Header().Add("Content-Type", "application/json")
551 w.WriteHeader(http.StatusOK)
561 func createMockSubmgrWithData(url string, t []byte) *httptest.Server {
562 l, err := net.Listen("tcp", url)
564 fmt.Println("Failed to create listener: " + err.Error())
566 ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
568 if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" {
569 w.Header().Add("Content-Type", "application/json")
570 w.WriteHeader(http.StatusOK)
580 func createMockPlatformComponents() {
581 var filename = "config.json"
582 file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
583 filestr := string(file)
584 filestr = "{\"PlatformComponents\":" + filestr + "}"
585 file = []byte(filestr)
586 _ = ioutil.WriteFile(filename, file, 644)
589 func TestProvideXappHandleHandlerImpl(t *testing.T) {
590 data := models.XappCallbackData{
591 XApps: *swag.String("[]"),
592 Version: *swag.Int64(1),
593 Event: *swag.String("someevent"),
594 ID: *swag.String("123456")}
595 err := provideXappHandleHandlerImpl( &data)
597 //Empty XappCallbackdata
598 data1 := models.XappCallbackData{}
599 err = provideXappHandleHandlerImpl(&data1)
603 func TestValidateXappCallbackData(t *testing.T) {
604 data := models.XappCallbackData{
605 XApps: *swag.String("[]"),
606 Version: *swag.Int64(1),
607 Event: *swag.String("someevent"),
608 ID: *swag.String("123456")}
610 err := validateXappCallbackData(&data)
612 t.Error("Invalid XApp callback data: " + err.Error())
616 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
617 data := models.XappCallbackData{
618 XApps: *swag.String("{}"),
619 Version: *swag.Int64(1),
620 Event: *swag.String("someevent"),
621 ID: *swag.String("123456")}
623 err := validateXappCallbackData(&data)
625 t.Error("Invalid XApp callback data: " + err.Error())
629 func TestHttpGetXAppsInvalidData(t *testing.T) {
630 _, err := httpGetXApps(XMURL)
632 t.Error("No XApp data received: " + err.Error())
636 func TestHttpGetXAppsWithValidData(t *testing.T) {
638 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
642 xapplist, err := httpGetXApps(XMURL)
644 t.Error("Error occured: " + err.Error())
646 if len(*xapplist) != expected {
647 t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
653 func TestRetrieveStartupDataTimeout(t *testing.T) {
654 sdlEngine, _ := sdl.GetSdl("file")
655 createMockPlatformComponents()
656 err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
658 t.Error("Cannot retrieve startup data: " + err.Error())
661 os.Remove("config.json")
664 func TestRetrieveStartupData(t *testing.T) {
665 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
669 ts1 := createMockAppmgrWithData("127.0.0.1:8080", nil, nil, E2TListResp)
673 ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList)
677 sdlEngine, _ := sdl.GetSdl("file")
678 var httpRestful, _ = GetNbi("httpRESTful")
679 createMockPlatformComponents()
680 httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
681 //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
683 t.Error("Cannot retrieve startup data: " + err.Error())
686 os.Remove("config.json")
689 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
690 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
693 sdlEngine, _ := sdl.GetSdl("file")
694 var httpRestful, _ = GetNbi("httpRESTful")
695 createMockPlatformComponents()
696 err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
698 t.Error("Cannot retrieve startup data: " + err.Error())
701 os.Remove("config.json")
704 func TestInvalidarguments(t *testing.T) {
705 _ = PostSubReq("\n","nbifinterface")
706 _ = PostSubReq("xmurl","\n")
709 func TestInitEngine(t *testing.T) {
713 func TestUpdateXappSubscription(t *testing.T) {
714 ep := make(map[string]*rtmgr.Endpoint)
715 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}
721 xapp := models.XappElement{
722 Address: swag.String("10.1.1.1"),
726 var b models.XappList
728 _ = updateXappSubscriptionHandleImpl(&b, 10)
730 //Test case when subscriptions already exist
731 data := models.XappSubscriptionData{
732 Address: swag.String("10.0.0.0"),
734 SubscriptionID: swag.Int32(12345)}
736 rtmgr.Subs = *stub.ValidSubscriptions
738 subscriptionExists(&data)
739 addSubscription(&rtmgr.Subs, &data)
740 _ = updateXappSubscriptionHandleImpl(&b, 10)
745 func TestDumpDebugdata(t *testing.T) {
746 _,_ = dumpDebugData()
749 func TestManagerRequest(t *testing.T) {
750 var params xapp.RMRParams
751 var rmrmeid xapp.RMRMeid
752 sdlEngine, _ = sdl.GetSdl("file")
753 sbiEngine, _ = sbi.GetSbi("rmrpush")
754 rpeEngine, _ = rpe.GetRpe ("rmrpush")
755 rmrmeid.RanName = "gnb1"
756 c := Control{make(chan *xapp.RMRParams)}
757 params.Payload = []byte{1, 2,3,4}
760 params.Meid = &rmrmeid
761 params.Src = "sender"
762 params.PayloadLen = 4
763 c.handleUpdateToRoutingManagerRequest(¶ms)
766 func TestRecievermr(t *testing.T) {
767 var params xapp.RMRParams
768 var rmrmeid xapp.RMRMeid
769 sdlEngine, _ = sdl.GetSdl("file")
770 sbiEngine, _ = sbi.GetSbi("rmrpush")
771 rpeEngine, _ = rpe.GetRpe ("rmrpush")
772 rmrmeid.RanName = "gnb1"
774 params.Payload = []byte{1, 2,3,4}
776 params.Meid = &rmrmeid
777 params.Src = "sender"
778 params.PayloadLen = 4
780 c := Control{make(chan *xapp.RMRParams)}
781 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
782 c.recievermr(¶ms)
783 params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"]
784 c.recievermr(¶ms)
786 c.recievermr(¶ms)
788 rtmgr.Rtmgr_ready = true
789 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
790 c.recievermr(¶ms)
793 func TestAddDelRmr(t *testing.T) {
794 sdlEngine, _ = sdl.GetSdl("file")
795 sbiEngine, _ = sbi.GetSbi("rmrpush")
796 rpeEngine, _ = rpe.GetRpe ("rmrpush")
797 var routelist models.Routelist
798 mtype := uint32(1234)
799 tendpoint := "goofle.com"
800 listofroutes := models.AddRmrRoute { SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint}
801 listofroutes2 := models.AddRmrRoute { SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint}
802 listofroutes3 := models.AddRmrRoute { MessageType: &mtype, TargetEndPoint: &tendpoint}
803 adddelrmrroute(routelist,false)
804 routelist = append(routelist,&listofroutes)
805 routelist = append(routelist,&listofroutes2)
806 routelist = append(routelist,&listofroutes3)
807 routelist = append(routelist,&listofroutes3)
808 adddelrmrroute(routelist,true)
810 adddelrmrroute(routelist,false)