pkg/control/ut_ctrl_submgr_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 control
  21
  22 import (
  23         "fmt"
  24         "io/ioutil"
  25         "net/http"
  26         "strconv"
  27         "strings"
  28         "testing"
  29         "time"
  30
  31         "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststub"
  32         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
  33         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  34 )
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39 type testingSubmgrControl struct {
  40         teststub.RmrControl
  41         c *Control
  42 }
  43
  44 type Counter struct {
  45         Name  string
  46         Value uint64
  47 }
  48
  49 type CountersToBeAdded []Counter
  50
  51 var countersBeforeMap map[string]Counter
  52 var toBeAddedCountersMap map[string]Counter
  53
  54 func createSubmgrControl(srcId teststub.RmrSrcId, rtgSvc teststub.RmrRtgSvc) *testingSubmgrControl {
  55         mainCtrl = &testingSubmgrControl{}
  56         mainCtrl.RmrControl.Init("SUBMGRCTL", srcId, rtgSvc)
  57         mainCtrl.c = NewControl()
  58         xapp.Logger.Debug("Replacing real db with test db")
  59         mainCtrl.c.db = CreateMock() // This overrides real database for testing
  60         xapp.SetReadyCB(mainCtrl.ReadyCB, nil)
  61         go xapp.RunWithParams(mainCtrl.c, false)
  62         mainCtrl.WaitCB()
  63         mainCtrl.c.ReadyCB(nil)
  64         return mainCtrl
  65 }
  66
  67 func (mc *testingSubmgrControl) SimulateRestart(t *testing.T) {
  68         mc.TestLog(t, "Simulating submgr restart")
  69         mainCtrl.c.registry.subIds = nil
  70         // Initialize subIds slice and subscription map
  71         mainCtrl.c.registry.Initialize()
  72         // Read subIds and subscriptions from database
  73         subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
  74         if err != nil {
  75                 mc.TestError(t, "%v", err)
  76         } else {
  77                 mainCtrl.c.registry.register = nil
  78                 mainCtrl.c.registry.subIds = subIds
  79                 mainCtrl.c.registry.register = register
  80
  81                 mc.TestLog(t, "register:")
  82                 for subId, subs := range register {
  83                         mc.TestLog(t, "  subId=%v", subId)
  84                         mc.TestLog(t, "  subs.SubRespRcvd=%v", subs.SubRespRcvd)
  85                         mc.TestLog(t, "  subs=%v\n", subs)
  86                 }
  87
  88                 mc.TestLog(t, "mainCtrl.c.registry.register:")
  89                 for subId, subs := range mainCtrl.c.registry.register {
  90                         mc.TestLog(t, "  subId=%v", subId)
  91                         mc.TestLog(t, "  subs.SubRespRcvd=%v", subs.SubRespRcvd)
  92                         mc.TestLog(t, "  subs=%v\n", subs)
  93                 }
  94         }
  95         go mainCtrl.c.HandleUncompletedSubscriptions(mainCtrl.c.registry.register)
  96 }
  97
  98 func (mc *testingSubmgrControl) SetResetTestFlag(t *testing.T, status bool) {
  99         mc.TestLog(t, "ResetTestFlag set to %v=", status)
 100         mainCtrl.c.ResetTestFlag = status
 101 }
 102
 103 func (mc *testingSubmgrControl) removeExistingSubscriptions(t *testing.T) {
 104
 105         mc.TestLog(t, "Removing existing subscriptions")
 106         mainCtrl.c.RemoveAllSubscriptionsFromSdl()
 107         mainCtrl.c.registry.subIds = nil
 108         // Initialize subIds slice and subscription map
 109         mainCtrl.c.registry.Initialize()
 110 }
 111
 112 func PringSubscriptionQueryResult(resp models.SubscriptionList) {
 113         for _, item := range resp {
 114                 fmt.Printf("item.SubscriptionID=%v\n", item.SubscriptionID)
 115                 fmt.Printf("item.Meid=%v\n", item.Meid)
 116                 fmt.Printf("item.Endpoint=%v\n", item.Endpoint)
 117         }
 118 }
 119
 120 func (mc *testingSubmgrControl) wait_registry_empty(t *testing.T, secs int) bool {
 121         cnt := int(0)
 122         i := 1
 123         for ; i <= secs*2; i++ {
 124                 cnt = len(mc.c.registry.register)
 125                 if cnt == 0 {
 126                         return true
 127                 }
 128                 time.Sleep(500 * time.Millisecond)
 129         }
 130         mc.TestError(t, "(submgr) no registry empty within %d secs: %d", secs, cnt)
 131         return false
 132 }
 133
 134 func (mc *testingSubmgrControl) get_registry_next_subid(t *testing.T) uint32 {
 135         mc.c.registry.mutex.Lock()
 136         defer mc.c.registry.mutex.Unlock()
 137         return mc.c.registry.subIds[0]
 138 }
 139
 140 func (mc *testingSubmgrControl) wait_registry_next_subid_change(t *testing.T, origSubId uint32, secs int) (uint32, bool) {
 141         i := 1
 142         for ; i <= secs*2; i++ {
 143                 mc.c.registry.mutex.Lock()
 144                 currSubId := mc.c.registry.subIds[0]
 145                 mc.c.registry.mutex.Unlock()
 146                 if currSubId != origSubId {
 147                         return currSubId, true
 148                 }
 149                 time.Sleep(500 * time.Millisecond)
 150         }
 151         mc.TestError(t, "(submgr) no subId change within %d secs", secs)
 152         return 0, false
 153 }
 154
 155 func (mc *testingSubmgrControl) wait_subs_clean(t *testing.T, e2SubsId uint32, secs int) bool {
 156         var subs *Subscription
 157         i := 1
 158         for ; i <= secs*2; i++ {
 159                 subs = mc.c.registry.GetSubscription(e2SubsId)
 160                 if subs == nil {
 161                         return true
 162                 }
 163                 time.Sleep(500 * time.Millisecond)
 164         }
 165         if subs != nil {
 166                 mc.TestError(t, "(submgr) no clean within %d secs: %s", secs, subs.String())
 167         } else {
 168                 mc.TestError(t, "(submgr) no clean within %d secs: subs(N/A)", secs)
 169         }
 170         return false
 171 }
 172
 173 func (mc *testingSubmgrControl) wait_subs_trans_clean(t *testing.T, e2SubsId uint32, secs int) bool {
 174         var trans TransactionIf
 175         i := 1
 176         for ; i <= secs*2; i++ {
 177                 subs := mc.c.registry.GetSubscription(e2SubsId)
 178                 if subs == nil {
 179                         return true
 180                 }
 181                 trans = subs.GetTransaction()
 182                 if trans == nil {
 183                         return true
 184                 }
 185                 time.Sleep(500 * time.Millisecond)
 186         }
 187         if trans != nil {
 188                 mc.TestError(t, "(submgr) no clean within %d secs: %s", secs, trans.String())
 189         } else {
 190                 mc.TestError(t, "(submgr) no clean within %d secs: trans(N/A)", secs)
 191         }
 192         return false
 193 }
 194
 195 func (mc *testingSubmgrControl) get_subs_entrypoint_cnt(t *testing.T, origSubId uint32) int {
 196         subs := mc.c.registry.GetSubscription(origSubId)
 197         if subs == nil {
 198                 mc.TestError(t, "(submgr) no subs %d exists during entrypoint cnt get", origSubId)
 199                 return -1
 200         }
 201         return subs.EpList.Size()
 202 }
 203
 204 func (mc *testingSubmgrControl) wait_subs_entrypoint_cnt_change(t *testing.T, origSubId uint32, orig int, secs int) (int, bool) {
 205
 206         subs := mc.c.registry.GetSubscription(origSubId)
 207         if subs == nil {
 208                 mc.TestError(t, "(submgr) no subs %d exists during entrypoint cnt wait", origSubId)
 209                 return -1, true
 210         }
 211
 212         i := 1
 213         for ; i <= secs*2; i++ {
 214                 curr := subs.EpList.Size()
 215                 if curr != orig {
 216                         return curr, true
 217                 }
 218                 time.Sleep(500 * time.Millisecond)
 219         }
 220         mc.TestError(t, "(submgr) no subs %d entrypoint cnt change within %d secs", origSubId, secs)
 221         return 0, false
 222 }
 223
 224 //
 225 // Counter check for received message. Note might not be yet handled
 226 //
 227 func (mc *testingSubmgrControl) get_msgcounter(t *testing.T) uint64 {
 228         return mc.c.CntRecvMsg
 229 }
 230
 231 func (mc *testingSubmgrControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
 232         i := 1
 233         for ; i <= secs*2; i++ {
 234                 curr := mc.c.CntRecvMsg
 235                 if curr != orig {
 236                         return curr, true
 237                 }
 238                 time.Sleep(500 * time.Millisecond)
 239         }
 240         mc.TestError(t, "(submgr) no msg counter change within %d secs", secs)
 241         return 0, false
 242 }
 243
 244 func (mc *testingSubmgrControl) GetMetrics(t *testing.T) (string, error) {
 245         req, err := http.NewRequest("GET", "http://localhost:8080/ric/v1/metrics", nil)
 246         if err != nil {
 247                 return "", fmt.Errorf("Error reading request. %v", err)
 248         }
 249         client := &http.Client{Timeout: time.Second * 10}
 250         resp, err := client.Do(req)
 251         if err != nil {
 252                 return "", fmt.Errorf("Error reading response. %v", err)
 253         }
 254         defer resp.Body.Close()
 255
 256         respBody, err := ioutil.ReadAll(resp.Body)
 257         if err != nil {
 258                 return "", fmt.Errorf("Error reading body. %v", err)
 259         }
 260         return string(respBody[:]), nil
 261 }
 262
 263 func (mc *testingSubmgrControl) CounterValuesToBeVeriefied(t *testing.T, countersToBeAdded CountersToBeAdded) {
 264
 265         if len(toBeAddedCountersMap) == 0 {
 266                 toBeAddedCountersMap = make(map[string]Counter)
 267         }
 268         for _, counter := range countersToBeAdded {
 269                 toBeAddedCountersMap[counter.Name] = counter
 270         }
 271         mc.GetCounterValuesBefore(t)
 272 }
 273
 274 func (mc *testingSubmgrControl) GetCounterValuesBefore(t *testing.T) {
 275         countersBeforeMap = make(map[string]Counter)
 276         countersBeforeMap = mc.GetCurrentCounterValues(t, toBeAddedCountersMap)
 277 }
 278
 279 func (mc *testingSubmgrControl) VerifyCounterValues(t *testing.T) {
 280         currentCountersMap := mc.GetCurrentCounterValues(t, toBeAddedCountersMap)
 281         for _, toBeAddedCounter := range toBeAddedCountersMap {
 282                 if currentCounter, ok := currentCountersMap[toBeAddedCounter.Name]; ok == true {
 283                         if beforeCounter, ok := countersBeforeMap[toBeAddedCounter.Name]; ok == true {
 284                                 if currentCounter.Value != beforeCounter.Value+toBeAddedCounter.Value {
 285                                         mc.TestError(t, "Error in expected counter value: counterName %v, current value %v, expected value %v",
 286                                                 currentCounter.Name, currentCounter.Value, beforeCounter.Value+toBeAddedCounter.Value)
 287
 288                                         //fmt.Printf("beforeCounter.Value=%v, toBeAddedCounter.Value=%v, \n",beforeCounter.Value, toBeAddedCounter.Value)
 289                                 }
 290                         } else {
 291                                 mc.TestError(t, "Counter %v not in countersBeforeMap", toBeAddedCounter.Name)
 292                         }
 293                 } else {
 294                         mc.TestError(t, "Counter %v not in currentCountersMap", toBeAddedCounter.Name)
 295                 }
 296         }
 297
 298         // Make map empty
 299         //fmt.Printf("toBeAddedCountersMap=%v\n",toBeAddedCountersMap)
 300         toBeAddedCountersMap = make(map[string]Counter)
 301 }
 302
 303 func (mc *testingSubmgrControl) GetCurrentCounterValues(t *testing.T, chekedCountersMap map[string]Counter) map[string]Counter {
 304         countersString, err := mc.GetMetrics(t)
 305         if err != nil {
 306                 mc.TestError(t, "Error GetMetrics() failed %v", err)
 307                 return nil
 308         }
 309
 310         retCounterMap := make(map[string]Counter)
 311         stringsTable := strings.Split(countersString, "\n")
 312         for _, counter := range chekedCountersMap {
 313                 for _, counterString := range stringsTable {
 314                         if !strings.Contains(counterString, "#") && strings.Contains(counterString, counter.Name) {
 315                                 counterString := strings.Split(counterString, " ")
 316                                 if strings.Contains(counterString[0], counter.Name) {
 317                                         val, err := strconv.ParseUint(counterString[1], 10, 64)
 318                                         if err != nil {
 319                                                 mc.TestError(t, "Error: strconv.ParseUint failed %v", err)
 320                                         }
 321                                         counter.Value = val
 322                                         //fmt.Printf("counter=%v\n", counter)
 323                                         retCounterMap[counter.Name] = counter
 324                                 }
 325                         }
 326                 }
 327         }
 328
 329         if len(retCounterMap) != len(chekedCountersMap) {
 330                 mc.TestError(t, "Error: len(retCounterMap) != len(chekedCountersMap)")
 331
 332         }
 333         return retCounterMap
 334 }