X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fnbi%2Fhttprestful_test.go;h=aece2b0c67ec8c31f3f7d1d280ab8c476b35c6fe;hb=1433f4d8e1022cdc6ffd505a9b18130c66f1101d;hp=e73f303774509d638d3f3356d4e06ddfa5249e67;hpb=2f9b55c1a2aac9f0865beb73b6619b106b32edb2;p=ric-plt%2Frtmgr.git diff --git a/pkg/nbi/httprestful_test.go b/pkg/nbi/httprestful_test.go index e73f303..aece2b0 100644 --- a/pkg/nbi/httprestful_test.go +++ b/pkg/nbi/httprestful_test.go @@ -32,6 +32,10 @@ package nbi import ( "encoding/json" "fmt" + xfmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models" + "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp" + "github.com/go-openapi/swag" + "github.com/spf13/viper" "io/ioutil" "net" "net/http" @@ -40,12 +44,12 @@ import ( "routing-manager/pkg/models" "routing-manager/pkg/rpe" "routing-manager/pkg/rtmgr" + "routing-manager/pkg/sbi" "routing-manager/pkg/sdl" "routing-manager/pkg/stub" + "sync" "testing" "time" - "sync" - "github.com/go-openapi/swag" ) var BasicXAppLists = []byte(`[ @@ -66,8 +70,27 @@ var BasicXAppLists = []byte(`[ var SubscriptionResp = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`) +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"]}]`) + +var SubscriptionList = []byte(`[{"SubscriptionId":11,"Meid":"Test-Gnb","Endpoint":["127.0.0.1:4056"]}]`) + var InvalidSubResp = []byte(`{"Version":0, "EventType":all}`) +type Consumer struct{} + +func (m Consumer) Consume(params *xapp.RMRParams) (err error) { + xapp.Sdl.Store("myKey", params.Payload) + return nil +} + +// Test cases +func TestMain(m *testing.M) { + go xapp.RunWithParams(Consumer{}, viper.GetBool("db.waitForSdl")) + time.Sleep(time.Duration(5) * time.Second) + code := m.Run() + os.Exit(code) +} + func TestValidateXappCallbackData_1(t *testing.T) { data := models.XappCallbackData{ XApps: *swag.String("[]"), @@ -81,15 +104,15 @@ func TestValidateXappCallbackData_1(t *testing.T) { } } -func TestValidateXappCallbackDataInvalid (t *testing.T) { +func TestValidateXappCallbackDataInvalid(t *testing.T) { data := models.XappCallbackData{} err := validateXappCallbackData(&data) t.Log(err) } - func TestValidateXappSubscriptionsData(t *testing.T) { + rtmgr.RMRConnStatus = make(map[string]bool) ep := make(map[string]*rtmgr.Endpoint) 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} p := uint16(1234) @@ -109,7 +132,6 @@ func TestValidateXappSubscriptionsData(t *testing.T) { Port: &p, SubscriptionID: swag.Int32(123456)} err = validateXappSubscriptionData(&data1) - t.Log(err) //Validate E2tData data2 := models.E2tData{ @@ -117,62 +139,76 @@ func TestValidateXappSubscriptionsData(t *testing.T) { } /*err = validateE2tData(&data2)*/ - e2tchannel := make(chan *models.E2tData, 10) - _ = createNewE2tHandleHandlerImpl(e2tchannel, &data2) - defer close(e2tchannel) + //e2tchannel := make(chan *models.E2tData, 10) + _ = CreateNewE2tHandleHandlerImpl(&data2) + //defer close(e2tchannel) //test case for provideXappSubscriptionHandleImp - datachannel := make(chan *models.XappSubscriptionData, 10) - _ = provideXappSubscriptionHandleImpl(datachannel, &data1) - defer close(datachannel) + //datachannel := make(chan *models.XappSubscriptionData, 10) + sdlEngine, _ = sdl.GetSdl("file") + sbiEngine, _ = sbi.GetSbi("rmrpush") + rpeEngine, _ = rpe.GetRpe("rmrpush") + _ = ProvideXappSubscriptionHandleImpl(&data1) + //defer close(datachannel) //test case for deleteXappSubscriptionHandleImpl - _ = deleteXappSubscriptionHandleImpl(datachannel, &data1) + _ = DeleteXappSubscriptionHandleImpl(&data1) data3 := models.XappSubscriptionData{ Address: swag.String("10.55.55.5"), Port: &p, SubscriptionID: swag.Int32(123456)} //test case for deleteXappSubscriptionHandleImpl - _ = deleteXappSubscriptionHandleImpl(datachannel, &data3) + _ = DeleteXappSubscriptionHandleImpl(&data3) + data4 := models.XappSubscriptionData{ + Address: swag.String("1.5.5.5"), + Port: &p, + SubscriptionID: swag.Int32(1236)} + _ = DeleteXappSubscriptionHandleImpl(&data4) + } func TestValidateE2tDataEmpty(t *testing.T) { data := models.E2tData{ E2TAddress: swag.String(""), } - err := validateE2tData(&data) + err, _ := validateE2tData(&data) t.Log(err) } func TestValidateE2tDataDNSLookUPfails(t *testing.T) { + rtmgr.RMRConnStatus = make(map[string]bool) data := models.E2tData{ E2TAddress: swag.String("e2t.1com:1234"), } - err := validateE2tData(&data) + err, _ := validateE2tData(&data) t.Log(err) } func TestValidateE2tDataInvalid(t *testing.T) { + rtmgr.RMRConnStatus = make(map[string]bool) data := models.E2tData{ E2TAddress: swag.String("10.101.01.1"), } - err := validateE2tData(&data) + err, _ := validateE2tData(&data) t.Log(err) } func TestValidateE2tDatavalid(t *testing.T) { + rtmgr.RMRConnStatus = make(map[string]bool) data := models.E2tData{ E2TAddress: swag.String("10.101.01.1:8098"), } - - err := validateE2tData(&data) + err, _ := validateE2tData(&data) t.Log(err) + _ = CreateNewE2tHandleHandlerImpl(&data) + } func TestValidateE2tDatavalidEndpointPresent(t *testing.T) { + rtmgr.RMRConnStatus = make(map[string]bool) data := models.E2tData{ E2TAddress: swag.String("10.101.01.1:8098"), } @@ -180,50 +216,49 @@ func TestValidateE2tDatavalidEndpointPresent(t *testing.T) { // insert endpoint for testing purpose uuid := "10.101.01.1:8098" ep := &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep - err := validateE2tData(&data) + err, _ := validateE2tData(&data) t.Log(err) - // delete endpoint for at end of test case - delete(rtmgr.Eps, uuid); + // delete endpoint for at end of test case + delete(rtmgr.Eps, uuid) } - func TestValidateDeleteE2tData(t *testing.T) { -// test-1 + rtmgr.RMRConnStatus = make(map[string]bool) + // test-1 data := models.E2tDeleteData{ E2TAddress: swag.String(""), } err := validateDeleteE2tData(&data) - if (err.Error() != "E2TAddress is empty!!!") { + if err.Error() != "E2TAddress is empty!!!" { t.Log(err) } - -// test-2 + // test-2 data = models.E2tDeleteData{ E2TAddress: swag.String("10.101.01.1:8098"), } err = validateDeleteE2tData(&data) - if (err != nil ) { + if err != nil { t.Log(err) } -// test-3 -//################ Create End Point dummy entry + // test-3 + //################ Create End Point dummy entry uuid := "10.101.01.1:8098" ep := &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep -//##################### + //##################### data = models.E2tDeleteData{ E2TAddress: swag.String("10.101.01.1:8098"), @@ -233,30 +268,30 @@ func TestValidateDeleteE2tData(t *testing.T) { } err = validateDeleteE2tData(&data) - if (err != nil ) { + if err != nil { t.Log(err) } - // delete endpoint for at end of test case -//################ Delete End Point dummy entry - delete(rtmgr.Eps, uuid); -//##################### + // delete endpoint for at end of test case + //################ Delete End Point dummy entry + delete(rtmgr.Eps, uuid) + //##################### -// test-4 + // test-4 -//################ Create End Point dummy entry + //################ Create End Point dummy entry uuid = "10.101.01.1:9991" ep = &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep uuid = "10.101.01.1:9992" ep = &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep -//##################### + //##################### data = models.E2tDeleteData{ E2TAddress: swag.String("10.101.01:8098"), @@ -267,15 +302,15 @@ func TestValidateDeleteE2tData(t *testing.T) { } err = validateDeleteE2tData(&data) - if (err != nil ) { + if err != nil { t.Log(err) } -//################ Delete End Point dummy entry - delete(rtmgr.Eps, "10.101.01.1:9991") - delete(rtmgr.Eps, "10.101.01.1:9992") -//##################### + //################ Delete End Point dummy entry + delete(rtmgr.Eps, "10.101.01.1:9991") + delete(rtmgr.Eps, "10.101.01.1:9992") + //##################### -// test-5 + // test-5 data = models.E2tDeleteData{ E2TAddress: swag.String("10.101.01:8098"), @@ -285,31 +320,30 @@ func TestValidateDeleteE2tData(t *testing.T) { } err = validateDeleteE2tData(&data) - if ( err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991") { + if err.Error() != "E2T Delete - RanAssocList E2TAddress is not a proper format like ip:port, 10.101.01.19991" { t.Log(err) } } - func TestValidateE2TAddressRANListData(t *testing.T) { data := models.RanE2tMap{ - { - E2TAddress: swag.String(""), - }, + { + E2TAddress: swag.String(""), + }, } err := validateE2TAddressRANListData(data) - if (err != nil ) { + if err != nil { t.Log(err) } data = models.RanE2tMap{ - { - E2TAddress: swag.String("10.101.01.1:8098"), - }, + { + E2TAddress: swag.String("10.101.01.1:8098"), + }, } err = validateE2TAddressRANListData(data) - if (err != nil ) { + if err != nil { t.Log(err) } @@ -317,112 +351,101 @@ func TestValidateE2TAddressRANListData(t *testing.T) { func TestAssociateRanToE2THandlerImpl(t *testing.T) { - associateranchan := make(chan models.RanE2tMap, 10) data := models.RanE2tMap{ - { - E2TAddress: swag.String("10.101.01.1:8098"), - }, + { + E2TAddress: swag.String("10.101.01.1:8098"), + }, } - err := associateRanToE2THandlerImpl(associateranchan, data) - if (err != nil ) { + err := AssociateRanToE2THandlerImpl(data) + if err != nil { t.Log(err) } -//################ Create End Point dummy entry + //################ Create End Point dummy entry uuid := "10.101.01.1:8098" ep := &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep -//##################### + //##################### data = models.RanE2tMap{ - { - E2TAddress: swag.String("10.101.01.1:8098"), - }, + { + E2TAddress: swag.String("10.101.01.1:8098"), + }, } - err = associateRanToE2THandlerImpl(associateranchan, data) - if (err != nil ) { + err = AssociateRanToE2THandlerImpl(data) + if err != nil { t.Log(err) } - data1 := <-associateranchan - fmt.Println(data1) -//################ Delete End Point dummy entry - delete(rtmgr.Eps, uuid); -//##################### + //################ Delete End Point dummy entry + delete(rtmgr.Eps, uuid) + //##################### } func TestDisassociateRanToE2THandlerImpl(t *testing.T) { - disassranchan := make(chan models.RanE2tMap, 10) - data := models.RanE2tMap{ - { - E2TAddress: swag.String("10.101.01.1:8098"), - }, + { + E2TAddress: swag.String("10.101.01.1:8098"), + }, } - err := disassociateRanToE2THandlerImpl(disassranchan, data) - if (err != nil ) { + err := DisassociateRanToE2THandlerImpl(data) + if err != nil { t.Log(err) } -//################ Create End Point dummy entry + //################ Create End Point dummy entry uuid := "10.101.01.1:8098" ep := &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep -//##################### + //##################### data = models.RanE2tMap{ - { - E2TAddress: swag.String("10.101.01.1:8098"), - }, + { + E2TAddress: swag.String("10.101.01.1:8098"), + }, } - err = disassociateRanToE2THandlerImpl(disassranchan, data) - if (err != nil ) { + err = DisassociateRanToE2THandlerImpl(data) + if err != nil { t.Log(err) } - data1 := <-disassranchan - fmt.Println(data1) -//################ Delete End Point dummy entry - delete(rtmgr.Eps, uuid); -//##################### + //################ Delete End Point dummy entry + delete(rtmgr.Eps, uuid) + //##################### } func TestDeleteE2tHandleHandlerImpl(t *testing.T) { - e2tdelchan := make(chan *models.E2tDeleteData, 10) data := models.E2tDeleteData{ E2TAddress: swag.String(""), } - err := deleteE2tHandleHandlerImpl(e2tdelchan, &data) - if (err != nil ) { + err := DeleteE2tHandleHandlerImpl(&data) + if err != nil { t.Log(err) } -//################ Create End Point dummy entry + //################ Create End Point dummy entry uuid := "10.101.01.1:8098" ep := &rtmgr.Endpoint{ - Uuid: uuid, + Uuid: uuid, } rtmgr.Eps[uuid] = ep -//##################### + //##################### data = models.E2tDeleteData{ E2TAddress: swag.String("10.101.01.1:8098"), } - err = deleteE2tHandleHandlerImpl(e2tdelchan, &data) - if (err != nil ) { + err = DeleteE2tHandleHandlerImpl(&data) + if err != nil { t.Log(err) } - data1 := <-e2tdelchan - - fmt.Println(data1) -//################ Delete End Point dummy entry - delete(rtmgr.Eps, uuid); -//##################### + //################ Delete End Point dummy entry + delete(rtmgr.Eps, uuid) + //##################### } func TestSubscriptionExists(t *testing.T) { @@ -454,55 +477,47 @@ func TestAddSubscriptions(t *testing.T) { t.Log(yes_no) } - func TestHttpInstance(t *testing.T) { sdlEngine, _ := sdl.GetSdl("file") rpeEngine, _ := rpe.GetRpe("rmrpush") + sbiEngine, _ := sbi.GetSbi("rmrpush") httpinstance := NewHttpRestful() err := httpinstance.Terminate() t.Log(err) + fmt.Printf("sbiEngine = %v", sbiEngine) - triggerSBI := make(chan bool) createMockPlatformComponents() //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil) //ts.Start() //defer ts.Close() var m sync.Mutex - err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine, rpeEngine, triggerSBI, &m) + err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine, rpeEngine, &m) } -func TestXappCallbackDataChannelwithdata(t *testing.T) { +func TestXappCallbackWithData(t *testing.T) { data := models.XappCallbackData{ XApps: *swag.String("[]"), Version: *swag.Int64(1), Event: *swag.String("someevent"), ID: *swag.String("123456")} - datach := make(chan *models.XappCallbackData, 1) - go func() { _, _ = recvXappCallbackData(datach) }() - defer close(datach) - datach <- &data + _, _ = recvXappCallbackData(&data) } -func TestXappCallbackDataChannelNodata(t *testing.T) { - datach := make(chan *models.XappCallbackData, 1) - go func() { _, _ = recvXappCallbackData(datach) }() - defer close(datach) + +func TestXappCallbackNodata(t *testing.T) { + //data := *models.XappCallbackData + _, _ = recvXappCallbackData(nil) } -func TestE2TChannelwithData(t *testing.T) { +func TestE2TwithData(t *testing.T) { data2 := models.E2tData{ - E2TAddress: swag.String("1.2.3.4"), - RanNamelist: []string{"ran1","ran2"}, + E2TAddress: swag.String("1.2.3.4"), + RanNamelist: []string{"ran1", "ran2"}, } - dataChannel := make(chan *models.E2tData, 10) - go func() { _, _,_ = recvNewE2Tdata(dataChannel) }() - defer close(dataChannel) - dataChannel <- &data2 + _, _, _ = recvNewE2Tdata(&data2) } -func TestE2TChannelwithNoData(t *testing.T) { - dataChannel := make(chan *models.E2tData, 10) - go func() { _, _ ,_= recvNewE2Tdata(dataChannel) }() - defer close(dataChannel) +func TestE2TwithNoData(t *testing.T) { + _, _, _ = recvNewE2Tdata(nil) } func TestProvideXappSubscriptionHandleImpl(t *testing.T) { @@ -511,15 +526,10 @@ func TestProvideXappSubscriptionHandleImpl(t *testing.T) { Address: swag.String("10.0.0.0"), Port: &p, SubscriptionID: swag.Int32(1234)} - datachannel := make(chan *models.XappSubscriptionData, 10) - go func() { _ = provideXappSubscriptionHandleImpl(datachannel, &data) }() - defer close(datachannel) - datachannel <- &data - - //subdel test + _ = ProvideXappSubscriptionHandleImpl(&data) } -func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server { +func createMockAppmgrWithData(url string, g []byte, p []byte, t []byte) *httptest.Server { l, err := net.Listen("tcp", url) if err != nil { fmt.Println("Failed to create listener: " + err.Error()) @@ -535,6 +545,30 @@ func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server { w.WriteHeader(http.StatusCreated) w.Write(p) } + if r.Method == "GET" && r.URL.String() == "/ric/v1/e2t/list" { + w.Header().Add("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(t) + } + + })) + ts.Listener.Close() + ts.Listener = l + return ts +} + +func createMockSubmgrWithData(url string, t []byte) *httptest.Server { + l, err := net.Listen("tcp", url) + if err != nil { + fmt.Println("Failed to create listener: " + err.Error()) + } + ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + + if r.Method == "GET" && r.URL.String() == "//ric/v1/subscriptions" { + w.Header().Add("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(t) + } })) ts.Listener.Close() @@ -551,58 +585,18 @@ func createMockPlatformComponents() { _ = ioutil.WriteFile(filename, file, 644) } -func TestRecvXappCallbackData(t *testing.T) { - data := models.XappCallbackData{ - XApps: *swag.String("[]"), - Version: *swag.Int64(1), - Event: *swag.String("any"), - ID: *swag.String("123456"), - } - - ch := make(chan *models.XappCallbackData) - defer close(ch) - httpRestful := NewHttpRestful() - go func() { ch <- &data }() - time.Sleep(1 * time.Second) - t.Log(string(len(ch))) - xappList, err := httpRestful.RecvXappCallbackData(ch) - if err != nil { - t.Error("Receive failed: " + err.Error()) - } else { - if xappList == nil { - t.Error("Expected an XApp notification list") - } else { - t.Log("whatever") - } - } -} - func TestProvideXappHandleHandlerImpl(t *testing.T) { - datach := make(chan *models.XappCallbackData, 10) - defer close(datach) data := models.XappCallbackData{ XApps: *swag.String("[]"), Version: *swag.Int64(1), Event: *swag.String("someevent"), ID: *swag.String("123456")} - var httpRestful, _ = GetNbi("httpRESTful") - err := httpRestful.(*HttpRestful).ProvideXappHandleHandlerImpl(datach, &data) - if err != nil { - t.Error("Error occured: " + err.Error()) - } else { - recv := <-datach - if recv == nil { - t.Error("Something gone wrong: " + err.Error()) - } else { - if recv != &data { - t.Error("Malformed data on channel") - } - } - } + err := ProvideXappHandleHandlerImpl(&data) //Empty XappCallbackdata data1 := models.XappCallbackData{} - err = httpRestful.(*HttpRestful).ProvideXappHandleHandlerImpl(datach, &data1) + err = ProvideXappHandleHandlerImpl(&data1) + t.Log(err) } func TestValidateXappCallbackData(t *testing.T) { @@ -640,7 +634,7 @@ func TestHttpGetXAppsInvalidData(t *testing.T) { func TestHttpGetXAppsWithValidData(t *testing.T) { var expected = 1 - ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil) + ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil) ts.Start() defer ts.Close() @@ -654,11 +648,10 @@ func TestHttpGetXAppsWithValidData(t *testing.T) { } } - func TestRetrieveStartupDataTimeout(t *testing.T) { sdlEngine, _ := sdl.GetSdl("file") createMockPlatformComponents() - err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine) + err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine) if err == nil { t.Error("Cannot retrieve startup data: " + err.Error()) } @@ -667,29 +660,38 @@ func TestRetrieveStartupDataTimeout(t *testing.T) { } func TestRetrieveStartupData(t *testing.T) { - ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp) + ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil) ts.Start() defer ts.Close() + + ts1 := createMockAppmgrWithData("127.0.0.1:8085", nil, nil, E2TListResp) + ts1.Start() + defer ts1.Close() + + ts2 := createMockSubmgrWithData("127.0.0.1:8089", SubscriptionList) + ts2.Start() + defer ts2.Close() + sdlEngine, _ := sdl.GetSdl("file") var httpRestful, _ = GetNbi("httpRESTful") createMockPlatformComponents() - err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine) + httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine) //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine) - if err != nil { + /*if err != nil { t.Error("Cannot retrieve startup data: " + err.Error()) - } + }*/ os.Remove("rt.json") os.Remove("config.json") } func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) { - ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp) + ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil) ts.Start() defer ts.Close() sdlEngine, _ := sdl.GetSdl("file") var httpRestful, _ = GetNbi("httpRESTful") createMockPlatformComponents() - err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine) + err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", E2MURL, sdlEngine) if err == nil { t.Error("Cannot retrieve startup data: " + err.Error()) } @@ -698,6 +700,123 @@ func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) { } func TestInvalidarguments(t *testing.T) { - _ = PostSubReq("\n","nbifinterface") - _ = PostSubReq("xmurl","\n") + _ = PostSubReq("\n", "nbifinterface") + _ = PostSubReq("xmurl", "\n") +} + +func TestInitEngine(t *testing.T) { + initRtmgr() +} + +func TestUpdateXappSubscription(t *testing.T) { + ep := make(map[string]*rtmgr.Endpoint) + 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} + + rtmgr.Eps = ep + + p := uint16(1234) + xapp := models.XappElement{ + Address: swag.String("10.1.1.1"), + Port: &p, + } + + var b models.XappList + b = append(b, &xapp) + _ = UpdateXappSubscriptionHandleImpl(&b, 10) + + //Test case when subscriptions already exist + data := models.XappSubscriptionData{ + Address: swag.String("10.0.0.0"), + Port: &p, + SubscriptionID: swag.Int32(12345)} + + rtmgr.Subs = *stub.ValidSubscriptions + + subscriptionExists(&data) + addSubscription(&rtmgr.Subs, &data) + _ = UpdateXappSubscriptionHandleImpl(&b, 10) + +} + +func TestDumpDebugdata(t *testing.T) { + _, _ = DumpDebugData() +} + +func TestManagerRequest(t *testing.T) { + var params xapp.RMRParams + var rmrmeid xapp.RMRMeid + sdlEngine, _ = sdl.GetSdl("file") + sbiEngine, _ = sbi.GetSbi("rmrpush") + rpeEngine, _ = rpe.GetRpe("rmrpush") + rmrmeid.RanName = "gnb1" + c := Control{make(chan *xapp.RMRParams)} + params.Payload = []byte{1, 2, 3, 4} + params.Mtype = 1234 + params.SubId = -1 + params.Meid = &rmrmeid + params.Src = "sender" + params.PayloadLen = 4 + c.handleUpdateToRoutingManagerRequest(¶ms) +} + +func TestRecievermr(t *testing.T) { + var params xapp.RMRParams + var rmrmeid xapp.RMRMeid + sdlEngine, _ = sdl.GetSdl("file") + sbiEngine, _ = sbi.GetSbi("rmrpush") + rpeEngine, _ = rpe.GetRpe("rmrpush") + rmrmeid.RanName = "gnb1" + + params.Payload = []byte{1, 2, 3, 4} + params.SubId = -1 + params.Meid = &rmrmeid + params.Src = "sender" + params.PayloadLen = 4 + + c := Control{make(chan *xapp.RMRParams)} + params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"] + c.recievermr(¶ms) + params.Mtype = xapp.RICMessageTypes["RMRRM_TABLE_STATE"] + c.recievermr(¶ms) + params.Mtype = 1234 + c.recievermr(¶ms) + + rtmgr.Rtmgr_ready = true + params.Mtype = xapp.RICMessageTypes["RMRRM_REQ_TABLE"] + c.recievermr(¶ms) + time.Sleep(time.Duration(5) * time.Second) +} + +func TestAddDelRmr(t *testing.T) { + sdlEngine, _ = sdl.GetSdl("file") + sbiEngine, _ = sbi.GetSbi("rmrpush") + rpeEngine, _ = rpe.GetRpe("rmrpush") + var routelist models.Routelist + mtype := uint32(1234) + tendpoint := "goofle.com" + listofroutes := models.AddRmrRoute{SubscriptionID: 0, SenderEndPoint: "nokia.com", MessageType: &mtype, TargetEndPoint: &tendpoint} + listofroutes2 := models.AddRmrRoute{SubscriptionID: 1, SenderEndPoint: "", MessageType: &mtype, TargetEndPoint: &tendpoint} + listofroutes3 := models.AddRmrRoute{MessageType: &mtype, TargetEndPoint: &tendpoint} + Adddelrmrroute(routelist, false) + routelist = append(routelist, &listofroutes) + routelist = append(routelist, &listofroutes2) + routelist = append(routelist, &listofroutes3) + routelist = append(routelist, &listofroutes3) + Adddelrmrroute(routelist, true) + + Adddelrmrroute(routelist, false) +} + +func TestPopulateSubscription(t *testing.T) { + var sublist xfmodel.SubscriptionList + + subdata := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp1.com:3800"}, SubscriptionID: -1, Meid: ""} + subdata2 := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp2.com:3800"}, SubscriptionID: 11, Meid: ""} + subdata3 := xfmodel.SubscriptionData{ClientEndpoint: []string{"xapp3.com:3800"}, SubscriptionID: 221, Meid: ""} + sublist = append(sublist, &subdata) + sublist = append(sublist, &subdata2) + sublist = append(sublist, &subdata3) + + PopulateSubscription(sublist) + }