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
  21 package controllers
  22
  23 import (
  24         "bytes"
  25         "e2mgr/configuration"
  26         "e2mgr/e2managererrors"
  27         "e2mgr/e2pdus"
  28         "e2mgr/logger"
  29         "e2mgr/managers"
  30         "e2mgr/mocks"
  31         "e2mgr/models"
  32         "e2mgr/providers/httpmsghandlerprovider"
  33         "e2mgr/rmrCgo"
  34         "e2mgr/services"
  35         "e2mgr/services/rmrsender"
  36         "e2mgr/tests"
  37         "encoding/json"
  38         "fmt"
  39         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  40         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
  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 )
  52
  53 type controllerGetNodebTestContext struct {
  54         ranName              string
  55         nodebInfo            *entities.NodebInfo
  56         rnibError            error
  57         expectedStatusCode   int
  58         expectedJsonResponse string
  59 }
  60
  61 type controllerGetNodebIdListTestContext struct {
  62         nodebIdList          []*entities.NbIdentity
  63         rnibError            error
  64         expectedStatusCode   int
  65         expectedJsonResponse string
  66 }
  67
  68 func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
  69         log := initLog(t)
  70         config := configuration.ParseConfiguration()
  71
  72         rmrMessengerMock := &mocks.RmrMessengerMock{}
  73         readerMock := &mocks.RnibReaderMock{}
  74
  75         writerMock := &mocks.RnibWriterMock{}
  76
  77         rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
  78         rmrSender := getRmrSender(rmrMessengerMock, log)
  79         ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
  80         e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
  81         handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager)
  82         controller := NewNodebController(log, handlerProvider)
  83         return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
  84 }
  85
  86 func TestX2SetupInvalidBody(t *testing.T) {
  87
  88         controller, _, _, _, _ := setupControllerTest(t)
  89
  90         header := http.Header{}
  91         header.Set("Content-Type", "application/json")
  92         httpRequest, _ := http.NewRequest("POST", "http://localhost:3800/v1/nodeb/x2-setup", strings.NewReader("{}{}"))
  93         httpRequest.Header = header
  94
  95         writer := httptest.NewRecorder()
  96         controller.X2Setup(writer, httpRequest)
  97
  98         var errorResponse = parseJsonRequest(t, writer.Body)
  99
 100         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 101         assert.Equal(t, e2managererrors.NewInvalidJsonError().Code, errorResponse.Code)
 102 }
 103
 104 func TestX2SetupSuccess(t *testing.T) {
 105
 106         controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
 107
 108         ranName := "test"
 109         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
 110         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 111         var nbUpdated = *nb
 112         nbUpdated.ConnectionAttempts = 0
 113         writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
 114
 115         var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
 116         writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
 117
 118         payload := e2pdus.PackedX2setupRequest
 119         var xAction []byte
 120         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
 121
 122         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
 123
 124         header := http.Header{}
 125         header.Set("Content-Type", "application/json")
 126         httpRequest := tests.GetHttpRequest()
 127         httpRequest.Header = header
 128
 129         writer := httptest.NewRecorder()
 130         controller.X2Setup(writer, httpRequest)
 131
 132         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 133 }
 134
 135
 136 func TestEndcSetupSuccess(t *testing.T) {
 137
 138         controller, readerMock, writerMock, rmrMessengerMock, _ := setupControllerTest(t)
 139
 140         ranName := "test"
 141         nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
 142         readerMock.On("GetNodeb", ranName).Return(nb, nil)
 143         var nbUpdated = *nb
 144         nbUpdated.ConnectionAttempts = 0
 145         writerMock.On("UpdateNodebInfo", &nbUpdated).Return(nil)
 146
 147         var nbUpdated2 = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1, AssociatedE2TInstanceAddress:"10.0.2.15:8989"}
 148         writerMock.On("UpdateNodebInfo", nbUpdated2).Return(nil)
 149
 150         payload := e2pdus.PackedEndcX2setupRequest
 151         var xAction[]byte
 152         msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
 153
 154         rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
 155
 156         header := http.Header{}
 157         header.Set("Content-Type", "application/json")
 158         httpRequest := tests.GetHttpRequest()
 159         httpRequest.Header = header
 160
 161         writer := httptest.NewRecorder()
 162         controller.EndcSetup(writer, httpRequest)
 163
 164         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 165 }
 166
 167 func TestShutdownHandlerRnibError(t *testing.T) {
 168         controller, readerMock, _, _, _ := setupControllerTest(t)
 169
 170         rnibErr := &common.ResourceNotFoundError{}
 171         var nbIdentityList []*entities.NbIdentity
 172         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
 173
 174         writer := httptest.NewRecorder()
 175
 176         controller.Shutdown(writer, tests.GetHttpRequest())
 177
 178         var errorResponse = parseJsonRequest(t, writer.Body)
 179
 180         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 181         assert.Equal(t, errorResponse.Code, e2managererrors.NewRnibDbError().Code)
 182 }
 183
 184 func controllerGetNodebTestExecuter(t *testing.T, context *controllerGetNodebTestContext) {
 185         controller, readerMock, _, _, _ := setupControllerTest(t)
 186         writer := httptest.NewRecorder()
 187         readerMock.On("GetNodeb", context.ranName).Return(context.nodebInfo, context.rnibError)
 188         req, _ := http.NewRequest("GET", "/nodeb", nil)
 189         req = mux.SetURLVars(req, map[string]string{"ranName": context.ranName})
 190         controller.GetNodeb(writer, req)
 191         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 192         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 193         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 194 }
 195
 196 func controllerGetNodebIdListTestExecuter(t *testing.T, context *controllerGetNodebIdListTestContext) {
 197         controller, readerMock, _, _, _ := setupControllerTest(t)
 198         writer := httptest.NewRecorder()
 199         readerMock.On("GetListNodebIds").Return(context.nodebIdList, context.rnibError)
 200         req, _ := http.NewRequest("GET", "/nodeb/ids", nil)
 201         controller.GetNodebIdList(writer, req)
 202         assert.Equal(t, context.expectedStatusCode, writer.Result().StatusCode)
 203         bodyBytes, _ := ioutil.ReadAll(writer.Body)
 204         assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
 205 }
 206
 207 func TestControllerGetNodebSuccess(t *testing.T) {
 208         ranName := "test"
 209         var rnibError error
 210         context := controllerGetNodebTestContext{
 211                 ranName:              ranName,
 212                 nodebInfo:            &entities.NodebInfo{RanName: ranName, Ip: "10.0.2.15", Port: 1234},
 213                 rnibError:            rnibError,
 214                 expectedStatusCode:   http.StatusOK,
 215                 expectedJsonResponse: fmt.Sprintf("{\"ranName\":\"%s\",\"ip\":\"10.0.2.15\",\"port\":1234}", ranName),
 216         }
 217
 218         controllerGetNodebTestExecuter(t, &context)
 219 }
 220
 221 func TestControllerGetNodebNotFound(t *testing.T) {
 222
 223         ranName := "test"
 224         var nodebInfo *entities.NodebInfo
 225         context := controllerGetNodebTestContext{
 226                 ranName:              ranName,
 227                 nodebInfo:            nodebInfo,
 228                 rnibError:            common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
 229                 expectedStatusCode:   http.StatusNotFound,
 230                 expectedJsonResponse: "{\"errorCode\":404,\"errorMessage\":\"Resource not found\"}",
 231         }
 232
 233         controllerGetNodebTestExecuter(t, &context)
 234 }
 235
 236 func TestControllerGetNodebInternal(t *testing.T) {
 237         ranName := "test"
 238         var nodebInfo *entities.NodebInfo
 239         context := controllerGetNodebTestContext{
 240                 ranName:              ranName,
 241                 nodebInfo:            nodebInfo,
 242                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 243                 expectedStatusCode:   http.StatusInternalServerError,
 244                 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
 245         }
 246
 247         controllerGetNodebTestExecuter(t, &context)
 248 }
 249
 250 func TestControllerGetNodebIdListSuccess(t *testing.T) {
 251         var rnibError error
 252         nodebIdList := []*entities.NbIdentity{
 253                 {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
 254                 {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
 255         }
 256
 257         context := controllerGetNodebIdListTestContext{
 258                 nodebIdList:          nodebIdList,
 259                 rnibError:            rnibError,
 260                 expectedStatusCode:   http.StatusOK,
 261                 expectedJsonResponse: "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}}]",
 262         }
 263
 264         controllerGetNodebIdListTestExecuter(t, &context)
 265 }
 266
 267 func TestControllerGetNodebIdListEmptySuccess(t *testing.T) {
 268         var rnibError error
 269         nodebIdList := []*entities.NbIdentity{}
 270
 271         context := controllerGetNodebIdListTestContext{
 272                 nodebIdList:          nodebIdList,
 273                 rnibError:            rnibError,
 274                 expectedStatusCode:   http.StatusOK,
 275                 expectedJsonResponse: "[]",
 276         }
 277
 278         controllerGetNodebIdListTestExecuter(t, &context)
 279 }
 280
 281 func TestControllerGetNodebIdListInternal(t *testing.T) {
 282         var nodebIdList []*entities.NbIdentity
 283         context := controllerGetNodebIdListTestContext{
 284                 nodebIdList:          nodebIdList,
 285                 rnibError:            common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
 286                 expectedStatusCode:   http.StatusInternalServerError,
 287                 expectedJsonResponse: "{\"errorCode\":500,\"errorMessage\":\"RNIB error\"}",
 288         }
 289
 290         controllerGetNodebIdListTestExecuter(t, &context)
 291 }
 292
 293 func TestHeaderValidationFailed(t *testing.T) {
 294         controller, _, _, _, _ := setupControllerTest(t)
 295
 296         writer := httptest.NewRecorder()
 297
 298         header := &http.Header{}
 299
 300         controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
 301
 302         var errorResponse = parseJsonRequest(t, writer.Body)
 303         err := e2managererrors.NewHeaderValidationError()
 304
 305         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 306         assert.Equal(t, errorResponse.Code, err.Code)
 307         assert.Equal(t, errorResponse.Message, err.Message)
 308 }
 309
 310 func TestShutdownStatusNoContent(t *testing.T) {
 311         controller, readerMock, _, _, _ := setupControllerTest(t)
 312
 313         var rnibError error
 314         nbIdentityList := []*entities.NbIdentity{}
 315         readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
 316
 317         writer := httptest.NewRecorder()
 318         controller.Shutdown(writer, tests.GetHttpRequest())
 319
 320         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 321 }
 322
 323 func TestHandleInternalError(t *testing.T) {
 324         controller, _, _, _, _ := setupControllerTest(t)
 325
 326         writer := httptest.NewRecorder()
 327         err := e2managererrors.NewInternalError()
 328
 329         controller.handleErrorResponse(err, writer)
 330         var errorResponse = parseJsonRequest(t, writer.Body)
 331
 332         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 333         assert.Equal(t, errorResponse.Code, err.Code)
 334         assert.Equal(t, errorResponse.Message, err.Message)
 335 }
 336
 337 func TestHandleCommandAlreadyInProgressError(t *testing.T) {
 338         controller, _, _, _, _ := setupControllerTest(t)
 339         writer := httptest.NewRecorder()
 340         err := e2managererrors.NewCommandAlreadyInProgressError()
 341
 342         controller.handleErrorResponse(err, writer)
 343         var errorResponse = parseJsonRequest(t, writer.Body)
 344
 345         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 346         assert.Equal(t, errorResponse.Code, err.Code)
 347         assert.Equal(t, errorResponse.Message, err.Message)
 348 }
 349
 350 func TestHandleE2TInstanceAbsenceError(t *testing.T) {
 351         controller, _, _, _, _ := setupControllerTest(t)
 352
 353         writer := httptest.NewRecorder()
 354         err := e2managererrors.NewE2TInstanceAbsenceError()
 355
 356         controller.handleErrorResponse(err, writer)
 357         var errorResponse = parseJsonRequest(t, writer.Body)
 358
 359         assert.Equal(t, http.StatusServiceUnavailable, writer.Result().StatusCode)
 360         assert.Equal(t, errorResponse.Code, err.Code)
 361         assert.Equal(t, errorResponse.Message, err.Message)
 362 }
 363
 364 func TestValidateHeaders(t *testing.T) {
 365         controller, _, _, _, _ := setupControllerTest(t)
 366
 367         header := http.Header{}
 368         header.Set("Content-Type", "application/json")
 369         result := controller.validateRequestHeader(&header)
 370
 371         assert.Nil(t, result)
 372 }
 373
 374 func parseJsonRequest(t *testing.T, r io.Reader) models.ErrorResponse {
 375
 376         var errorResponse models.ErrorResponse
 377         body, err := ioutil.ReadAll(r)
 378         if err != nil {
 379                 t.Errorf("Error cannot deserialize json request")
 380         }
 381         json.Unmarshal(body, &errorResponse)
 382
 383         return errorResponse
 384 }
 385
 386 func initLog(t *testing.T) *logger.Logger {
 387         log, err := logger.InitLogger(logger.InfoLevel)
 388         if err != nil {
 389                 t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
 390         }
 391         return log
 392 }
 393
 394 func TestX2ResetHandleSuccessfulRequestedCause(t *testing.T) {
 395         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
 396
 397         ranName := "test1"
 398         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
 399         var xAction []byte
 400         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
 401         rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
 402
 403         writer := httptest.NewRecorder()
 404
 405         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 406         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 407
 408         data4Req := map[string]interface{}{"cause": "protocol:transfer-syntax-error"}
 409         b := new(bytes.Buffer)
 410         _ = json.NewEncoder(b).Encode(data4Req)
 411         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 412         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 413
 414         controller.X2Reset(writer, req)
 415         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 416
 417 }
 418
 419 func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T) {
 420         controller, readerMock, _, rmrMessengerMock, _ := setupControllerTest(t)
 421
 422         ranName := "test1"
 423         // o&m intervention
 424         payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
 425         var xAction []byte
 426         msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
 427         rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
 428
 429         writer := httptest.NewRecorder()
 430
 431         var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
 432         readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
 433
 434         // no body
 435         b := new(bytes.Buffer)
 436         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 437         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 438
 439         controller.X2Reset(writer, req)
 440         assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
 441
 442 }
 443
 444 func TestX2ResetHandleFailureInvalidBody(t *testing.T) {
 445         controller, _, _, _ , _:= setupControllerTest(t)
 446
 447         ranName := "test1"
 448
 449         writer := httptest.NewRecorder()
 450
 451         // Invalid json: attribute name without quotes (should be "cause":).
 452         b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
 453         req, _ := http.NewRequest("PUT", "https://localhost:3800/nodeb-reset", b)
 454         req = mux.SetURLVars(req, map[string]string{"ranName": ranName})
 455
 456         controller.X2Reset(writer, req)
 457         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 458
 459 }
 460
 461 func TestHandleErrorResponse(t *testing.T) {
 462         controller, _, _, _ , _:= setupControllerTest(t)
 463
 464         writer := httptest.NewRecorder()
 465         controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
 466         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 467
 468         writer = httptest.NewRecorder()
 469         controller.handleErrorResponse(e2managererrors.NewCommandAlreadyInProgressError(), writer)
 470         assert.Equal(t, http.StatusMethodNotAllowed, writer.Result().StatusCode)
 471
 472         writer = httptest.NewRecorder()
 473         controller.handleErrorResponse(e2managererrors.NewHeaderValidationError(), writer)
 474         assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
 475
 476         writer = httptest.NewRecorder()
 477         controller.handleErrorResponse(e2managererrors.NewWrongStateError("", ""), writer)
 478         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 479
 480         writer = httptest.NewRecorder()
 481         controller.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
 482         assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
 483
 484         writer = httptest.NewRecorder()
 485         controller.handleErrorResponse(e2managererrors.NewRmrError(), writer)
 486         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 487
 488         writer = httptest.NewRecorder()
 489         controller.handleErrorResponse(e2managererrors.NewResourceNotFoundError(), writer)
 490         assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
 491
 492         writer = httptest.NewRecorder()
 493         controller.handleErrorResponse(fmt.Errorf("ErrorError"), writer)
 494         assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
 495 }
 496
 497 func getRmrSender(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *rmrsender.RmrSender {
 498         rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
 499         rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
 500         return rmrsender.NewRmrSender(log, rmrMessenger)
 501 }