E2Manager/handlers/ranLostConnectionHandler_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
  18 package handlers
  19
  20 import (
  21         "e2mgr/logger"
  22         "e2mgr/mocks"
  23         "e2mgr/models"
  24         "e2mgr/rNibWriter"
  25         "e2mgr/rmrCgo"
  26         "e2mgr/sessions"
  27         "e2mgr/tests"
  28         "fmt"
  29         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  30         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  31         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  32         "github.com/stretchr/testify/mock"
  33         "testing"
  34         "time"
  35 )
  36
  37 /*
  38  * Test an error response while in an x2 setup request session
  39  */
  40 func TestHandleInSession(t *testing.T){
  41         log, err := logger.InitLogger(logger.InfoLevel)
  42         if err!=nil{
  43                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleInSession - failed to initialize logger, error: %s", err)
  44         }
  45
  46         readerMock :=&mocks.RnibReaderMock{}
  47         rnibReaderProvider := func() reader.RNibReader {
  48                 return readerMock
  49         }
  50         writerMock := &mocks.RnibWriterMock{}
  51         rnibWriterProvider := func() rNibWriter.RNibWriter {
  52                 return writerMock
  53         }
  54         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
  55
  56         e2Sessions := make(sessions.E2Sessions)
  57         xaction := []byte(fmt.Sprintf("%32s", "1234"))
  58         e2Sessions[string(xaction)] = sessions.E2SessionDetails{SessionStart: time.Now()}
  59         payload := []byte("Error")
  60         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
  61         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
  62                 StartTime: time.Now(), TransactionId: string(xaction)}
  63         var messageChannel chan<- *models.NotificationResponse
  64
  65         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
  66         var rnibErr common.IRNibError
  67         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
  68         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
  69         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
  70
  71         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
  72
  73         if _, ok := e2Sessions[string(xaction)]; ok {
  74                 t.Errorf("want: no session entry, got: session entry for: %s", string(xaction) )
  75         }
  76 }
  77
  78 /*
  79  * Test an error response triggered by the E2 Term
  80  */
  81
  82 func TestHandleNoSession(t *testing.T){
  83         log, err := logger.InitLogger(logger.InfoLevel)
  84         if err!=nil{
  85                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
  86         }
  87
  88         readerMock :=&mocks.RnibReaderMock{}
  89         rnibReaderProvider := func() reader.RNibReader {
  90                 return readerMock
  91         }
  92         writerMock := &mocks.RnibWriterMock{}
  93         rnibWriterProvider := func() rNibWriter.RNibWriter {
  94                 return writerMock
  95         }
  96         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
  97
  98         e2Sessions := make(sessions.E2Sessions)
  99         transactionId := "1234"
 100         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 101         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 102         payload := []byte("Error")
 103         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 104         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 105                         TransactionId: string(xaction)}
 106         var messageChannel chan<- *models.NotificationResponse
 107
 108         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
 109         var rnibErr common.IRNibError
 110         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 111         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 112         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 113
 114         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 115
 116         if _, ok := e2Sessions[transactionId]; !ok {
 117                 t.Errorf("want: session entry for %s, got: no session entry", transactionId )
 118         }
 119 }
 120 /*
 121  * Test an error response triggered by the E2 Term
 122  */
 123 func TestHandleUnsolicitedDisconnectionConnectedSuccess(t *testing.T){
 124         log, err := logger.InitLogger(logger.DebugLevel)
 125         if err!=nil{
 126                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 127         }
 128
 129         readerMock :=&mocks.RnibReaderMock{}
 130         rnibReaderProvider := func() reader.RNibReader {
 131                 return readerMock
 132         }
 133         writerMock := &mocks.RnibWriterMock{}
 134         rnibWriterProvider := func() rNibWriter.RNibWriter {
 135                 return writerMock
 136         }
 137         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 138
 139         e2Sessions := make(sessions.E2Sessions)
 140         transactionId := "1234"
 141         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 142         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 143         payload := []byte("Error")
 144         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 145         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 146                 TransactionId: string(xaction)}
 147         var messageChannel chan<- *models.NotificationResponse
 148
 149         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
 150         var rnibErr common.IRNibError
 151         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 152         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 153         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 154
 155         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 156 }
 157
 158 func TestHandleUnsolicitedDisconnectionNotConnectedSuccess(t *testing.T){
 159         log, err := logger.InitLogger(logger.DebugLevel)
 160         if err!=nil{
 161                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 162         }
 163
 164         readerMock :=&mocks.RnibReaderMock{}
 165         rnibReaderProvider := func() reader.RNibReader {
 166                 return readerMock
 167         }
 168         writerMock := &mocks.RnibWriterMock{}
 169         rnibWriterProvider := func() rNibWriter.RNibWriter {
 170                 return writerMock
 171         }
 172         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 173
 174         e2Sessions := make(sessions.E2Sessions)
 175         transactionId := "1234"
 176         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 177         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 178         payload := []byte("Error")
 179         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 180         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 181                 TransactionId: string(xaction)}
 182         var messageChannel chan<- *models.NotificationResponse
 183
 184         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 185         var rnibErr common.IRNibError
 186         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 187         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 188         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 189
 190         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 191 }
 192
 193 func TestHandleUnsolicitedDisconnectionShuttingDownSuccess(t *testing.T){
 194         log, err := logger.InitLogger(logger.DebugLevel)
 195         if err!=nil{
 196                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 197         }
 198
 199         readerMock :=&mocks.RnibReaderMock{}
 200         rnibReaderProvider := func() reader.RNibReader {
 201                 return readerMock
 202         }
 203         writerMock := &mocks.RnibWriterMock{}
 204         rnibWriterProvider := func() rNibWriter.RNibWriter {
 205                 return writerMock
 206         }
 207         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 208
 209         e2Sessions := make(sessions.E2Sessions)
 210         transactionId := "1234"
 211         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 212         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 213         payload := []byte("Error")
 214         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 215         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 216                 TransactionId: string(xaction)}
 217         var messageChannel chan<- *models.NotificationResponse
 218
 219         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
 220         var rnibErr common.IRNibError
 221         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 222         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 223         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 224
 225         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 226 }
 227
 228 func TestHandleUnsolicitedDisconnectionShutDownSuccess(t *testing.T){
 229         log, err := logger.InitLogger(logger.DebugLevel)
 230         if err!=nil{
 231                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 232         }
 233
 234         readerMock :=&mocks.RnibReaderMock{}
 235         rnibReaderProvider := func() reader.RNibReader {
 236                 return readerMock
 237         }
 238         writerMock := &mocks.RnibWriterMock{}
 239         rnibWriterProvider := func() rNibWriter.RNibWriter {
 240                 return writerMock
 241         }
 242         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 243
 244         e2Sessions := make(sessions.E2Sessions)
 245         transactionId := "1234"
 246         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 247         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 248         payload := []byte("Error")
 249         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 250         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 251                 TransactionId: string(xaction)}
 252         var messageChannel chan<- *models.NotificationResponse
 253
 254         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 255         var rnibErr common.IRNibError
 256         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 257         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 258         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 259
 260         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 261 }
 262
 263 func TestHandleUnsolicitedDisconnectionReaderFailure(t *testing.T){
 264         log, err := logger.InitLogger(logger.DebugLevel)
 265         if err!=nil{
 266                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 267         }
 268
 269         readerMock :=&mocks.RnibReaderMock{}
 270         rnibReaderProvider := func() reader.RNibReader {
 271                 return readerMock
 272         }
 273         writerMock := &mocks.RnibWriterMock{}
 274         rnibWriterProvider := func() rNibWriter.RNibWriter {
 275                 return writerMock
 276         }
 277         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 278
 279         e2Sessions := make(sessions.E2Sessions)
 280         transactionId := "1234"
 281         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 282         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 283         payload := []byte("Error")
 284         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 285         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 286                 TransactionId: string(xaction)}
 287         var messageChannel chan<- *models.NotificationResponse
 288
 289         var nb *entities.NodebInfo
 290         rnibErr := common.RNibError{}
 291         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 292         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 293 }
 294
 295 func TestHandleUnsolicitedDisconnectionWriterFailure(t *testing.T){
 296         log, err := logger.InitLogger(logger.DebugLevel)
 297         if err!=nil{
 298                 t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 299         }
 300
 301         readerMock :=&mocks.RnibReaderMock{}
 302         rnibReaderProvider := func() reader.RNibReader {
 303                 return readerMock
 304         }
 305         writerMock := &mocks.RnibWriterMock{}
 306         rnibWriterProvider := func() rNibWriter.RNibWriter {
 307                 return writerMock
 308         }
 309         h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 310
 311         e2Sessions := make(sessions.E2Sessions)
 312         transactionId := "1234"
 313         xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 314         e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 315         payload := []byte("Error")
 316         mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 317         notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 318                 TransactionId: string(xaction)}
 319         var messageChannel chan<- *models.NotificationResponse
 320
 321         nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
 322         var rnibErr common.IRNibError
 323         readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 324         updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 325         writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(common.RNibError{})
 326
 327         h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 328 }