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"
38 xfmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
42 "routing-manager/pkg/models"
43 "routing-manager/pkg/rpe"
44 "routing-manager/pkg/rtmgr"
45 "routing-manager/pkg/sdl"
46 "routing-manager/pkg/sbi"
47 "routing-manager/pkg/stub"
50 "github.com/go-openapi/swag"
51 "github.com/spf13/viper"
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)
95 func TestValidateXappCallbackData_1(t *testing.T) {
96 data := models.XappCallbackData{
97 XApps: *swag.String("[]"),
98 Version: *swag.Int64(1),
99 Event: *swag.String("someevent"),
100 ID: *swag.String("123456")}
102 err := validateXappCallbackData(&data)
104 t.Error("Invalid XApp callback data: " + err.Error())
108 func TestValidateXappCallbackDataInvalid (t *testing.T) {
109 data := models.XappCallbackData{}
110 err := validateXappCallbackData(&data)
115 func TestValidateXappSubscriptionsData(t *testing.T) {
117 ep := make(map[string]*rtmgr.Endpoint)
118 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}
120 data := models.XappSubscriptionData{
121 Address: swag.String("10.1.1.1"),
123 SubscriptionID: swag.Int32(123456)}
126 err = validateXappSubscriptionData(&data)
131 data1 := models.XappSubscriptionData{
132 Address: swag.String(""),
134 SubscriptionID: swag.Int32(123456)}
135 err = validateXappSubscriptionData(&data1)
138 data2 := models.E2tData{
139 E2TAddress: swag.String(""),
141 /*err = validateE2tData(&data2)*/
143 //e2tchannel := make(chan *models.E2tData, 10)
144 _ = createNewE2tHandleHandlerImpl(&data2)
145 //defer close(e2tchannel)
147 //test case for provideXappSubscriptionHandleImp
148 //datachannel := make(chan *models.XappSubscriptionData, 10)
149 sdlEngine, _ = sdl.GetSdl("file")
150 sbiEngine, _ = sbi.GetSbi("rmrpush")
151 rpeEngine, _ = rpe.GetRpe ("rmrpush")
152 _ = provideXappSubscriptionHandleImpl( &data1)
153 //defer close(datachannel)
155 //test case for deleteXappSubscriptionHandleImpl
156 _ = deleteXappSubscriptionHandleImpl(&data1)
158 data3 := models.XappSubscriptionData{
159 Address: swag.String("10.55.55.5"),
161 SubscriptionID: swag.Int32(123456)}
162 //test case for deleteXappSubscriptionHandleImpl
163 _ = deleteXappSubscriptionHandleImpl(&data3)
164 data4 := models.XappSubscriptionData{
165 Address: swag.String("1.5.5.5"),
167 SubscriptionID: swag.Int32(1236)}
168 _ = deleteXappSubscriptionHandleImpl(&data4)
172 func TestValidateE2tDataEmpty(t *testing.T) {
173 data := models.E2tData{
174 E2TAddress: swag.String(""),
176 err := validateE2tData(&data)
180 func TestValidateE2tDataDNSLookUPfails(t *testing.T) {
181 data := models.E2tData{
182 E2TAddress: swag.String("e2t.1com:1234"),
184 err := validateE2tData(&data)
188 func TestValidateE2tDataInvalid(t *testing.T) {
189 data := models.E2tData{
190 E2TAddress: swag.String("10.101.01.1"),
192 err := validateE2tData(&data)
196 func TestValidateE2tDatavalid(t *testing.T) {
197 data := models.E2tData{
198 E2TAddress: swag.String("10.101.01.1:8098"),
202 err := validateE2tData(&data)
205 _ = createNewE2tHandleHandlerImpl(&data)
209 func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
210 data := models.E2tData{
211 E2TAddress: swag.String("10.101.01.1:8098"),
214 // insert endpoint for testing purpose
215 uuid := "10.101.01.1:8098"
216 ep := &rtmgr.Endpoint{
221 err := validateE2tData(&data)
224 // delete endpoint for at end of test case
225 delete(rtmgr.Eps, uuid);
230 func TestValidateDeleteE2tData(t *testing.T) {
233 data := models.E2tDeleteData{
234 E2TAddress: swag.String(""),
237 err := validateDeleteE2tData(&data)
238 if (err.Error() != "E2TAddress is empty!!!") {
244 data = models.E2tDeleteData{
245 E2TAddress: swag.String("10.101.01.1:8098"),
248 err = validateDeleteE2tData(&data)
254 //################ Create End Point dummy entry
255 uuid := "10.101.01.1:8098"
256 ep := &rtmgr.Endpoint{
260 //#####################
262 data = models.E2tDeleteData{
263 E2TAddress: swag.String("10.101.01.1:8098"),
264 RanAssocList: models.RanE2tMap{
265 {E2TAddress: swag.String("10.101.01.1:8098")},
269 err = validateDeleteE2tData(&data)
274 // delete endpoint for at end of test case
275 //################ Delete End Point dummy entry
276 delete(rtmgr.Eps, uuid);
277 //#####################
281 //################ Create End Point dummy entry
282 uuid = "10.101.01.1:9991"
283 ep = &rtmgr.Endpoint{
288 uuid = "10.101.01.1:9992"
289 ep = &rtmgr.Endpoint{
293 //#####################
295 data = models.E2tDeleteData{
296 E2TAddress: swag.String("10.101.01:8098"),
297 RanAssocList: models.RanE2tMap{
298 {E2TAddress: swag.String("10.101.01.1:9991")},
299 {E2TAddress: swag.String("10.101.01.1:9992")},
303 err = validateDeleteE2tData(&data)
307 //################ Delete End Point dummy entry
308 delete(rtmgr.Eps, "10.101.01.1:9991")
309 delete(rtmgr.Eps, "10.101.01.1:9992")
310 //#####################
314 data = models.E2tDeleteData{
315 E2TAddress: swag.String("10.101.01:8098"),
316 RanAssocList: models.RanE2tMap{
317 {E2TAddress: swag.String("10.101.01.19991")},
321 err = validateDeleteE2tData(&data)
322 if ( err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991") {
328 func TestValidateE2TAddressRANListData(t *testing.T) {
330 data := models.RanE2tMap{
332 E2TAddress: swag.String(""),
335 err := validateE2TAddressRANListData(data)
340 data = models.RanE2tMap{
342 E2TAddress: swag.String("10.101.01.1:8098"),
345 err = validateE2TAddressRANListData(data)
352 func TestAssociateRanToE2THandlerImpl(t *testing.T) {
354 data := models.RanE2tMap{
356 E2TAddress: swag.String("10.101.01.1:8098"),
359 err := associateRanToE2THandlerImpl( data)
364 //################ Create End Point dummy entry
365 uuid := "10.101.01.1:8098"
366 ep := &rtmgr.Endpoint{
370 //#####################
372 data = models.RanE2tMap{
374 E2TAddress: swag.String("10.101.01.1:8098"),
377 err = associateRanToE2THandlerImpl(data)
382 //################ Delete End Point dummy entry
383 delete(rtmgr.Eps, uuid);
384 //#####################
387 func TestDisassociateRanToE2THandlerImpl(t *testing.T) {
390 data := models.RanE2tMap{
392 E2TAddress: swag.String("10.101.01.1:8098"),
395 err := disassociateRanToE2THandlerImpl(data)
399 //################ Create End Point dummy entry
400 uuid := "10.101.01.1:8098"
401 ep := &rtmgr.Endpoint{
405 //#####################
407 data = models.RanE2tMap{
409 E2TAddress: swag.String("10.101.01.1:8098"),
412 err = disassociateRanToE2THandlerImpl(data)
417 //################ Delete End Point dummy entry
418 delete(rtmgr.Eps, uuid);
419 //#####################
422 func TestDeleteE2tHandleHandlerImpl(t *testing.T) {
424 data := models.E2tDeleteData{
425 E2TAddress: swag.String(""),
427 err := deleteE2tHandleHandlerImpl(&data)
432 //################ Create End Point dummy entry
433 uuid := "10.101.01.1:8098"
434 ep := &rtmgr.Endpoint{
438 //#####################
440 data = models.E2tDeleteData{
441 E2TAddress: swag.String("10.101.01.1:8098"),
443 err = deleteE2tHandleHandlerImpl(&data)
447 //################ Delete End Point dummy entry
448 delete(rtmgr.Eps, uuid);
449 //#####################
452 func TestSubscriptionExists(t *testing.T) {
454 data := models.XappSubscriptionData{
455 Address: swag.String("10.0.0.0"),
457 SubscriptionID: swag.Int32(1234)}
459 rtmgr.Subs = *stub.ValidSubscriptions
461 yes_no := subscriptionExists(&data)
462 yes_no = addSubscription(&rtmgr.Subs, &data)
463 yes_no = addSubscription(&rtmgr.Subs, &data)
464 yes_no = delSubscription(&rtmgr.Subs, &data)
465 yes_no = delSubscription(&rtmgr.Subs, &data)
469 func TestAddSubscriptions(t *testing.T) {
471 subdata := models.XappSubscriptionData{
472 Address: swag.String("10.0.0.0"),
474 SubscriptionID: swag.Int32(1234)}
476 rtmgr.Subs = *stub.ValidSubscriptions
477 yes_no := addSubscription(&rtmgr.Subs, &subdata)
482 func TestHttpInstance(t *testing.T) {
483 sdlEngine, _ := sdl.GetSdl("file")
484 rpeEngine, _ := rpe.GetRpe("rmrpush")
485 sbiEngine,_ := sbi.GetSbi("rmrpush")
486 httpinstance := NewHttpRestful()
487 err := httpinstance.Terminate()
489 fmt.Printf("sbiEngine = %v",sbiEngine)
491 createMockPlatformComponents()
492 //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
496 err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m)
499 func TestXappCallbackWithData(t *testing.T) {
500 data := models.XappCallbackData{
501 XApps: *swag.String("[]"),
502 Version: *swag.Int64(1),
503 Event: *swag.String("someevent"),
504 ID: *swag.String("123456")}
505 _, _ = recvXappCallbackData(&data)
508 func TestXappCallbackNodata(t *testing.T) {
509 //data := *models.XappCallbackData
510 _, _ = recvXappCallbackData(nil)
513 func TestE2TwithData(t *testing.T) {
514 data2 := models.E2tData{
515 E2TAddress: swag.String("1.2.3.4"),
516 RanNamelist: []string{"ran1","ran2"},
518 _, _,_ = recvNewE2Tdata(&data2)
521 func TestE2TwithNoData(t *testing.T) {
522 _, _,_ = recvNewE2Tdata(nil)
525 func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
527 data := models.XappSubscriptionData{
528 Address: swag.String("10.0.0.0"),
530 SubscriptionID: swag.Int32(1234)}
531 _ = provideXappSubscriptionHandleImpl(&data)
534 func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server {
535 l, err := net.Listen("tcp", url)
537 fmt.Println("Failed to create listener: " + err.Error())
539 ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
540 if r.Method == "GET" && r.URL.String() == "/ric/v1/xapps" {
541 w.Header().Add("Content-Type", "application/json")
542 w.WriteHeader(http.StatusOK)
545 if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
546 w.Header().Add("Content-Type", "application/json")
547 w.WriteHeader(http.StatusCreated)
550 if r.Method == "GET" && r.URL.String() == "/ric/v1/e2t/list" {
551 w.Header().Add("Content-Type", "application/json")
552 w.WriteHeader(http.StatusOK)
562 func createMockSubmgrWithData(url string, t []byte) *httptest.Server {
563 l, err := net.Listen("tcp", url)
565 fmt.Println("Failed to create listener: " + err.Error())
567 ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
569 if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" {
570 w.Header().Add("Content-Type", "application/json")
571 w.WriteHeader(http.StatusOK)
581 func createMockPlatformComponents() {
582 var filename = "config.json"
583 file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
584 filestr := string(file)
585 filestr = "{\"PlatformComponents\":" + filestr + "}"
586 file = []byte(filestr)
587 _ = ioutil.WriteFile(filename, file, 644)
590 func TestProvideXappHandleHandlerImpl(t *testing.T) {
591 data := models.XappCallbackData{
592 XApps: *swag.String("[]"),
593 Version: *swag.Int64(1),
594 Event: *swag.String("someevent"),
595 ID: *swag.String("123456")}
596 err := provideXappHandleHandlerImpl( &data)
598 //Empty XappCallbackdata
599 data1 := models.XappCallbackData{}
600 err = provideXappHandleHandlerImpl(&data1)
604 func TestValidateXappCallbackData(t *testing.T) {
605 data := models.XappCallbackData{
606 XApps: *swag.String("[]"),
607 Version: *swag.Int64(1),
608 Event: *swag.String("someevent"),
609 ID: *swag.String("123456")}
611 err := validateXappCallbackData(&data)
613 t.Error("Invalid XApp callback data: " + err.Error())
617 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
618 data := models.XappCallbackData{
619 XApps: *swag.String("{}"),
620 Version: *swag.Int64(1),
621 Event: *swag.String("someevent"),
622 ID: *swag.String("123456")}
624 err := validateXappCallbackData(&data)
626 t.Error("Invalid XApp callback data: " + err.Error())
630 func TestHttpGetXAppsInvalidData(t *testing.T) {
631 _, err := httpGetXApps(XMURL)
633 t.Error("No XApp data received: " + err.Error())
637 func TestHttpGetXAppsWithValidData(t *testing.T) {
639 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
643 xapplist, err := httpGetXApps(XMURL)
645 t.Error("Error occured: " + err.Error())
647 if len(*xapplist) != expected {
648 t.Error("Invalid XApp data: got " + string(len(*xapplist)) + ", expected " + string(expected))
654 func TestRetrieveStartupDataTimeout(t *testing.T) {
655 sdlEngine, _ := sdl.GetSdl("file")
656 createMockPlatformComponents()
657 err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
659 t.Error("Cannot retrieve startup data: " + err.Error())
662 os.Remove("config.json")
665 func TestRetrieveStartupData(t *testing.T) {
666 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
670 ts1 := createMockAppmgrWithData("127.0.0.1:8080", nil, nil, E2TListResp)
674 ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList)
678 sdlEngine, _ := sdl.GetSdl("file")
679 var httpRestful, _ = GetNbi("httpRESTful")
680 createMockPlatformComponents()
681 httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
682 //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
684 t.Error("Cannot retrieve startup data: " + err.Error())
687 os.Remove("config.json")
690 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
691 ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
694 sdlEngine, _ := sdl.GetSdl("file")
695 var httpRestful, _ = GetNbi("httpRESTful")
696 createMockPlatformComponents()
697 err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine)
699 t.Error("Cannot retrieve startup data: " + err.Error())
702 os.Remove("config.json")
705 func TestInvalidarguments(t *testing.T) {
706 _ = PostSubReq("\n","nbifinterface")
707 _ = PostSubReq("xmurl","\n")
710 func TestInitEngine(t *testing.T) {
714 func TestUpdateXappSubscription(t *testing.T) {
715 ep := make(map[string]*rtmgr.Endpoint)
716 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}
722 xapp := models.XappElement{
723 Address: swag.String("10.1.1.1"),
727 var b models.XappList
729 _ = updateXappSubscriptionHandleImpl(&b, 10)
731 //Test case when subscriptions already exist
732 data := models.XappSubscriptionData{
733 Address: swag.String("10.0.0.0"),
735 SubscriptionID: swag.Int32(12345)}
737 rtmgr.Subs = *stub.ValidSubscriptions
739 subscriptionExists(&data)
740 addSubscription(&rtmgr.Subs, &data)
741 _ = updateXappSubscriptionHandleImpl(&b, 10)
746 func TestDumpDebugdata(t *testing.T) {
747 _,_ = dumpDebugData()
750 func TestManagerRequest(t *testing.T) {
751 var params xapp.RMRParams
752 var rmrmeid xapp.RMRMeid
753 sdlEngine, _ = sdl.GetSdl("file")
754 sbiEngine, _ = sbi.GetSbi("rmrpush")
755 rpeEngine, _ = rpe.GetRpe ("rmrpush")
756 rmrmeid.RanName = "gnb1"
757 c := Control{make(chan *xapp.RMRParams)}
758 params.Payload = []byte{1, 2,3,4}
761 params.Meid = &rmrmeid
762 params.Src = "sender"
763 params.PayloadLen = 4
764 c.handleUpdateToRoutingManagerRequest(¶ms)
767 func TestRecievermr(t *testing.T) {
768 var params xapp.RMRParams
769 var rmrmeid xapp.RMRMeid
770 sdlEngine, _ = sdl.GetSdl("file")
771 sbiEngine, _ = sbi.GetSbi("rmrpush")
772 rpeEngine, _ = rpe.GetRpe ("rmrpush")
773 rmrmeid.RanName = "gnb1"
775 params.Payload = []byte{1, 2,3,4}
777 params.Meid = &rmrmeid
778 params.Src = "sender"
779 params.PayloadLen = 4
781 c := Control{make(chan *xapp.RMRParams)}
782 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
783 c.recievermr(¶ms)
784 params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"]
785 c.recievermr(¶ms)
787 c.recievermr(¶ms)
789 rtmgr.Rtmgr_ready = true
790 params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"]
791 c.recievermr(¶ms)
794 func TestAddDelRmr(t *testing.T) {
795 sdlEngine, _ = sdl.GetSdl("file")
796 sbiEngine, _ = sbi.GetSbi("rmrpush")
797 rpeEngine, _ = rpe.GetRpe ("rmrpush")
798 var routelist models.Routelist
799 mtype := uint32(1234)
800 tendpoint := "goofle.com"
801 listofroutes := models.AddRmrRoute { SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint}
802 listofroutes2 := models.AddRmrRoute { SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint}
803 listofroutes3 := models.AddRmrRoute { MessageType: &mtype, TargetEndPoint: &tendpoint}
804 adddelrmrroute(routelist,false)
805 routelist = append(routelist,&listofroutes)
806 routelist = append(routelist,&listofroutes2)
807 routelist = append(routelist,&listofroutes3)
808 routelist = append(routelist,&listofroutes3)
809 adddelrmrroute(routelist,true)
811 adddelrmrroute(routelist,false)
814 func TestPopulateSubscription(t *testing.T) {
815 var sublist xfmodel.SubscriptionList
817 subdata := xfmodel.SubscriptionData { Endpoint: []string{"xapp1.com:3800"}, SubscriptionID: -1, Meid: "" }
818 subdata2 := xfmodel.SubscriptionData { Endpoint: []string{"xapp2.com:3800"}, SubscriptionID: 11, Meid: "" }
819 subdata3 := xfmodel.SubscriptionData { Endpoint: []string{"xapp3.com:3800"}, SubscriptionID: 221, Meid: "" }
820 sublist = append(sublist,&subdata)
821 sublist = append(sublist,&subdata2)
822 sublist = append(sublist,&subdata3)
824 PopulateSubscription(sublist)