2 ==================================================================================
3 Copyright (c) 2019 AT&T Intellectual Property.
4 Copyright (c) 2019 Nokia
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
10 http://www.apache.org/licenses/LICENSE-2.0
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 ==================================================================================
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"
36 //-----------------------------------------------------------------------------
38 //-----------------------------------------------------------------------------
39 type testingSubmgrControl struct {
49 type CountersToBeAdded []Counter
51 var countersBeforeMap map[string]Counter
52 var toBeAddedCountersMap map[string]Counter
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)
63 mainCtrl.c.ReadyCB(nil)
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()
75 mc.TestError(t, "%v", err)
77 mainCtrl.c.registry.register = nil
78 mainCtrl.c.registry.subIds = subIds
79 mainCtrl.c.registry.register = register
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)
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)
95 go mainCtrl.c.HandleUncompletedSubscriptions(mainCtrl.c.registry.register)
98 func (mc *testingSubmgrControl) MakeTransactionNil(t *testing.T, subId uint32) {
100 mc.TestLog(t, "Makin transaction nil for SubId=%v", subId)
101 subs := mainCtrl.c.registry.GetSubscription(subId)
105 func (mc *testingSubmgrControl) SetResetTestFlag(t *testing.T, status bool) {
106 mc.TestLog(t, "ResetTestFlag set to %v", status)
107 mainCtrl.c.ResetTestFlag = status
110 func (mc *testingSubmgrControl) removeExistingSubscriptions(t *testing.T) {
112 mc.TestLog(t, "Removing existing subscriptions")
113 mainCtrl.c.RemoveAllSubscriptionsFromSdl()
114 mainCtrl.c.registry.subIds = nil
115 // Initialize subIds slice and subscription map
116 mainCtrl.c.registry.Initialize()
119 func PringSubscriptionQueryResult(resp models.SubscriptionList) {
120 for _, item := range resp {
121 fmt.Printf("item.SubscriptionID=%v\n", item.SubscriptionID)
122 fmt.Printf("item.Meid=%v\n", item.Meid)
123 fmt.Printf("item.ClientEndpoint=%v\n", item.ClientEndpoint)
127 func (mc *testingSubmgrControl) wait_registry_empty(t *testing.T, secs int) bool {
130 for ; i <= secs*10; i++ {
131 cnt = len(mc.c.registry.register)
135 time.Sleep(100 * time.Millisecond)
137 mc.TestError(t, "(submgr) no registry empty within %d secs: %d", secs, cnt)
141 func (mc *testingSubmgrControl) get_registry_next_subid(t *testing.T) uint32 {
142 mc.c.registry.mutex.Lock()
143 defer mc.c.registry.mutex.Unlock()
144 return mc.c.registry.subIds[0]
147 func (mc *testingSubmgrControl) wait_registry_next_subid_change(t *testing.T, origSubId uint32, secs int) (uint32, bool) {
149 for ; i <= secs*10; i++ {
150 mc.c.registry.mutex.Lock()
151 currSubId := mc.c.registry.subIds[0]
152 mc.c.registry.mutex.Unlock()
153 if currSubId != origSubId {
154 return currSubId, true
156 time.Sleep(100 * time.Millisecond)
158 mc.TestError(t, "(submgr) no subId change within %d secs", secs)
162 func (mc *testingSubmgrControl) wait_subs_clean(t *testing.T, e2SubsId uint32, secs int) bool {
163 var subs *Subscription
165 for ; i <= secs*10; i++ {
166 subs = mc.c.registry.GetSubscription(e2SubsId)
170 time.Sleep(100 * time.Millisecond)
173 mc.TestError(t, "(submgr) no clean within %d secs: %s", secs, subs.String())
175 mc.TestError(t, "(submgr) no clean within %d secs: subs(N/A)", secs)
180 func (mc *testingSubmgrControl) wait_multi_subs_clean(t *testing.T, e2SubsIds []uint32, secs int) bool {
182 purgedSubscriptions := 0
184 for i := 1; i <= secs*10; i++ {
185 purgedSubscriptions = 0
186 for k := 0; k <= len(e2SubsIds); i++ {
187 subs := mc.c.registry.GetSubscription(e2SubsIds[k])
189 mc.TestLog(t, "(submgr) subscriber purged for esSubsId %v", e2SubsIds[k])
190 purgedSubscriptions += 1
191 if purgedSubscriptions == len(e2SubsIds) {
196 mc.TestLog(t, "(submgr) subscriptions pending purging %v/%v after %d msecs", purgedSubscriptions, len(e2SubsIds), i+500)
197 time.Sleep(100 * time.Millisecond)
200 mc.TestError(t, "(submgr) no clean within %d secs: subs(N/A) - %v/%v subscriptions found still", secs, purgedSubscriptions, len(e2SubsIds))
205 func (mc *testingSubmgrControl) wait_subs_trans_clean(t *testing.T, e2SubsId uint32, secs int) bool {
206 var trans TransactionIf
208 for ; i <= secs*10; i++ {
209 subs := mc.c.registry.GetSubscription(e2SubsId)
213 trans = subs.GetTransaction()
217 time.Sleep(100 * time.Millisecond)
220 mc.TestError(t, "(submgr) no clean within %d secs: %s", secs, trans.String())
222 mc.TestError(t, "(submgr) no clean within %d secs: trans(N/A)", secs)
227 func (mc *testingSubmgrControl) get_subs_entrypoint_cnt(t *testing.T, origSubId uint32) int {
228 subs := mc.c.registry.GetSubscription(origSubId)
230 mc.TestError(t, "(submgr) no subs %d exists during entrypoint cnt get", origSubId)
233 return subs.EpList.Size()
236 func (mc *testingSubmgrControl) wait_subs_entrypoint_cnt_change(t *testing.T, origSubId uint32, orig int, secs int) (int, bool) {
238 subs := mc.c.registry.GetSubscription(origSubId)
240 mc.TestError(t, "(submgr) no subs %d exists during entrypoint cnt wait", origSubId)
245 for ; i <= secs*10; i++ {
246 curr := subs.EpList.Size()
250 time.Sleep(100 * time.Millisecond)
252 mc.TestError(t, "(submgr) no subs %d entrypoint cnt change within %d secs", origSubId, secs)
257 // Counter check for received message. Note might not be yet handled
259 func (mc *testingSubmgrControl) get_msgcounter(t *testing.T) uint64 {
260 return mc.c.CntRecvMsg
263 func (mc *testingSubmgrControl) wait_msgcounter_change(t *testing.T, orig uint64, secs int) (uint64, bool) {
265 for ; i <= secs*10; i++ {
266 curr := mc.c.CntRecvMsg
270 time.Sleep(100 * time.Millisecond)
272 mc.TestError(t, "(submgr) no msg counter change within %d secs", secs)
276 func (mc *testingSubmgrControl) GetMetrics(t *testing.T) (string, error) {
277 req, err := http.NewRequest("GET", "http://localhost:8080/ric/v1/metrics", nil)
279 return "", fmt.Errorf("Error reading request. %v", err)
281 client := &http.Client{Timeout: time.Second * 10}
282 resp, err := client.Do(req)
284 return "", fmt.Errorf("Error reading response. %v", err)
286 defer resp.Body.Close()
288 respBody, err := ioutil.ReadAll(resp.Body)
290 return "", fmt.Errorf("Error reading body. %v", err)
292 return string(respBody[:]), nil
295 func (mc *testingSubmgrControl) CounterValuesToBeVeriefied(t *testing.T, countersToBeAdded CountersToBeAdded) {
297 if len(toBeAddedCountersMap) == 0 {
298 toBeAddedCountersMap = make(map[string]Counter)
300 for _, counter := range countersToBeAdded {
301 toBeAddedCountersMap[counter.Name] = counter
303 mc.GetCounterValuesBefore(t)
306 func (mc *testingSubmgrControl) GetCounterValuesBefore(t *testing.T) {
307 countersBeforeMap = make(map[string]Counter)
308 countersBeforeMap = mc.GetCurrentCounterValues(t, toBeAddedCountersMap)
311 func (mc *testingSubmgrControl) VerifyCounterValues(t *testing.T) {
312 currentCountersMap := mc.GetCurrentCounterValues(t, toBeAddedCountersMap)
313 for _, toBeAddedCounter := range toBeAddedCountersMap {
314 if currentCounter, ok := currentCountersMap[toBeAddedCounter.Name]; ok == true {
315 if beforeCounter, ok := countersBeforeMap[toBeAddedCounter.Name]; ok == true {
316 if currentCounter.Value != beforeCounter.Value+toBeAddedCounter.Value {
317 mc.TestError(t, "Error in expected counter value: counterName %v, current value %v, expected value %v",
318 currentCounter.Name, currentCounter.Value, beforeCounter.Value+toBeAddedCounter.Value)
320 //fmt.Printf("beforeCounter.Value=%v, toBeAddedCounter.Value=%v, \n",beforeCounter.Value, toBeAddedCounter.Value)
323 mc.TestError(t, "Counter %v not in countersBeforeMap", toBeAddedCounter.Name)
326 mc.TestError(t, "Counter %v not in currentCountersMap", toBeAddedCounter.Name)
331 //fmt.Printf("toBeAddedCountersMap=%v\n",toBeAddedCountersMap)
332 toBeAddedCountersMap = make(map[string]Counter)
335 func (mc *testingSubmgrControl) GetCurrentCounterValues(t *testing.T, chekedCountersMap map[string]Counter) map[string]Counter {
336 countersString, err := mc.GetMetrics(t)
338 mc.TestError(t, "Error GetMetrics() failed %v", err)
342 retCounterMap := make(map[string]Counter)
343 stringsTable := strings.Split(countersString, "\n")
344 for _, counter := range chekedCountersMap {
345 for _, counterString := range stringsTable {
346 if !strings.Contains(counterString, "#") && strings.Contains(counterString, counter.Name) {
347 counterString := strings.Split(counterString, " ")
348 if strings.Contains(counterString[0], counter.Name) {
349 val, err := strconv.ParseUint(counterString[1], 10, 64)
351 mc.TestError(t, "Error: strconv.ParseUint failed %v", err)
354 //fmt.Printf("counter=%v\n", counter)
355 retCounterMap[counter.Name] = counter
361 if len(retCounterMap) != len(chekedCountersMap) {
362 mc.TestError(t, "Error: len(retCounterMap) != len(chekedCountersMap)")
368 func (mc *testingSubmgrControl) sendGetRequest(t *testing.T, addr string, path string) {
370 mc.TestLog(t, "GET http://"+addr+"%v", path)
371 req, err := http.NewRequest("GET", "http://"+addr+path, nil)
373 mc.TestError(t, "Error reading request. %v", err)
376 req.Header.Set("Cache-Control", "no-cache")
377 client := &http.Client{Timeout: time.Second * 2}
378 resp, err := client.Do(req)
380 mc.TestError(t, "Error reading response. %v", err)
383 defer resp.Body.Close()
385 mc.TestLog(t, "Response status: %v", resp.Status)
386 mc.TestLog(t, "Response Headers: %v", resp.Header)
387 if !strings.Contains(resp.Status, "200 OK") {
388 mc.TestError(t, "Wrong response status")
392 respBody, err := ioutil.ReadAll(resp.Body)
394 mc.TestError(t, "Error reading body. %v", err)
397 mc.TestLog(t, "%s", respBody)
401 func (mc *testingSubmgrControl) sendPostRequest(t *testing.T, addr string, path string) {
403 mc.TestLog(t, "POST http://"+addr+"%v", path)
404 req, err := http.NewRequest("POST", "http://"+addr+path, nil)
406 mc.TestError(t, "Error reading request. %v", err)
409 client := &http.Client{Timeout: time.Second * 2}
410 resp, err := client.Do(req)
412 mc.TestError(t, "Error reading response. %v", err)
415 defer resp.Body.Close()
417 mc.TestLog(t, "Response status: %v", resp.Status)
418 mc.TestLog(t, "Response Headers: %v", resp.Header)
419 if !strings.Contains(resp.Status, "200 OK") {
420 mc.TestError(t, "Wrong response status")
424 respBody, err := ioutil.ReadAll(resp.Body)
426 mc.TestError(t, "Error reading body. %v", err)
429 mc.TestLog(t, "%s", respBody)