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 package handlers
  18
  19 import (
  20         "e2mgr/logger"
  21         "e2mgr/mocks"
  22         "e2mgr/models"
  23         "e2mgr/sessions"
  24         "github.com/pkg/errors"
  25         "testing"
  26 )
  27
  28 func TestLostConnectionHandlerSuccess(t *testing.T) {
  29         logger, _ := logger.InitLogger(logger.InfoLevel)
  30         ranName := "test"
  31         notificationRequest := models.NotificationRequest{RanName: ranName}
  32         ranReconnectionManagerMock := &mocks.RanReconnectionManagerMock{}
  33         ranReconnectionManagerMock.On("ReconnectRan", ranName).Return(nil)
  34         handler := NewRanLostConnectionHandler(ranReconnectionManagerMock)
  35         handler.Handle(logger, make(sessions.E2Sessions), &notificationRequest, nil)
  36         ranReconnectionManagerMock.AssertCalled(t, "ReconnectRan", ranName)
  37 }
  38
  39 func TestLostConnectionHandlerFailure(t *testing.T) {
  40         logger, _ := logger.InitLogger(logger.InfoLevel)
  41         ranName := "test"
  42         notificationRequest := models.NotificationRequest{RanName: ranName}
  43         ranReconnectionManagerMock := &mocks.RanReconnectionManagerMock{}
  44         ranReconnectionManagerMock.On("ReconnectRan", ranName).Return(errors.New("error"))
  45         handler := NewRanLostConnectionHandler(ranReconnectionManagerMock)
  46         handler.Handle(logger, make(sessions.E2Sessions), &notificationRequest, nil)
  47         ranReconnectionManagerMock.AssertCalled(t, "ReconnectRan", ranName)
  48 }
  49
  50 //
  51 //func TestHandleUnsolicitedDisconnectionNotConnectedSuccess(t *testing.T){
  52 //      log, err := logger.InitLogger(logger.DebugLevel)
  53 //      if err!=nil{
  54 //              t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
  55 //      }
  56 //
  57 //      readerMock :=&mocks.RnibReaderMock{}
  58 //      rnibReaderProvider := func() reader.RNibReader {
  59 //              return readerMock
  60 //      }
  61 //      writerMock := &mocks.RnibWriterMock{}
  62 //      rnibWriterProvider := func() rNibWriter.RNibWriter {
  63 //              return writerMock
  64 //      }
  65 //      h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
  66 //
  67 //      e2Sessions := make(sessions.E2Sessions)
  68 //      transactionId := "1234"
  69 //      xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
  70 //      e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
  71 //      payload := []byte("Error")
  72 //      mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
  73 //      notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
  74 //              TransactionId: string(xaction)}
  75 //      var messageChannel chan<- *models.NotificationResponse
  76 //
  77 //      nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
  78 //      var rnibErr common.IRNibError
  79 //      readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
  80 //      updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
  81 //      writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
  82 //
  83 //      h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
  84 //}
  85 //
  86 //func TestHandleUnsolicitedDisconnectionShuttingDownSuccess(t *testing.T){
  87 //      log, err := logger.InitLogger(logger.DebugLevel)
  88 //      if err!=nil{
  89 //              t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
  90 //      }
  91 //
  92 //      readerMock :=&mocks.RnibReaderMock{}
  93 //      rnibReaderProvider := func() reader.RNibReader {
  94 //              return readerMock
  95 //      }
  96 //      writerMock := &mocks.RnibWriterMock{}
  97 //      rnibWriterProvider := func() rNibWriter.RNibWriter {
  98 //              return writerMock
  99 //      }
 100 //      h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 101 //
 102 //      e2Sessions := make(sessions.E2Sessions)
 103 //      transactionId := "1234"
 104 //      xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 105 //      e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 106 //      payload := []byte("Error")
 107 //      mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 108 //      notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 109 //              TransactionId: string(xaction)}
 110 //      var messageChannel chan<- *models.NotificationResponse
 111 //
 112 //      nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
 113 //      var rnibErr common.IRNibError
 114 //      readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 115 //      updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 116 //      writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 117 //
 118 //      h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 119 //}
 120 //
 121 //func TestHandleUnsolicitedDisconnectionShutDownSuccess(t *testing.T){
 122 //      log, err := logger.InitLogger(logger.DebugLevel)
 123 //      if err!=nil{
 124 //              t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 125 //      }
 126 //
 127 //      readerMock :=&mocks.RnibReaderMock{}
 128 //      rnibReaderProvider := func() reader.RNibReader {
 129 //              return readerMock
 130 //      }
 131 //      writerMock := &mocks.RnibWriterMock{}
 132 //      rnibWriterProvider := func() rNibWriter.RNibWriter {
 133 //              return writerMock
 134 //      }
 135 //      h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 136 //
 137 //      e2Sessions := make(sessions.E2Sessions)
 138 //      transactionId := "1234"
 139 //      xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 140 //      e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 141 //      payload := []byte("Error")
 142 //      mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 143 //      notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 144 //              TransactionId: string(xaction)}
 145 //      var messageChannel chan<- *models.NotificationResponse
 146 //
 147 //      nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 148 //      var rnibErr common.IRNibError
 149 //      readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 150 //      updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
 151 //      writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(rnibErr)
 152 //
 153 //      h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 154 //}
 155 //
 156 //func TestHandleUnsolicitedDisconnectionReaderFailure(t *testing.T){
 157 //      log, err := logger.InitLogger(logger.DebugLevel)
 158 //      if err!=nil{
 159 //              t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 160 //      }
 161 //
 162 //      readerMock :=&mocks.RnibReaderMock{}
 163 //      rnibReaderProvider := func() reader.RNibReader {
 164 //              return readerMock
 165 //      }
 166 //      writerMock := &mocks.RnibWriterMock{}
 167 //      rnibWriterProvider := func() rNibWriter.RNibWriter {
 168 //              return writerMock
 169 //      }
 170 //      h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 171 //
 172 //      e2Sessions := make(sessions.E2Sessions)
 173 //      transactionId := "1234"
 174 //      xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 175 //      e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 176 //      payload := []byte("Error")
 177 //      mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 178 //      notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 179 //              TransactionId: string(xaction)}
 180 //      var messageChannel chan<- *models.NotificationResponse
 181 //
 182 //      var nb *entities.NodebInfo
 183 //      rnibErr := common.RNibError{}
 184 //      readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 185 //      h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 186 //}
 187 //
 188 //func TestHandleUnsolicitedDisconnectionWriterFailure(t *testing.T){
 189 //      log, err := logger.InitLogger(logger.DebugLevel)
 190 //      if err!=nil{
 191 //              t.Errorf("#sctp_errors_notification_handler_test.TestHandleNoSession - failed to initialize logger, error: %s", err)
 192 //      }
 193 //
 194 //      readerMock :=&mocks.RnibReaderMock{}
 195 //      rnibReaderProvider := func() reader.RNibReader {
 196 //              return readerMock
 197 //      }
 198 //      writerMock := &mocks.RnibWriterMock{}
 199 //      rnibWriterProvider := func() rNibWriter.RNibWriter {
 200 //              return writerMock
 201 //      }
 202 //      h := NewRanLostConnectionHandler(rnibReaderProvider,rnibWriterProvider)
 203 //
 204 //      e2Sessions := make(sessions.E2Sessions)
 205 //      transactionId := "1234"
 206 //      xaction := []byte(fmt.Sprintf("%32s", transactionId+"6"))
 207 //      e2Sessions[transactionId] = sessions.E2SessionDetails{SessionStart: time.Now()}
 208 //      payload := []byte("Error")
 209 //      mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
 210 //      notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
 211 //              TransactionId: string(xaction)}
 212 //      var messageChannel chan<- *models.NotificationResponse
 213 //
 214 //      nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
 215 //      var rnibErr common.IRNibError
 216 //      readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
 217 //      updatedNb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
 218 //      writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(common.RNibError{})
 219 //
 220 //      h.Handle(log,e2Sessions, &notificationRequest, messageChannel)
 221 //}