Adding Unit Test cases for rtmgr

[ric-plt/rtmgr.git] / pkg / nbi / httprestful_test.go

diff --git a/pkg/nbi/httprestful_test.go b/pkg/nbi/httprestful_test.go
index c52643b..cfa644e 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).
+

 ==================================================================================
 */
 /*
 ==================================================================================
 */
 /*


@@ -25,22 +30,25 @@
 package nbi
 
 import (
 package nbi
 
 import (

-       "routing-manager/pkg/stub"
-        "routing-manager/pkg/models"
-        "routing-manager/pkg/sdl"
-       "github.com/go-openapi/swag"
-        "testing"
-       "time"
-        "net"
-        "net/http"
-        "net/http/httptest"
+       "encoding/json"

        "fmt"
        "fmt"

-       "os"

        "io/ioutil"
        "io/ioutil"

-       "encoding/json"
+       "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"
+       "time"
+
+       "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 +64,175 @@ var BASIC_XAPPLIST = []byte(`[
 }
 ]`)
 
 }
 ]`)
 

-var SUBSCRIPTION_RESP = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
+var SubscriptionResp = []byte(`{"ID":"deadbeef1234567890", "Version":0, "EventType":"all"}`)
+
+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 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)
+       t.Log(err)
+
+       //Validate E2tData
+       data2 := models.E2tData{
+               E2TAddress: swag.String(""),
+       }
+       err = validateE2tData(&data2)
+
+       e2tchannel := make(chan *models.E2tData, 10)
+       _ = createNewE2tHandleHandlerImpl(e2tchannel, &data2)
+       defer close(e2tchannel)
+
+       //test case for provideXappSubscriptionHandleImp
+       datachannel := make(chan *models.XappSubscriptionData, 10)
+       _ = provideXappSubscriptionHandleImpl(datachannel, &data1)
+       defer close(datachannel)
+
+       //test case for deleteXappSubscriptionHandleImpl
+       _ = deleteXappSubscriptionHandleImpl(datachannel, &data1)
+}
+
+func TestvalidateE2tData(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String(""),
+       }
+       err := validateE2tData(&data)
+       t.Log(err)
+}
+
+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)
+}
+
+func TestHttpInstance(t *testing.T) {
+       sdlEngine, _ := sdl.GetSdl("file")
+       rpeEngine, _ := rpe.GetRpe("rmrpush")
+       httpinstance := NewHttpRestful()
+       err := httpinstance.Terminate()
+       t.Log(err)
+
+       triggerSBI := make(chan bool)
+       createMockPlatformComponents()
+       //ts := createMockAppmgrWithData("127.0.0.1:3000", BasicXAppLists, nil)
+       //ts.Start()
+       //defer ts.Close()
+       err = httpinstance.Initialize(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine, rpeEngine, triggerSBI)
+}
+
+func TestXappCallbackDataChannelwithdata(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
+}
+func TestXappCallbackDataChannelNodata(t *testing.T) {
+       datach := make(chan *models.XappCallbackData, 1)
+       go func() { _, _ = recvXappCallbackData(datach) }()
+       defer close(datach)
+}
+
+func TestE2TChannelwithData(t *testing.T) {
+       data2 := models.E2tData{
+               E2TAddress: swag.String(""),
+       }
+       dataChannel := make(chan *models.E2tData, 10)
+       go func() { _, _ = recvNewE2Tdata(dataChannel) }()
+       defer close(dataChannel)
+       dataChannel <- &data2
+}
+
+func TestE2TChannelwithNoData(t *testing.T) {
+       dataChannel := make(chan *models.E2tData, 10)
+       go func() { _, _ = recvNewE2Tdata(dataChannel) }()
+       defer close(dataChannel)
+}

 
 

+func TestprovideXappSubscriptionHandleImpl(t *testing.T) {
+       p := uint16(0)
+       data := models.XappSubscriptionData{
+               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

 
 

-var INVALID_SUB_RESP = []byte(`{"Version":0, "EventType":all}`)
+       //subdel test
+}

 
 

+func TestdeleteXappSubscriptionHandleImpl(t *testing.T) {
+       p := uint16(1)
+       subdeldata := models.XappSubscriptionData{
+               Address:        swag.String("10.0.0.0"),
+               Port:           &p,
+               SubscriptionID: swag.Int32(1234)}
+       subdelchannel := make(chan *models.XappSubscriptionData, 10)
+       go func() { _ = deleteXappSubscriptionHandleImpl(subdelchannel, &subdeldata) }()
+       defer close(subdelchannel)
+       subdelchannel <- &subdeldata
+}

 
 func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
        l, err := net.Listen("tcp", url)
 
 func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
        l, err := net.Listen("tcp", url)


@@ -74,10 +246,10 @@ func createMockAppmgrWithData(url string, g []byte, p []byte) *httptest.Server {
                        w.Write(g)
                }
                if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {
                        w.Write(g)
                }
                if r.Method == "POST" && r.URL.String() == "/ric/v1/subscriptions" {

-                        w.Header().Add("Content-Type", "application/json")
-                        w.WriteHeader(http.StatusCreated)
-                        w.Write(p)
-                }
+                       w.Header().Add("Content-Type", "application/json")
+                       w.WriteHeader(http.StatusCreated)
+                       w.Write(p)
+               }

 
        }))
        ts.Listener.Close()
 
        }))
        ts.Listener.Close()


@@ -86,31 +258,31 @@ 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)
        file, _ := json.MarshalIndent(stub.ValidPlatformComponents, "", "")
        filestr := string(file)

-       filestr = "{\"PlatformComponents\":"+filestr+"}"
+       filestr = "{\"PlatformComponents\":" + filestr + "}"

        file = []byte(filestr)
        _ = ioutil.WriteFile(filename, file, 644)
 }
 
 func TestRecvXappCallbackData(t *testing.T) {
        file = []byte(filestr)
        _ = 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"),
+       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()
        }
 
        ch := make(chan *models.XappCallbackData)
        defer close(ch)
        httpRestful := NewHttpRestful()

-       go func() {ch<- &data}()
+       go func() { ch <- &data }()

        time.Sleep(1 * time.Second)
        t.Log(string(len(ch)))
        xappList, err := httpRestful.RecvXappCallbackData(ch)
        if err != nil {
        time.Sleep(1 * time.Second)
        t.Log(string(len(ch)))
        xappList, err := httpRestful.RecvXappCallbackData(ch)
        if err != nil {

-               t.Error("Receive failed: "+err.Error())
+               t.Error("Receive failed: " + err.Error())

        } else {
                if xappList == nil {
                        t.Error("Expected an XApp notification list")
        } else {
                if xappList == nil {
                        t.Error("Expected an XApp notification list")


@@ -124,18 +296,18 @@ func TestProvideXappHandleHandlerImpl(t *testing.T) {
        datach := make(chan *models.XappCallbackData, 10)
        defer close(datach)
        data := models.XappCallbackData{
        datach := make(chan *models.XappCallbackData, 10)
        defer close(datach)
        data := models.XappCallbackData{

-               XApps: *swag.String("[]"),
+               XApps:   *swag.String("[]"),

                Version: *swag.Int64(1),
                Version: *swag.Int64(1),

-               Event: *swag.String("someevent"),
-               ID: *swag.String("123456")}
+               Event:   *swag.String("someevent"),
+               ID:      *swag.String("123456")}

        var httpRestful, _ = GetNbi("httpRESTful")
        err := httpRestful.(*HttpRestful).ProvideXappHandleHandlerImpl(datach, &data)
        if err != nil {
        var httpRestful, _ = GetNbi("httpRESTful")
        err := httpRestful.(*HttpRestful).ProvideXappHandleHandlerImpl(datach, &data)
        if err != nil {

-               t.Error("Error occured: "+err.Error())
+               t.Error("Error occured: " + err.Error())

        } else {
                recv := <-datach
                if recv == nil {
        } else {
                recv := <-datach
                if recv == nil {

-                       t.Error("Something gone wrong: "+err.Error())
+                       t.Error("Something gone wrong: " + err.Error())

                } else {
                        if recv != &data {
                                t.Error("Malformed data on channel")
                } else {
                        if recv != &data {
                                t.Error("Malformed data on channel")


@@ -145,46 +317,45 @@ func TestProvideXappHandleHandlerImpl(t *testing.T) {
 }
 
 func TestValidateXappCallbackData(t *testing.T) {
 }
 
 func TestValidateXappCallbackData(t *testing.T) {

-        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")}

 
        err := validateXappCallbackData(&data)
        if err != nil {
 
        err := validateXappCallbackData(&data)
        if err != nil {

-               t.Error("Invalid XApp callback data: "+err.Error())
+               t.Error("Invalid XApp callback data: " + err.Error())

        }
 }
 
 func TestValidateXappCallbackDataWithInvalidData(t *testing.T) {
        }
 }
 
 func TestValidateXappCallbackDataWithInvalidData(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())
-        }
-}
+       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 TestHttpGetXappsInvalidData(t *testing.T) {
-        _, err := httpGetXapps(XMURL)
-        if err == nil {
-                t.Error("No XApp data received: "+err.Error())
-        }
+func TestHttpGetXAppsInvalidData(t *testing.T) {
+       _, err := httpGetXApps(XMURL)
+       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)

 
        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 {


@@ -193,45 +364,61 @@ 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", 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 TestRetrieveStartupData(t *testing.T) {
        }
        os.Remove("rt.json")
        os.Remove("config.json")
 }
 
 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)

        ts.Start()
        defer ts.Close()
        ts.Start()
        defer ts.Close()

-        sdlEngine, _ := sdl.GetSdl("file")
+       sdlEngine, _ := sdl.GetSdl("file")

        var httpRestful, _ = GetNbi("httpRESTful")
        createMockPlatformComponents()
        var httpRestful, _ = GetNbi("httpRESTful")
        createMockPlatformComponents()

-       err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json","config.json", sdlEngine)
-        //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
-        if err != nil {
-                t.Error("Cannot retrieve startup data: "+err.Error())
-        }
+       err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
+       //err := retrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
+       if err != nil {
+               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)

        ts.Start()
        defer ts.Close()
        ts.Start()
        defer ts.Close()

-        sdlEngine, _ := sdl.GetSdl("file")
+       sdlEngine, _ := sdl.GetSdl("file")

        var httpRestful, _ = GetNbi("httpRESTful")
        createMockPlatformComponents()
        var httpRestful, _ = GetNbi("httpRESTful")
        createMockPlatformComponents()

-        err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
-        if err == nil {
-                t.Error("Cannot retrieve startup data: "+err.Error())
-        }
+       err := httpRestful.(*HttpRestful).RetrieveStartupData(XMURL, "httpgetter", "rt.json", "config.json", sdlEngine)
+       if err == nil {
+               t.Error("Cannot retrieve startup data: " + err.Error())
+       }

        os.Remove("rt.json")
        os.Remove("config.json")
 }
        os.Remove("rt.json")
        os.Remove("config.json")
 }

+
+func TestrecvXappCallbackData(t *testing.T) {
+       data := models.E2tData{
+               E2TAddress: swag.String("123456")}
+
+       var err error
+
+       e2tch := make(chan *models.E2tData)
+       go func() { e2tch <- &data }()
+       time.Sleep(1 * time.Second)
+       t.Log(string(len(e2tch)))
+       defer close(e2tch)
+
+       var httpRestful, _ = GetNbi("httpRESTful")
+       _, err = httpRestful.(*HttpRestful).RecvNewE2Tdata(e2tch)
+       t.Log(err)
+}