gerrit.onap Code Review - sdc.git/blob

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