catalog-be/src/test/java/org/openecomp/sdc/be/components/scheduledtasks/RecoveryThreadManagerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.scheduledtasks;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.lang3.math.NumberUtils;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.InjectMocks;
  28 import org.mockito.Mockito;
  29 import org.mockito.MockitoAnnotations;
  30 import org.openecomp.sdc.be.components.BeConfDependentTest;
  31 import org.openecomp.sdc.be.components.distribution.engine.EnvironmentsEngine;
  32 import org.openecomp.sdc.be.components.scheduledtasks.RecoveryThreadManager.FixEnvironmentTask;
  33 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  34 import org.openecomp.sdc.be.dao.cassandra.OperationalEnvironmentDao;
  35 import org.openecomp.sdc.be.datatypes.enums.EnvironmentStatusEnum;
  36 import org.openecomp.sdc.be.resources.data.OperationalEnvironmentEntry;
  37 import org.openecomp.sdc.common.datastructure.Wrapper;
  38
  39 import java.util.Arrays;
  40 import java.util.Date;
  41 import java.util.List;
  42 import java.util.concurrent.ScheduledExecutorService;
  43 import java.util.concurrent.TimeUnit;
  44
  45 import static org.mockito.Mockito.doReturn;
  46 import static org.mockito.Mockito.mock;
  47 import static org.mockito.Mockito.reset;
  48 import static org.mockito.Mockito.times;
  49 import static org.mockito.Mockito.verify;
  50 import static org.mockito.Mockito.when;
  51
  52 public class RecoveryThreadManagerTest extends BeConfDependentTest {
  53
  54     @InjectMocks
  55     RecoveryThreadManager recoveryThreadManager = new RecoveryThreadManager();
  56
  57     private OperationalEnvironmentDao operationalEnvironmentDao = mock(OperationalEnvironmentDao.class);
  58     private EnvironmentsEngine environmentsEngine = mock(EnvironmentsEngine.class);
  59     private ScheduledExecutorService scheduledService = mock(ScheduledExecutorService.class);
  60
  61     @Before
  62     public void initMocks() {
  63         MockitoAnnotations.openMocks(this);
  64         reset(operationalEnvironmentDao, environmentsEngine, scheduledService);
  65         recoveryThreadManager.init();
  66     }
  67
  68     @Test
  69     public void testInit() {
  70         verify(scheduledService, Mockito.times(1)).scheduleAtFixedRate(recoveryThreadManager.task,
  71                 NumberUtils.LONG_ZERO, 180L, TimeUnit.SECONDS);
  72
  73     }
  74     @SuppressWarnings("unchecked")
  75     @Test
  76     public void testTaskNoRecords() {
  77         FixEnvironmentTask fixEnvironmentTask = recoveryThreadManager.task;
  78         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> emptyList = Either.left(Arrays.asList());
  79         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.FAILED)).thenReturn(emptyList);
  80         fixEnvironmentTask.run();
  81         verify(environmentsEngine, Mockito.times(0)).buildOpEnv(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
  82
  83     }
  84
  85     @SuppressWarnings("unchecked")
  86     @Test
  87     public void testTaskCassandraCrash() {
  88         FixEnvironmentTask fixEnvironmentTask = recoveryThreadManager.task;
  89         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> eitherResult = Either.right(CassandraOperationStatus.GENERAL_ERROR);
  90         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.FAILED)).thenReturn(eitherResult);
  91         fixEnvironmentTask.run();
  92         verify(environmentsEngine, Mockito.times(0)).buildOpEnv(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
  93
  94     }
  95
  96     @SuppressWarnings("unchecked")
  97     @Test
  98     public void testTaskMultipleFailedRecords() {
  99         FixEnvironmentTask fixEnvironmentTask = recoveryThreadManager.task;
 100         OperationalEnvironmentEntry mockEntry = Mockito.mock(OperationalEnvironmentEntry.class);
 101         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> nonEmptyList = Either.left(Arrays.asList(mockEntry, mockEntry, mockEntry));
 102         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> emptyList = Either.left(Arrays.asList());
 103         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.FAILED)).thenReturn(nonEmptyList);
 104         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.IN_PROGRESS)).thenReturn(emptyList);
 105         fixEnvironmentTask.run();
 106         verify(environmentsEngine, Mockito.times(3)).buildOpEnv(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
 107
 108     }
 109
 110     @SuppressWarnings("unchecked")
 111     @Test
 112     public void testTaskStaleRecords() {
 113         FixEnvironmentTask fixEnvironmentTask = recoveryThreadManager.task;
 114         OperationalEnvironmentEntry mockFailedEntryFirst = Mockito.mock(OperationalEnvironmentEntry.class);
 115         OperationalEnvironmentEntry mockFailedEntrySecond = Mockito.mock(OperationalEnvironmentEntry.class);
 116         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> failedRecordsList = Either.left(Arrays.asList(mockFailedEntryFirst, mockFailedEntrySecond));
 117         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.FAILED)).thenReturn(failedRecordsList);
 118
 119         OperationalEnvironmentEntry mockInProgressNonStaleEntry = Mockito.mock(OperationalEnvironmentEntry.class);
 120         OperationalEnvironmentEntry mockInProgressStaleEntry = Mockito.mock(OperationalEnvironmentEntry.class);
 121         doReturn(new Date(System.currentTimeMillis() - recoveryThreadManager.allowedTimeBeforeStaleSec * 1000 /2)).when(mockInProgressNonStaleEntry).getLastModified();
 122         doReturn(new Date(System.currentTimeMillis() - recoveryThreadManager.allowedTimeBeforeStaleSec * 1000 * 2)).when(mockInProgressStaleEntry).getLastModified();
 123         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> inProgressList = Either.left(Arrays.asList(mockInProgressNonStaleEntry, mockInProgressStaleEntry));
 124         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.IN_PROGRESS)).thenReturn(inProgressList);
 125         fixEnvironmentTask.run();
 126
 127         verify(environmentsEngine).buildOpEnv(Mockito.any(Wrapper.class), Mockito.eq(mockFailedEntryFirst));
 128         verify(environmentsEngine).buildOpEnv(Mockito.any(Wrapper.class), Mockito.eq(mockFailedEntrySecond));
 129         verify(environmentsEngine).buildOpEnv(Mockito.any(Wrapper.class), Mockito.eq(mockInProgressStaleEntry));
 130         verify(environmentsEngine, times(0)).buildOpEnv(Mockito.any(Wrapper.class), Mockito.eq(mockInProgressNonStaleEntry));
 131
 132         verify(environmentsEngine, times(3)).buildOpEnv(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
 133
 134     }
 135
 136
 137
 138     @Test
 139     public void testUnconnectedRecords() {
 140         FixEnvironmentTask fixEnvironmentTask = recoveryThreadManager.task;
 141         OperationalEnvironmentEntry mockCompleteConnected = Mockito.mock(OperationalEnvironmentEntry.class);
 142         OperationalEnvironmentEntry mockCompleteUnconnected = Mockito.mock(OperationalEnvironmentEntry.class);
 143         Either<List<OperationalEnvironmentEntry>, CassandraOperationStatus> completeRecordsList = Either.left(Arrays.asList(mockCompleteConnected, mockCompleteUnconnected));
 144         when(environmentsEngine.isInMap(mockCompleteConnected)).thenReturn(true);
 145         when(environmentsEngine.isInMap(mockCompleteUnconnected)).thenReturn(false);
 146         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED)).thenReturn(completeRecordsList);
 147         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.FAILED)).thenReturn(Either.left(Arrays.asList()));
 148         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.IN_PROGRESS)).thenReturn(Either.left(Arrays.asList()));
 149         fixEnvironmentTask.run();
 150
 151         verify(environmentsEngine).createUebTopicsForEnvironment(mockCompleteUnconnected);
 152         verify(environmentsEngine, times(0)).createUebTopicsForEnvironment(mockCompleteConnected);
 153         verify(environmentsEngine).addToMap(mockCompleteUnconnected);
 154         verify(environmentsEngine, times(0)).addToMap(mockCompleteConnected);
 155         verify(environmentsEngine, times(1)).createUebTopicsForEnvironment(Mockito.any(OperationalEnvironmentEntry.class));
 156
 157     }
 158 }