Generalized unittest stubs so frame can be used also in other apps

[ric-plt/submgr.git] / pkg / control / ut_stub_rtmgr_test.go

diff --git a/pkg/control/ut_stub_rtmgr_test.go b/pkg/control/ut_stub_rtmgr_test.go
index 59467dc..8546ad4 100644 (file)
--- a/pkg/control/ut_stub_rtmgr_test.go
+++ b/pkg/control/ut_stub_rtmgr_test.go
@@ -22,7 +22,7 @@ package control
 import (
        "encoding/json"
        "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_models"
-       "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
+       "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststub"
        "net/http"
        "sync"
        "testing"
@@ -33,24 +33,25 @@ import (
 //
 //-----------------------------------------------------------------------------
 
-type httpEventWaiter struct {
+type HttpEventWaiter struct {
+       teststub.TestWrapper
        resultChan   chan bool
        nextActionOk bool
 }
 
-func (msg *httpEventWaiter) SetResult(res bool) {
+func (msg *HttpEventWaiter) SetResult(res bool) {
        msg.resultChan <- res
 }
 
-func (msg *httpEventWaiter) WaitResult(t *testing.T) bool {
+func (msg *HttpEventWaiter) WaitResult(t *testing.T) bool {
        select {
        case result := <-msg.resultChan:
                return result
        case <-time.After(15 * time.Second):
-               testError(t, "Waiter not received result status from case within 15 secs")
+               msg.TestError(t, "Waiter not received result status from case within 15 secs")
                return false
        }
-       testError(t, "Waiter error in default branch")
+       msg.TestError(t, "Waiter error in default branch")
        return false
 }
 
@@ -59,68 +60,69 @@ func (msg *httpEventWaiter) WaitResult(t *testing.T) bool {
 //-----------------------------------------------------------------------------
 type testingHttpRtmgrStub struct {
        sync.Mutex
-       desc        string
+       teststub.TestWrapper
        port        string
-       eventWaiter *httpEventWaiter
+       eventWaiter *HttpEventWaiter
 }
 
-func (hc *testingHttpRtmgrStub) NextEvent(eventWaiter *httpEventWaiter) {
-       hc.Lock()
-       defer hc.Unlock()
-       hc.eventWaiter = eventWaiter
+func (tc *testingHttpRtmgrStub) NextEvent(eventWaiter *HttpEventWaiter) {
+       tc.Lock()
+       defer tc.Unlock()
+       tc.eventWaiter = eventWaiter
 }
 
-func (hc *testingHttpRtmgrStub) AllocNextEvent(nextAction bool) *httpEventWaiter {
-       eventWaiter := &httpEventWaiter{
+func (tc *testingHttpRtmgrStub) AllocNextEvent(nextAction bool) *HttpEventWaiter {
+       eventWaiter := &HttpEventWaiter{
                resultChan:   make(chan bool),
                nextActionOk: nextAction,
        }
-       hc.NextEvent(eventWaiter)
+       eventWaiter.TestWrapper.Init("localhost:" + tc.port)
+       tc.NextEvent(eventWaiter)
        return eventWaiter
 }
 
-func (hc *testingHttpRtmgrStub) http_handler(w http.ResponseWriter, r *http.Request) {
+func (tc *testingHttpRtmgrStub) http_handler(w http.ResponseWriter, r *http.Request) {
 
-       hc.Lock()
-       defer hc.Unlock()
+       tc.Lock()
+       defer tc.Unlock()
 
        if r.Method == http.MethodPost || r.Method == http.MethodDelete {
                var req rtmgr_models.XappSubscriptionData
                err := json.NewDecoder(r.Body).Decode(&req)
                if err != nil {
-                       xapp.Logger.Error("%s", err.Error())
+                       tc.Logger.Error("%s", err.Error())
                }
-               xapp.Logger.Info("(%s) handling SubscriptionID=%d Address=%s Port=%d", hc.desc, *req.SubscriptionID, *req.Address, *req.Port)
+               tc.Logger.Info("handling SubscriptionID=%d Address=%s Port=%d", *req.SubscriptionID, *req.Address, *req.Port)
        }
        if r.Method == http.MethodPut {
                var req rtmgr_models.XappList
                err := json.NewDecoder(r.Body).Decode(&req)
                if err != nil {
-                       xapp.Logger.Error("%s", err.Error())
+                       tc.Logger.Error("%s", err.Error())
                }
-               xapp.Logger.Info("(%s) handling put", hc.desc)
+               tc.Logger.Info("handling put")
        }
 
        var code int = 0
        switch r.Method {
        case http.MethodPost:
                code = 201
-               if hc.eventWaiter != nil {
-                       if hc.eventWaiter.nextActionOk == false {
+               if tc.eventWaiter != nil {
+                       if tc.eventWaiter.nextActionOk == false {
                                code = 400
                        }
                }
        case http.MethodDelete:
                code = 200
-               if hc.eventWaiter != nil {
-                       if hc.eventWaiter.nextActionOk == false {
+               if tc.eventWaiter != nil {
+                       if tc.eventWaiter.nextActionOk == false {
                                code = 400
                        }
                }
        case http.MethodPut:
                code = 201
-               if hc.eventWaiter != nil {
-                       if hc.eventWaiter.nextActionOk == false {
+               if tc.eventWaiter != nil {
+                       if tc.eventWaiter.nextActionOk == false {
                                code = 400
                        }
                }
@@ -128,24 +130,24 @@ func (hc *testingHttpRtmgrStub) http_handler(w http.ResponseWriter, r *http.Requ
                code = 200
        }
 
-       waiter := hc.eventWaiter
-       hc.eventWaiter = nil
+       waiter := tc.eventWaiter
+       tc.eventWaiter = nil
        if waiter != nil {
                waiter.SetResult(true)
        }
-       xapp.Logger.Info("(%s) Method=%s Reply with code %d", hc.desc, r.Method, code)
+       tc.Logger.Info("Method=%s Reply with code %d", r.Method, code)
        w.WriteHeader(code)
 
 }
 
-func (hc *testingHttpRtmgrStub) run() {
-       http.HandleFunc("/", hc.http_handler)
-       http.ListenAndServe("localhost:"+hc.port, nil)
+func (tc *testingHttpRtmgrStub) run() {
+       http.HandleFunc("/", tc.http_handler)
+       http.ListenAndServe("localhost:"+tc.port, nil)
 }
 
 func createNewHttpRtmgrStub(desc string, port string) *testingHttpRtmgrStub {
-       hc := &testingHttpRtmgrStub{}
-       hc.desc = desc
-       hc.port = port
-       return hc
+       tc := &testingHttpRtmgrStub{}
+       tc.port = port
+       tc.TestWrapper.Init(desc)
+       return tc
 }