Code Review / ric-plt / rtmgr.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Making Route Distribution Synchronous
[ric-plt/rtmgr.git] / pkg / nbi / httprestful_test.go
diff --git a/pkg/nbi/httprestful_test.go b/pkg/nbi/httprestful_test.go
index a844425..bebc4f7 100644 (file)
--- a/pkg/nbi/httprestful_test.go
+++ b/pkg/nbi/httprestful_test.go
@@ -14,6 +14,11 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+   This source code is part of the near-RT RIC (RAN Intelligent Controller)
+   platform project (RICP).
+
 ==================================================================================
 */
 /*
 ==================================================================================
 */
 /*
@@ -27,20 +32,22 @@ package nbi
 import (
        "encoding/json"
        "fmt"
 import (
        "encoding/json"
        "fmt"
-       "github.com/go-openapi/swag"
        "io/ioutil"
        "net"
        "net/http"
        "net/http/httptest"
        "os"
        "routing-manager/pkg/models"
        "io/ioutil"
        "net"
        "net/http"
        "net/http/httptest"
        "os"
        "routing-manager/pkg/models"
+       "routing-manager/pkg/rpe"
+       "routing-manager/pkg/rtmgr"
        "routing-manager/pkg/sdl"
        "routing-manager/pkg/stub"
        "testing"
        "routing-manager/pkg/sdl"
        "routing-manager/pkg/stub"
        "testing"
-       "time"
+       "sync"
+       "github.com/go-openapi/swag"
 )
 
 )
 
-var BASIC_XAPPLIST = []byte(`[
+var BasicXAppLists = []byte(`[
  {
  "name":"xapp-01","status":"unknown","version":"1.2.3",
     "instances":[
  {
  "name":"xapp-01","status":"unknown","version":"1.2.3",
     "instances":[
@@ -56,11 +63,450 @@ var BASIC_XAPPLIST = []byte(`[
 }
 ]`)
 
 }
 ]`)
 
-var SUBSCRIPTION_RESP = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
+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}`)
+
+func TestValidateXappCallbackData_1(t *testing.T) {
+       data := models.XappCallbackData{
+               XApps:   *swag.String("[]"),
+               Version: *swag.Int64(1),
+               Event:   *swag.String("someevent"),
+               ID:      *swag.String("123456")}
+
+       err := validateXappCallbackData(&data)
+       if err != nil {
+               t.Error("Invalid XApp callback data: " + err.Error())
+       }
+}
+
+func TestValidateXappCallbackDataInvalid (t *testing.T) {
+       data := models.XappCallbackData{}
+       err := validateXappCallbackData(&data)
+       t.Log(err)
+}
+
+
+func TestValidateXappSubscriptionsData(t *testing.T) {
+
+       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)
+       data := models.XappSubscriptionData{
+               Address:        swag.String("10.1.1.1"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(123456)}
+
+       var err error
+       err = validateXappSubscriptionData(&data)
+       t.Log(err)
+
+       rtmgr.Eps = ep
+       p = uint16(0)
+       data1 := models.XappSubscriptionData{
+               Address:        swag.String(""),
+               Port:           &p,
+               SubscriptionID: swag.Int32(123456)}
+       err = validateXappSubscriptionData(&data1)
+
+       //Validate E2tData
+       data2 := models.E2tData{
+               E2TAddress: swag.String(""),
+       }
+       /*err = validateE2tData(&data2)*/
+
+       //e2tchannel := make(chan *models.E2tData, 10)
+       _ = createNewE2tHandleHandlerImpl(&data2)
+       //defer close(e2tchannel)
+
+       //test case for provideXappSubscriptionHandleImp
+       //datachannel := make(chan *models.XappSubscriptionData, 10)
+       sdlEngine, _ = sdl.GetSdl("file")
+       _ = provideXappSubscriptionHandleImpl( &data1)
+       //defer close(datachannel)
+
+       //test case for deleteXappSubscriptionHandleImpl
+       _ = deleteXappSubscriptionHandleImpl(&data1)
+
+       data3 := models.XappSubscriptionData{
+               Address:        swag.String("10.55.55.5"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(123456)}
+       //test case for deleteXappSubscriptionHandleImpl
+       _ = 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)
+       t.Log(err)
+}
+
+func TestValidateE2tDataDNSLookUPfails(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String("e2t.1com:1234"),
+       }
+       err := validateE2tData(&data)
+       t.Log(err)
+}
+
+func TestValidateE2tDataInvalid(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String("10.101.01.1"),
+       }
+       err := validateE2tData(&data)
+       t.Log(err)
+}
+
+func TestValidateE2tDatavalid(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String("10.101.01.1:8098"),
+       }
+
+
+       err := validateE2tData(&data)
+       t.Log(err)
+
+       _ = createNewE2tHandleHandlerImpl(&data)
+
+}
+
+func TestValidateE2tDatavalidEndpointPresent(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String("10.101.01.1:8098"),
+       }
+
+       // insert endpoint for testing purpose
+       uuid := "10.101.01.1:8098"
+       ep := &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+
+       err := validateE2tData(&data)
+       t.Log(err)
+
+       // delete endpoint for at end of test case 
+    delete(rtmgr.Eps, uuid);
+
+}
+
+
+func TestValidateDeleteE2tData(t *testing.T) {
+
+// test-1              
+       data := models.E2tDeleteData{
+               E2TAddress: swag.String(""),
+       }
+
+       err := validateDeleteE2tData(&data)
+       if (err.Error() != "E2TAddress is empty!!!") {
+               t.Log(err)
+       }
+
+
+// test-2
+       data = models.E2tDeleteData{
+               E2TAddress: swag.String("10.101.01.1:8098"),
+       }
+
+       err = validateDeleteE2tData(&data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+// test-3
+//################ Create End Point dummy entry  
+       uuid := "10.101.01.1:8098"
+       ep := &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+//#####################
+
+       data = models.E2tDeleteData{
+               E2TAddress: swag.String("10.101.01.1:8098"),
+               RanAssocList: models.RanE2tMap{
+                       {E2TAddress: swag.String("10.101.01.1:8098")},
+               },
+       }
+
+       err = validateDeleteE2tData(&data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+       // delete endpoint for at end of test case 
+//################ Delete End Point dummy entry  
+    delete(rtmgr.Eps, uuid);
+//#####################
+
+// test-4
+
+//################ Create End Point dummy entry  
+       uuid = "10.101.01.1:9991"
+       ep = &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+
+       uuid = "10.101.01.1:9992"
+       ep = &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+//#####################
+
+       data = models.E2tDeleteData{
+               E2TAddress: swag.String("10.101.01:8098"),
+               RanAssocList: models.RanE2tMap{
+                       {E2TAddress: swag.String("10.101.01.1:9991")},
+                       {E2TAddress: swag.String("10.101.01.1:9992")},
+               },
+       }
+
+       err = validateDeleteE2tData(&data)
+       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")
+//#####################
+
+// test-5
+
+       data = models.E2tDeleteData{
+               E2TAddress: swag.String("10.101.01:8098"),
+               RanAssocList: models.RanE2tMap{
+                       {E2TAddress: swag.String("10.101.01.19991")},
+               },
+       }
+
+       err = validateDeleteE2tData(&data)
+       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(""),
+                       },
+       }
+       err := validateE2TAddressRANListData(data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+       data = models.RanE2tMap{
+                               {
+                                       E2TAddress: swag.String("10.101.01.1:8098"),
+                       },
+       }
+       err = validateE2TAddressRANListData(data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+}
+
+func TestAssociateRanToE2THandlerImpl(t *testing.T) {
+
+       data := models.RanE2tMap{
+                               {
+                                       E2TAddress: swag.String("10.101.01.1:8098"),
+                       },
+       }
+       err := associateRanToE2THandlerImpl( data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+//################ Create End Point dummy entry  
+       uuid := "10.101.01.1:8098"
+       ep := &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+//#####################
+
+       data = models.RanE2tMap{
+                               {
+                                       E2TAddress: swag.String("10.101.01.1:8098"),
+                       },
+       }
+       err = associateRanToE2THandlerImpl(data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+//################ Delete End Point dummy entry  
+    delete(rtmgr.Eps, uuid);
+//#####################
+}
+
+func TestDisassociateRanToE2THandlerImpl(t *testing.T) {
+
+
+       data := models.RanE2tMap{
+                               {
+                                       E2TAddress: swag.String("10.101.01.1:8098"),
+                       },
+       }
+       err := disassociateRanToE2THandlerImpl(data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+//################ Create End Point dummy entry  
+       uuid := "10.101.01.1:8098"
+       ep := &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+//#####################
+
+       data = models.RanE2tMap{
+                               {
+                                       E2TAddress: swag.String("10.101.01.1:8098"),
+                       },
+       }
+       err = disassociateRanToE2THandlerImpl(data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+//################ Delete End Point dummy entry  
+    delete(rtmgr.Eps, uuid);
+//#####################
+}
+
+func TestDeleteE2tHandleHandlerImpl(t *testing.T) {
+
+       data := models.E2tDeleteData{
+               E2TAddress: swag.String(""),
+       }
+       err := deleteE2tHandleHandlerImpl(&data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+
+//################ Create End Point dummy entry  
+       uuid := "10.101.01.1:8098"
+       ep := &rtmgr.Endpoint{
+               Uuid:       uuid,
+       }
+       rtmgr.Eps[uuid] = ep
+//#####################
+
+       data = models.E2tDeleteData{
+               E2TAddress: swag.String("10.101.01.1:8098"),
+       }
+       err = deleteE2tHandleHandlerImpl(&data)
+       if (err != nil ) {
+               t.Log(err)
+       }
+//################ Delete End Point dummy entry  
+    delete(rtmgr.Eps, uuid);
+//#####################
+}
+
+func TestSubscriptionExists(t *testing.T) {
+       p := uint16(0)
+       data := models.XappSubscriptionData{
+               Address:        swag.String("10.0.0.0"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(1234)}
+
+       rtmgr.Subs = *stub.ValidSubscriptions
+
+       yes_no := subscriptionExists(&data)
+       yes_no = addSubscription(&rtmgr.Subs, &data)
+       yes_no = addSubscription(&rtmgr.Subs, &data)
+       yes_no = delSubscription(&rtmgr.Subs, &data)
+       yes_no = delSubscription(&rtmgr.Subs, &data)
+       t.Log(yes_no)
+}
+
+func TestAddSubscriptions(t *testing.T) {
+       p := uint16(1)
+       subdata := models.XappSubscriptionData{
+               Address:        swag.String("10.0.0.0"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(1234)}
+
+       rtmgr.Subs = *stub.ValidSubscriptions
+       yes_no := addSubscription(&rtmgr.Subs, &subdata)
+       t.Log(yes_no)
+}
 
 
-var INVALID_SUB_RESP = []byte(`{"Version":0, "EventType":all}`)
 
 
-func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
+func TestHttpInstance(t *testing.T) {
+       sdlEngine, _ := sdl.GetSdl("file")
+       rpeEngine, _ := rpe.GetRpe("rmrpush")
+       httpinstance := NewHttpRestful()
+       err := httpinstance.Terminate()
+       t.Log(err)
+
+       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", E2MURL, sdlEngine, rpeEngine, &m)
+}
+
+func TestXappCallbackWithData(t *testing.T) {
+       data := models.XappCallbackData{
+               XApps:   *swag.String("[]"),
+               Version: *swag.Int64(1),
+               Event:   *swag.String("someevent"),
+               ID:      *swag.String("123456")}
+        _, _ = recvXappCallbackData(&data)
+}
+
+func TestXappCallbackNodata(t *testing.T) {
+       //data := *models.XappCallbackData
+        _, _ = recvXappCallbackData(nil)
+}
+
+func TestE2TwithData(t *testing.T) {
+        data2 := models.E2tData{
+                E2TAddress: swag.String("1.2.3.4"),
+                RanNamelist: []string{"ran1","ran2"},
+        }
+         _, _,_ = recvNewE2Tdata(&data2)
+}
+
+func TestE2TwithNoData(t *testing.T) {
+         _, _,_ = recvNewE2Tdata(nil)
+}
+
+func TestProvideXappSubscriptionHandleImpl(t *testing.T) {
+       p := uint16(0)
+       data := models.XappSubscriptionData{
+               Address:        swag.String("10.0.0.0"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(1234)}
+        _ = provideXappSubscriptionHandleImpl(&data)
+}
+
+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())
        l, err := net.Listen("tcp", url)
        if err != nil {
                fmt.Println("Failed to create listener: " + err.Error())
@@ -76,6 +522,30 @@ func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
                        w.WriteHeader(http.StatusCreated)
                        w.Write(p)
                }
                        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()
 
        }))
        ts.Listener.Close()
@@ -84,7 +554,7 @@ func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
 }
 
 func createMockPlatformComponents() {
 }
 
 func createMockPlatformComponents() {
-       var filename = string("config.json")
+       var filename = "config.json"
        file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
        filestr := string(file)
        filestr = "{\"PlatformComponents\":" + filestr + "}"
        file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
        filestr := string(file)
        filestr = "{\"PlatformComponents\":" + filestr + "}"
@@ -92,54 +562,18 @@ func createMockPlatformComponents() {
        _ = ioutil.WriteFile(filename, file, 644)
 }
 
        _ = 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) {
 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")}
        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 = provideXappHandleHandlerImpl(&data1)
+       t.Log(err)
 }
 
 func TestValidateXappCallbackData(t *testing.T) {
 }
 
 func TestValidateXappCallbackData(t *testing.T) {
@@ -168,20 +602,20 @@ func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
        }
 }
 
        }
 }
 
-func TestHttpGetXappsInvalidData(t *testing.T) {
-       _, err := httpGetXapps(XMURL)
+func TestHttpGetXAppsInvalidData(t *testing.T) {
+       _, err := httpGetXApps(XMURL)
        if err == nil {
                t.Error("No XApp data received: " + err.Error())
        }
 }
 
        if err == nil {
                t.Error("No XApp data received: " + err.Error())
        }
 }
 
-func TestHttpGetXappsWithValidData(t *testing.T) {
-       var expected int = 1
-       ts := createMockAppmgrWithData("127.0.0.1:3000", BASIC_XAPPLIST, nil)
+func TestHttpGetXAppsWithValidData(t *testing.T) {
+       var expected = 1
+       ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil, nil)
 
        ts.Start()
        defer ts.Close()
 
        ts.Start()
        defer ts.Close()
-       xapplist, err := httpGetXapps(XMURL)
+       xapplist, err := httpGetXApps(XMURL)
        if err != nil {
                t.Error("Error occured: " + err.Error())
        } else {
        if err != nil {
                t.Error("Error occured: " + err.Error())
        } else {
@@ -191,10 +625,11 @@ func TestHttpGetXappsWithValidData(t *testing.T) {
        }
 }
 
        }
 }
 
+
 func TestRetrieveStartupDataTimeout(t *testing.T) {
        sdlEngine, _ := sdl.GetSdl("file")
        createMockPlatformComponents()
 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())
        }
        if err == nil {
                t.Error("Cannot retrieve startup data: " + err.Error())
        }
@@ -203,32 +638,88 @@ func TestRetrieveStartupDataTimeout(t *testing.T) {
 }
 
 func TestRetrieveStartupData(t *testing.T) {
 }
 
 func TestRetrieveStartupData(t *testing.T) {
-       ts := createMockAppmgrWithData("127.0.0.1:3000", BASIC_XAPPLIST, SUBSCRIPTION_RESP)
+       ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, SubscriptionResp, nil)
        ts.Start()
        defer ts.Close()
        ts.Start()
        defer ts.Close()
+
+       ts1 := createMockAppmgrWithData("127.0.0.1:8080", 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()
        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)
        //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
-       if err != nil {
+       /*if err != nil {
                t.Error("Cannot retrieve startup data: " + err.Error())
                t.Error("Cannot retrieve startup data: " + err.Error())
-       }
+       }*/
        os.Remove("rt.json")
        os.Remove("config.json")
 }
 
 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
        os.Remove("rt.json")
        os.Remove("config.json")
 }
 
 func TestRetrieveStartupDataWithInvalidSubResp(t *testing.T) {
-       ts := createMockAppmgrWithData("127.0.0.1:3000", BASIC_XAPPLIST, INVALID_SUB_RESP)
+       ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, InvalidSubResp, nil)
        ts.Start()
        defer ts.Close()
        sdlEngine, _ := sdl.GetSdl("file")
        var httpRestful, _ = GetNbi("httpRESTful")
        createMockPlatformComponents()
        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())
        }
        os.Remove("rt.json")
        os.Remove("config.json")
 }
        if err == nil {
                t.Error("Cannot retrieve startup data: " + err.Error())
        }
        os.Remove("rt.json")
        os.Remove("config.json")
 }
+
+func TestInvalidarguments(t *testing.T) {
+       _ = 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()
+}
+
+
Routing Manager (ric-plt/rtmgr) is a basic RIC platform service, responsible for generating and distributing routing policies to xApps.