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).
24 "e2mgr/e2managererrors"
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 "github.com/pkg/errors"
32 "github.com/stretchr/testify/assert"
33 "github.com/stretchr/testify/mock"
37 const E2TAddress = "10.10.2.15:9800"
38 const E2TAddress2 = "10.10.2.16:9800"
40 func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *E2TInstancesManager) {
41 logger, err := logger.InitLogger(logger.DebugLevel)
43 t.Errorf("#... - failed to initialize logger, error: %s", err)
45 config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
47 readerMock := &mocks.RnibReaderMock{}
48 writerMock := &mocks.RnibWriterMock{}
49 rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
50 e2tInstancesManager := NewE2TInstancesManager(rnibDataService, logger)
51 return readerMock, writerMock, e2tInstancesManager
54 func TestAddNewE2TInstanceSaveE2TInstanceFailure(t *testing.T) {
55 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
56 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
57 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
59 rnibReaderMock.AssertNotCalled(t, "GetE2TAddresses")
62 func TestAddNewE2TInstanceGetE2TAddressesInternalFailure(t *testing.T) {
63 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
64 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
65 e2tAddresses := []string{}
66 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewInternalError(errors.New("Error")))
67 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
69 rnibReaderMock.AssertNotCalled(t, "SaveE2TAddresses")
72 func TestAddNewE2TInstanceSaveE2TAddressesFailure(t *testing.T) {
73 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
74 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
75 E2TAddresses := []string{}
76 rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
77 E2TAddresses = append(E2TAddresses, E2TAddress)
78 rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(common.NewResourceNotFoundError(""))
79 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
83 func TestAddNewE2TInstanceNoE2TAddressesSuccess(t *testing.T) {
84 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
85 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
86 e2tAddresses := []string{}
87 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, common.NewResourceNotFoundError(""))
88 e2tAddresses = append(e2tAddresses, E2TAddress)
89 rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
90 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
92 rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
95 func TestAddNewE2TInstanceEmptyE2TAddressesSuccess(t *testing.T) {
96 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
97 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
98 e2tAddresses := []string{}
99 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
100 e2tAddresses = append(e2tAddresses, E2TAddress)
101 rnibWriterMock.On("SaveE2TAddresses", e2tAddresses).Return(nil)
102 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
104 rnibWriterMock.AssertCalled(t, "SaveE2TAddresses", e2tAddresses)
107 func TestAddNewE2TInstanceExistingE2TAddressesSuccess(t *testing.T) {
108 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
109 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
110 E2TAddresses := []string{"10.0.1.15:3030"}
111 rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
112 E2TAddresses = append(E2TAddresses, E2TAddress)
113 rnibWriterMock.On("SaveE2TAddresses", E2TAddresses).Return(nil)
114 err := e2tInstancesManager.AddE2TInstance(E2TAddress)
118 func TestGetE2TInstanceFailure(t *testing.T) {
119 rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
120 var e2tInstance *entities.E2TInstance
121 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("for test")))
122 res, err := e2tInstancesManager.GetE2TInstance(E2TAddress)
123 assert.NotNil(t, err)
127 func TestGetE2TInstanceSuccess(t *testing.T) {
128 rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
129 address := "10.10.2.15:9800"
130 e2tInstance := entities.NewE2TInstance(address)
131 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
132 res, err := e2tInstancesManager.GetE2TInstance(address)
134 assert.Equal(t, e2tInstance, res)
137 func TestAddRanToInstanceGetInstanceFailure(t *testing.T) {
138 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
140 var e2tInstance1 *entities.E2TInstance
141 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
143 err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
144 assert.NotNil(t, err)
145 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
148 func TestAddRanToInstanceSaveInstanceFailure(t *testing.T) {
149 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
150 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
151 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
152 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
154 err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
155 assert.NotNil(t, err)
156 rnibReaderMock.AssertExpectations(t)
157 rnibWriterMock.AssertExpectations(t)
160 func TestAddRanToInstanceSuccess(t *testing.T) {
161 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
162 e2tInstance := entities.NewE2TInstance(E2TAddress)
163 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
165 updateE2TInstance := *e2tInstance
166 updateE2TInstance.AssociatedRanList = append(updateE2TInstance.AssociatedRanList, "test1")
168 rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
170 err := e2tInstancesManager.AddRansToInstance(E2TAddress, []string{"test1"})
172 rnibReaderMock.AssertExpectations(t)
173 rnibWriterMock.AssertExpectations(t)
176 func TestRemoveRanFromInstanceGetInstanceFailure(t *testing.T) {
177 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
179 var e2tInstance1 *entities.E2TInstance
180 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
181 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
182 assert.NotNil(t, err)
183 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
186 func TestRemoveRanFromInstanceSaveInstanceFailure(t *testing.T) {
187 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
189 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
190 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
191 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
193 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
194 assert.NotNil(t, err)
195 rnibReaderMock.AssertExpectations(t)
196 rnibWriterMock.AssertExpectations(t)
199 func TestRemoveRanFromInstanceSuccess(t *testing.T) {
200 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
202 e2tInstance := entities.NewE2TInstance(E2TAddress)
203 e2tInstance.AssociatedRanList = []string{"test0", "test1"}
204 updatedE2TInstance := *e2tInstance
205 updatedE2TInstance.AssociatedRanList = []string{"test0"}
206 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
207 rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
209 err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
211 rnibReaderMock.AssertExpectations(t)
212 rnibWriterMock.AssertExpectations(t)
215 func TestSelectE2TInstancesGetE2TAddressesFailure(t *testing.T) {
216 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
218 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(fmt.Errorf("for test")))
219 address, err := e2tInstancesManager.SelectE2TInstance()
220 assert.NotNil(t, err)
221 assert.Empty(t, address)
222 rnibReaderMock.AssertExpectations(t)
223 rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
226 func TestSelectE2TInstancesEmptyE2TAddressList(t *testing.T) {
227 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
229 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
230 address, err := e2tInstancesManager.SelectE2TInstance()
231 assert.NotNil(t, err)
232 assert.Empty(t, address)
233 rnibReaderMock.AssertExpectations(t)
234 rnibWriterMock.AssertNotCalled(t, "GetE2TInstances")
237 func TestSelectE2TInstancesGetE2TInstancesFailure(t *testing.T) {
238 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
240 addresses := []string{E2TAddress}
241 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
242 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, common.NewInternalError(fmt.Errorf("for test")))
243 address, err := e2tInstancesManager.SelectE2TInstance()
244 assert.NotNil(t, err)
245 assert.Empty(t, address)
246 rnibReaderMock.AssertExpectations(t)
247 rnibWriterMock.AssertExpectations(t)
250 func TestSelectE2TInstancesEmptyE2TInstancesList(t *testing.T) {
251 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
253 addresses := []string{E2TAddress}
254 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
255 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{}, nil)
256 address, err := e2tInstancesManager.SelectE2TInstance()
257 assert.NotNil(t, err)
258 assert.Empty(t, address)
259 rnibReaderMock.AssertExpectations(t)
260 rnibWriterMock.AssertExpectations(t)
263 func TestSelectE2TInstancesNoActiveE2TInstance(t *testing.T) {
264 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
265 addresses := []string{E2TAddress, E2TAddress2}
266 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
267 e2tInstance1.State = entities.ToBeDeleted
268 e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
269 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
270 e2tInstance2.State = entities.ToBeDeleted
271 e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
273 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
274 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
275 address, err := e2tInstancesManager.SelectE2TInstance()
276 assert.NotNil(t, err)
277 assert.Equal(t, "", address)
278 rnibReaderMock.AssertExpectations(t)
279 rnibWriterMock.AssertExpectations(t)
282 func TestSelectE2TInstancesSuccess(t *testing.T) {
283 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
284 addresses := []string{E2TAddress, E2TAddress2}
285 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
286 e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
287 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
288 e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
290 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
291 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
292 address, err := e2tInstancesManager.SelectE2TInstance()
294 assert.Equal(t, E2TAddress, address)
295 rnibReaderMock.AssertExpectations(t)
296 rnibWriterMock.AssertExpectations(t)
299 func TestActivateE2TInstanceSuccess(t *testing.T) {
300 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
302 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
303 e2tInstance1.State = entities.ToBeDeleted
304 e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
305 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
306 rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.State == entities.Active })).Return(nil)
308 err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
310 assert.Equal(t, entities.Active, e2tInstance1.State)
311 rnibWriterMock.AssertExpectations(t)
314 func TestActivateE2TInstance_RnibError(t *testing.T) {
315 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
317 var e2tInstance1 *entities.E2TInstance
318 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(errors.New("for test")))
320 err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
321 assert.NotNil(t, err)
322 rnibWriterMock.AssertExpectations(t)
325 func TestActivateE2TInstance_NoInstance(t *testing.T) {
326 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
328 var e2tInstance1 *entities.E2TInstance
329 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, e2managererrors.NewResourceNotFoundError())
331 err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
333 assert.NotNil(t, err)
334 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
337 func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
338 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
340 address := "10.10.2.15:9800"
341 e2tInstance := entities.NewE2TInstance(address)
342 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(errors.New("Error")))
343 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
345 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
346 assert.NotNil(t, err)
347 rnibReaderMock.AssertNotCalled(t, "SaveE2TInstance")
350 func TestAResetKeepAliveTimestampSaveInternalFailure(t *testing.T) {
351 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
353 address := "10.10.2.15:9800"
354 e2tInstance := entities.NewE2TInstance(address)
355 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
356 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
358 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
359 assert.NotNil(t, err)
362 func TestResetKeepAliveTimestampSuccess(t *testing.T) {
363 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
365 address := "10.10.2.15:9800"
366 e2tInstance := entities.NewE2TInstance(address)
367 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
368 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
370 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
372 rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
373 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
376 func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
377 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
379 address := "10.10.2.15:9800"
380 e2tInstance := entities.NewE2TInstance(address)
381 e2tInstance.State = entities.ToBeDeleted
382 rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
384 err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
386 rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
387 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
390 func TestResetKeepAliveTimestampsForAllE2TInstancesGetE2TInstancesFailure(t *testing.T) {
391 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
392 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("Error")))
393 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
394 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
397 func TestResetKeepAliveTimestampsForAllE2TInstancesNoInstances(t *testing.T) {
398 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
399 rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
400 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
401 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
404 func TestResetKeepAliveTimestampsForAllE2TInstancesNoActiveInstances(t *testing.T) {
405 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
406 e2tAddresses := []string{E2TAddress, E2TAddress2}
407 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
408 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
409 e2tInstance1.State = entities.ToBeDeleted
410 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
411 e2tInstance2.State = entities.ToBeDeleted
412 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
413 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
414 rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
417 func TestResetKeepAliveTimestampsForAllE2TInstancesOneActiveInstance(t *testing.T) {
418 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
419 e2tAddresses := []string{E2TAddress, E2TAddress2}
420 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
421 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
422 e2tInstance1.State = entities.Active
423 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
424 e2tInstance2.State = entities.ToBeDeleted
425 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
426 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
427 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
428 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
431 func TestResetKeepAliveTimestampsForAllE2TInstancesSaveE2TInstanceFailure(t *testing.T) {
432 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
433 e2tAddresses := []string{E2TAddress, E2TAddress2}
434 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
435 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
436 e2tInstance1.State = entities.Active
437 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
438 e2tInstance2.State = entities.ToBeDeleted
439 rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
440 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
441 e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
442 rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance",1)
445 func TestRemoveE2TInstanceSuccess(t *testing.T) {
446 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
447 rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
448 e2tAddresses := []string{E2TAddress, E2TAddress2}
449 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
450 e2tAddressesNew := []string{E2TAddress2}
451 rnibWriterMock.On("SaveE2TAddresses", e2tAddressesNew).Return(nil)
453 err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
455 rnibReaderMock.AssertExpectations(t)
456 rnibWriterMock.AssertExpectations(t)
459 func TestRemoveE2TInstanceRnibErrorInRemoveInstance(t *testing.T) {
460 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
461 rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(e2managererrors.NewRnibDbError())
463 err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
464 assert.NotNil(t, err)
465 assert.IsType(t, e2managererrors.NewRnibDbError(), err)
466 rnibReaderMock.AssertExpectations(t)
467 rnibWriterMock.AssertExpectations(t)
470 func TestRemoveE2TInstanceRnibErrorInGetAddresses(t *testing.T) {
471 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
472 rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
473 var e2tAddresses []string
474 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, e2managererrors.NewRnibDbError())
476 err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
477 assert.NotNil(t, err)
478 assert.IsType(t, e2managererrors.NewRnibDbError(), err)
479 rnibReaderMock.AssertExpectations(t)
480 rnibWriterMock.AssertExpectations(t)
483 func TestRemoveE2TInstanceRnibErrorInSaveAddresses(t *testing.T) {
484 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
485 rnibWriterMock.On("RemoveE2TInstance", E2TAddress).Return(nil)
486 e2tAddresses := []string{E2TAddress, E2TAddress2}
487 rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
488 e2tAddressesNew := []string{E2TAddress2}
489 rnibWriterMock.On("SaveE2TAddresses", e2tAddressesNew).Return(e2managererrors.NewRnibDbError())
491 err := e2tInstancesManager.RemoveE2TInstance(E2TAddress)
492 assert.NotNil(t, err)
493 assert.IsType(t, e2managererrors.NewRnibDbError(), err)
494 rnibReaderMock.AssertExpectations(t)
495 rnibWriterMock.AssertExpectations(t)
498 func TestSetE2tInstanceStateCurrentStateHasChanged(t *testing.T) {
499 rnibReaderMock, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
501 e2tInstance := entities.NewE2TInstance(E2TAddress)
502 e2tInstance.State = entities.Active
504 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
506 err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
507 assert.NotNil(t, err)
508 assert.IsType(t, e2managererrors.NewInternalError(), err)
509 rnibReaderMock.AssertExpectations(t)
512 func TestSetE2tInstanceStateErrorInSaveE2TInstance(t *testing.T) {
513 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
515 e2tInstance := entities.NewE2TInstance(E2TAddress)
516 e2tInstance.State = entities.ToBeDeleted
517 rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
518 rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for testing")))
520 err := e2tInstancesManager.SetE2tInstanceState(E2TAddress, entities.ToBeDeleted, entities.Active)
521 assert.NotNil(t, err)
522 assert.IsType(t, &common.InternalError{}, err)
523 rnibReaderMock.AssertExpectations(t)
526 func TestClearRansOfAllE2TInstancesEmptyList(t *testing.T) {
527 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
528 E2TAddresses := []string{}
529 rnibReaderMock.On("GetE2TAddresses").Return(E2TAddresses, nil)
530 err := e2tInstancesManager.ClearRansOfAllE2TInstances()
532 rnibReaderMock.AssertExpectations(t)
533 rnibWriterMock.AssertExpectations(t)
536 func TestClearRansOfAllE2TInstancesErrorInSaveE2TInstance(t *testing.T) {
537 rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
538 addresses := []string{E2TAddress, E2TAddress2}
539 e2tInstance1 := entities.NewE2TInstance(E2TAddress)
540 e2tInstance1.AssociatedRanList = []string{"test1", "test2", "test3"}
541 e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
542 e2tInstance2.AssociatedRanList = []string{"test4", "test5", "test6", "test7"}
544 rnibReaderMock.On("GetE2TAddresses").Return(addresses, nil)
545 rnibReaderMock.On("GetE2TInstances", addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
546 rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress})).Return(common.NewInternalError(fmt.Errorf("for testing")))
547 rnibWriterMock.On("SaveE2TInstance", mock.MatchedBy(func(e2tInstance *entities.E2TInstance) bool { return e2tInstance.Address == E2TAddress2})).Return(nil)
548 err := e2tInstancesManager.ClearRansOfAllE2TInstances()
550 rnibReaderMock.AssertExpectations(t)
551 rnibWriterMock.AssertExpectations(t)