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.DistributionEngine;
  33 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngineInitTask;
  34 import org.openecomp.sdc.be.components.distribution.engine.SubscriberTypeEnum;
  35 import org.openecomp.sdc.be.config.DistributionEngineConfiguration;
  36 import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus;
  37 import org.openecomp.sdc.be.distribution.api.client.RegistrationRequest;
  38 import org.openecomp.sdc.be.distribution.api.client.TopicRegistrationResponse;
  39 import org.openecomp.sdc.be.distribution.api.client.TopicUnregistrationResponse;
  40 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  41 import org.openecomp.sdc.common.datastructure.Wrapper;
  42
  43 import javax.ws.rs.core.Response;
  44 import java.util.Arrays;
  45 import java.util.List;
  46
  47 import static org.junit.Assert.assertEquals;
  48 import static org.junit.Assert.assertTrue;
  49 import static org.mockito.ArgumentMatchers.eq;
  50 import static org.mockito.Mockito.verify;
  51 import static org.mockito.Mockito.when;
  52 import static org.openecomp.sdc.be.components.distribution.engine.DistributionEngineInitTask.buildTopicName;
  53
  54 public class DistributionBusinessLogicTest extends BeConfDependentTest {
  55
  56     @InjectMocks
  57     DistributionBusinessLogic distributionBusinessLogic = Mockito.spy(DistributionBusinessLogic.class);
  58
  59     private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class);
  60     private AuditHandler auditHandler = Mockito.mock(AuditHandler.class);
  61     private DistributionEngine distributionEngine = Mockito.mock(DistributionEngine.class);
  62
  63     private CambriaErrorResponse errorResponse = new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR,
  64             HttpStatus.SC_SERVICE_UNAVAILABLE);
  65     private CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
  66     private DistributionEngineConfiguration config = configurationManager.getDistributionEngineConfiguration();
  67
  68     @Before
  69     public void init() {
  70         MockitoAnnotations.openMocks(this);
  71         Mockito.reset(cambriaHandler);
  72     }
  73
  74     @Test
  75     public void testHandleRegistrationOnTenant() {
  76         List<String> uebs = Arrays.asList("11","22");
  77         OperationalEnvironmentEntry environment = new OperationalEnvironmentEntry();
  78         environment.setEnvironmentId("1");
  79         environment.setUebApikey("11");
  80         environment.setUebSecretKey("22");
  81         RegistrationRequest registrationRequest =
  82                 new RegistrationRequest("myPublicKey", "myEnv",uebs ,false);
  83         Wrapper<Response> responseWrapper = new Wrapper<>();
  84         when(distributionEngine.getEnvironmentByDmaapUebAddress(uebs))
  85                 .thenReturn(environment);
  86         testHandleRegistrationBasic(registrationRequest, responseWrapper);
  87     }
  88
  89     @Test
  90     public void handleUnregistrationOnTenant() {
  91         List<String> uebs = Arrays.asList("11","22");
  92         OperationalEnvironmentEntry environment = new OperationalEnvironmentEntry();
  93         environment.setEnvironmentId("1");
  94         environment.setUebApikey("11");
  95         environment.setUebSecretKey("22");
  96         RegistrationRequest registrationRequest =
  97                 new RegistrationRequest("myPublicKey", "myEnv",uebs ,false);
  98         Wrapper<Response> responseWrapper = new Wrapper<>();
  99         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 100
 101         when(cambriaHandler.unRegisterFromTopic(Mockito.anyCollection(), eq("11"),
 102                 eq("22"), eq("myPublicKey"), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString()))
 103                 .thenReturn(okResponse);
 104         when(distributionEngine.getEnvironmentByDmaapUebAddress(uebs))
 105                 .thenReturn(environment);
 106
 107         distributionBusinessLogic.handleUnRegistration(responseWrapper, registrationRequest, auditHandler);
 108
 109         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 110                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER),
 111                 Mockito.anyString());
 112         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 113                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER),
 114                 Mockito.anyString());
 115         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 116                 eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER), Mockito.anyString());
 117         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 118                 eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER), Mockito.anyString());
 119
 120         Mockito.verify(cambriaHandler, Mockito.times(2)).unRegisterFromTopic(Mockito.anyCollection(),
 121                 Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class),
 122                 Mockito.anyString());
 123
 124         assertTrue(!responseWrapper.isEmpty());
 125         Response response = responseWrapper.getInnerElement();
 126         assertEquals(response.getStatus(), HttpStatus.SC_OK);
 127
 128         TopicUnregistrationResponse okTopicUnregisterResponse = (TopicUnregistrationResponse) response.getEntity();
 129
 130         String expectedStatusTopicName = DistributionEngineInitTask.buildTopicName(
 131                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 132                 registrationRequest.getDistrEnvName());
 133         String actualStatusTopicName = okTopicUnregisterResponse.getDistrStatusTopicName();
 134         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 135
 136         String expectedNotificationTopicName = DistributionEngineInitTask.buildTopicName(
 137                 configurationManager.getDistributionEngineConfiguration().getDistributionNotifTopicName(),
 138                 registrationRequest.getDistrEnvName());
 139         String actualNotificationTopicName = okTopicUnregisterResponse.getDistrNotificationTopicName();
 140         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 141
 142         assertEquals(okTopicUnregisterResponse.getNotificationUnregisterResult(), CambriaOperationStatus.OK);
 143         assertEquals(okTopicUnregisterResponse.getStatusUnregisterResult(), CambriaOperationStatus.OK);
 144     }
 145
 146     @Test
 147     public void testHandleRegistrationNoConsumeStatusTopic() {
 148         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 149         Wrapper<Response> responseWrapper = new Wrapper<>();
 150
 151         testHandleRegistrationBasic(registrationRequest, responseWrapper);
 152
 153         String expectedStatusTopicName = buildTopicName(
 154                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 155                 registrationRequest.getDistrEnvName());
 156         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(responseWrapper,
 157                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 158
 159     }
 160
 161     @Test
 162     public void testHandleRegistrationConsumeStatusTopic() {
 163         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 164         Wrapper<Response> responseWrapper = new Wrapper<>();
 165
 166         testHandleRegistrationBasic(registrationRequest, responseWrapper);
 167
 168         String expectedStatusTopicName = buildTopicName(
 169                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 170                 registrationRequest.getDistrEnvName());
 171         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
 172                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 173     }
 174     /**
 175      * Registration Fails When registering as consumer to Notification With Consumer Status flag false.
 176      */
 177     @Test
 178     public void testHandleRegistrationFailedScenario() {
 179
 180         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 181         Wrapper<Response> responseWrapper = new Wrapper<>();
 182         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 183         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 184
 185         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 186                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 187                 expectedNotificationTopicName)).thenReturn(errorResponse);
 188         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 189         //Registered
 190         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 191                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 192                 expectedStatusTopicName);
 193         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 194                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 195                 expectedNotificationTopicName);
 196         //Did Not Register
 197         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 198                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 199                 expectedStatusTopicName);
 200         //Unregistered Activated (rollback)
 201         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 202                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 203                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 204
 205         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 206                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 207                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 208
 209     }
 210
 211     /**
 212      * Registration Fails When registering as consumer to Notification With Consumer Status flag true.
 213      */
 214     @Test
 215     public void testHandleRegistrationFailedConsumeStatusTopic() {
 216
 217         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 218         Wrapper<Response> responseWrapper = new Wrapper<>();
 219         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 220         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 221
 222         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 223                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 224                 expectedNotificationTopicName)).thenReturn(errorResponse);
 225         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 226
 227         //Registered
 228         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 229                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 230                 expectedStatusTopicName);
 231         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 232                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 233                 expectedNotificationTopicName);
 234         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 235                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 236                 expectedStatusTopicName);
 237         //Unregistered Activated (rollback)
 238         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 239                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 240                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 241         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 242                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 243                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 244         //Unregistered Not Activated
 245         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 246                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 247                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 248     }
 249
 250     /**
 251      * Registration Fails When registering as consumer to status With Consumer Status flag true.
 252      */
 253     @Test
 254     public void testHandleRegistrationFailedConsumeStatusTopic2() {
 255
 256         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 257         Wrapper<Response> responseWrapper = new Wrapper<>();
 258         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 259         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 260
 261         //Failing on new registration
 262         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 263                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 264                 expectedStatusTopicName)).thenReturn(errorResponse);
 265         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 266         //Registered
 267         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 268                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 269                 expectedStatusTopicName);
 270         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 271                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 272                 expectedStatusTopicName);
 273         //Did Not Register
 274         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 275                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 276                 expectedNotificationTopicName);
 277         //Unregistered Activated (rollback)
 278         verify(cambriaHandler, Mockito.times(1)).unRegisterFromTopic(config.getUebServers(),
 279                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 280                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 281         //Unregistered Not Activated
 282         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 283                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 284                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 285         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 286                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 287                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 288
 289     }
 290
 291
 292     /**
 293      * Registration Fails When registering as PRODUCER to status With Consumer Status flag true.
 294      */
 295     @Test
 296     public void testHandleRegistrationFailedConsumeStatusTopic3() {
 297
 298         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", true);
 299         Wrapper<Response> responseWrapper = new Wrapper<>();
 300         String expectedNotificationTopicName = buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 301         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 302
 303         //Failing on new registration
 304         Runnable failWhen = () -> when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 305                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 306                 expectedStatusTopicName)).thenReturn(errorResponse);
 307         testHandleRegistrationFailed(registrationRequest, responseWrapper, failWhen);
 308         //Registered
 309         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(
 310                 responseWrapper,registrationRequest, SubscriberTypeEnum.PRODUCER,
 311                 expectedStatusTopicName);
 312         //Did Not Register
 313         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 314                 responseWrapper,registrationRequest, SubscriberTypeEnum.CONSUMER,
 315                 expectedStatusTopicName);
 316         verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 317                 responseWrapper, registrationRequest,SubscriberTypeEnum.CONSUMER,
 318                 expectedNotificationTopicName);
 319         //Unregistered Not Activated
 320         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 321                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 322                 SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 323         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 324                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 325                 SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 326         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(config.getUebServers(),
 327                 config.getUebPublicKey(), config.getUebSecretKey(), registrationRequest.getApiPublicKey(),
 328                 SubscriberTypeEnum.CONSUMER, expectedStatusTopicName);
 329
 330     }
 331
 332     @SuppressWarnings("unchecked")
 333     @Test
 334     public void testHandleUnRegistrationHappyScenario() {
 335         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 336
 337         when(cambriaHandler.unRegisterFromTopic(Mockito.anyCollection(), Mockito.anyString(),
 338                 Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString()))
 339                 .thenReturn(okResponse);
 340
 341         Wrapper<Response> responseWrapper = new Wrapper<>();
 342         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 343         distributionBusinessLogic.handleUnRegistration(responseWrapper, registrationRequest, auditHandler);
 344
 345         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 346                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER),
 347                 Mockito.anyString());
 348         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 349                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER),
 350                 Mockito.anyString());
 351         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 352                 eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER), Mockito.anyString());
 353         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 354                 eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER), Mockito.anyString());
 355
 356         Mockito.verify(cambriaHandler, Mockito.times(2)).unRegisterFromTopic(Mockito.anyCollection(),
 357                 Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class),
 358                 Mockito.anyString());
 359
 360         assertTrue(!responseWrapper.isEmpty());
 361         Response response = responseWrapper.getInnerElement();
 362         assertEquals(response.getStatus(), HttpStatus.SC_OK);
 363
 364         TopicUnregistrationResponse okTopicUnregisterResponse = (TopicUnregistrationResponse) response.getEntity();
 365
 366         String expectedStatusTopicName = DistributionEngineInitTask.buildTopicName(
 367                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 368                 registrationRequest.getDistrEnvName());
 369         String actualStatusTopicName = okTopicUnregisterResponse.getDistrStatusTopicName();
 370         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 371
 372         String expectedNotificationTopicName = DistributionEngineInitTask.buildTopicName(
 373                 configurationManager.getDistributionEngineConfiguration().getDistributionNotifTopicName(),
 374                 registrationRequest.getDistrEnvName());
 375         String actualNotificationTopicName = okTopicUnregisterResponse.getDistrNotificationTopicName();
 376         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 377
 378         assertEquals(okTopicUnregisterResponse.getNotificationUnregisterResult(), CambriaOperationStatus.OK);
 379         assertEquals(okTopicUnregisterResponse.getStatusUnregisterResult(), CambriaOperationStatus.OK);
 380
 381     }
 382
 383     @Test
 384     public void testHandleUnRegistrationFailedScenario() {
 385         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 386         CambriaErrorResponse errorResponse = new CambriaErrorResponse(CambriaOperationStatus.AUTHENTICATION_ERROR,
 387                 HttpStatus.SC_INTERNAL_SERVER_ERROR);
 388
 389         Wrapper<Response> responseWrapper = new Wrapper<>();
 390         RegistrationRequest registrationRequest = new RegistrationRequest("myPublicKey", "myEnv", false);
 391         DistributionEngineConfiguration config = configurationManager.getDistributionEngineConfiguration();
 392         String expectedStatusTopicName = DistributionEngineInitTask
 393                 .buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 394         String expectedNotificationTopicName = DistributionEngineInitTask
 395                 .buildTopicName(config.getDistributionNotifTopicName(), registrationRequest.getDistrEnvName());
 396         when(cambriaHandler.unRegisterFromTopic(config.getUebServers(), config.getUebPublicKey(),
 397                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 398                 expectedStatusTopicName)).thenReturn(okResponse);
 399         when(cambriaHandler.unRegisterFromTopic(config.getUebServers(), config.getUebPublicKey(),
 400                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 401                 expectedNotificationTopicName)).thenReturn(errorResponse);
 402
 403         distributionBusinessLogic.handleUnRegistration(responseWrapper, registrationRequest, auditHandler);
 404
 405         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 406                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER),
 407                 Mockito.anyString());
 408         Mockito.verify(distributionBusinessLogic, Mockito.times(0)).registerDistributionClientToTopic(
 409                 eq(responseWrapper), eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER),
 410                 Mockito.anyString());
 411         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 412                 eq(registrationRequest), eq(SubscriberTypeEnum.PRODUCER), Mockito.anyString());
 413         Mockito.verify(distributionBusinessLogic, Mockito.times(1)).unRegisterDistributionClientFromTopic(
 414                 eq(registrationRequest), eq(SubscriberTypeEnum.CONSUMER), Mockito.anyString());
 415
 416         assertTrue(!responseWrapper.isEmpty());
 417         Response response = responseWrapper.getInnerElement();
 418         assertEquals(response.getStatus(), HttpStatus.SC_INTERNAL_SERVER_ERROR);
 419
 420         TopicUnregistrationResponse okTopicUnregisterResponse = (TopicUnregistrationResponse) response.getEntity();
 421
 422         String actualStatusTopicName = okTopicUnregisterResponse.getDistrStatusTopicName();
 423         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 424
 425         String actualNotificationTopicName = okTopicUnregisterResponse.getDistrNotificationTopicName();
 426         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 427
 428         assertEquals(okTopicUnregisterResponse.getNotificationUnregisterResult(),
 429                 CambriaOperationStatus.AUTHENTICATION_ERROR);
 430         assertEquals(okTopicUnregisterResponse.getStatusUnregisterResult(), CambriaOperationStatus.OK);
 431
 432     }
 433
 434     @SuppressWarnings("unchecked")
 435     private void testHandleRegistrationBasic(RegistrationRequest registrationRequest,
 436             Wrapper<Response> responseWrapper) {
 437         CambriaErrorResponse okResponse = new CambriaErrorResponse(CambriaOperationStatus.OK, HttpStatus.SC_OK);
 438         when(cambriaHandler.registerToTopic(Mockito.anyCollection(), Mockito.anyString(), Mockito.anyString(),
 439                 Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString()))
 440                 .thenReturn(okResponse);
 441
 442         String expectedStatusTopicName = buildTopicName(
 443                 configurationManager.getDistributionEngineConfiguration().getDistributionStatusTopicName(),
 444                 registrationRequest.getDistrEnvName());
 445         String expectedNotificationTopicName = buildTopicName(
 446                 configurationManager.getDistributionEngineConfiguration().getDistributionNotifTopicName(),
 447                 registrationRequest.getDistrEnvName());
 448
 449         distributionBusinessLogic.handleRegistration(responseWrapper, registrationRequest, auditHandler);
 450
 451         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
 452                 registrationRequest, SubscriberTypeEnum.PRODUCER, expectedStatusTopicName);
 453         verify(distributionBusinessLogic, Mockito.times(1)).registerDistributionClientToTopic(responseWrapper,
 454                 registrationRequest, SubscriberTypeEnum.CONSUMER, expectedNotificationTopicName);
 455
 456         verify(cambriaHandler, Mockito.times(0)).unRegisterFromTopic(Mockito.anyCollection(), Mockito.anyString(),
 457                 Mockito.anyString(), Mockito.anyString(), Mockito.any(SubscriberTypeEnum.class), Mockito.anyString());
 458
 459         assertTrue(!responseWrapper.isEmpty());
 460         Response response = responseWrapper.getInnerElement();
 461         assertEquals(response.getStatus(), HttpStatus.SC_OK);
 462
 463         TopicRegistrationResponse okTopicResponse = (TopicRegistrationResponse) response.getEntity();
 464
 465         String actualStatusTopicName = okTopicResponse.getDistrStatusTopicName();
 466         assertEquals(expectedStatusTopicName, actualStatusTopicName);
 467
 468         String actualNotificationTopicName = okTopicResponse.getDistrNotificationTopicName();
 469         assertEquals(expectedNotificationTopicName, actualNotificationTopicName);
 470     }
 471
 472     private void testHandleRegistrationFailed(RegistrationRequest registrationRequest,
 473             Wrapper<Response> responseWrapper, Runnable failWhen) {
 474         String expectedStatusTopicName = buildTopicName(config.getDistributionStatusTopicName(), registrationRequest.getDistrEnvName());
 475
 476
 477
 478
 479
 480         when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 481                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.CONSUMER,
 482                 expectedStatusTopicName)).thenReturn(okResponse);
 483
 484         when(cambriaHandler.registerToTopic(config.getUebServers(), config.getUebPublicKey(),
 485                 config.getUebSecretKey(), registrationRequest.getApiPublicKey(), SubscriberTypeEnum.PRODUCER,
 486                 expectedStatusTopicName)).thenReturn(okResponse);
 487
 488         failWhen.run();
 489
 490         distributionBusinessLogic.handleRegistration(responseWrapper, registrationRequest, auditHandler);
 491
 492         assertTrue(!responseWrapper.isEmpty());
 493         Response response = responseWrapper.getInnerElement();
 494         assertEquals(response.getStatus(), HttpStatus.SC_INTERNAL_SERVER_ERROR);
 495
 496
 497
 498     }
 499 }