catalog-be/src/test/java/org/openecomp/sdc/be/components/health/HealthCheckBusinessLogicHealthTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2020 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.health;
  22
  23 import mockit.Deencapsulation;
  24 import org.junit.Assert;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.junit.MockitoJUnitRunner;
  29 import org.onap.portalsdk.core.onboarding.exception.CipherUtilException;
  30 import org.openecomp.sdc.be.catalog.impl.DmaapProducerHealth;
  31 import org.openecomp.sdc.be.components.BeConfDependentTest;
  32 import org.openecomp.sdc.be.components.distribution.engine.DistributionEngineClusterHealth;
  33 import org.openecomp.sdc.be.components.distribution.engine.DmaapHealth;
  34 import org.openecomp.sdc.be.switchover.detector.SwitchoverDetector;
  35 import org.openecomp.sdc.common.api.HealthCheckInfo;
  36 import org.openecomp.sdc.common.http.client.api.HttpExecuteException;
  37 import org.springframework.test.util.ReflectionTestUtils;
  38
  39 import java.util.LinkedList;
  40 import java.util.List;
  41
  42 import static org.mockito.ArgumentMatchers.eq;
  43 import static org.mockito.Mockito.doReturn;
  44 import static org.mockito.Mockito.doThrow;
  45 import static org.mockito.Mockito.mock;
  46 import static org.mockito.Mockito.spy;
  47 import static org.mockito.Mockito.when;
  48 import static org.openecomp.sdc.common.api.Constants.HC_COMPONENT_ON_BOARDING;
  49
  50 @RunWith(MockitoJUnitRunner.class)
  51 public class HealthCheckBusinessLogicHealthTest extends BeConfDependentTest {
  52         private DmaapProducerHealth dmaapProducerHealth = mock(DmaapProducerHealth.class);
  53         private HealthCheckInfo dmaapProducerHealthCheckInfo = mock(HealthCheckInfo.class);
  54
  55         private SwitchoverDetector switchoverDetector;
  56
  57         private HealthCheckBusinessLogic createTestSubject() {
  58
  59                 HealthCheckBusinessLogic healthCheckBusinessLogic = new HealthCheckBusinessLogic();
  60                 DmaapHealth dmaapHealth = new DmaapHealth();
  61                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "dmaapHealth", dmaapHealth);
  62                 PortalHealthCheckBuilder portalHealthCheckBuilder = new PortalHealthCheckBuilder();
  63                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "portalHealthCheck", portalHealthCheckBuilder);
  64                 DistributionEngineClusterHealth distributionEngineClusterHealth = new DistributionEngineClusterHealth();
  65                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "distributionEngineClusterHealth",
  66                                 distributionEngineClusterHealth);
  67                 SwitchoverDetector switchoverDetector = new SwitchoverDetector();
  68                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "switchoverDetector", switchoverDetector);
  69                 List<HealthCheckInfo> prevBeHealthCheckInfos = new LinkedList<>();
  70                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "prevBeHealthCheckInfos", prevBeHealthCheckInfos);
  71                 ReflectionTestUtils.setField(healthCheckBusinessLogic, "dmaapProducerHealth", dmaapProducerHealth);
  72                 return healthCheckBusinessLogic;
  73         }
  74
  75
  76
  77         @Before
  78         public void beforeTest() {
  79                 when(dmaapProducerHealth.getHealthCheckInfo())
  80                                 .thenReturn(dmaapProducerHealthCheckInfo);
  81         }
  82
  83         @Test
  84         public void testInit() throws Exception {
  85                 HealthCheckBusinessLogic testSubject = createTestSubject();
  86                 testSubject.init();
  87         }
  88
  89         @Test
  90         public void testIsDistributionEngineUp() throws Exception {
  91                 HealthCheckBusinessLogic testSubject;
  92                 // default test
  93                 testSubject = createTestSubject();
  94                 testSubject.isDistributionEngineUp();
  95         }
  96
  97         @Test
  98         public void testGetBeHealthCheckInfosStatus() throws Exception {
  99                 HealthCheckBusinessLogic testSubject;
 100
 101                 // default test
 102                 testSubject = createTestSubject();
 103                 testSubject.getBeHealthCheckInfosStatus();
 104         }
 105
 106         @Test
 107         public void testGetBeHealthCheckInfos() throws Exception {
 108                 HealthCheckBusinessLogic testSubject;
 109
 110                 // default test
 111                 testSubject = createTestSubject();
 112                 Deencapsulation.invoke(testSubject, "getBeHealthCheckInfos");
 113         }
 114
 115         @Test
 116         public void testGetDmaapHealthCheck() throws Exception {
 117                 HealthCheckBusinessLogic testSubject;
 118                 List<HealthCheckInfo> healthCheckInfos = new LinkedList<>();
 119
 120                 // default test
 121                 testSubject = createTestSubject();
 122                 Deencapsulation.invoke(testSubject, "getDmaapHealthCheck");
 123         }
 124
 125         @Test
 126         public void testGetJanusGraphHealthCheck() throws Exception {
 127                 HealthCheckBusinessLogic testSubject;
 128                 List<HealthCheckInfo> healthCheckInfos = new LinkedList<>();
 129
 130                 // default test
 131                 testSubject = createTestSubject();
 132 //              testSubject.getJanusGraphHealthCheck(healthCheckInfos);
 133                 healthCheckInfos.add(testSubject.getJanusGraphHealthCheck());
 134         }
 135
 136         @Test
 137         public void testGetCassandraHealthCheck() throws Exception {
 138                 HealthCheckBusinessLogic testSubject;
 139
 140                 // default test
 141                 testSubject = createTestSubject();
 142                 Deencapsulation.invoke(testSubject, "getCassandraHealthCheck");
 143         }
 144
 145         @Test
 146         public void testGetDistributionEngineCheck() throws Exception {
 147 //              HealthCheckBusinessLogic testSubject;
 148                 DistributionEngineClusterHealth testSubject = new DistributionEngineClusterHealth();
 149
 150                 // default test
 151                 Deencapsulation.invoke(testSubject, "getHealthCheckInfo");
 152         }
 153
 154         @Test
 155         public void testGetAmdocsHealthCheck() throws Exception {
 156                 HealthCheckBusinessLogic testSubject;
 157                 List<HealthCheckInfo> healthCheckInfos = new LinkedList<>();
 158
 159                 // default test
 160                 testSubject = createTestSubject();
 161                 String url = testSubject.buildOnBoardingHealthCheckUrl();
 162                 Deencapsulation.invoke(testSubject, "getHostedComponentsBeHealthCheck", HC_COMPONENT_ON_BOARDING, url);
 163         }
 164
 165         @Test
 166         public void testGetPortalHealthCheckSuccess() throws Exception {
 167                 PortalHealthCheckBuilder testSubject = spy(PortalHealthCheckBuilder.class);
 168                 String healthCheckURL = testSubject.buildPortalHealthCheckUrl();
 169                 int timeout = 3000;
 170                 doReturn(200).when(testSubject).getStatusCode(eq(healthCheckURL), eq(timeout));
 171                 testSubject.init();
 172                 testSubject.runTask();
 173                 HealthCheckInfo hci = testSubject.getHealthCheckInfo();
 174                 Assert.assertEquals("PORTAL", hci.getHealthCheckComponent());
 175                 Assert.assertEquals(HealthCheckInfo.HealthCheckStatus.UP, hci.getHealthCheckStatus());
 176                 Assert.assertEquals("OK", hci.getDescription());
 177         }
 178
 179         @Test
 180         public void testGetPortalHealthCheckFailureMissingConfig() throws Exception{
 181                 PortalHealthCheckBuilder testSubject = new PortalHealthCheckBuilder();
 182                 testSubject.init(null);
 183                 HealthCheckInfo hci = testSubject.getHealthCheckInfo();
 184                 Assert.assertEquals("PORTAL", hci.getHealthCheckComponent());
 185                 Assert.assertEquals(HealthCheckInfo.HealthCheckStatus.DOWN, hci.getHealthCheckStatus());
 186                 Assert.assertEquals("PORTAL health check configuration is missing", hci.getDescription());
 187         }
 188
 189
 190         @Test
 191         public void testGetPortalHealthCheckFailureErrorResponse() throws HttpExecuteException, CipherUtilException {
 192                 PortalHealthCheckBuilder testSubject = spy(PortalHealthCheckBuilder.class);
 193                 String healthCheckURL = testSubject.buildPortalHealthCheckUrl();
 194                 int timeout = 3000;
 195 //              when(testSubject.getStatusCode(healthCheckURL,timeout)).thenReturn(404);
 196                 doReturn(404).when(testSubject).getStatusCode(eq(healthCheckURL), eq(timeout));
 197                 testSubject.init(testSubject.getConfiguration());
 198                 testSubject.runTask();
 199                 HealthCheckInfo hci = testSubject.getHealthCheckInfo();
 200                 Assert.assertEquals("PORTAL", hci.getHealthCheckComponent());
 201                 Assert.assertEquals(HealthCheckInfo.HealthCheckStatus.DOWN, hci.getHealthCheckStatus());
 202                 Assert.assertEquals("PORTAL responded with 404 status code", hci.getDescription());
 203         }
 204
 205         @Test
 206         public void testGetPortalHealthCheckFailureNoResponse() throws HttpExecuteException, CipherUtilException {
 207                 PortalHealthCheckBuilder testSubject = spy(PortalHealthCheckBuilder.class);
 208                 String healthCheckURL = testSubject.buildPortalHealthCheckUrl();
 209                 int timeout = 3000;
 210 //              when(testSubject.getStatusCode(healthCheckURL, timeout)).thenThrow(HttpExecuteException.class);
 211                 doThrow(HttpExecuteException.class).when(testSubject).getStatusCode(eq(healthCheckURL), eq(timeout));
 212                 testSubject.init(testSubject.getConfiguration());
 213                 testSubject.runTask();
 214                 HealthCheckInfo hci = testSubject.getHealthCheckInfo();
 215                 Assert.assertEquals("PORTAL", hci.getHealthCheckComponent());
 216                 Assert.assertEquals(HealthCheckInfo.HealthCheckStatus.DOWN, hci.getHealthCheckStatus());
 217                 Assert.assertEquals("PORTAL is not available", hci.getDescription());
 218         }
 219
 220         @Test
 221         public void testGetHostedComponentsBeHealthCheck() throws Exception {
 222                 HealthCheckBusinessLogic testSubject;
 223                 String componentName = "mock";
 224                 String healthCheckUrl = "mock";
 225                 // test 1
 226                 testSubject = createTestSubject();
 227                 Deencapsulation.invoke(testSubject, "getHostedComponentsBeHealthCheck", componentName, healthCheckUrl);
 228
 229                 // test 2
 230                 testSubject = createTestSubject();
 231                 healthCheckUrl = "";
 232                 Deencapsulation.invoke(testSubject, "getHostedComponentsBeHealthCheck", componentName, healthCheckUrl);
 233         }
 234
 235         @Test
 236         public void testDestroy() throws Exception {
 237                 HealthCheckBusinessLogic testSubject;
 238
 239                 // default test
 240                 testSubject = createTestSubject();
 241                 Deencapsulation.invoke(testSubject, "destroy");
 242         }
 243
 244         @Test
 245         public void testLogAlarm() throws Exception {
 246                 HealthCheckBusinessLogic testSubject;
 247                 String componentChangedMsg = "mock";
 248
 249                 // default test
 250                 testSubject = createTestSubject();
 251                 Deencapsulation.invoke(testSubject, "logAlarm", componentChangedMsg);
 252         }
 253
 254         @Test
 255         public void testGetSiteMode() throws Exception {
 256                 HealthCheckBusinessLogic testSubject;
 257
 258                 // default test
 259                 testSubject = createTestSubject();
 260                 testSubject.getSiteMode();
 261         }
 262
 263         @Test
 264         public void testAnyStatusChanged() throws Exception {
 265                 HealthCheckBusinessLogic testSubject;
 266                 List<HealthCheckInfo> beHealthCheckInfos = null;
 267                 List<HealthCheckInfo> prevBeHealthCheckInfos = null;
 268                 boolean result;
 269
 270                 // test 1
 271                 testSubject = createTestSubject();
 272                 beHealthCheckInfos = null;
 273                 prevBeHealthCheckInfos = null;
 274                 result = testSubject.anyStatusChanged(beHealthCheckInfos, prevBeHealthCheckInfos);
 275                 Assert.assertEquals(false, result);
 276
 277                 // test 2
 278                 testSubject = createTestSubject();
 279                 prevBeHealthCheckInfos = null;
 280                 beHealthCheckInfos = null;
 281                 result = testSubject.anyStatusChanged(beHealthCheckInfos, prevBeHealthCheckInfos);
 282                 Assert.assertEquals(false, result);
 283
 284                 // test 3
 285                 testSubject = createTestSubject();
 286                 beHealthCheckInfos = null;
 287                 prevBeHealthCheckInfos = null;
 288                 result = testSubject.anyStatusChanged(beHealthCheckInfos, prevBeHealthCheckInfos);
 289                 Assert.assertEquals(false, result);
 290
 291                 // test 4
 292                 testSubject = createTestSubject();
 293                 prevBeHealthCheckInfos = null;
 294                 beHealthCheckInfos = null;
 295                 result = testSubject.anyStatusChanged(beHealthCheckInfos, prevBeHealthCheckInfos);
 296                 Assert.assertEquals(false, result);
 297         }
 298
 299         @Test
 300         public void testBuildOnBoardingHealthCheckUrl() throws Exception {
 301                 HealthCheckBusinessLogic testSubject;
 302
 303                 // default test
 304                 testSubject = createTestSubject();
 305                 Deencapsulation.invoke(testSubject, "buildOnBoardingHealthCheckUrl");
 306         }
 307
 308 }