2 // Copyright 2019 AT&T Intellectual Property
3 // Copyright 2019 Nokia
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 // platform project (RICP).
27 "e2mgr/e2managererrors"
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"
43 const E2TAddress3 = "10.10.2.17:9800"
45 func initE2TShutdownManagerTest(t *testing.T) (*E2TShutdownManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
47 config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, E2TInstanceDeletionTimeoutMs: 15000}
49 readerMock := &mocks.RnibReaderMock{}
50 writerMock := &mocks.RnibWriterMock{}
51 rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
53 e2tInstancesManager := NewE2TInstancesManager(rnibDataService, log)
54 httpClientMock := &mocks.HttpClientMock{}
55 rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
56 associationManager := NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
58 shutdownManager := NewE2TShutdownManager(log, config, rnibDataService, e2tInstancesManager, associationManager)
60 return shutdownManager, readerMock, writerMock, httpClientMock
63 func TestShutdownSuccess1OutOf3Instances(t *testing.T) {
64 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
84 e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
85 readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
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)
93 writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
94 writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
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)
109 err := shutdownManager.Shutdown(e2tInstance1)
112 readerMock.AssertExpectations(t)
113 writerMock.AssertExpectations(t)
114 httpClientMock.AssertExpectations(t)
117 func TestShutdownSuccess1InstanceWithoutRans(t *testing.T) {
118 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
131 writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
132 readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
133 writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
135 err := shutdownManager.Shutdown(e2tInstance1)
138 readerMock.AssertExpectations(t)
139 writerMock.AssertExpectations(t)
140 httpClientMock.AssertExpectations(t)
143 func TestShutdownSuccess1Instance2Rans(t *testing.T) {
144 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
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)
162 writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
163 readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
164 writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
167 nodeb1new.AssociatedE2TInstanceAddress = ""
168 nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
169 writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
171 nodeb2new.AssociatedE2TInstanceAddress = ""
172 nodeb2new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
173 writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
175 err := shutdownManager.Shutdown(e2tInstance1)
178 readerMock.AssertExpectations(t)
179 writerMock.AssertExpectations(t)
180 httpClientMock.AssertExpectations(t)
184 func TestShutdownE2tInstanceAlreadyBeingDeleted(t *testing.T) {
185 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
187 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
188 e2tInstance1.State = entities.ToBeDeleted
189 e2tInstance1.AssociatedRanList = []string{"test1"}
190 e2tInstance1.DeletionTimestamp = time.Now().UnixNano()
192 err := shutdownManager.Shutdown(e2tInstance1)
195 readerMock.AssertExpectations(t)
196 writerMock.AssertExpectations(t)
197 httpClientMock.AssertExpectations(t)
201 func TestShutdownFailureMarkInstanceAsToBeDeleted(t *testing.T) {
202 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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())
209 err := shutdownManager.Shutdown(e2tInstance1)
211 assert.NotNil(t, err)
212 readerMock.AssertExpectations(t)
213 writerMock.AssertExpectations(t)
214 httpClientMock.AssertExpectations(t)
218 func TestShutdownFailureRoutingManagerError(t *testing.T) {
219 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
239 e2tAddresses := []string{E2TAddress, E2TAddress2,E2TAddress3}
240 readerMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
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)
248 writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
249 writerMock.On("SaveE2TAddresses", []string{E2TAddress2,E2TAddress3}).Return(nil)
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)
264 err := shutdownManager.Shutdown(e2tInstance1)
267 readerMock.AssertExpectations(t)
268 writerMock.AssertExpectations(t)
269 httpClientMock.AssertExpectations(t)
273 func TestShutdownFailureInClearNodebsAssociation(t *testing.T) {
274 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
285 nodeb1new.AssociatedE2TInstanceAddress = ""
286 nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
287 writerMock.On("UpdateNodebInfo", &nodeb1new).Return(common.NewInternalError(fmt.Errorf("for tests")))
289 err := shutdownManager.Shutdown(e2tInstance1)
291 assert.NotNil(t, err)
292 readerMock.AssertExpectations(t)
293 writerMock.AssertExpectations(t)
294 httpClientMock.AssertExpectations(t)
297 func TestShutdownResourceNotFoundErrorInGetNodeb(t *testing.T) {
298 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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"))
311 nodeb1new.AssociatedE2TInstanceAddress = ""
312 nodeb1new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
313 writerMock.On("UpdateNodebInfo", &nodeb1new).Return(nil)
315 err := shutdownManager.Shutdown(e2tInstance1)
317 assert.NotNil(t, err)
318 readerMock.AssertExpectations(t)
319 writerMock.AssertExpectations(t)
320 httpClientMock.AssertExpectations(t)
323 func TestShutdownResourceGeneralErrorInGetNodeb(t *testing.T) {
324 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
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)
342 writerMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
343 readerMock.On("GetE2TAddresses").Return([]string{E2TAddress}, nil)
344 writerMock.On("SaveE2TAddresses", []string{}).Return(nil)
347 nodeb2new.AssociatedE2TInstanceAddress = ""
348 nodeb2new.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
349 writerMock.On("UpdateNodebInfo", &nodeb2new).Return(nil)
351 err := shutdownManager.Shutdown(e2tInstance1)
354 readerMock.AssertExpectations(t)
355 writerMock.AssertExpectations(t)
356 httpClientMock.AssertExpectations(t)
360 func TestShutdownFailureInRemoveE2TInstance(t *testing.T) {
361 shutdownManager, readerMock, writerMock, httpClientMock := initE2TShutdownManagerTest(t)
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)
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)
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)
387 writerMock.On("RemoveE2TInstance", E2TAddress).Return(common.NewInternalError(fmt.Errorf("for tests")))
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)
402 err := shutdownManager.Shutdown(e2tInstance1)
404 assert.IsType(t, &e2managererrors.RnibDbError{}, err)
405 readerMock.AssertExpectations(t)
406 writerMock.AssertExpectations(t)
407 httpClientMock.AssertExpectations(t)