catalog-be/src/test/java/org/openecomp/sdc/be/components/scheduledtasks/ComponentsCleanBusinessLogicTest.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 com.google.common.collect.Lists;
  24 import fj.data.Either;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.InjectMocks;
  29 import org.mockito.Mock;
  30 import org.mockito.junit.MockitoJUnitRunner;
  31 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  32 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.impl.ComponentsUtils;
  35 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  36 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  37 import org.openecomp.sdc.exception.ResponseFormat;
  38
  39 import java.util.ArrayList;
  40 import java.util.List;
  41 import java.util.Map;
  42
  43 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
  44 import static org.mockito.ArgumentMatchers.any;
  45 import static org.mockito.ArgumentMatchers.eq;
  46 import static org.mockito.Mockito.*;
  47
  48 @RunWith(MockitoJUnitRunner.class)
  49 public class ComponentsCleanBusinessLogicTest {
  50
  51     @Mock
  52     private ResourceBusinessLogic resourceBusinessLogic;
  53     @Mock
  54     private ServiceBusinessLogic serviceBusinessLogic;
  55     @Mock
  56     private IGraphLockOperation graphLockOperation;
  57     @Mock
  58     private ComponentsUtils componentsUtils;
  59
  60     @InjectMocks
  61     private ComponentsCleanBusinessLogic componentsCleanBL = new ComponentsCleanBusinessLogic();
  62
  63     @Before
  64     public void setUp() {
  65         mockResourceDeleting();
  66         mockServiceDeleting();
  67     }
  68
  69     @Test
  70     public void deleteAll() {
  71         List<NodeTypeEnum> cleanList = new ArrayList<>();
  72         cleanList.add(NodeTypeEnum.Resource);
  73         cleanList.add(NodeTypeEnum.Service);
  74         when(graphLockOperation.lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER),
  75                 eq(NodeTypeEnum.Component))).thenReturn(StorageOperationStatus.OK);
  76         componentsCleanBL.cleanComponents(cleanList);
  77         verify(resourceBusinessLogic).deleteMarkedComponents();
  78         verify(serviceBusinessLogic).deleteMarkedComponents();
  79         verify(graphLockOperation).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
  80                 eq(NodeTypeEnum.Component));
  81     }
  82
  83     @Test
  84     public void deleteResourceWhenOperationAlreadyLocked() {
  85         List<NodeTypeEnum> cleanList = new ArrayList<>();
  86         cleanList.add(NodeTypeEnum.Resource);
  87         componentsCleanBL.cleanComponents(cleanList, true);
  88         verify(resourceBusinessLogic).deleteMarkedComponents();
  89         verify(graphLockOperation, times(0)).lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any());
  90         verify(graphLockOperation, times(0)).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
  91                 eq(NodeTypeEnum.Component));
  92     }
  93
  94     @Test
  95     public void deleteResource() {
  96         List<NodeTypeEnum> cleanList = new ArrayList<>();
  97         cleanList.add(NodeTypeEnum.Resource);
  98         when(graphLockOperation.lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER),
  99                 eq(NodeTypeEnum.Component))).thenReturn(StorageOperationStatus.OK);
 100         componentsCleanBL.cleanComponents(cleanList);
 101         verify(resourceBusinessLogic).deleteMarkedComponents();
 102         verify(graphLockOperation).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 103                 eq(NodeTypeEnum.Component));
 104     }
 105
 106     @Test
 107     public void deleteServiceWhenOperationAlreadyLocked() {
 108         List<NodeTypeEnum> cleanList = new ArrayList<>();
 109         cleanList.add(NodeTypeEnum.Service);
 110         componentsCleanBL.cleanComponents(cleanList, true);
 111         verify(serviceBusinessLogic).deleteMarkedComponents();
 112         verify(graphLockOperation, times(0)).lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any());
 113         verify(graphLockOperation, times(0)).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 114                 eq(NodeTypeEnum.Component));
 115     }
 116
 117
 118     @Test
 119     public void deleteResourceIsNotCalledDueToCleanupLock() {
 120         List<NodeTypeEnum> cleanList = new ArrayList<>();
 121
 122         cleanList.add(NodeTypeEnum.Resource);
 123         when(graphLockOperation.lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER),
 124                 eq(NodeTypeEnum.Component))).thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT);
 125         Map<NodeTypeEnum, Either<List<String>, ResponseFormat>> cleanedComponents = componentsCleanBL.cleanComponents(cleanList);
 126
 127         assertThat(cleanedComponents.get(NodeTypeEnum.Resource)).isNotNull();
 128         verify(resourceBusinessLogic, times(0)).deleteMarkedComponents();
 129         verify(graphLockOperation, times(0)).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 130                 eq(NodeTypeEnum.Component));
 131     }
 132
 133
 134     @Test
 135     public void deleteService() {
 136         List<NodeTypeEnum> cleanList = new ArrayList<>();
 137         cleanList.add(NodeTypeEnum.Service);
 138         when(graphLockOperation.lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER),
 139                 eq(NodeTypeEnum.Component))).thenReturn(StorageOperationStatus.OK);
 140         componentsCleanBL.cleanComponents(cleanList);
 141         verify(serviceBusinessLogic).deleteMarkedComponents();
 142         verify(graphLockOperation).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 143                 eq(NodeTypeEnum.Component));
 144     }
 145
 146     @Test
 147     public void deleteServiceIsNotCalledDueToCleanupLock() {
 148         List<NodeTypeEnum> cleanList = new ArrayList<>();
 149         cleanList.add(NodeTypeEnum.Service);
 150         when(graphLockOperation.lockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER),
 151                 eq(NodeTypeEnum.Component))).thenReturn(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT);
 152
 153         Map<NodeTypeEnum, Either<List<String>, ResponseFormat>> cleanedComponents = componentsCleanBL.cleanComponents(cleanList);
 154
 155         assertThat(cleanedComponents.get(NodeTypeEnum.Service)).isNotNull();
 156         verify(serviceBusinessLogic, times(0)).deleteMarkedComponents();
 157         verify(graphLockOperation, times(0)).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 158                 eq(NodeTypeEnum.Component));
 159     }
 160
 161     @Test
 162     public void deleteWrongElement() {
 163         List<NodeTypeEnum> cleanList = new ArrayList<>();
 164         cleanList.add(NodeTypeEnum.User);
 165         componentsCleanBL.cleanComponents(cleanList);
 166         verify(resourceBusinessLogic, times(0)).deleteMarkedComponents();
 167         verify(serviceBusinessLogic, times(0)).deleteMarkedComponents();
 168         verify(graphLockOperation, times(0)).unlockComponentByName(eq(ComponentsCleanBusinessLogic.DELETE_LOCKER), any(),
 169                 eq(NodeTypeEnum.Component));
 170     }
 171
 172     private void mockResourceDeleting() {
 173         when(resourceBusinessLogic.deleteMarkedComponents()).thenReturn(Either.left(Lists.newArrayList()));
 174     }
 175
 176     private void mockServiceDeleting() {
 177         when(serviceBusinessLogic.deleteMarkedComponents()).thenReturn(Either.left(Lists.newArrayList()));
 178     }
 179
 180 }
 181