catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/DistributionEngineInitTaskTest.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.components.distribution.engine;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.Mockito.when;
  27
  28 import java.io.File;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.HashSet;
  32 import java.util.List;
  33 import java.util.Set;
  34 import java.util.concurrent.atomic.AtomicBoolean;
  35
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.openecomp.sdc.be.components.distribution.engine.CambriaErrorResponse;
  41 import org.openecomp.sdc.be.components.distribution.engine.CambriaHandler;
  42 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngineInitTask;
  43 import org.openecomp.sdc.be.components.distribution.engine.SubscriberTypeEnum;
  44 import org.openecomp.sdc.be.config.ConfigurationManager;
  45 import org.openecomp.sdc.be.config.DistributionEngineConfiguration;
  46 import org.openecomp.sdc.be.config.DistributionEngineConfiguration.CreateTopicConfig;
  47 import org.openecomp.sdc.be.distribution.api.client.CambriaOperationStatus;
  48 import org.openecomp.sdc.be.impl.ComponentsUtils;
  49 import org.openecomp.sdc.common.api.ConfigurationSource;
  50 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  51 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  52
  53 import fj.data.Either;
  54
  55 public class DistributionEngineInitTaskTest {
  56
  57         @Mock
  58         private ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
  59
  60         @Mock
  61         private CambriaHandler cambriaHandler = Mockito.mock(CambriaHandler.class);
  62
  63         // public static final IAuditingDao iAuditingDao =
  64         // Mockito.mock(AuditingDao.class);
  65
  66         @Before
  67         public void setup() {
  68                 // ExternalConfiguration.setAppName("distribEngine1");
  69                 ExternalConfiguration.setAppName("catalog-be");
  70                 ExternalConfiguration.setConfigDir("src/test/resources/config");
  71                 ExternalConfiguration.listenForChanges();
  72
  73                 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), ExternalConfiguration.getConfigDir() + File.separator + ExternalConfiguration.getAppName());
  74
  75                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  76         }
  77
  78         @Test
  79         public void checkIncrement() {
  80
  81                 String envName = "PrOD";
  82
  83                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
  84                 int retry = 2;
  85                 int maxRetry = 40;
  86                 deConfiguration.setInitRetryIntervalSec(retry);
  87                 deConfiguration.setInitMaxIntervalSec(maxRetry);
  88                 DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null);
  89
  90                 for (int i = 1; i < 5; i++) {
  91                         initTask.incrementRetryInterval();
  92                         assertEquals("check next retry interval", initTask.getCurrentRetryInterval(), retry * (long) Math.pow(2, i));
  93                 }
  94
  95                 initTask.incrementRetryInterval();
  96                 assertEquals("check next retry interval reach max retry interval", initTask.getCurrentRetryInterval(), maxRetry);
  97
  98         }
  99
 100         @Test
 101         public void testInitFlowScenarioSuccess() {
 102
 103                 String notifTopic = "notif";
 104                 String statusTopic = "status";
 105
 106                 List<String> uebServers = new ArrayList<>();
 107                 uebServers.add("server1");
 108                 CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND);
 109                 Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse);
 110                 when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right);
 111
 112                 String envName = "PrOD";
 113
 114                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 115                 deConfiguration.setUebServers(uebServers);
 116                 int retry = 2;
 117                 int maxRetry = 40;
 118                 deConfiguration.setInitRetryIntervalSec(retry);
 119                 deConfiguration.setInitMaxIntervalSec(maxRetry);
 120                 deConfiguration.setDistributionNotifTopicName(notifTopic);
 121                 deConfiguration.setDistributionStatusTopicName(statusTopic);
 122                 CreateTopicConfig createTopic = new CreateTopicConfig();
 123                 createTopic.setPartitionCount(1);
 124                 createTopic.setReplicationCount(1);
 125                 deConfiguration.setCreateTopic(createTopic);
 126
 127                 cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK);
 128
 129                 String realNotifTopic = notifTopic + "-" + envName.toUpperCase();
 130                 String realStatusTopic = statusTopic + "-" + envName.toUpperCase();
 131                 when(cambriaHandler.createTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse);
 132                 when(cambriaHandler.createTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse);
 133
 134                 cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK);
 135                 when(cambriaHandler.registerToTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(SubscriberTypeEnum.class)))
 136                                 .thenReturn(cambriaErrorResponse);
 137
 138                 DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null);
 139                 initTask.setCambriaHandler(cambriaHandler);
 140
 141                 boolean initFlow = initTask.initFlow();
 142                 assertTrue("check init flow succeed", initFlow);
 143
 144         }
 145
 146         @Test
 147         public void testInitFlowScenarioSuccessTopicsAlreadyExists() {
 148
 149                 String envName = "PrOD";
 150                 String notifTopic = "notif";
 151                 String statusTopic = "status";
 152
 153                 String realNotifTopic = notifTopic + "-" + envName.toUpperCase();
 154                 String realStatusTopic = statusTopic + "-" + envName.toUpperCase();
 155
 156                 Set<String> topics = new HashSet<String>();
 157                 topics.add(realNotifTopic);
 158                 topics.add(realStatusTopic);
 159
 160                 List<String> uebServers = new ArrayList<>();
 161                 uebServers.add("server1");
 162                 CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND);
 163                 Either<Set<String>, CambriaErrorResponse> left = Either.left(topics);
 164
 165                 when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(left);
 166
 167                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 168                 deConfiguration.setUebServers(uebServers);
 169                 int retry = 2;
 170                 int maxRetry = 40;
 171                 deConfiguration.setInitRetryIntervalSec(retry);
 172                 deConfiguration.setInitMaxIntervalSec(maxRetry);
 173                 deConfiguration.setDistributionNotifTopicName(notifTopic);
 174                 deConfiguration.setDistributionStatusTopicName(statusTopic);
 175                 CreateTopicConfig createTopic = new CreateTopicConfig();
 176                 createTopic.setPartitionCount(1);
 177                 createTopic.setReplicationCount(1);
 178                 deConfiguration.setCreateTopic(createTopic);
 179
 180                 cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK);
 181                 when(cambriaHandler.registerToTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(SubscriberTypeEnum.class)))
 182                                 .thenReturn(cambriaErrorResponse);
 183
 184                 DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null);
 185                 initTask.setCambriaHandler(cambriaHandler);
 186
 187                 try {
 188                         boolean initFlow = initTask.initFlow();
 189                         assertTrue("check init flow succeed", initFlow);
 190                 } catch (Exception e) {
 191                         assertTrue("Should not throw exception", false);
 192                 }
 193
 194         }
 195
 196         @Test
 197         public void testInitFlowScenarioFailToRegister() {
 198
 199                 String notifTopic = "notif";
 200                 String statusTopic = "status";
 201
 202                 List<String> uebServers = new ArrayList<>();
 203                 uebServers.add("server1");
 204                 CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.NOT_FOUND);
 205                 Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse);
 206                 when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right);
 207
 208                 String envName = "PrOD";
 209
 210                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 211                 deConfiguration.setUebServers(uebServers);
 212                 int retry = 2;
 213                 int maxRetry = 40;
 214                 deConfiguration.setInitRetryIntervalSec(retry);
 215                 deConfiguration.setInitMaxIntervalSec(maxRetry);
 216                 deConfiguration.setDistributionNotifTopicName(notifTopic);
 217                 deConfiguration.setDistributionStatusTopicName(statusTopic);
 218                 CreateTopicConfig createTopic = new CreateTopicConfig();
 219                 createTopic.setPartitionCount(1);
 220                 createTopic.setReplicationCount(1);
 221                 deConfiguration.setCreateTopic(createTopic);
 222
 223                 cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.OK);
 224
 225                 String realNotifTopic = notifTopic + "-" + envName.toUpperCase();
 226                 String realStatusTopic = statusTopic + "-" + envName.toUpperCase();
 227                 when(cambriaHandler.createTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(realNotifTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse);
 228                 when(cambriaHandler.createTopic(Mockito.any(Collection.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(realStatusTopic), Mockito.eq(1), Mockito.eq(1))).thenReturn(cambriaErrorResponse);
 229
 230                 when(cambriaHandler.registerToTopic(Mockito.any(Collection.class), Mockito.eq(realNotifTopic), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(SubscriberTypeEnum.class)))
 231                                 .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.OK));
 232
 233                 when(cambriaHandler.registerToTopic(Mockito.any(Collection.class), Mockito.eq(realStatusTopic), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(String.class), Mockito.any(SubscriberTypeEnum.class)))
 234                                 .thenReturn(new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR));
 235
 236                 DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null);
 237                 initTask.setCambriaHandler(cambriaHandler);
 238
 239                 boolean initFlow = initTask.initFlow();
 240                 assertFalse("check init flow failed", initFlow);
 241
 242         }
 243
 244         @Test
 245         public void testInitFlowScenario1GetTopicsFailed() {
 246
 247                 List<String> uebServers = new ArrayList<>();
 248                 uebServers.add("server1");
 249                 CambriaErrorResponse cambriaErrorResponse = new CambriaErrorResponse(CambriaOperationStatus.CONNNECTION_ERROR);
 250                 Either<Set<String>, CambriaErrorResponse> right = Either.right(cambriaErrorResponse);
 251                 when(cambriaHandler.getTopics(Mockito.any(List.class))).thenReturn(right);
 252
 253                 String envName = "PrOD";
 254
 255                 DistributionEngineConfiguration deConfiguration = new DistributionEngineConfiguration();
 256                 deConfiguration.setUebServers(uebServers);
 257                 int retry = 2;
 258                 int maxRetry = 40;
 259                 deConfiguration.setInitRetryIntervalSec(retry);
 260                 deConfiguration.setInitMaxIntervalSec(maxRetry);
 261                 DistributionEngineInitTask initTask = new DistributionEngineInitTask(0l, deConfiguration, envName, new AtomicBoolean(false), componentsUtils, null);
 262                 initTask.setCambriaHandler(cambriaHandler);
 263
 264                 boolean initFlow = initTask.initFlow();
 265                 assertFalse("check init flow failed", initFlow);
 266
 267         }
 268
 269 }