E2Manager/managers/e2t_shutdown_manager_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19 //  platform project (RICP).
  20
  21 package managers
  22
  23 import (
  24         "bytes"
  25         "e2mgr/clients"
  26         "e2mgr/configuration"
  27         "e2mgr/e2managererrors"
  28         "e2mgr/mocks"
  29         "e2mgr/models"
  30         "e2mgr/services"
  31         "encoding/json"
  32         "fmt"
  33         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  34         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  35         "github.com/stretchr/testify/assert"
  36         "github.com/stretchr/testify/mock"
  37         "io/ioutil"
  38         "net/http"
  39         "testing"
  40         "time"
  41 )
  42
  43 const E2TAddress3 = "10.10.2.17:9800"
  44
  45 func initE2TShutdownManagerTest(t *testing.T) (*E2TShutdownManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
  46         log := initLog(t)
  47         config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, E2TInstanceDeletionTimeoutMs: 15000}
  48
  49         readerMock := &mocks.RnibReaderMock{}
  50         writerMock := &mocks.RnibWriterMock{}
  51         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  52
  53         e2tInstancesManager := NewE2TInstancesManager(rnibDataService, log)
  54         httpClientMock := &mocks.HttpClientMock{}
  55         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
  56         associationManager := NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
  57
  58         shutdownManager := NewE2TShutdownManager(log, config, rnibDataService, e2tInstancesManager, associationManager)
  59
  60         return shutdownManager, readerMock, writerMock, httpClientMock
  61 }
  62
  63 func TestShutdownSuccess1OutOf3Instances(t *testing.T) {
  64         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
  65
  66         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
  67         e2tInstance1.State = entities.Active
  68         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
  69         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
  70         e2tInstance2.State = entities.Active
  71         e2tInstance2.AssociatedRanList = []string{"test3"}
  72         e2tInstance3 := entities.NewE2TInstance(E2TAddress3)
  73         e2tInstance3.State = entities.Active
  74         e2tInstance3.AssociatedRanList = []string{"test4"}
  75         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
  76
  77         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
  78         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
  79         nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
  80         readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
  81         nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
  82         readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
  83
  84         e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
  85         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
  86
  87         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
  88         marshaled, _ := json.Marshal(data)
  89         body := bytes.NewBuffer(marshaled)
  90         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
  91         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
  92
  93         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
  94         writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
  95
  96         nodeb1connected := *nodeb1
  97         nodeb1connected.AssociatedE2TInstanceAddress = ""
  98         nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
  99         writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
 100         nodeb2connected := *nodeb2
 101         nodeb2connected.AssociatedE2TInstanceAddress = ""
 102         nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 103         writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
 104         nodeb5connected := *nodeb5
 105         nodeb5connected.AssociatedE2TInstanceAddress = ""
 106         nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 107         writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
 108
 109         err := shutdownManager.Shutdown(e2tInstance1)
 110
 111         assert.Nil(t, err)
 112         readerMock.AssertExpectations(t)
 113         writerMock.AssertExpectations(t)
 114         httpClientMock.AssertExpectations(t)
 115 }
 116
 117 func TestShutdownSuccess1InstanceWithoutRans(t *testing.T) {
 118         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 119
 120         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 121         e2tInstance1.State = entities.Active
 122         e2tInstance1.AssociatedRanList = []string{}
 123         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 124
 125         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, nil, nil)
 126         marshaled, _ := json.Marshal(data)
 127         body := bytes.NewBuffer(marshaled)
 128         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 129         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 130
 131         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 132         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 133         writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
 134
 135         err := shutdownManager.Shutdown(e2tInstance1)
 136
 137         assert.Nil(t, err)
 138         readerMock.AssertExpectations(t)
 139         writerMock.AssertExpectations(t)
 140         httpClientMock.AssertExpectations(t)
 141 }
 142
 143 func TestShutdownSuccess1Instance2Rans(t *testing.T) {
 144         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 145
 146         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 147         e2tInstance1.State = entities.Active
 148         e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
 149         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 150
 151         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 152         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
 153         nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 154         readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
 155
 156         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1", "test2"}, nil)
 157         marshaled, _ := json.Marshal(data)
 158         body := bytes.NewBuffer(marshaled)
 159         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 160         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 161
 162         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 163         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 164         writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
 165
 166         nodeb1new := *nodeb1
 167         nodeb1new.AssociatedE2TInstanceAddress = ""
 168         nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 169         writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
 170         nodeb2new := *nodeb2
 171         nodeb2new.AssociatedE2TInstanceAddress = ""
 172         nodeb2new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 173         writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
 174
 175         err := shutdownManager.Shutdown(e2tInstance1)
 176
 177         assert.Nil(t, err)
 178         readerMock.AssertExpectations(t)
 179         writerMock.AssertExpectations(t)
 180         httpClientMock.AssertExpectations(t)
 181
 182 }
 183
 184 func TestShutdownE2tInstanceAlreadyBeingDeleted(t *testing.T) {
 185         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 186
 187         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 188         e2tInstance1.State = entities.ToBeDeleted
 189         e2tInstance1.AssociatedRanList = []string{"test1"}
 190         e2tInstance1.DeletionTimestamp = time.Now().UnixNano()
 191
 192         err := shutdownManager.Shutdown(e2tInstance1)
 193
 194         assert.Nil(t, err)
 195         readerMock.AssertExpectations(t)
 196         writerMock.AssertExpectations(t)
 197         httpClientMock.AssertExpectations(t)
 198
 199 }
 200
 201 func TestShutdownFailureMarkInstanceAsToBeDeleted(t *testing.T) {
 202         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 203
 204         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 205         e2tInstance1.State = entities.Active
 206         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
 207         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(e2managererrors.NewRnibDbError())
 208
 209         err := shutdownManager.Shutdown(e2tInstance1)
 210
 211         assert.NotNil(t, err)
 212         readerMock.AssertExpectations(t)
 213         writerMock.AssertExpectations(t)
 214         httpClientMock.AssertExpectations(t)
 215
 216 }
 217
 218 func TestShutdownFailureRoutingManagerError(t *testing.T) {
 219         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 220
 221         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 222         e2tInstance1.State = entities.Active
 223         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
 224         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 225         e2tInstance2.State = entities.Active
 226         e2tInstance2.AssociatedRanList = []string{"test3"}
 227         e2tInstance3 := entities.NewE2TInstance(E2TAddress3)
 228         e2tInstance3.State = entities.Active
 229         e2tInstance3.AssociatedRanList = []string{"test4"}
 230         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 231
 232         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 233         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
 234         nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 235         readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
 236         nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 237         readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
 238
 239         e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
 240         readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
 241
 242         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
 243         marshaled, _ := json.Marshal(data)
 244         body := bytes.NewBuffer(marshaled)
 245         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 246         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body: respBody}, nil)
 247
 248         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 249         writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
 250
 251         nodeb1connected := *nodeb1
 252         nodeb1connected.AssociatedE2TInstanceAddress = ""
 253         nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 254         writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
 255         nodeb2connected := *nodeb2
 256         nodeb2connected.AssociatedE2TInstanceAddress = ""
 257         nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 258         writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
 259         nodeb5connected := *nodeb5
 260         nodeb5connected.AssociatedE2TInstanceAddress = ""
 261         nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 262         writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
 263
 264         err := shutdownManager.Shutdown(e2tInstance1)
 265
 266         assert.Nil(t, err)
 267         readerMock.AssertExpectations(t)
 268         writerMock.AssertExpectations(t)
 269         httpClientMock.AssertExpectations(t)
 270
 271 }
 272
 273 func TestShutdownFailureInClearNodebsAssociation(t *testing.T) {
 274         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 275
 276         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 277         e2tInstance1.State = entities.Active
 278         e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
 279         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 280
 281         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 282         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
 283
 284         nodeb1new := *nodeb1
 285         nodeb1new.AssociatedE2TInstanceAddress = ""
 286         nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 287         writerMock.On("UpdateNodebInfo", &nodeb1new).Return(common.NewInternalError(fmt.Errorf("for tests")))
 288
 289         err := shutdownManager.Shutdown(e2tInstance1)
 290
 291         assert.NotNil(t, err)
 292         readerMock.AssertExpectations(t)
 293         writerMock.AssertExpectations(t)
 294         httpClientMock.AssertExpectations(t)
 295 }
 296
 297 func TestShutdownResourceNotFoundErrorInGetNodeb(t *testing.T) {
 298         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 299
 300         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 301         e2tInstance1.State = entities.Active
 302         e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
 303         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 304
 305         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 306         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
 307         var nodeb2 *entities.NodebInfo
 308         readerMock.On("GetNodeb", "test2").Return(nodeb2, common.NewResourceNotFoundError("for testing"))
 309
 310         nodeb1new := *nodeb1
 311         nodeb1new.AssociatedE2TInstanceAddress = ""
 312         nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 313         writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
 314
 315         err := shutdownManager.Shutdown(e2tInstance1)
 316
 317         assert.NotNil(t, err)
 318         readerMock.AssertExpectations(t)
 319         writerMock.AssertExpectations(t)
 320         httpClientMock.AssertExpectations(t)
 321 }
 322
 323 func TestShutdownResourceGeneralErrorInGetNodeb(t *testing.T) {
 324         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 325
 326         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 327         e2tInstance1.State = entities.Active
 328         e2tInstance1.AssociatedRanList = []string{"test1", "test2"}
 329         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 330
 331         var nodeb1 *entities.NodebInfo
 332         readerMock.On("GetNodeb", "test1").Return(nodeb1, common.NewInternalError(fmt.Errorf("for testing")))
 333         nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 334         readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
 335
 336         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, []string{"test1", "test2"}, nil)
 337         marshaled, _ := json.Marshal(data)
 338         body := bytes.NewBuffer(marshaled)
 339         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 340         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 341
 342         writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
 343         readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
 344         writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
 345
 346         nodeb2new := *nodeb2
 347         nodeb2new.AssociatedE2TInstanceAddress = ""
 348         nodeb2new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 349         writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
 350
 351         err := shutdownManager.Shutdown(e2tInstance1)
 352
 353         assert.Nil(t, err)
 354         readerMock.AssertExpectations(t)
 355         writerMock.AssertExpectations(t)
 356         httpClientMock.AssertExpectations(t)
 357
 358 }
 359
 360 func TestShutdownFailureInRemoveE2TInstance(t *testing.T) {
 361         shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
 362
 363         e2tInstance1 := entities.NewE2TInstance(E2TAddress)
 364         e2tInstance1.State = entities.Active
 365         e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test5"}
 366         e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
 367         e2tInstance2.State = entities.Active
 368         e2tInstance2.AssociatedRanList = []string{"test3"}
 369         e2tInstance3 := entities.NewE2TInstance(E2TAddress3)
 370         e2tInstance3.State = entities.Active
 371         e2tInstance3.AssociatedRanList = []string{"test4"}
 372         writerMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress && e2tInstance.State == entities.ToBeDeleted })).Return(nil)
 373
 374         nodeb1 := &entities.NodebInfo{RanName:"test1", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 375         readerMock.On("GetNodeb", "test1").Return(nodeb1, nil)
 376         nodeb2 := &entities.NodebInfo{RanName:"test2", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 377         readerMock.On("GetNodeb", "test2").Return(nodeb2, nil)
 378         nodeb5 := &entities.NodebInfo{RanName:"test5", AssociatedE2TInstanceAddress:E2TAddress, ConnectionStatus:entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
 379         readerMock.On("GetNodeb", "test5").Return(nodeb5, nil)
 380
 381         data := models.NewRoutingManagerDeleteRequestModel(E2TAddress, e2tInstance1.AssociatedRanList, nil)
 382         marshaled, _ := json.Marshal(data)
 383         body := bytes.NewBuffer(marshaled)
 384         respBody := ioutil.NopCloser(bytes.NewBufferString(""))
 385         httpClientMock.On("Delete", "e2t", "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 386
 387         writerMock.On("RemoveE2TInstance", E2TAddress).Return(common.NewInternalError(fmt.Errorf("for tests")))
 388
 389         nodeb1connected := *nodeb1
 390         nodeb1connected.AssociatedE2TInstanceAddress = ""
 391         nodeb1connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 392         writerMock.On("UpdateNodebInfo", &nodeb1connected).Return(nil)
 393         nodeb2connected := *nodeb2
 394         nodeb2connected.AssociatedE2TInstanceAddress = ""
 395         nodeb2connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 396         writerMock.On("UpdateNodebInfo", &nodeb2connected).Return(nil)
 397         nodeb5connected := *nodeb5
 398         nodeb5connected.AssociatedE2TInstanceAddress = ""
 399         nodeb5connected.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
 400         writerMock.On("UpdateNodebInfo", &nodeb5connected).Return(nil)
 401
 402         err := shutdownManager.Shutdown(e2tInstance1)
 403
 404         assert.IsType(t, &e2managererrors.RnibDbError{}, err)
 405         readerMock.AssertExpectations(t)
 406         writerMock.AssertExpectations(t)
 407         httpClientMock.AssertExpectations(t)
 408 }