pkg/xapp/xapp_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   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
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  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.
  17 ==================================================================================
  18 */
  19
  20 package xapp
  21
  22 import (
  23         "github.com/gorilla/mux"
  24         "github.com/spf13/viper"
  25         "net/http"
  26         "net/http/httptest"
  27         "os"
  28         "strings"
  29         "testing"
  30         "time"
  31 )
  32
  33 //var _ = func() bool {
  34 //      testing.Init()
  35 //      return true
  36 //}()
  37
  38 type Consumer struct{}
  39
  40 func (m Consumer) Consume(params *RMRParams) (err error) {
  41         Sdl.Store("myKey", params.Payload)
  42         return nil
  43 }
  44
  45 // Test cases
  46 func TestMain(m *testing.M) {
  47         go RunWithParams(Consumer{}, viper.GetBool("db.waitForSdl"))
  48         time.Sleep(time.Duration(5) * time.Second)
  49         code := m.Run()
  50         os.Exit(code)
  51 }
  52
  53 func TestGetHealthCheckRetursServiceUnavailableError(t *testing.T) {
  54         req, _ := http.NewRequest("GET", "/ric/v1/health/ready", nil)
  55         /*response :=*/ executeRequest(req)
  56
  57         //checkResponseCode(t, http.StatusServiceUnavailable, response.Code)
  58 }
  59
  60 func TestGetHealthCheckReturnsSuccess(t *testing.T) {
  61         for Rmr.IsReady() == false {
  62                 time.Sleep(time.Duration(2) * time.Second)
  63         }
  64
  65         req, _ := http.NewRequest("GET", "/ric/v1/health/ready", nil)
  66         response := executeRequest(req)
  67
  68         checkResponseCode(t, http.StatusOK, response.Code)
  69 }
  70
  71 func TestInjectQuerySinglePath(t *testing.T) {
  72         var handler = func(w http.ResponseWriter, r *http.Request) {
  73         }
  74
  75         Resource.InjectQueryRoute("/ric/v1/user", handler, "GET", "foo", "bar")
  76
  77         req, _ := http.NewRequest("GET", "/ric/v1/user?foo=bar", nil)
  78         response := executeRequest(req)
  79         checkResponseCode(t, http.StatusOK, response.Code)
  80 }
  81
  82 func TestInjectQueryMultiplePaths(t *testing.T) {
  83         var handler = func(w http.ResponseWriter, r *http.Request) {
  84         }
  85
  86         Resource.InjectQueryRoute("/ric/v1/user", handler, "GET", "foo", "bar", "id", "mykey")
  87
  88         req, _ := http.NewRequest("GET", "/ric/v1/user?foo=bar&id=mykey", nil)
  89         response := executeRequest(req)
  90         checkResponseCode(t, http.StatusOK, response.Code)
  91 }
  92
  93 func TestInjectQueryFailures(t *testing.T) {
  94         var handler = func(w http.ResponseWriter, r *http.Request) {
  95         }
  96
  97         Resource.InjectQueryRoute("/ric/v1/user", handler, "GET", "foo", "bar", "id", "mykey")
  98
  99         req, _ := http.NewRequest("GET", "/ric/v1/user?invalid=bar&no=mykey", nil)
 100         response := executeRequest(req)
 101         checkResponseCode(t, http.StatusNotFound, response.Code)
 102 }
 103
 104 func TestMessagesReceivedSuccessfully(t *testing.T) {
 105         time.Sleep(time.Duration(5) * time.Second)
 106         for i := 0; i < 100; i++ {
 107                 params := &RMRParams{}
 108                 params.Mtype = 10004
 109                 params.SubId = -1
 110                 params.Payload = []byte{1, 2, 3, 4, 5, 6}
 111                 params.Meid = &RMRMeid{PlmnID: "1234", EnbID: "7788", RanName: "RanName-1234"}
 112                 params.Xid = "TestXID"
 113                 Rmr.SendMsg(params)
 114         }
 115
 116         // Allow time to process the messages
 117         time.Sleep(time.Duration(2) * time.Second)
 118
 119         waitForSdl := viper.GetBool("db.waitForSdl")
 120         stats := getMetrics(t)
 121         if !strings.Contains(stats, "ricxapp_RMR_Transmitted 100") {
 122                 t.Errorf("Error: ricxapp_RMR_Transmitted value incorrect: %v", stats)
 123         }
 124
 125         if !strings.Contains(stats, "ricxapp_RMR_Received 100") {
 126                 t.Errorf("Error: ricxapp_RMR_Received value incorrect: %v", stats)
 127         }
 128
 129         if !strings.Contains(stats, "ricxapp_RMR_TransmitError 0") {
 130                 t.Errorf("Error: ricxapp_RMR_TransmitError value incorrect")
 131         }
 132
 133         if !strings.Contains(stats, "ricxapp_RMR_ReceiveError 0") {
 134                 t.Errorf("Error: ricxapp_RMR_ReceiveError value incorrect")
 135         }
 136
 137         if waitForSdl && !strings.Contains(stats, "ricxapp_SDL_Stored 100") {
 138                 t.Errorf("Error: ricxapp_SDL_Stored value incorrect")
 139         }
 140
 141         if waitForSdl && !strings.Contains(stats, "ricxapp_SDL_StoreError 0") {
 142                 t.Errorf("Error: ricxapp_SDL_StoreError value incorrect")
 143         }
 144 }
 145
 146 func TestMessagesReceivedSuccessfullyUsingWh(t *testing.T) {
 147         time.Sleep(time.Duration(5) * time.Second)
 148         whid := Rmr.Openwh("localhost:4560")
 149         time.Sleep(time.Duration(1) * time.Second)
 150         for i := 0; i < 100; i++ {
 151                 params := &RMRParams{}
 152                 params.Mtype = 10004
 153                 params.SubId = -1
 154                 params.Payload = []byte{1, 2, 3, 4, 5, 6}
 155                 params.Meid = &RMRMeid{PlmnID: "1234", EnbID: "7788", RanName: "RanName-1234"}
 156                 params.Xid = "TestXID"
 157                 params.Whid = int(whid)
 158                 Rmr.SendMsg(params)
 159         }
 160
 161         // Allow time to process the messages
 162         time.Sleep(time.Duration(2) * time.Second)
 163
 164         waitForSdl := viper.GetBool("db.waitForSdl")
 165         stats := getMetrics(t)
 166         if !strings.Contains(stats, "ricxapp_RMR_Transmitted 200") {
 167                 t.Errorf("Error: ricxapp_RMR_Transmitted value incorrect: %v", stats)
 168         }
 169
 170         if !strings.Contains(stats, "ricxapp_RMR_Received 200") {
 171                 t.Errorf("Error: ricxapp_RMR_Received value incorrect: %v", stats)
 172         }
 173
 174         if !strings.Contains(stats, "ricxapp_RMR_TransmitError 0") {
 175                 t.Errorf("Error: ricxapp_RMR_TransmitError value incorrect")
 176         }
 177
 178         if !strings.Contains(stats, "ricxapp_RMR_ReceiveError 0") {
 179                 t.Errorf("Error: ricxapp_RMR_ReceiveError value incorrect")
 180         }
 181
 182         if waitForSdl && !strings.Contains(stats, "ricxapp_SDL_Stored 200") {
 183                 t.Errorf("Error: ricxapp_SDL_Stored value incorrect")
 184         }
 185
 186         if waitForSdl && !strings.Contains(stats, "ricxapp_SDL_StoreError 0") {
 187                 t.Errorf("Error: ricxapp_SDL_StoreError value incorrect")
 188         }
 189         Rmr.Closewh(int(whid))
 190 }
 191
 192 func TestSubscribeChannels(t *testing.T) {
 193         if !viper.GetBool("db.waitForSdl") {
 194                 return
 195         }
 196
 197         var NotificationCb = func(ch string, events ...string) {
 198                 if ch != "channel1" {
 199                         t.Errorf("Error: Callback function called with incorrect params")
 200                 }
 201         }
 202
 203         if err := Sdl.Subscribe(NotificationCb, "channel1"); err != nil {
 204                 t.Errorf("Error: Subscribe failed: %v", err)
 205         }
 206         time.Sleep(time.Duration(2) * time.Second)
 207
 208         if err := Sdl.StoreAndPublish("channel1", "event", "key1", "data1"); err != nil {
 209                 t.Errorf("Error: Publish failed: %v", err)
 210         }
 211 }
 212
 213 func TestGetRicMessageSuccess(t *testing.T) {
 214         id, ok := Rmr.GetRicMessageId("RIC_SUB_REQ")
 215         if !ok || id != 12010 {
 216                 t.Errorf("Error: GetRicMessageId failed: id=%d", id)
 217         }
 218
 219         name := Rmr.GetRicMessageName(12010)
 220         if name != "RIC_SUB_REQ" {
 221                 t.Errorf("Error: GetRicMessageName failed: name=%s", name)
 222         }
 223 }
 224
 225 func TestGetRicMessageFails(t *testing.T) {
 226         ok := Rmr.IsRetryError(&RMRParams{status: 0})
 227         if ok {
 228                 t.Errorf("Error: IsRetryError returned wrong value")
 229         }
 230
 231         ok = Rmr.IsRetryError(&RMRParams{status: 10})
 232         if !ok {
 233                 t.Errorf("Error: IsRetryError returned wrong value")
 234         }
 235
 236         ok = Rmr.IsNoEndPointError(&RMRParams{status: 5})
 237         if ok {
 238                 t.Errorf("Error: IsNoEndPointError returned wrong value")
 239         }
 240
 241         ok = Rmr.IsNoEndPointError(&RMRParams{status: 2})
 242         if !ok {
 243                 t.Errorf("Error: IsNoEndPointError returned wrong value")
 244         }
 245 }
 246
 247 func TestIsErrorFunctions(t *testing.T) {
 248         id, ok := Rmr.GetRicMessageId("RIC_SUB_REQ")
 249         if !ok || id != 12010 {
 250                 t.Errorf("Error: GetRicMessageId failed: id=%d", id)
 251         }
 252
 253         name := Rmr.GetRicMessageName(12010)
 254         if name != "RIC_SUB_REQ" {
 255                 t.Errorf("Error: GetRicMessageName failed: name=%s", name)
 256         }
 257 }
 258
 259 func TestTeardown(t *testing.T) {
 260         Sdl.Clear()
 261 }
 262
 263 // Helper functions
 264 func executeRequest(req *http.Request) *httptest.ResponseRecorder {
 265         rr := httptest.NewRecorder()
 266         vars := map[string]string{"id": "1"}
 267         req = mux.SetURLVars(req, vars)
 268         Resource.router.ServeHTTP(rr, req)
 269
 270         return rr
 271 }
 272
 273 func checkResponseCode(t *testing.T, expected, actual int) {
 274         if expected != actual {
 275                 t.Errorf("Expected response code %d. Got %d\n", expected, actual)
 276         }
 277 }
 278
 279 func getMetrics(t *testing.T) string {
 280         req, _ := http.NewRequest("GET", "/ric/v1/metrics", nil)
 281         response := executeRequest(req)
 282
 283         return response.Body.String()
 284 }