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.
17 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 // platform project (RICP).
28 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
29 "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
30 "github.com/pkg/errors"
31 "github.com/stretchr/testify/assert"
32 "github.com/stretchr/testify/mock"
36 const E2TAddress = "10.10.2.15:9800"
37 const E2TAddress2 = "10.10.2.16:9800"
39 func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *E2TInstancesManager) {
40 logger, err := logger.InitLogger(logger.DebugLevel)
42 t.Errorf("#... - failed to initialize logger, error: %s", err)
44 config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
46 readerMock := &mocks.RnibReaderMock{}
47 writerMock := &mocks.RnibWriterMock{}
48 rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
49 e2tInstancesManager := NewE2TInstancesManager(rnibDataService, logger)
50 return readerMock, writerMock, e2tInstancesManager
53 func TestAddNewE2TInstanceSaveE2TInstanceFailure(t *testing.T) {
54 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
55 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
56 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
58 rnibReaderMock.AssertNotCalled(t, "GetE2TAddresses")
61 func TestAddNewE2TInstanceGetE2TAddressesInternalFailure(t *testing.T) {
62 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
63 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
64 e2tAddresses := []string{}
65 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewInternalError(errors.New("Error")))
66 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
68 rnibReaderMock.AssertNotCalled(t, "SaveE2TAddresses")
71 func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
72 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
73 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
74 E2TAddresses := []string{}
75 rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
76 E2TAddresses = append(E2TAddresses, E2TAddress)
77 rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(common.NewResourceNotFoundError(""))
78 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
82 func TestAddNewE2TInstanceNoE2TAddressesSuccess(t *testing.T) {
83 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
84 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
85 e2tAddresses := []string{}
86 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
87 e2tAddresses = append(e2tAddresses, E2TAddress)
88 rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
89 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
91 rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
94 func TestAddNewE2TInstanceEmptyE2TAddressesSuccess(t *testing.T) {
95 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
96 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
97 e2tAddresses := []string{}
98 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
99 e2tAddresses = append(e2tAddresses, E2TAddress)
100 rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
101 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
103 rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
106 func TestAddNewE2TInstanceExistingE2TAddressesSuccess(t *testing.T) {
107 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
108 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
109 E2TAddresses := []string{"10.0.1.15:3030"}
110 rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
111 E2TAddresses = append(E2TAddresses, E2TAddress)
112 rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(nil)
113 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
117 func TestGetE2TInstanceFailure(t *testing.T) {
118 rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
119 var e2tInstance *entities.E2TInstance
120 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("for test")))
121 res, err := e2tInstancesManager.GetE2TInstance(E2TAddress)
122 assert.NotNil(t, err)
126 func TestGetE2TInstanceSuccess(t *testing.T) {
127 rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
128 address := "10.10.2.15:9800"
129 e2tInstance := entities.NewE2TInstance(address)
130 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
131 res, err := e2tInstancesManager.GetE2TInstance(address)
133 assert.Equal(t, e2tInstance, res)
136 func TestAddRanToInstanceGetInstanceFailure(t *testing.T) {
137 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
139 var e2tInstance1 *entities.E2TInstance
140 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
142 err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
143 assert.NotNil(t, err)
144 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
147 func TestAddRanToInstanceSaveInstanceFailure(t *testing.T) {
148 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
149 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
150 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
151 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
153 err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
154 assert.NotNil(t, err)
155 rnibReaderMock.AssertExpectations(t)
156 rnibWriterMock.AssertExpectations(t)
159 func TestAddRanToInstanceSuccess(t *testing.T) {
160 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
161 e2tInstance := entities.NewE2TInstance(E2TAddress)
162 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
164 updateE2TInstance := *e2tInstance
165 updateE2TInstance.AssociatedRanList = append(updateE2TInstance.AssociatedRanList, "test1")
167 rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
169 err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
171 rnibReaderMock.AssertExpectations(t)
172 rnibWriterMock.AssertExpectations(t)
175 func TestRemoveRanFromInstanceGetInstanceFailure(t *testing.T) {
176 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
178 var e2tInstance1 *entities.E2TInstance
179 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
180 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
181 assert.NotNil(t, err)
182 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
185 func TestRemoveRanFromInstanceSaveInstanceFailure(t *testing.T) {
186 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
188 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
189 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
190 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
192 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
193 assert.NotNil(t, err)
194 rnibReaderMock.AssertExpectations(t)
195 rnibWriterMock.AssertExpectations(t)
198 func TestRemoveRanFromInstanceSuccess(t *testing.T) {
199 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
201 e2tInstance := entities.NewE2TInstance(E2TAddress)
202 e2tInstance.AssociatedRanList = []string{"test0", "test1"}
203 updatedE2TInstance := *e2tInstance
204 updatedE2TInstance.AssociatedRanList = []string{"test0"}
205 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
206 rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
208 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
210 rnibReaderMock.AssertExpectations(t)
211 rnibWriterMock.AssertExpectations(t)
214 func TestSelectE2TInstancesGetE2TAddressesFailure(t *testing.T) {
215 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
217 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(fmt.Errorf("for test")))
218 address, err := e2tInstancesManager.SelectE2TInstance()
219 assert.NotNil(t, err)
220 assert.Empty(t, address)
221 rnibReaderMock.AssertExpectations(t)
222 rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
225 func TestSelectE2TInstancesEmptyE2TAddressList(t *testing.T) {
226 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
228 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
229 address, err := e2tInstancesManager.SelectE2TInstance()
230 assert.NotNil(t, err)
231 assert.Empty(t, address)
232 rnibReaderMock.AssertExpectations(t)
233 rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
236 func TestSelectE2TInstancesGetE2TInstancesFailure(t *testing.T) {
237 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
239 addresses := []string{E2TAddress}
240 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
241 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, common.NewInternalError(fmt.Errorf("for test")))
242 address, err := e2tInstancesManager.SelectE2TInstance()
243 assert.NotNil(t, err)
244 assert.Empty(t, address)
245 rnibReaderMock.AssertExpectations(t)
246 rnibWriterMock.AssertExpectations(t)
249 func TestSelectE2TInstancesEmptyE2TInstancesList(t *testing.T) {
250 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
252 addresses := []string{E2TAddress}
253 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
254 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, nil)
255 address, err := e2tInstancesManager.SelectE2TInstance()
256 assert.NotNil(t, err)
257 assert.Empty(t, address)
258 rnibReaderMock.AssertExpectations(t)
259 rnibWriterMock.AssertExpectations(t)
262 func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
263 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
264 addresses := []string{E2TAddress, E2TAddress2}
265 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
266 e2tInstance1.State = entities.ToBeDeleted
267 e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
268 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
269 e2tInstance2.State = entities.ToBeDeleted
270 e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
272 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
273 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
274 address, err := e2tInstancesManager.SelectE2TInstance()
275 assert.NotNil(t, err)
276 assert.Equal(t, "", address)
277 rnibReaderMock.AssertExpectations(t)
278 rnibWriterMock.AssertExpectations(t)
281 func TestSelectE2TInstancesSuccess(t *testing.T) {
282 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
283 addresses := []string{E2TAddress, E2TAddress2}
284 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
285 e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
286 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
287 e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
289 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
290 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
291 address, err := e2tInstancesManager.SelectE2TInstance()
293 assert.Equal(t, E2TAddress, address)
294 rnibReaderMock.AssertExpectations(t)
295 rnibWriterMock.AssertExpectations(t)
298 func TestActivateE2TInstanceSuccess(t *testing.T) {
299 _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
301 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
302 e2tInstance1.State = entities.RoutingManagerFailure
303 e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
305 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
307 err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
309 assert.Equal(t, entities.Active, e2tInstance1.State)
310 rnibWriterMock.AssertExpectations(t)
313 func TestActivateE2TInstance_RnibError(t *testing.T) {
314 _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
316 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
317 e2tInstance1.State = entities.RoutingManagerFailure
318 e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
320 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
322 err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
323 assert.NotNil(t, err)
326 func TestActivateE2TInstance_NoInstance(t *testing.T) {
327 _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
329 err := e2tInstancesManager.ActivateE2TInstance(nil)
331 assert.NotNil(t, err)
332 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
335 func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
336 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
338 address := "10.10.2.15:9800"
339 e2tInstance := entities.NewE2TInstance(address)
340 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(errors.New("Error")))
341 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
343 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
344 assert.NotNil(t, err)
345 rnibReaderMock.AssertNotCalled(t, "SaveE2TInstance")
348 func TestAResetKeepAliveTimestampSaveInternalFailure(t *testing.T) {
349 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
351 address := "10.10.2.15:9800"
352 e2tInstance := entities.NewE2TInstance(address)
353 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
354 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
356 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
357 assert.NotNil(t, err)
360 func TestResetKeepAliveTimestampSuccess(t *testing.T) {
361 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
363 address := "10.10.2.15:9800"
364 e2tInstance := entities.NewE2TInstance(address)
365 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
366 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
368 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
370 rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
371 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
374 func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
375 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
377 address := "10.10.2.15:9800"
378 e2tInstance := entities.NewE2TInstance(address)
379 e2tInstance.State = entities.ToBeDeleted
380 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
382 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
384 rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
385 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
388 func TestResetKeepAliveTimestampRoutingManagerFailure(t *testing.T) {
389 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
391 address := "10.10.2.15:9800"
392 e2tInstance := entities.NewE2TInstance(address)
393 e2tInstance.State = entities.RoutingManagerFailure
394 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
396 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
398 rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
399 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
402 func TestRemoveE2TInstance(t *testing.T) {
403 _, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
404 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
405 err := e2tInstancesManager.RemoveE2TInstance(e2tInstance1)
409 func TestResetKeepAliveTimestampsForAllE2TInstancesGetE2TInstancesFailure(t *testing.T) {
410 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
411 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("Error")))
412 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
413 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
416 func TestResetKeepAliveTimestampsForAllE2TInstancesNoInstances(t *testing.T) {
417 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
418 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
419 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
420 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
423 func TestResetKeepAliveTimestampsForAllE2TInstancesNoActiveInstances(t *testing.T) {
424 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
425 e2tAddresses := []string{E2TAddress, E2TAddress2}
426 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
427 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
428 e2tInstance1.State = entities.ToBeDeleted
429 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
430 e2tInstance2.State = entities.RoutingManagerFailure
431 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
432 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
433 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
436 func TestResetKeepAliveTimestampsForAllE2TInstancesOneActiveInstance(t *testing.T) {
437 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
438 e2tAddresses := []string{E2TAddress, E2TAddress2}
439 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
440 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
441 e2tInstance1.State = entities.Active
442 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
443 e2tInstance2.State = entities.ToBeDeleted
444 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
445 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
446 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
447 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
450 func TestResetKeepAliveTimestampsForAllE2TInstancesSaveE2TInstanceFailure(t *testing.T) {
451 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
452 e2tAddresses := []string{E2TAddress, E2TAddress2}
453 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
454 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
455 e2tInstance1.State = entities.Active
456 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
457 e2tInstance2.State = entities.ToBeDeleted
458 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
459 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
460 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
461 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)