catalog-be/src/test/java/org/openecomp/sdc/be/distribution/DistributionBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.distribution;
  22
  23 import org.apache.http.HttpStatus;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.mockito.InjectMocks;
  27 import org.mockito.Mockito;
  28 import org.mockito.MockitoAnnotations;
  29 import org.openecomp.sdc.be.components.BeConfDependentTest;
  30 import org.openecomp.sdc.be.components.distribution.engine.CambriaErrorResponse;
  31 import org.openecomp.sdc.be.components.distribution.engine.CambriaHandler;
  32 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngineInitTask;
  33 import org.openecomp.sdc.be.components.distribution.engine.SubscriberTypeEnum;
  34 import org.openecomp.sdc.be.config.DistributionEngineConfiguration;
  35 import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus;
  36 import org.openecomp.sdc.be.distribution.api.client.RegistrationRequest;
  37 import org.openecomp.sdc.be.distribution.api.client.TopicRegistrationResponse;
  38 import org.openecomp.sdc.be.distribution.api.client.TopicUnregistrationResponse;
  39 import org.openecomp.sdc.common.datastructure.Wrapper;
  40
  41 import javax.ws.rs.core.Response;
  42
  43 import static org.junit.Assert.assertEquals;
  44 import static org.junit.Assert.assertTrue;
  45 import static org.mockito.Mockito.verify;
  46 import static org.mockito.Mockito.when;
  47 import static org.openecomp.sdc.be.components.distribution.engine.DistributionEngineInitTask.buildTopicName;
  48
  49 public class DistributionBusinessLogicTest extends BeConfDependentTest {
  50
  51     @InjectMocks
  52     DistributionBusinessLogic distributionBusinessLogic = Mockito.spy(DistributionBusinessLogic.class);
  53
  54     CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class);
  55     AuditHandler auditHandler = Mockito.mock(AuditHandler.class);
  56
  57     CambriaErrorResponse errorResponse = new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR,
  58             HttpStatus.SC_SERVICE_UNAVAILABLE);
  59     CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
  60     DistributionEngineConfiguration config = configurationManager.getDistributionEngineConfiguration();
  61
  62     @Before
  63     public void init() {
  64         MockitoAnnotations.initMocks(this);
  65         Mockito.reset(cambriaHandler);
  66     }
  67
  68     @Test
  69     public void testHandleRegistrationNoConsumeStatusTopic() {
  70         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
  71         Wrapper<Response> responseWrapper = new Wrapper<>();
  72
  73         testHandleRegistrationBasic(registrationRequest, responseWrapper);
  74
  75         String expectedStatusTopicName = buildTopicName(
  76                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
  77                 registrationRequest.getDistrEnvName());
  78         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(responseWrapper,
  79                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
  80
  81     }
  82
  83     @Test
  84     public void testHandleRegistrationConsumeStatusTopic() {
  85         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
  86         Wrapper<Response> responseWrapper = new Wrapper<>();
  87
  88         testHandleRegistrationBasic(registrationRequest, responseWrapper);
  89
  90         String expectedStatusTopicName = buildTopicName(
  91                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
  92                 registrationRequest.getDistrEnvName());
  93         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
  94                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
  95     }
  96     /**
  97      * Registration Fails When registering as consumer to Notification With Consumer Status flag false.
  98      */
  99     @Test
 100     public void testHandleRegistrationFailedScenario() {
 101
 102         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 103         Wrapper<Response> responseWrapper = new Wrapper<>();
 104         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 105         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 106
 107         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 108                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 109                 expectedNotificationTopicName)).thenReturn(errorResponse);
 110         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 111         //Registered
 112         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 113                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 114                 expectedStatusTopicName);
 115         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 116                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 117                 expectedNotificationTopicName);
 118         //Did Not Register
 119         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 120                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 121                 expectedStatusTopicName);
 122         //Unregistered Activated (rollback)
 123         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 124                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 125                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 126
 127         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 128                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 129                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 130
 131     }
 132
 133     /**
 134      * Registration Fails When registering as consumer to Notification With Consumer Status flag true.
 135      */
 136     @Test
 137     public void testHandleRegistrationFailedConsumeStatusTopic() {
 138
 139         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 140         Wrapper<Response> responseWrapper = new Wrapper<>();
 141         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 142         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 143
 144         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 145                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 146                 expectedNotificationTopicName)).thenReturn(errorResponse);
 147         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 148
 149         //Registered
 150         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 151                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 152                 expectedStatusTopicName);
 153         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 154                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 155                 expectedNotificationTopicName);
 156         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 157                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 158                 expectedStatusTopicName);
 159         //Unregistered Activated (rollback)
 160         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 161                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 162                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 163         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 164                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 165                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 166         //Unregistered Not Activated
 167         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 168                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 169                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 170     }
 171
 172     /**
 173      * Registration Fails When registering as consumer to status With Consumer Status flag true.
 174      */
 175     @Test
 176     public void testHandleRegistrationFailedConsumeStatusTopic2() {
 177
 178         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 179         Wrapper<Response> responseWrapper = new Wrapper<>();
 180         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 181         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 182
 183         //Failing on new registration
 184         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 185                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 186                 expectedStatusTopicName)).thenReturn(errorResponse);
 187         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 188         //Registered
 189         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 190                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 191                 expectedStatusTopicName);
 192         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 193                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 194                 expectedStatusTopicName);
 195         //Did Not Register
 196         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 197                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 198                 expectedNotificationTopicName);
 199         //Unregistered Activated (rollback)
 200         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 201                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 202                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 203         //Unregistered Not Activated
 204         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 205                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 206                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 207         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 208                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 209                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 210
 211     }
 212
 213
 214     /**
 215      * Registration Fails When registering as PRODUCER to status With Consumer Status flag true.
 216      */
 217     @Test
 218     public void testHandleRegistrationFailedConsumeStatusTopic3() {
 219
 220         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 221         Wrapper<Response> responseWrapper = new Wrapper<>();
 222         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 223         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 224
 225         //Failing on new registration
 226         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 227                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 228                 expectedStatusTopicName)).thenReturn(errorResponse);
 229         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 230         //Registered
 231         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 232                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 233                 expectedStatusTopicName);
 234         //Did Not Register
 235         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 236                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 237                 expectedStatusTopicName);
 238         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 239                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 240                 expectedNotificationTopicName);
 241         //Unregistered Not Activated
 242         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 243                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 244                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 245         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 246                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 247                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 248         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 249                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 250                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 251
 252     }
 253
 254     @SuppressWarnings("unchecked")
 255     @Test
 256     public void testHandleUnRegistrationHappyScenario() {
 257         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 258
 259         Mockito.when(cambriaHandler.unRegisterFromTopic(Mockito.anyCollection(), Mockito.anyString(),
 260                 Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString()))
 261                 .thenReturn(okResponse);
 262
 263         Wrapper<Response> responseWrapper = new Wrapper<>();
 264         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 265         distributionBusinessLogic.handleUnRegistration(responseWrapper, registrationRequest, auditHandler);
 266
 267         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 268                 Mockito.eq(responseWrapper), Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.PRODUCER),
 269                 Mockito.anyString());
 270         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 271                 Mockito.eq(responseWrapper), Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.CONSUMER),
 272                 Mockito.anyString());
 273         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 274                 Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.PRODUCER), Mockito.anyString());
 275         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 276                 Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.CONSUMER), Mockito.anyString());
 277
 278         Mockito.verify(cambriaHandler, Mockito.times(2)).unRegisterFromTopic(Mockito.anyCollection(),
 279                 Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class),
 280                 Mockito.anyString());
 281
 282         assertTrue(!responseWrapper.isEmpty());
 283         Response response = responseWrapper.getInnerElement();
 284         assertTrue(response.getStatus() == HttpStatus.SC_OK);
 285
 286         TopicUnregistrationResponse okTopicUnregisterResponse = (TopicUnregistrationResponse) response.getEntity();
 287
 288         String expectedStatusTopicName = DistributionEngineInitTask.buildTopicName(
 289                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 290                 registrationRequest.getDistrEnvName());
 291         String actualStatusTopicName = okTopicUnregisterResponse.getDistrStatusTopicName();
 292         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 293
 294         String expectedNotificationTopicName = DistributionEngineInitTask.buildTopicName(
 295                 configurationManager.getDistributionEngineConfiguration().getDistributionNotifTopicName(),
 296                 registrationRequest.getDistrEnvName());
 297         String actualNotificationTopicName = okTopicUnregisterResponse.getDistrNotificationTopicName();
 298         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 299
 300         assertEquals(okTopicUnregisterResponse.getNotificationUnregisterResult(), CambriaOperationStatus.OK);
 301         assertEquals(okTopicUnregisterResponse.getStatusUnregisterResult(), CambriaOperationStatus.OK);
 302
 303     }
 304
 305     @Test
 306     public void testHandleUnRegistrationFailedScenario() {
 307         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 308         CambriaErrorResponse errorResponse = new CambriaErrorResponse(CambriaOperationStatus.AUTHENTICATION_ERROR,
 309                 HttpStatus.SC_INTERNAL_SERVER_ERROR);
 310
 311         Wrapper<Response> responseWrapper = new Wrapper<>();
 312         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 313         DistributionEngineConfiguration config = configurationManager.getDistributionEngineConfiguration();
 314         String expectedStatusTopicName = DistributionEngineInitTask
 315                 .buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 316         String expectedNotificationTopicName = DistributionEngineInitTask
 317                 .buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 318         Mockito.when(cambriaHandler.unRegisterFromTopic(config.getUebServers(), config.getUebPublicKey(),
 319                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 320                 expectedStatusTopicName)).thenReturn(okResponse);
 321         Mockito.when(cambriaHandler.unRegisterFromTopic(config.getUebServers(), config.getUebPublicKey(),
 322                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 323                 expectedNotificationTopicName)).thenReturn(errorResponse);
 324
 325         distributionBusinessLogic.handleUnRegistration(responseWrapper, registrationRequest, auditHandler);
 326
 327         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 328                 Mockito.eq(responseWrapper), Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.PRODUCER),
 329                 Mockito.anyString());
 330         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 331                 Mockito.eq(responseWrapper), Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.CONSUMER),
 332                 Mockito.anyString());
 333         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 334                 Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.PRODUCER), Mockito.anyString());
 335         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 336                 Mockito.eq(registrationRequest), Mockito.eq(SubscriberTypeEnum.CONSUMER), Mockito.anyString());
 337
 338         assertTrue(!responseWrapper.isEmpty());
 339         Response response = responseWrapper.getInnerElement();
 340         assertTrue(response.getStatus() == HttpStatus.SC_INTERNAL_SERVER_ERROR);
 341
 342         TopicUnregistrationResponse okTopicUnregisterResponse = (TopicUnregistrationResponse) response.getEntity();
 343
 344         String actualStatusTopicName = okTopicUnregisterResponse.getDistrStatusTopicName();
 345         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 346
 347         String actualNotificationTopicName = okTopicUnregisterResponse.getDistrNotificationTopicName();
 348         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 349
 350         assertEquals(okTopicUnregisterResponse.getNotificationUnregisterResult(),
 351                 CambriaOperationStatus.AUTHENTICATION_ERROR);
 352         assertEquals(okTopicUnregisterResponse.getStatusUnregisterResult(), CambriaOperationStatus.OK);
 353
 354     }
 355
 356     @SuppressWarnings("unchecked")
 357     private void testHandleRegistrationBasic(RegistrationRequest registrationRequest,
 358             Wrapper<Response> responseWrapper) {
 359         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 360         Mockito.when(cambriaHandler.registerToTopic(Mockito.anyCollection(), Mockito.anyString(), Mockito.anyString(),
 361                 Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString()))
 362                 .thenReturn(okResponse);
 363
 364         String expectedStatusTopicName = buildTopicName(
 365                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 366                 registrationRequest.getDistrEnvName());
 367         String expectedNotificationTopicName = buildTopicName(
 368                 configurationManager.getDistributionEngineConfiguration().getDistributionNotifTopicName(),
 369                 registrationRequest.getDistrEnvName());
 370
 371         distributionBusinessLogic.handleRegistration(responseWrapper, registrationRequest, auditHandler);
 372
 373         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
 374                 registrationRequest, SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 375         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
 376                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 377
 378         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(Mockito.anyCollection(), Mockito.anyString(),
 379                 Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString());
 380
 381         assertTrue(!responseWrapper.isEmpty());
 382         Response response = responseWrapper.getInnerElement();
 383         assertTrue(response.getStatus() == HttpStatus.SC_OK);
 384
 385         TopicRegistrationResponse okTopicResponse = (TopicRegistrationResponse) response.getEntity();
 386
 387         String actualStatusTopicName = okTopicResponse.getDistrStatusTopicName();
 388         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 389
 390         String actualNotificationTopicName = okTopicResponse.getDistrNotificationTopicName();
 391         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 392     }
 393
 394     private void testHandleRegistrationFailed(RegistrationRequest registrationRequest,
 395             Wrapper<Response> responseWrapper, Runnable failWhen) {
 396         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 397
 398
 399
 400
 401
 402         when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 403                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 404                 expectedStatusTopicName)).thenReturn(okResponse);
 405
 406         when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 407                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 408                 expectedStatusTopicName)).thenReturn(okResponse);
 409
 410         failWhen.run();
 411
 412         distributionBusinessLogic.handleRegistration(responseWrapper, registrationRequest, auditHandler);
 413
 414         assertTrue(!responseWrapper.isEmpty());
 415         Response response = responseWrapper.getInnerElement();
 416         assertTrue(response.getStatus() == HttpStatus.SC_INTERNAL_SERVER_ERROR);
 417
 418
 419
 420     }
 421 }