E2Manager/services/rmrsender/rmr_sender_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18 //  platform project (RICP).
  19
  20 package rmrsender
  21
  22 import (
  23         "e2mgr/logger"
  24         "e2mgr/mocks"
  25         "e2mgr/models"
  26         "e2mgr/rmrCgo"
  27         "fmt"
  28         "github.com/stretchr/testify/assert"
  29         "testing"
  30         "unsafe"
  31 )
  32
  33 func initRmrSenderTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock) {
  34         log := initLog(t)
  35         rmrMessengerMock := &mocks.RmrMessengerMock{}
  36         rmrMessengerMock.On("IsReady").Return(true)
  37         rmrMessengerMock.On("Close").Return()
  38         return log, rmrMessengerMock
  39 }
  40
  41 //func TestRmrSender_CloseContext(t *testing.T) {
  42 //      logger, rmrMessengerMock := initRmrSenderTest(t)
  43 //
  44 //      rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
  45 //      rmrSender := NewRmrSender(logger, &rmrMessenger)
  46 //
  47 //      rmrSender.CloseContext()
  48 //      time.Sleep(time.Microsecond * 10)
  49 //}
  50
  51 func TestRmrSenderSendSuccess(t *testing.T) {
  52         logger, rmrMessengerMock := initRmrSenderTest(t)
  53
  54         ranName := "test"
  55         payload := []byte("some payload")
  56         var xAction []byte
  57         var msgSrc unsafe.Pointer
  58         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
  59         rmrMessengerMock.On("SendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
  60         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
  61         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
  62         rmrSender := NewRmrSender(logger, rmrMessenger)
  63         err := rmrSender.Send(rmrMsg)
  64         assert.Nil(t, err)
  65         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
  66
  67 }
  68
  69 func TestRmrSenderSendFailure(t *testing.T) {
  70         logger, rmrMessengerMock := initRmrSenderTest(t)
  71
  72         ranName := "test"
  73         payload := []byte("some payload")
  74         var xAction []byte
  75         var msgSrc unsafe.Pointer
  76         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
  77         rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, fmt.Errorf("rmr send failure"))
  78         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
  79         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
  80         rmrSender := NewRmrSender(logger, rmrMessenger)
  81         err := rmrSender.Send(rmrMsg)
  82         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, true)
  83         assert.NotNil(t, err)
  84 }
  85
  86 func TestRmrSenderSendWithoutLogsSuccess(t *testing.T) {
  87         logger, rmrMessengerMock := initRmrSenderTest(t)
  88
  89         ranName := "test"
  90         payload := []byte("some payload")
  91         var xAction []byte
  92         var msgSrc unsafe.Pointer
  93         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
  94         rmrMessengerMock.On("SendMsg", mbuf, false).Return(&rmrCgo.MBuf{}, nil)
  95         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
  96         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
  97         rmrSender := NewRmrSender(logger, rmrMessenger)
  98         err := rmrSender.SendWithoutLogs(rmrMsg)
  99         assert.Nil(t, err)
 100         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, false)
 101
 102 }
 103
 104 func TestRmrSenderSendWithoutLogsFailure(t *testing.T) {
 105         logger, rmrMessengerMock := initRmrSenderTest(t)
 106
 107         ranName := "test"
 108         payload := []byte("some payload")
 109         var xAction []byte
 110         var msgSrc unsafe.Pointer
 111         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
 112         rmrMessengerMock.On("SendMsg", mbuf, false).Return(mbuf, fmt.Errorf("rmr send failure"))
 113         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
 114         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 115         rmrSender := NewRmrSender(logger, rmrMessenger)
 116         err := rmrSender.SendWithoutLogs(rmrMsg)
 117         rmrMessengerMock.AssertCalled(t, "SendMsg", mbuf, false)
 118         assert.NotNil(t, err)
 119 }
 120
 121 func TestRmrSenderWhSendSuccess(t *testing.T) {
 122         logger, rmrMessengerMock := initRmrSenderTest(t)
 123
 124         ranName := "test"
 125         payload := []byte("some payload")
 126         var xAction []byte
 127         var msgSrc unsafe.Pointer
 128         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
 129         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
 130         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
 131         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 132         rmrSender := NewRmrSender(logger, rmrMessenger)
 133         err := rmrSender.WhSend(rmrMsg)
 134         assert.Nil(t, err)
 135         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 136 }
 137
 138 func TestRmrSenderWhSendFailure(t *testing.T) {
 139         logger, rmrMessengerMock := initRmrSenderTest(t)
 140
 141         ranName := "test"
 142         payload := []byte("some payload")
 143         var xAction []byte
 144         var msgSrc unsafe.Pointer
 145         mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
 146         rmrMessengerMock.On("WhSendMsg", mbuf, true).Return(mbuf, fmt.Errorf("rmr send failure"))
 147         rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
 148         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 149         rmrSender := NewRmrSender(logger, rmrMessenger)
 150         err := rmrSender.WhSend(rmrMsg)
 151         rmrMessengerMock.AssertCalled(t, "WhSendMsg", mbuf, true)
 152         assert.NotNil(t, err)
 153 }
 154
 155 // TODO: extract to test_utils
 156 func initLog(t *testing.T) *logger.Logger {
 157         InfoLevel := int8(3)
 158         log, err := logger.InitLogger(InfoLevel)
 159         if err != nil {
 160                 t.Fatalf("#initLog - failed to initialize logger, error: %s", err)
 161         }
 162         return log
 163 }