f57522c7841924a480c538a8c5aaf0402709c10c
[ric-plt/e2mgr.git] / E2Manager / controllers / nodeb_controller_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 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 //  platform project (RICP).
19
20 package controllers
21
22 import (
23         "bytes"
24         "e2mgr/clients"
25         "e2mgr/configuration"
26         "e2mgr/e2managererrors"
27         "e2mgr/logger"
28         "e2mgr/managers"
29         "e2mgr/mocks"
30         "e2mgr/models"
31         "e2mgr/providers/httpmsghandlerprovider"
32         "e2mgr/rmrCgo"
33         "e2mgr/services"
34         "e2mgr/services/rmrsender"
35         "e2mgr/tests"
36         "encoding/json"
37         "fmt"
38         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
40         "github.com/golang/protobuf/jsonpb"
41         "github.com/gorilla/mux"
42         "github.com/pkg/errors"
43         "github.com/stretchr/testify/assert"
44         "github.com/stretchr/testify/mock"
45         "io"
46         "io/ioutil"
47         "net/http"
48         "net/http/httptest"
49         "strings"
50         "testing"
51         "unsafe"
52 )
53
54 const (
55         RanName                      = "test"
56         AssociatedE2TInstanceAddress = "10.0.2.15:38000"
57         CorruptedJson                = "{\"errorCode\":401,\"errorMessage\":\"corrupted json\"}"
58         ValidationFailureJson        = "{\"errorCode\":402,\"errorMessage\":\"Validation error\"}"
59         ResourceNotFoundJson         = "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}"
60         NodebExistsJson              = "{\"errorCode\":406,\"errorMessage\":\"Nodeb already exists\"}"
61         RnibErrorJson                = "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}"
62         InternalErrorJson            = "{\"errorCode\":501,\"errorMessage\":\"Internal Server Error. Please try again later\"}"
63         AddEnbUrl                    = "/nodeb/enb"
64 )
65
66 var (
67         ServedNrCellInformationRequiredFields = []string{"cellId", "choiceNrMode", "nrMode", "servedPlmns"}
68         NrNeighbourInformationRequiredFields  = []string{"nrCgi", "choiceNrMode", "nrMode"}
69         AddEnbRequestRequiredFields           = []string{"ranName", "enb", "globalNbId"}
70         UpdateEnbRequestRequiredFields        = []string{"enb"}
71         GlobalIdRequiredFields                = []string{"plmnId", "nbId"}
72         EnbRequiredFields                     = []string{"enbType", "servedCells"}
73         ServedCellRequiredFields              = []string{"broadcastPlmns", "cellId", "choiceEutraMode", "eutraMode", "tac"}
74 )
75
76 type controllerGetNodebTestContext struct {
77         ranName              string
78         nodebInfo            *entities.NodebInfo
79         rnibError            error
80         expectedStatusCode   int
81         expectedJsonResponse string
82 }
83
84 type controllerGetNodebIdListTestContext struct {
85         nodebIdList          []*entities.NbIdentity
86         rnibError            error
87         expectedStatusCode   int
88         expectedJsonResponse string
89 }
90
91 type getNodebInfoResult struct {
92         nodebInfo *entities.NodebInfo
93         rnibError error
94 }
95
96 type updateGnbCellsParams struct {
97         err error
98 }
99
100 type updateEnbCellsParams struct {
101         err error
102 }
103
104 type addEnbParams struct {
105         err error
106 }
107
108 type addNbIdentityParams struct {
109         err error
110 }
111
112 type removeServedCellsParams struct {
113         servedCellInfo []*entities.ServedCellInfo
114         err            error
115 }
116
117 type removeServedNrCellsParams struct {
118         servedNrCells []*entities.ServedNRCell
119         err           error
120 }
121
122 type controllerUpdateEnbTestContext struct {
123         getNodebInfoResult      *getNodebInfoResult
124         removeServedCellsParams *removeServedCellsParams
125         updateEnbCellsParams    *updateEnbCellsParams
126         requestBody             map[string]interface{}
127         expectedStatusCode      int
128         expectedJsonResponse    string
129 }
130
131 type controllerUpdateGnbTestContext struct {
132         getNodebInfoResult        *getNodebInfoResult
133         removeServedNrCellsParams *removeServedNrCellsParams
134         updateGnbCellsParams      *updateGnbCellsParams
135         requestBody               map[string]interface{}
136         expectedStatusCode        int
137         expectedJsonResponse      string
138 }
139
140 type controllerAddEnbTestContext struct {
141         getNodebInfoResult   *getNodebInfoResult
142         addEnbParams         *addEnbParams
143         addNbIdentityParams  *addNbIdentityParams
144         requestBody          map[string]interface{}
145         expectedStatusCode   int
146         expectedJsonResponse string
147 }
148
149 type controllerDeleteEnbTestContext struct {
150         getNodebInfoResult   *getNodebInfoResult
151         expectedStatusCode   int
152         expectedJsonResponse string
153 }
154
155 func generateServedNrCells(cellIds ...string) []*entities.ServedNRCell {
156
157         servedNrCells := []*entities.ServedNRCell{}
158
159         for _, v := range cellIds {
160                 servedNrCells = append(servedNrCells, &entities.ServedNRCell{ServedNrCellInformation: &entities.ServedNRCellInformation{
161                         CellId: v,
162                         ChoiceNrMode: &entities.ServedNRCellInformation_ChoiceNRMode{
163                                 Fdd: &entities.ServedNRCellInformation_ChoiceNRMode_FddInfo{
164
165                                 },
166                         },
167                         NrMode:      entities.Nr_FDD,
168                         NrPci:       5,
169                         ServedPlmns: []string{"whatever"},
170                 }})
171         }
172
173         return servedNrCells
174 }
175
176 func generateServedCells(cellIds ...string) []*entities.ServedCellInfo {
177
178         var servedCells []*entities.ServedCellInfo
179
180         for i, v := range cellIds {
181                 servedCells = append(servedCells, &entities.ServedCellInfo{
182                         CellId: v,
183                         ChoiceEutraMode: &entities.ChoiceEUTRAMode{
184                                 Fdd: &entities.FddInfo{},
185                         },
186                         Pci:            uint32(i + 1),
187                         BroadcastPlmns: []string{"whatever"},
188                 })
189         }
190
191         return servedCells
192 }
193
194 func buildNrNeighbourInformation(propToOmit string) map[string]interface{} {
195         ret := map[string]interface{}{
196                 "nrCgi": "whatever",
197                 "choiceNrMode": map[string]interface{}{
198                         "tdd": map[string]interface{}{},
199                 },
200                 "nrMode": 1,
201                 "nrPci":  1,
202         }
203
204         if len(propToOmit) != 0 {
205                 delete(ret, propToOmit)
206         }
207
208         return ret
209 }
210
211 func buildServedNrCellInformation(propToOmit string) map[string]interface{} {
212         ret := map[string]interface{}{
213                 "cellId": "whatever",
214                 "choiceNrMode": map[string]interface{}{
215                         "fdd": map[string]interface{}{},
216                 },
217                 "nrMode": 1,
218                 "nrPci":  1,
219                 "servedPlmns": []interface{}{
220                         "whatever",
221                 },
222         }
223
224         if len(propToOmit) != 0 {
225                 delete(ret, propToOmit)
226         }
227
228         return ret
229 }
230
231 func buildServedCell(propToOmit string) map[string]interface{} {
232         ret := map[string]interface{}{
233                 "cellId": "whatever",
234                 "choiceEutraMode": map[string]interface{}{
235                         "fdd": map[string]interface{}{},
236                 },
237                 "eutraMode": 1,
238                 "pci":       1,
239                 "tac":       "whatever3",
240                 "broadcastPlmns": []interface{}{
241                         "whatever",
242                 },
243         }
244
245         if len(propToOmit) != 0 {
246                 delete(ret, propToOmit)
247         }
248
249         return ret
250 }
251
252 func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
253         ret := map[string]interface{}{
254                 "enb": buildEnb(propToOmit),
255         }
256
257         if len(propToOmit) != 0 {
258                 delete(ret, propToOmit)
259         }
260
261         return ret
262 }
263
264 func getAddEnbRequest(propToOmit string) map[string]interface{} {
265         ret := map[string]interface{}{
266                 "ranName":    RanName,
267                 "globalNbId": buildGlobalNbId(""),
268                 "enb":        buildEnb(""),
269         }
270
271         if len(propToOmit) != 0 {
272                 delete(ret, propToOmit)
273         }
274
275         return ret
276 }
277
278 func buildEnb(propToOmit string) map[string]interface{} {
279         ret := map[string]interface{}{
280                 "enbType": 1,
281                 "servedCells": []interface{}{
282                         buildServedCell(""),
283                 }}
284
285         if len(propToOmit) != 0 {
286                 delete(ret, propToOmit)
287         }
288
289         return ret
290 }
291
292 func buildGlobalNbId(propToOmit string) map[string]interface{} {
293         ret := map[string]interface{}{
294                 "plmnId": "whatever",
295                 "nbId":   "whatever2",
296         }
297
298         if len(propToOmit) != 0 {
299                 delete(ret, propToOmit)
300         }
301
302         return ret
303 }
304
305 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, managers.RanListManager) {
306         log := initLog(t)
307         config := configuration.ParseConfiguration()
308
309         rmrMessengerMock := &mocks.RmrMessengerMock{}
310         readerMock := &mocks.RnibReaderMock{}
311
312         writerMock := &mocks.RnibWriterMock{}
313
314         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
315         rmrSender := getRmrSender(rmrMessengerMock, log)
316         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
317         httpClientMock := &mocks.HttpClientMock{}
318         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
319         ranListManager := managers.NewRanListManager(log, rnibDataService)
320         ranAlarmService := &mocks.RanAlarmServiceMock{}
321         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
322         nodebValidator := managers.NewNodebValidator()
323         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
324         updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
325         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
326         controller := NewNodebController(log, handlerProvider)
327         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager, ranListManager
328 }
329
330 func setupDeleteEnbControllerTest(t *testing.T, preAddNbIdentity bool) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *entities.NbIdentity) {
331         log := initLog(t)
332         config := configuration.ParseConfiguration()
333
334         rmrMessengerMock := &mocks.RmrMessengerMock{}
335         readerMock := &mocks.RnibReaderMock{}
336
337         writerMock := &mocks.RnibWriterMock{}
338
339         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
340         rmrSender := getRmrSender(rmrMessengerMock, log)
341         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
342         httpClientMock := &mocks.HttpClientMock{}
343         rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
344         ranListManager := managers.NewRanListManager(log, rnibDataService)
345         var nbIdentity *entities.NbIdentity
346         if preAddNbIdentity {
347                 nbIdentity = &entities.NbIdentity{InventoryName: RanName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}}
348                 writerMock.On("AddNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
349                 ranListManager.AddNbIdentity(entities.Node_ENB, nbIdentity)
350         }
351         ranAlarmService := &mocks.RanAlarmServiceMock{}
352         ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
353         nodebValidator := managers.NewNodebValidator()
354         updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
355         updateGnbManager := managers.NewUpdateGnbManager(log, rnibDataService, nodebValidator)
356
357         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
358         controller := NewNodebController(log, handlerProvider)
359         return controller, readerMock, writerMock, nbIdentity
360 }
361
362 func TestShutdownHandlerRnibError(t *testing.T) {
363         controller, _, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
364         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, e2managererrors.NewRnibDbError())
365
366         writer := httptest.NewRecorder()
367
368         controller.Shutdown(writer, tests.GetHttpRequest())
369
370         var errorResponse = parseJsonRequest(t, writer.Body)
371
372         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
373         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
374 }
375
376 func TestSetGeneralConfigurationHandlerRnibError(t *testing.T) {
377         controller, readerMock, _, _, _, _ := setupControllerTest(t)
378
379         configuration := &entities.GeneralConfiguration{}
380         readerMock.On("GetGeneralConfiguration").Return(configuration, e2managererrors.NewRnibDbError())
381
382         writer := httptest.NewRecorder()
383
384         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false}"))
385
386         controller.SetGeneralConfiguration(writer, httpRequest)
387
388         var errorResponse = parseJsonRequest(t, writer.Body)
389
390         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
391         assert.Equal(t, e2managererrors.NewRnibDbError().Code, errorResponse.Code)
392 }
393
394 func TestSetGeneralConfigurationInvalidJson(t *testing.T) {
395         controller, _, _, _, _, _ := setupControllerTest(t)
396
397         writer := httptest.NewRecorder()
398
399         httpRequest, _ := http.NewRequest("PUT", "https://localhost:3800/v1/nodeb/parameters", strings.NewReader("{\"enableRic\":false, \"someValue\":false}"))
400
401         controller.SetGeneralConfiguration(writer, httpRequest)
402
403         var errorResponse = parseJsonRequest(t, writer.Body)
404
405         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
406         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
407 }
408
409 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
410         controller, readerMock, _, _, _, _ := setupControllerTest(t)
411         writer := httptest.NewRecorder()
412         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
413         req, _ := http.NewRequest(http.MethodGet, "/nodeb", nil)
414         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
415         controller.GetNodeb(writer, req)
416         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
417         bodyBytes, _ := ioutil.ReadAll(writer.Body)
418         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
419 }
420
421 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
422         controller, readerMock, _, _, _, ranListManager := setupControllerTest(t)
423         writer := httptest.NewRecorder()
424         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
425
426         err := ranListManager.InitNbIdentityMap()
427         if err != nil {
428                 t.Errorf("Error cannot init identity")
429         }
430
431         req, _ := http.NewRequest(http.MethodGet, "/nodeb/states", nil)
432         controller.GetNodebIdList(writer, req)
433         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
434         bodyBytes, _ := ioutil.ReadAll(writer.Body)
435         assert.Contains(t, context.expectedJsonResponse, string(bodyBytes))
436 }
437
438 func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
439         if context.getNodebInfoResult != nil {
440                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
441         }
442
443         if context.removeServedCellsParams != nil {
444                 writerMock.On("RemoveServedCells", RanName, context.removeServedCellsParams.servedCellInfo).Return(context.removeServedCellsParams.err)
445         }
446
447         if context.updateEnbCellsParams != nil {
448                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
449
450                 if context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
451                         updateEnbRequest.Enb.EnbType = context.getNodebInfoResult.nodebInfo.GetEnb().EnbType
452                 }
453
454                 updatedNodebInfo.Configuration = &entities.NodebInfo_Enb{Enb: updateEnbRequest.Enb}
455
456                 writerMock.On("UpdateEnb", &updatedNodebInfo, updateEnbRequest.Enb.ServedCells).Return(context.updateEnbCellsParams.err)
457         }
458 }
459
460 func activateControllerUpdateGnbMocks(context *controllerUpdateGnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
461         if context.getNodebInfoResult != nil {
462                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
463         }
464
465         if context.removeServedNrCellsParams != nil {
466                 writerMock.On("RemoveServedNrCells", RanName, context.removeServedNrCellsParams.servedNrCells).Return(context.removeServedNrCellsParams.err)
467         }
468
469         if context.updateGnbCellsParams != nil {
470                 updatedNodebInfo := *context.getNodebInfoResult.nodebInfo
471                 gnb := entities.Gnb{}
472                 _ = jsonpb.Unmarshal(getJsonRequestAsBuffer(context.requestBody), &gnb)
473                 updatedGnb := *updatedNodebInfo.GetGnb()
474                 updatedGnb.ServedNrCells = gnb.ServedNrCells
475                 writerMock.On("UpdateGnbCells", &updatedNodebInfo, gnb.ServedNrCells).Return(context.updateGnbCellsParams.err)
476         }
477 }
478
479 func assertControllerUpdateGnb(t *testing.T, context *controllerUpdateGnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
480         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
481         bodyBytes, _ := ioutil.ReadAll(writer.Body)
482         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
483         readerMock.AssertExpectations(t)
484         writerMock.AssertExpectations(t)
485 }
486
487 func assertControllerUpdateEnb(t *testing.T, context *controllerUpdateEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
488         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
489         bodyBytes, _ := ioutil.ReadAll(writer.Body)
490         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
491         readerMock.AssertExpectations(t)
492         writerMock.AssertExpectations(t)
493 }
494
495 func assertControllerAddEnb(t *testing.T, context *controllerAddEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
496         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
497         bodyBytes, _ := ioutil.ReadAll(writer.Body)
498         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
499         readerMock.AssertExpectations(t)
500         writerMock.AssertExpectations(t)
501 }
502
503 func assertControllerDeleteEnb(t *testing.T, context *controllerDeleteEnbTestContext, writer *httptest.ResponseRecorder, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock) {
504         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
505         bodyBytes, _ := ioutil.ReadAll(writer.Body)
506         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
507         readerMock.AssertExpectations(t)
508         writerMock.AssertExpectations(t)
509 }
510
511 func buildUpdateEnbRequest(context *controllerUpdateEnbTestContext) *http.Request {
512         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
513         requestBody := getJsonRequestAsBuffer(context.requestBody)
514         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, requestBody)
515         req.Header.Set("Content-Type", "application/json")
516         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
517         return req
518 }
519
520 func buildUpdateGnbRequest(context *controllerUpdateGnbTestContext) *http.Request {
521         updateGnbUrl := fmt.Sprintf("/nodeb/gnb/%s", RanName)
522         requestBody := getJsonRequestAsBuffer(context.requestBody)
523         req, _ := http.NewRequest(http.MethodPut, updateGnbUrl, requestBody)
524         req.Header.Set("Content-Type", "application/json")
525         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
526         return req
527 }
528
529 func buildAddEnbRequest(context *controllerAddEnbTestContext) *http.Request {
530         requestBody := getJsonRequestAsBuffer(context.requestBody)
531         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, requestBody)
532         req.Header.Set("Content-Type", "application/json")
533         return req
534 }
535
536 func controllerUpdateEnbTestExecuter(t *testing.T, context *controllerUpdateEnbTestContext) {
537         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
538         writer := httptest.NewRecorder()
539
540         r := buildUpdateEnbRequest(context)
541         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
542
543         updateEnbRequest := models.UpdateEnbRequest{}
544         _ = json.Unmarshal(body, &updateEnbRequest)
545
546         activateControllerUpdateEnbMocks(context, readerMock, writerMock, &updateEnbRequest)
547         r = buildUpdateEnbRequest(context)
548         defer r.Body.Close()
549
550         controller.UpdateEnb(writer, r)
551
552         assertControllerUpdateEnb(t, context, writer, readerMock, writerMock)
553 }
554
555 func controllerUpdateGnbTestExecuter(t *testing.T, context *controllerUpdateGnbTestContext) {
556         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
557         writer := httptest.NewRecorder()
558
559         activateControllerUpdateGnbMocks(context, readerMock, writerMock)
560         req := buildUpdateGnbRequest(context)
561         controller.UpdateGnb(writer, req)
562         assertControllerUpdateGnb(t, context, writer, readerMock, writerMock)
563 }
564
565 func activateControllerAddEnbMocks(context *controllerAddEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, addEnbRequest *models.AddEnbRequest) {
566         if context.getNodebInfoResult != nil {
567                 readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
568         }
569
570         if context.addEnbParams != nil {
571                 nodebInfo := entities.NodebInfo{
572                         RanName:          addEnbRequest.RanName,
573                         Ip:               addEnbRequest.Ip,
574                         Port:             addEnbRequest.Port,
575                         NodeType:         entities.Node_ENB,
576                         GlobalNbId:       addEnbRequest.GlobalNbId,
577                         Configuration:    &entities.NodebInfo_Enb{Enb: addEnbRequest.Enb},
578                         ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
579                 }
580
581                 writerMock.On("AddEnb", &nodebInfo).Return(context.addEnbParams.err)
582         }
583
584         if context.addNbIdentityParams != nil {
585                 nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
586                 writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
587         }
588 }
589
590 func controllerAddEnbTestExecuter(t *testing.T, context *controllerAddEnbTestContext) {
591         controller, readerMock, writerMock, _, _, _ := setupControllerTest(t)
592         writer := httptest.NewRecorder()
593         r := buildAddEnbRequest(context)
594         body, _ := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
595
596         addEnbRequest := models.AddEnbRequest{}
597
598         _ = json.Unmarshal(body, &addEnbRequest)
599         activateControllerAddEnbMocks(context, readerMock, writerMock, &addEnbRequest)
600         r = buildAddEnbRequest(context)
601         defer r.Body.Close()
602         controller.AddEnb(writer, r)
603         assertControllerAddEnb(t, context, writer, readerMock, writerMock)
604 }
605
606 func controllerDeleteEnbTestExecuter(t *testing.T, context *controllerDeleteEnbTestContext, preAddNbIdentity bool) {
607         controller, readerMock, writerMock, nbIdentity := setupDeleteEnbControllerTest(t, preAddNbIdentity)
608         readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
609         if context.getNodebInfoResult.rnibError == nil && context.getNodebInfoResult.nodebInfo.GetNodeType() == entities.Node_ENB &&
610                 !context.getNodebInfoResult.nodebInfo.SetupFromNetwork {
611                 writerMock.On("RemoveEnb", context.getNodebInfoResult.nodebInfo).Return(nil)
612                 if preAddNbIdentity {
613                         writerMock.On("RemoveNbIdentity", entities.Node_ENB, nbIdentity).Return(nil)
614                 }
615         }
616         writer := httptest.NewRecorder()
617         r, _ := http.NewRequest(http.MethodDelete, AddEnbUrl+"/"+RanName, nil)
618         r.Header.Set("Content-Type", "application/json")
619         r = mux.SetURLVars(r, map[string]string{"ranName": RanName})
620         controller.DeleteEnb(writer, r)
621         assertControllerDeleteEnb(t, context, writer, readerMock, writerMock)
622 }
623
624 /*
625 UpdateGnb UTs
626 */
627
628 // BEGIN - UpdateGnb Validation Failure UTs
629
630 func TestControllerUpdateGnbEmptyServedNrCells(t *testing.T) {
631         context := controllerUpdateGnbTestContext{
632                 getNodebInfoResult: nil,
633                 requestBody: map[string]interface{}{
634                         "servedNrCells": []interface{}{
635                         },
636                 },
637                 expectedStatusCode:   http.StatusBadRequest,
638                 expectedJsonResponse: ValidationFailureJson,
639         }
640
641         controllerUpdateGnbTestExecuter(t, &context)
642 }
643
644 func TestControllerUpdateGnbMissingServedNrCellInformation(t *testing.T) {
645         context := controllerUpdateGnbTestContext{
646                 getNodebInfoResult: nil,
647                 requestBody: map[string]interface{}{
648                         "servedNrCells": []interface{}{
649                                 map[string]interface{}{
650                                         "servedNrCellInformation": nil,
651                                 },
652                         },
653                 },
654                 expectedStatusCode:   http.StatusBadRequest,
655                 expectedJsonResponse: ValidationFailureJson,
656         }
657
658         controllerUpdateGnbTestExecuter(t, &context)
659 }
660
661 func TestControllerUpdateGnbMissingServedNrCellRequiredProp(t *testing.T) {
662
663         for _, v := range ServedNrCellInformationRequiredFields {
664                 context := controllerUpdateGnbTestContext{
665                         getNodebInfoResult: nil,
666                         requestBody: map[string]interface{}{
667                                 "servedNrCells": []interface{}{
668                                         map[string]interface{}{
669                                                 "servedNrCellInformation": buildServedNrCellInformation(v),
670                                         },
671                                 },
672                         },
673                         expectedStatusCode:   http.StatusBadRequest,
674                         expectedJsonResponse: ValidationFailureJson,
675                 }
676
677                 controllerUpdateGnbTestExecuter(t, &context)
678         }
679 }
680
681 func TestControllerUpdateGnbMissingServedNrCellFddOrTdd(t *testing.T) {
682
683         servedNrCellInformation := buildServedNrCellInformation("")
684         servedNrCellInformation["choiceNrMode"] = map[string]interface{}{}
685
686         context := controllerUpdateGnbTestContext{
687                 getNodebInfoResult: nil,
688                 requestBody: map[string]interface{}{
689                         "servedNrCells": []interface{}{
690                                 map[string]interface{}{
691                                         "servedNrCellInformation": servedNrCellInformation,
692                                 },
693                         },
694                 },
695                 expectedStatusCode:   http.StatusBadRequest,
696                 expectedJsonResponse: ValidationFailureJson,
697         }
698
699         controllerUpdateGnbTestExecuter(t, &context)
700 }
701
702 func TestControllerUpdateGnbMissingNeighbourInfoFddOrTdd(t *testing.T) {
703
704         nrNeighbourInfo := buildNrNeighbourInformation("")
705         nrNeighbourInfo["choiceNrMode"] = map[string]interface{}{}
706
707         context := controllerUpdateGnbTestContext{
708                 getNodebInfoResult: nil,
709                 requestBody: map[string]interface{}{
710                         "servedNrCells": []interface{}{
711                                 map[string]interface{}{
712                                         "servedNrCellInformation": buildServedNrCellInformation(""),
713                                         "nrNeighbourInfos": []interface{}{
714                                                 nrNeighbourInfo,
715                                         },
716                                 },
717                         },
718                 },
719                 expectedStatusCode:   http.StatusBadRequest,
720                 expectedJsonResponse: ValidationFailureJson,
721         }
722
723         controllerUpdateGnbTestExecuter(t, &context)
724 }
725
726 func TestControllerUpdateGnbMissingNrNeighbourInformationRequiredProp(t *testing.T) {
727
728         for _, v := range NrNeighbourInformationRequiredFields {
729                 context := controllerUpdateGnbTestContext{
730                         getNodebInfoResult: nil,
731                         requestBody: map[string]interface{}{
732                                 "servedNrCells": []interface{}{
733                                         map[string]interface{}{
734                                                 "servedNrCellInformation": buildServedNrCellInformation(""),
735                                                 "nrNeighbourInfos": []interface{}{
736                                                         buildNrNeighbourInformation(v),
737                                                 },
738                                         },
739                                 },
740                         },
741                         expectedStatusCode:   http.StatusBadRequest,
742                         expectedJsonResponse: ValidationFailureJson,
743                 }
744
745                 controllerUpdateGnbTestExecuter(t, &context)
746         }
747 }
748
749 // END - UpdateGnb Validation Failure UTs
750
751 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebNotFound(t *testing.T) {
752         context := controllerUpdateGnbTestContext{
753                 getNodebInfoResult: &getNodebInfoResult{
754                         nodebInfo: nil,
755                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
756                 },
757                 requestBody: map[string]interface{}{
758                         "servedNrCells": []interface{}{
759                                 map[string]interface{}{
760                                         "servedNrCellInformation": buildServedNrCellInformation(""),
761                                 },
762                         },
763                 },
764                 expectedStatusCode:   http.StatusNotFound,
765                 expectedJsonResponse: ResourceNotFoundJson,
766         }
767
768         controllerUpdateGnbTestExecuter(t, &context)
769 }
770
771 func TestControllerUpdateGnbValidServedNrCellInformationGetNodebInternalError(t *testing.T) {
772         context := controllerUpdateGnbTestContext{
773                 getNodebInfoResult: &getNodebInfoResult{
774                         nodebInfo: nil,
775                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
776                 },
777                 requestBody: map[string]interface{}{
778                         "servedNrCells": []interface{}{
779                                 map[string]interface{}{
780                                         "servedNrCellInformation": buildServedNrCellInformation(""),
781                                 },
782                         },
783                 },
784                 expectedStatusCode:   http.StatusInternalServerError,
785                 expectedJsonResponse: RnibErrorJson,
786         }
787
788         controllerUpdateGnbTestExecuter(t, &context)
789 }
790
791 func TestControllerUpdateGnbGetNodebSuccessInvalidGnbConfiguration(t *testing.T) {
792         context := controllerUpdateGnbTestContext{
793                 getNodebInfoResult: &getNodebInfoResult{
794                         nodebInfo: &entities.NodebInfo{
795                                 RanName:                      RanName,
796                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
797                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
798                                 NodeType:                     entities.Node_ENB,
799                         },
800                         rnibError: nil,
801                 },
802                 requestBody: map[string]interface{}{
803                         "servedNrCells": []interface{}{
804                                 map[string]interface{}{
805                                         "servedNrCellInformation": buildServedNrCellInformation(""),
806                                         "nrNeighbourInfos": []interface{}{
807                                                 buildNrNeighbourInformation(""),
808                                         },
809                                 },
810                         },
811                 },
812                 expectedStatusCode:   http.StatusBadRequest,
813                 expectedJsonResponse: ValidationFailureJson,
814         }
815
816         controllerUpdateGnbTestExecuter(t, &context)
817 }
818
819 func TestControllerUpdateGnbGetNodebSuccessRemoveServedNrCellsFailure(t *testing.T) {
820         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
821         context := controllerUpdateGnbTestContext{
822                 removeServedNrCellsParams: &removeServedNrCellsParams{
823                         err:           common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
824                         servedNrCells: oldServedNrCells,
825                 },
826                 getNodebInfoResult: &getNodebInfoResult{
827                         nodebInfo: &entities.NodebInfo{
828                                 RanName:                      RanName,
829                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
830                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
831                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
832                                 NodeType:                     entities.Node_GNB,
833                         },
834                         rnibError: nil,
835                 },
836                 requestBody: map[string]interface{}{
837                         "servedNrCells": []interface{}{
838                                 map[string]interface{}{
839                                         "servedNrCellInformation": buildServedNrCellInformation(""),
840                                         "nrNeighbourInfos": []interface{}{
841                                                 buildNrNeighbourInformation(""),
842                                         },
843                                 },
844                         },
845                 },
846                 expectedStatusCode:   http.StatusInternalServerError,
847                 expectedJsonResponse: RnibErrorJson,
848         }
849
850         controllerUpdateGnbTestExecuter(t, &context)
851 }
852
853 func TestControllerUpdateGnbGetNodebSuccessUpdateGnbCellsFailure(t *testing.T) {
854         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
855         context := controllerUpdateGnbTestContext{
856                 removeServedNrCellsParams: &removeServedNrCellsParams{
857                         err:           nil,
858                         servedNrCells: oldServedNrCells,
859                 },
860                 updateGnbCellsParams: &updateGnbCellsParams{
861                         err: common.NewInternalError(errors.New("#writer.UpdateGnbCells - Internal Error")),
862                 },
863                 getNodebInfoResult: &getNodebInfoResult{
864                         nodebInfo: &entities.NodebInfo{
865                                 RanName:                      RanName,
866                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
867                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
868                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
869                                 NodeType:                     entities.Node_GNB,
870                         },
871                         rnibError: nil,
872                 },
873                 requestBody: map[string]interface{}{
874                         "servedNrCells": []interface{}{
875                                 map[string]interface{}{
876                                         "servedNrCellInformation": buildServedNrCellInformation(""),
877                                         "nrNeighbourInfos": []interface{}{
878                                                 buildNrNeighbourInformation(""),
879                                         },
880                                 },
881                         },
882                 },
883                 expectedStatusCode:   http.StatusInternalServerError,
884                 expectedJsonResponse: RnibErrorJson,
885         }
886
887         controllerUpdateGnbTestExecuter(t, &context)
888 }
889
890 func TestControllerUpdateGnbExistingEmptyCellsSuccess(t *testing.T) {
891         oldServedNrCells := []*entities.ServedNRCell{}
892
893         context := controllerUpdateGnbTestContext{
894                 updateGnbCellsParams: &updateGnbCellsParams{
895                         err: nil,
896                 },
897                 getNodebInfoResult: &getNodebInfoResult{
898                         nodebInfo: &entities.NodebInfo{
899                                 RanName:                      RanName,
900                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
901                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
902                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
903                                 NodeType:                     entities.Node_GNB,
904                         },
905                         rnibError: nil,
906                 },
907                 requestBody: map[string]interface{}{
908                         "servedNrCells": []interface{}{
909                                 map[string]interface{}{
910                                         "servedNrCellInformation": buildServedNrCellInformation(""),
911                                         "nrNeighbourInfos": []interface{}{
912                                                 buildNrNeighbourInformation(""),
913                                         },
914                                 },
915                         },
916                 },
917                 expectedStatusCode:   http.StatusOK,
918                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
919         }
920
921         controllerUpdateGnbTestExecuter(t, &context)
922 }
923
924 func TestControllerUpdateGnbSuccess(t *testing.T) {
925         oldServedNrCells := generateServedNrCells("whatever1", "whatever2")
926
927         context := controllerUpdateGnbTestContext{
928                 removeServedNrCellsParams: &removeServedNrCellsParams{
929                         err:           nil,
930                         servedNrCells: oldServedNrCells,
931                 },
932                 updateGnbCellsParams: &updateGnbCellsParams{
933                         err: nil,
934                 },
935                 getNodebInfoResult: &getNodebInfoResult{
936                         nodebInfo: &entities.NodebInfo{
937                                 RanName:                      RanName,
938                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
939                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
940                                 Configuration:                &entities.NodebInfo_Gnb{Gnb: &entities.Gnb{ServedNrCells: oldServedNrCells}},
941                                 NodeType:                     entities.Node_GNB,
942                         },
943                         rnibError: nil,
944                 },
945                 requestBody: map[string]interface{}{
946                         "servedNrCells": []interface{}{
947                                 map[string]interface{}{
948                                         "servedNrCellInformation": buildServedNrCellInformation(""),
949                                         "nrNeighbourInfos": []interface{}{
950                                                 buildNrNeighbourInformation(""),
951                                         },
952                                 },
953                         },
954                 },
955                 expectedStatusCode:   http.StatusOK,
956                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"GNB\",\"gnb\":{\"servedNrCells\":[{\"servedNrCellInformation\":{\"nrPci\":1,\"cellId\":\"whatever\",\"servedPlmns\":[\"whatever\"],\"nrMode\":\"FDD\",\"choiceNrMode\":{\"fdd\":{}}},\"nrNeighbourInfos\":[{\"nrPci\":1,\"nrCgi\":\"whatever\",\"nrMode\":\"FDD\",\"choiceNrMode\":{\"tdd\":{}}}]}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
957         }
958
959         controllerUpdateGnbTestExecuter(t, &context)
960 }
961
962 /*
963 UpdateEnb UTs
964 */
965
966 func TestControllerUpdateEnbInvalidRequest(t *testing.T) {
967         controller, _, _, _, _, _ := setupControllerTest(t)
968
969         writer := httptest.NewRecorder()
970         invalidJson := strings.NewReader("{enb:\"whatever\"")
971
972         updateEnbUrl := fmt.Sprintf("/nodeb/enb/%s", RanName)
973         req, _ := http.NewRequest(http.MethodPut, updateEnbUrl, invalidJson)
974         req.Header.Set("Content-Type", "application/json")
975         req = mux.SetURLVars(req, map[string]string{"ranName": RanName})
976
977         controller.UpdateEnb(writer, req)
978
979         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
980         bodyBytes, _ := ioutil.ReadAll(writer.Body)
981         assert.Equal(t, CorruptedJson, string(bodyBytes))
982 }
983
984 func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
985         context := controllerUpdateEnbTestContext{
986                 getNodebInfoResult:   nil,
987                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[0]),
988                 expectedStatusCode:   http.StatusBadRequest,
989                 expectedJsonResponse: ValidationFailureJson,
990         }
991
992         controllerUpdateEnbTestExecuter(t, &context)
993 }
994
995 func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
996         context := controllerUpdateEnbTestContext{
997                 getNodebInfoResult:   nil,
998                 requestBody:          getUpdateEnbRequest(EnbRequiredFields[1]),
999                 expectedStatusCode:   http.StatusBadRequest,
1000                 expectedJsonResponse: ValidationFailureJson,
1001         }
1002
1003         controllerUpdateEnbTestExecuter(t, &context)
1004 }
1005
1006 func TestControllerUpdateEnbMissingEnb(t *testing.T) {
1007         context := controllerUpdateEnbTestContext{
1008                 getNodebInfoResult:   nil,
1009                 requestBody:          getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
1010                 expectedStatusCode:   http.StatusBadRequest,
1011                 expectedJsonResponse: ValidationFailureJson,
1012         }
1013
1014         controllerUpdateEnbTestExecuter(t, &context)
1015 }
1016
1017 func TestControllerUpdateEnbMissingRequiredServedCellProps(t *testing.T) {
1018
1019         r := getUpdateEnbRequest("")
1020
1021         for _, v := range ServedCellRequiredFields {
1022                 enb := r["enb"]
1023
1024                 enbMap, _ := enb.(map[string]interface{})
1025
1026                 enbMap["servedCells"] = []interface{}{
1027                         buildServedCell(v),
1028                 }
1029
1030                 context := controllerUpdateEnbTestContext{
1031                         requestBody:          r,
1032                         expectedStatusCode:   http.StatusBadRequest,
1033                         expectedJsonResponse: ValidationFailureJson,
1034                 }
1035
1036                 controllerUpdateEnbTestExecuter(t, &context)
1037         }
1038 }
1039
1040 func TestControllerUpdateEnbValidServedCellsGetNodebNotFound(t *testing.T) {
1041         context := controllerUpdateEnbTestContext{
1042                 getNodebInfoResult: &getNodebInfoResult{
1043                         nodebInfo: nil,
1044                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1045                 },
1046                 requestBody:          getUpdateEnbRequest(""),
1047                 expectedStatusCode:   http.StatusNotFound,
1048                 expectedJsonResponse: ResourceNotFoundJson,
1049         }
1050
1051         controllerUpdateEnbTestExecuter(t, &context)
1052 }
1053
1054 func TestControllerUpdateEnbValidServedCellsGetNodebInternalError(t *testing.T) {
1055         context := controllerUpdateEnbTestContext{
1056                 getNodebInfoResult: &getNodebInfoResult{
1057                         nodebInfo: nil,
1058                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1059                 },
1060                 requestBody:          getUpdateEnbRequest(""),
1061                 expectedStatusCode:   http.StatusInternalServerError,
1062                 expectedJsonResponse: RnibErrorJson,
1063         }
1064
1065         controllerUpdateEnbTestExecuter(t, &context)
1066 }
1067
1068 func TestControllerUpdateEnbGetNodebSuccessGnbTypeFailure(t *testing.T) {
1069         oldServedCells := generateServedCells("whatever1", "whatever2")
1070         context := controllerUpdateEnbTestContext{
1071                 getNodebInfoResult: &getNodebInfoResult{
1072                         nodebInfo: &entities.NodebInfo{
1073                                 RanName:                      RanName,
1074                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1075                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1076                                 NodeType:                     entities.Node_GNB,
1077                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1078                         },
1079                         rnibError: nil,
1080                 },
1081                 requestBody:          getUpdateEnbRequest(""),
1082                 expectedStatusCode:   http.StatusBadRequest,
1083                 expectedJsonResponse: ValidationFailureJson,
1084         }
1085
1086         controllerUpdateEnbTestExecuter(t, &context)
1087 }
1088
1089 func TestControllerUpdateEnbGetNodebSuccessRemoveServedCellsFailure(t *testing.T) {
1090         oldServedCells := generateServedCells("whatever1", "whatever2")
1091         context := controllerUpdateEnbTestContext{
1092                 removeServedCellsParams: &removeServedCellsParams{
1093                         err:            common.NewInternalError(errors.New("#writer.RemoveServedCells - Internal Error")),
1094                         servedCellInfo: oldServedCells,
1095                 },
1096                 getNodebInfoResult: &getNodebInfoResult{
1097                         nodebInfo: &entities.NodebInfo{
1098                                 RanName:                      RanName,
1099                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1100                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1101                                 NodeType:                     entities.Node_ENB,
1102                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells}},
1103                         },
1104                         rnibError: nil,
1105                 },
1106                 requestBody:          getUpdateEnbRequest(""),
1107                 expectedStatusCode:   http.StatusInternalServerError,
1108                 expectedJsonResponse: RnibErrorJson,
1109         }
1110
1111         controllerUpdateEnbTestExecuter(t, &context)
1112 }
1113
1114 func TestControllerUpdateEnbGetNodebSuccessUpdateEnbFailure(t *testing.T) {
1115         oldServedCells := generateServedCells("whatever1", "whatever2")
1116         context := controllerUpdateEnbTestContext{
1117                 removeServedCellsParams: &removeServedCellsParams{
1118                         err:            nil,
1119                         servedCellInfo: oldServedCells,
1120                 },
1121                 updateEnbCellsParams: &updateEnbCellsParams{
1122                         err: common.NewInternalError(errors.New("#writer.UpdateEnb - Internal Error")),
1123                 },
1124                 getNodebInfoResult: &getNodebInfoResult{
1125                         nodebInfo: &entities.NodebInfo{
1126                                 RanName:                      RanName,
1127                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1128                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1129                                 NodeType:                     entities.Node_ENB,
1130                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1131                         },
1132                         rnibError: nil,
1133                 },
1134                 requestBody:          getUpdateEnbRequest(""),
1135                 expectedStatusCode:   http.StatusInternalServerError,
1136                 expectedJsonResponse: RnibErrorJson,
1137         }
1138
1139         controllerUpdateEnbTestExecuter(t, &context)
1140 }
1141
1142 func TestControllerUpdateEnbExistingEmptyCellsSuccess(t *testing.T) {
1143         oldServedCells := []*entities.ServedCellInfo{}
1144         context := controllerUpdateEnbTestContext{
1145                 updateEnbCellsParams: &updateEnbCellsParams{
1146                         err: nil,
1147                 },
1148                 getNodebInfoResult: &getNodebInfoResult{
1149                         nodebInfo: &entities.NodebInfo{
1150                                 RanName:                      RanName,
1151                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1152                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1153                                 NodeType:                     entities.Node_ENB,
1154                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_ENB}},
1155                         },
1156                         rnibError: nil,
1157                 },
1158                 requestBody:          getUpdateEnbRequest(""),
1159                 expectedStatusCode:   http.StatusOK,
1160                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1161         }
1162
1163         controllerUpdateEnbTestExecuter(t, &context)
1164 }
1165
1166 func TestControllerUpdateEnbNgEnbFailure(t *testing.T) {
1167
1168         requestBody := map[string]interface{}{
1169                 "enb": map[string]interface{}{
1170                         "enbType": 3,
1171                         "servedCells": []interface{}{
1172                                 buildServedCell(""),
1173                         }},
1174         }
1175
1176         oldServedCells := generateServedCells("whatever1", "whatever2")
1177
1178         context := controllerUpdateEnbTestContext{
1179                 getNodebInfoResult:  &getNodebInfoResult{
1180                 nodebInfo: &entities.NodebInfo{
1181                 RanName:                      RanName,
1182                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1183                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1184                 NodeType:                     entities.Node_ENB,
1185                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_MACRO_NG_ENB}},
1186         },
1187                 rnibError: nil,
1188         },
1189                 requestBody:          requestBody,
1190                 expectedStatusCode:   http.StatusBadRequest,
1191                 expectedJsonResponse: ValidationFailureJson,
1192         }
1193
1194         controllerUpdateEnbTestExecuter(t, &context)
1195 }
1196
1197 func TestControllerUpdateEnbSuccessSetupFromNwFalse(t *testing.T) {
1198         oldServedCells := generateServedCells("whatever1", "whatever2")
1199         context := controllerUpdateEnbTestContext{
1200                 removeServedCellsParams: &removeServedCellsParams{
1201                         err:            nil,
1202                         servedCellInfo: oldServedCells,
1203                 },
1204                 updateEnbCellsParams: &updateEnbCellsParams{
1205                         err: nil,
1206                 },
1207                 getNodebInfoResult: &getNodebInfoResult{
1208                         nodebInfo: &entities.NodebInfo{
1209                                 RanName:                      RanName,
1210                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1211                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1212                                 NodeType:                     entities.Node_ENB,
1213                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1214                         },
1215                         rnibError: nil,
1216                 },
1217                 requestBody:          getUpdateEnbRequest(""),
1218                 expectedStatusCode:   http.StatusOK,
1219                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
1220         }
1221
1222         controllerUpdateEnbTestExecuter(t, &context)
1223 }
1224
1225 func TestControllerUpdateEnbSuccessSetupFromNwTrue(t *testing.T) {
1226         oldServedCells := generateServedCells("whatever1", "whatever2")
1227         context := controllerUpdateEnbTestContext{
1228                 removeServedCellsParams: &removeServedCellsParams{
1229                         err:            nil,
1230                         servedCellInfo: oldServedCells,
1231                 },
1232                 updateEnbCellsParams: &updateEnbCellsParams{
1233                         err: nil,
1234                 },
1235                 getNodebInfoResult: &getNodebInfoResult{
1236                         nodebInfo: &entities.NodebInfo{
1237                                 RanName:                      RanName,
1238                                 ConnectionStatus:             entities.ConnectionStatus_CONNECTED,
1239                                 AssociatedE2TInstanceAddress: AssociatedE2TInstanceAddress,
1240                                 NodeType:                     entities.Node_ENB,
1241                                 Configuration:                &entities.NodebInfo_Enb{Enb: &entities.Enb{ServedCells: oldServedCells, EnbType: entities.EnbType_LONG_MACRO_ENB}},
1242                                 SetupFromNetwork:             true,
1243                         },
1244                         rnibError: nil,
1245                 },
1246                 requestBody:          getUpdateEnbRequest(""),
1247                 expectedStatusCode:   http.StatusOK,
1248                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"LONG_MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\",\"setupFromNetwork\":true}",
1249         }
1250
1251         controllerUpdateEnbTestExecuter(t, &context)
1252 }
1253
1254 /*
1255 AddEnb UTs
1256 */
1257
1258 func TestControllerAddEnbGetNodebInternalError(t *testing.T) {
1259         context := controllerAddEnbTestContext{
1260                 getNodebInfoResult: &getNodebInfoResult{
1261                         nodebInfo: nil,
1262                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1263                 },
1264                 requestBody:          getAddEnbRequest(""),
1265                 expectedStatusCode:   http.StatusInternalServerError,
1266                 expectedJsonResponse: RnibErrorJson,
1267         }
1268
1269         controllerAddEnbTestExecuter(t, &context)
1270 }
1271
1272 func TestControllerAddEnbNodebExistsFailure(t *testing.T) {
1273         context := controllerAddEnbTestContext{
1274                 getNodebInfoResult: &getNodebInfoResult{
1275                         nodebInfo: &entities.NodebInfo{},
1276                         rnibError: nil,
1277                 },
1278                 requestBody:          getAddEnbRequest(""),
1279                 expectedStatusCode:   http.StatusBadRequest,
1280                 expectedJsonResponse: NodebExistsJson,
1281         }
1282
1283         controllerAddEnbTestExecuter(t, &context)
1284 }
1285
1286 func TestControllerAddEnbSaveNodebFailure(t *testing.T) {
1287         context := controllerAddEnbTestContext{
1288                 addEnbParams: &addEnbParams{
1289                         err: common.NewInternalError(errors.New("#reader.AddEnb - Internal Error")),
1290                 },
1291                 getNodebInfoResult: &getNodebInfoResult{
1292                         nodebInfo: nil,
1293                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1294                 },
1295                 requestBody:          getAddEnbRequest(""),
1296                 expectedStatusCode:   http.StatusInternalServerError,
1297                 expectedJsonResponse: RnibErrorJson,
1298         }
1299
1300         controllerAddEnbTestExecuter(t, &context)
1301 }
1302
1303 func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
1304         context := controllerAddEnbTestContext{
1305                 addEnbParams: &addEnbParams{
1306                         err: nil,
1307                 },
1308                 addNbIdentityParams: &addNbIdentityParams{
1309                         err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
1310                 },
1311                 getNodebInfoResult: &getNodebInfoResult{
1312                         nodebInfo: nil,
1313                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1314                 },
1315                 requestBody:          getAddEnbRequest(""),
1316                 expectedStatusCode:   http.StatusInternalServerError,
1317                 expectedJsonResponse: RnibErrorJson,
1318         }
1319
1320         controllerAddEnbTestExecuter(t, &context)
1321 }
1322
1323 func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
1324
1325         for _, v := range AddEnbRequestRequiredFields {
1326                 context := controllerAddEnbTestContext{
1327                         requestBody:          getAddEnbRequest(v),
1328                         expectedStatusCode:   http.StatusBadRequest,
1329                         expectedJsonResponse: ValidationFailureJson,
1330                 }
1331
1332                 controllerAddEnbTestExecuter(t, &context)
1333         }
1334 }
1335
1336 func TestControllerAddEnbInvalidRequest(t *testing.T) {
1337         controller, _, _, _, _, _ := setupControllerTest(t)
1338         writer := httptest.NewRecorder()
1339
1340         // Invalid json: attribute name without quotes (should be "cause":).
1341         invalidJson := strings.NewReader("{ranName:\"whatever\"")
1342         req, _ := http.NewRequest(http.MethodPost, AddEnbUrl, invalidJson)
1343
1344         controller.AddEnb(writer, req)
1345         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1346         bodyBytes, _ := ioutil.ReadAll(writer.Body)
1347         assert.Equal(t, CorruptedJson, string(bodyBytes))
1348
1349 }
1350
1351 func TestControllerAddEnbMissingRequiredGlobalNbIdProps(t *testing.T) {
1352
1353         r := getAddEnbRequest("")
1354
1355         for _, v := range GlobalIdRequiredFields {
1356                 r["globalNbId"] = buildGlobalNbId(v)
1357
1358                 context := controllerAddEnbTestContext{
1359                         requestBody:          r,
1360                         expectedStatusCode:   http.StatusBadRequest,
1361                         expectedJsonResponse: ValidationFailureJson,
1362                 }
1363
1364                 controllerAddEnbTestExecuter(t, &context)
1365         }
1366 }
1367
1368 func TestControllerAddEnbMissingRequiredEnbProps(t *testing.T) {
1369
1370         r := getAddEnbRequest("")
1371
1372         for _, v := range EnbRequiredFields {
1373                 r["enb"] = buildEnb(v)
1374
1375                 context := controllerAddEnbTestContext{
1376                         requestBody:          r,
1377                         expectedStatusCode:   http.StatusBadRequest,
1378                         expectedJsonResponse: ValidationFailureJson,
1379                 }
1380
1381                 controllerAddEnbTestExecuter(t, &context)
1382         }
1383 }
1384
1385 func TestControllerAddEnbMissingRequiredServedCellProps(t *testing.T) {
1386
1387         r := getAddEnbRequest("")
1388
1389         for _, v := range ServedCellRequiredFields {
1390                 enb := r["enb"]
1391
1392                 enbMap, _ := enb.(map[string]interface{})
1393
1394                 enbMap["servedCells"] = []interface{}{
1395                         buildServedCell(v),
1396                 }
1397
1398                 context := controllerAddEnbTestContext{
1399                         requestBody:          r,
1400                         expectedStatusCode:   http.StatusBadRequest,
1401                         expectedJsonResponse: ValidationFailureJson,
1402                 }
1403
1404                 controllerAddEnbTestExecuter(t, &context)
1405         }
1406 }
1407
1408 func TestControllerAddEnbNgEnbFailure(t *testing.T) {
1409
1410         requestBody := map[string]interface{}{
1411                 "ranName":    RanName,
1412                 "globalNbId": buildGlobalNbId(""),
1413                 "enb": map[string]interface{}{
1414                         "enbType": 5,
1415                         "servedCells": []interface{}{
1416                                 buildServedCell(""),
1417                         },
1418                 },
1419         }
1420
1421         context := controllerAddEnbTestContext{
1422                 requestBody:          requestBody,
1423                 expectedStatusCode:   http.StatusBadRequest,
1424                 expectedJsonResponse: ValidationFailureJson,
1425         }
1426
1427         controllerAddEnbTestExecuter(t, &context)
1428 }
1429
1430 func TestControllerAddEnbSuccess(t *testing.T) {
1431         context := controllerAddEnbTestContext{
1432                 addEnbParams: &addEnbParams{
1433                         err: nil,
1434                 },
1435                 addNbIdentityParams: &addNbIdentityParams{
1436                         err: nil,
1437                 },
1438                 getNodebInfoResult: &getNodebInfoResult{
1439                         nodebInfo: nil,
1440                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1441                 },
1442                 requestBody:          getAddEnbRequest(""),
1443                 expectedStatusCode:   http.StatusCreated,
1444                 expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"DISCONNECTED\",\"globalNbId\":{\"plmnId\":\"whatever\",\"nbId\":\"whatever2\"},\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]}}",
1445         }
1446
1447         controllerAddEnbTestExecuter(t, &context)
1448 }
1449
1450 func TestControllerDeleteEnbGetNodebInternalError(t *testing.T) {
1451         context := controllerDeleteEnbTestContext{
1452                 getNodebInfoResult: &getNodebInfoResult{
1453                         nodebInfo: nil,
1454                         rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1455                 },
1456                 expectedStatusCode:   http.StatusInternalServerError,
1457                 expectedJsonResponse: RnibErrorJson,
1458         }
1459
1460         controllerDeleteEnbTestExecuter(t, &context, false)
1461 }
1462
1463 /*
1464 DeleteEnb UTs
1465 */
1466
1467 func TestControllerDeleteEnbNodebNotExistsFailure(t *testing.T) {
1468         context := controllerDeleteEnbTestContext{
1469                 getNodebInfoResult: &getNodebInfoResult{
1470                         nodebInfo: nil,
1471                         rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found"),
1472                 },
1473                 expectedStatusCode:   http.StatusNotFound,
1474                 expectedJsonResponse: ResourceNotFoundJson,
1475         }
1476
1477         controllerDeleteEnbTestExecuter(t, &context, false)
1478 }
1479
1480 func TestControllerDeleteEnbNodebNotEnb(t *testing.T) {
1481         context := controllerDeleteEnbTestContext{
1482                 getNodebInfoResult: &getNodebInfoResult{
1483                         nodebInfo: &entities.NodebInfo{RanName: "ran1", NodeType: entities.Node_GNB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1484                         rnibError: nil,
1485                 },
1486                 expectedStatusCode:   http.StatusBadRequest,
1487                 expectedJsonResponse: ValidationFailureJson,
1488         }
1489
1490         controllerDeleteEnbTestExecuter(t, &context, false)
1491 }
1492
1493 func TestControllerDeleteEnbSetupFromNetworkTrueFailure(t *testing.T) {
1494         context := controllerDeleteEnbTestContext{
1495                 getNodebInfoResult: &getNodebInfoResult{
1496                         nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, SetupFromNetwork: true},
1497                         rnibError: nil,
1498                 },
1499                 expectedStatusCode:   http.StatusBadRequest,
1500                 expectedJsonResponse: ValidationFailureJson,
1501         }
1502         controllerDeleteEnbTestExecuter(t, &context, true)
1503 }
1504
1505 func TestControllerDeleteEnbSuccess(t *testing.T) {
1506         context := controllerDeleteEnbTestContext{
1507                 getNodebInfoResult: &getNodebInfoResult{
1508                         nodebInfo: &entities.NodebInfo{RanName: RanName, NodeType: entities.Node_ENB, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED},
1509                         rnibError: nil,
1510                 },
1511                 expectedStatusCode:   http.StatusNoContent,
1512                 expectedJsonResponse: "",
1513         }
1514         controllerDeleteEnbTestExecuter(t, &context, true)
1515 }
1516
1517 func getJsonRequestAsBuffer(requestJson map[string]interface{}) *bytes.Buffer {
1518         b := new(bytes.Buffer)
1519         _ = json.NewEncoder(b).Encode(requestJson)
1520         return b
1521 }
1522
1523 /*
1524 GetNodeb UTs
1525 */
1526
1527 func TestControllerGetNodebSuccess(t *testing.T) {
1528         ranName := "test"
1529         var rnibError error
1530         context := controllerGetNodebTestContext{
1531                 ranName:              ranName,
1532                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
1533                 rnibError:            rnibError,
1534                 expectedStatusCode:   http.StatusOK,
1535                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
1536         }
1537
1538         controllerGetNodebTestExecuter(t, &context)
1539 }
1540
1541 func TestControllerGetNodebNotFound(t *testing.T) {
1542
1543         ranName := "test"
1544         var nodebInfo *entities.NodebInfo
1545         context := controllerGetNodebTestContext{
1546                 ranName:              ranName,
1547                 nodebInfo:            nodebInfo,
1548                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
1549                 expectedStatusCode:   http.StatusNotFound,
1550                 expectedJsonResponse: ResourceNotFoundJson,
1551         }
1552
1553         controllerGetNodebTestExecuter(t, &context)
1554 }
1555
1556 func TestControllerGetNodebInternal(t *testing.T) {
1557         ranName := "test"
1558         var nodebInfo *entities.NodebInfo
1559         context := controllerGetNodebTestContext{
1560                 ranName:              ranName,
1561                 nodebInfo:            nodebInfo,
1562                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
1563                 expectedStatusCode:   http.StatusInternalServerError,
1564                 expectedJsonResponse: RnibErrorJson,
1565         }
1566
1567         controllerGetNodebTestExecuter(t, &context)
1568 }
1569
1570 func TestControllerGetNodebIdListSuccess(t *testing.T) {
1571         var rnibError error
1572         nodebIdList := []*entities.NbIdentity{
1573                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
1574                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
1575         }
1576
1577         context := controllerGetNodebIdListTestContext{
1578                 nodebIdList:          nodebIdList,
1579                 rnibError:            rnibError,
1580                 expectedStatusCode:   http.StatusOK,
1581                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}][{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}}]",
1582         }
1583
1584         controllerGetNodebIdListTestExecuter(t, &context)
1585 }
1586
1587 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
1588         var rnibError error
1589         var nodebIdList []*entities.NbIdentity
1590
1591         context := controllerGetNodebIdListTestContext{
1592                 nodebIdList:          nodebIdList,
1593                 rnibError:            rnibError,
1594                 expectedStatusCode:   http.StatusOK,
1595                 expectedJsonResponse: "[]",
1596         }
1597
1598         controllerGetNodebIdListTestExecuter(t, &context)
1599 }
1600
1601 func TestHeaderValidationFailed(t *testing.T) {
1602         controller, _, _, _, _, _ := setupControllerTest(t)
1603
1604         writer := httptest.NewRecorder()
1605
1606         header := &http.Header{}
1607
1608         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, 0)
1609
1610         var errorResponse = parseJsonRequest(t, writer.Body)
1611         err := e2managererrors.NewHeaderValidationError()
1612
1613         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1614         assert.Equal(t, errorResponse.Code, err.Code)
1615         assert.Equal(t, errorResponse.Message, err.Message)
1616 }
1617
1618 func TestShutdownStatusNoContent(t *testing.T) {
1619         controller, readerMock, _, _, e2tInstancesManagerMock, _ := setupControllerTest(t)
1620         e2tInstancesManagerMock.On("GetE2TAddresses").Return([]string{}, nil)
1621         readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, nil)
1622
1623         writer := httptest.NewRecorder()
1624         controller.Shutdown(writer, tests.GetHttpRequest())
1625
1626         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1627 }
1628
1629 func TestHandleInternalError(t *testing.T) {
1630         controller, _, _, _, _, _ := setupControllerTest(t)
1631
1632         writer := httptest.NewRecorder()
1633         err := e2managererrors.NewInternalError()
1634
1635         controller.handleErrorResponse(err, writer)
1636         var errorResponse = parseJsonRequest(t, writer.Body)
1637
1638         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1639         assert.Equal(t, errorResponse.Code, err.Code)
1640         assert.Equal(t, errorResponse.Message, err.Message)
1641 }
1642
1643 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
1644         controller, _, _, _, _, _ := setupControllerTest(t)
1645         writer := httptest.NewRecorder()
1646         err := e2managererrors.NewCommandAlreadyInProgressError()
1647
1648         controller.handleErrorResponse(err, writer)
1649         var errorResponse = parseJsonRequest(t, writer.Body)
1650
1651         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1652         assert.Equal(t, errorResponse.Code, err.Code)
1653         assert.Equal(t, errorResponse.Message, err.Message)
1654 }
1655
1656 func TestHandleRoutingManagerError(t *testing.T) {
1657         controller, _, _, _, _, _ := setupControllerTest(t)
1658         writer := httptest.NewRecorder()
1659         err := e2managererrors.NewRoutingManagerError()
1660
1661         controller.handleErrorResponse(err, writer)
1662         var errorResponse = parseJsonRequest(t, writer.Body)
1663
1664         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1665         assert.Equal(t, errorResponse.Code, err.Code)
1666         assert.Equal(t, errorResponse.Message, err.Message)
1667 }
1668
1669 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
1670         controller, _, _, _, _, _ := setupControllerTest(t)
1671
1672         writer := httptest.NewRecorder()
1673         err := e2managererrors.NewE2TInstanceAbsenceError()
1674
1675         controller.handleErrorResponse(err, writer)
1676         var errorResponse = parseJsonRequest(t, writer.Body)
1677
1678         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
1679         assert.Equal(t, errorResponse.Code, err.Code)
1680         assert.Equal(t, errorResponse.Message, err.Message)
1681 }
1682
1683 func TestValidateHeaders(t *testing.T) {
1684         controller, _, _, _, _, _ := setupControllerTest(t)
1685
1686         header := http.Header{}
1687         header.Set("Content-Type", "application/json")
1688         result := controller.validateRequestHeader(&header)
1689
1690         assert.Nil(t, result)
1691 }
1692
1693 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
1694
1695         var errorResponse models.ErrorResponse
1696         body, err := ioutil.ReadAll(r)
1697         if err != nil {
1698                 t.Errorf("Error cannot deserialize json request")
1699         }
1700         _ = json.Unmarshal(body, &errorResponse)
1701
1702         return errorResponse
1703 }
1704
1705 func initLog(t *testing.T) *logger.Logger {
1706         log, err := logger.InitLogger(logger.InfoLevel)
1707         if err != nil {
1708                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
1709         }
1710         return log
1711 }
1712
1713 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
1714         controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1715
1716         ranName := "test1"
1717         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
1718         var xAction []byte
1719         var msgSrc unsafe.Pointer
1720         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1721         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
1722
1723         writer := httptest.NewRecorder()
1724
1725         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1726         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1727
1728         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
1729         b := new(bytes.Buffer)
1730         _ = json.NewEncoder(b).Encode(data4Req)
1731         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1732         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1733
1734         controller.X2Reset(writer, req)
1735         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1736
1737 }
1738
1739 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
1740         controller, readerMock, _, rmrMessengerMock, _, _ := setupControllerTest(t)
1741
1742         ranName := "test1"
1743         // o&m intervention
1744         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
1745         var xAction []byte
1746         var msgSrc unsafe.Pointer
1747         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
1748         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
1749
1750         writer := httptest.NewRecorder()
1751
1752         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
1753         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
1754
1755         // no body
1756         b := new(bytes.Buffer)
1757         data4Req := map[string]interface{}{}
1758         _ = json.NewEncoder(b).Encode(data4Req)
1759         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1760         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1761
1762         controller.X2Reset(writer, req)
1763         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
1764 }
1765
1766 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
1767         controller, _, _, _, _, _ := setupControllerTest(t)
1768
1769         ranName := "test1"
1770
1771         writer := httptest.NewRecorder()
1772
1773         // Invalid json: attribute name without quotes (should be "cause":).
1774         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
1775         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
1776         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
1777
1778         controller.X2Reset(writer, req)
1779         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1780
1781 }
1782
1783 func TestHandleErrorResponse(t *testing.T) {
1784         controller, _, _, _, _, _ := setupControllerTest(t)
1785
1786         writer := httptest.NewRecorder()
1787         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
1788         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1789
1790         writer = httptest.NewRecorder()
1791         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
1792         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
1793
1794         writer = httptest.NewRecorder()
1795         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
1796         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
1797
1798         writer = httptest.NewRecorder()
1799         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
1800         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1801
1802         writer = httptest.NewRecorder()
1803         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
1804         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
1805
1806         writer = httptest.NewRecorder()
1807         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
1808         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1809
1810         writer = httptest.NewRecorder()
1811         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
1812         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
1813
1814         writer = httptest.NewRecorder()
1815         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
1816         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
1817 }
1818
1819 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
1820         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
1821         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
1822         return rmrsender.NewRmrSender(log, rmrMessenger)
1823 }