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 //}