catalog-be/src/test/java/org/openecomp/sdc/be/servlets/AutomatedUpgradeEndpointTest.java

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import com.fasterxml.jackson.databind.DeserializationFeature;
   4 import fj.data.Either;
   5 import org.glassfish.jersey.client.ClientConfig;
   6 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
   7 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
   8 import org.glassfish.jersey.server.ResourceConfig;
   9 import org.junit.Before;
  10 import org.junit.BeforeClass;
  11 import org.junit.Test;
  12 import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
  13 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  14 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  15 import org.openecomp.sdc.be.components.upgrade.ServiceInfo;
  16 import org.openecomp.sdc.be.components.upgrade.UpgradeBusinessLogic;
  17 import org.openecomp.sdc.be.components.upgrade.UpgradeRequest;
  18 import org.openecomp.sdc.be.components.upgrade.UpgradeStatus;
  19 import org.openecomp.sdc.be.components.validation.UserValidations;
  20 import org.openecomp.sdc.be.config.ConfigurationManager;
  21 import org.openecomp.sdc.be.dao.api.ActionStatus;
  22 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  23 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  24 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  25 import org.openecomp.sdc.be.impl.ComponentsUtils;
  26 import org.openecomp.sdc.be.model.*;
  27 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  28 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.UpgradeOperation;
  29 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  30 import org.openecomp.sdc.common.api.ConfigurationSource;
  31 import org.openecomp.sdc.common.api.Constants;
  32 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  33 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  34 import org.openecomp.sdc.exception.ResponseFormat;
  35 import org.openecomp.sdc.exception.ServiceException;
  36 import org.springframework.context.annotation.Bean;
  37 import org.springframework.context.annotation.Import;
  38 import org.springframework.http.HttpStatus;
  39
  40 import javax.ws.rs.client.Entity;
  41 import javax.ws.rs.client.Invocation;
  42 import javax.ws.rs.core.MediaType;
  43 import javax.ws.rs.core.Response;
  44 import java.util.ArrayList;
  45 import java.util.List;
  46
  47 import static org.assertj.core.api.Assertions.assertThat;
  48 import static org.mockito.ArgumentMatchers.any;
  49 import static org.mockito.ArgumentMatchers.anyBoolean;
  50 import static org.mockito.ArgumentMatchers.anyString;
  51 import static org.mockito.ArgumentMatchers.eq;
  52 import static org.mockito.Mockito.*;
  53
  54 public class AutomatedUpgradeEndpointTest extends JerseySpringBaseTest {
  55     static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
  56     static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  57
  58     private static final String RESOURCE_ID_PREV = "prevVF";
  59     private static final String RESOURCE_ID_NEW = "newVF";
  60     private static final String SERVICE_ID_PREV = "prevSer";
  61     private static final String SERVICE_ID_NEW = "newSer";
  62     private static final String SERVICE_ID_PROXY = "serProxy";
  63     private static final String SERVICE_ID_PROXY_PREV = "serProxyContainerPrev";
  64     private static final String SERVICE_ID_PROXY_NEW = "serProxyContainerNew";
  65     private static final String INVARIANT_ID = "invariantUUID";
  66     private static final String USER_ID = "userId";
  67
  68     private static LifecycleBusinessLogic lifecycleBusinessLogic;
  69     private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
  70     private static UserValidations userValidations;
  71     private static ToscaOperationFacade toscaOperationFacade;
  72     private static ComponentsUtils componentsUtils;
  73     private static UpgradeOperation upgradeOperation;
  74     private static JanusGraphDao janusGraphDao;
  75
  76     private static User user;
  77     private static Resource vfPrev;
  78     private static Resource vfNew;
  79     private static Service servicePrev;
  80     private static Service serviceNew;
  81     private static Service serviceNewCheckIn;
  82     private static ComponentInstance istanceNew;
  83
  84     private static Service serviceProxy;
  85     private static Service serviceProxyContainerPrev;
  86     private static Service serviceProxyContainerNew;
  87
  88     @org.springframework.context.annotation.Configuration
  89     @Import(BaseTestConfig.class)
  90     static class AutomatedUpgradeTestConfig {
  91
  92         @Bean
  93         AutomatedUpgradeEndpoint automatedUpgradeEndpoint() {
  94             return new AutomatedUpgradeEndpoint(upgradeBusinessLogic());
  95         }
  96
  97         @Bean
  98         UpgradeBusinessLogic upgradeBusinessLogic() {
  99             return new UpgradeBusinessLogic(lifecycleBusinessLogic, componentInstanceBusinessLogic, userValidations, toscaOperationFacade, componentsUtils, upgradeOperation,
 100                 janusGraphDao);
 101         }
 102     }
 103
 104     @BeforeClass
 105     public static void initClass() {
 106         lifecycleBusinessLogic = mock(LifecycleBusinessLogic.class);
 107         componentInstanceBusinessLogic = mock(ComponentInstanceBusinessLogic.class);
 108         userValidations = mock(UserValidations.class);
 109         toscaOperationFacade = mock(ToscaOperationFacade.class);
 110         componentsUtils = mock(ComponentsUtils.class);
 111         upgradeOperation = mock(UpgradeOperation.class);
 112         janusGraphDao = mock(JanusGraphDao.class);
 113         user = mock(User.class);
 114     }
 115
 116     @Before
 117     public void init() {
 118         prepareComponents();
 119         when(userValidations.validateUserExists(eq(USER_ID), anyString(), anyBoolean())).thenReturn(user);
 120         when(toscaOperationFacade.getToscaFullElement(eq(RESOURCE_ID_PREV))).thenReturn(Either.left(vfPrev));
 121         when(toscaOperationFacade.getToscaFullElement(eq(RESOURCE_ID_NEW))).thenReturn(Either.left(vfNew));
 122         when(toscaOperationFacade.getToscaFullElement(eq(SERVICE_ID_PREV))).thenReturn(Either.left(servicePrev));
 123         when(toscaOperationFacade.getToscaFullElement(eq(SERVICE_ID_NEW))).thenReturn(Either.left(serviceNew));
 124
 125         Either<Service, ResponseFormat> fromLifeCycle = Either.left(serviceNew);
 126         doReturn(fromLifeCycle).when(lifecycleBusinessLogic).changeComponentState(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID_PREV), any(User.class), eq(LifeCycleTransitionEnum.CHECKOUT), any(LifecycleChangeInfoWithAction.class), eq(false),
 127                 eq(true));
 128
 129         when(toscaOperationFacade.getToscaElement(eq(RESOURCE_ID_PREV), any(ComponentParametersView.class))).thenReturn(Either.left(vfPrev));
 130         when(componentInstanceBusinessLogic.changeInstanceVersion(any(Service.class), any(ComponentInstance.class), any(ComponentInstance.class), any(User.class), eq(ComponentTypeEnum.SERVICE))).thenReturn(Either.left(istanceNew));
 131
 132         doReturn(Either.left(serviceNewCheckIn)).when(lifecycleBusinessLogic).changeComponentState(eq(ComponentTypeEnum.SERVICE), eq(SERVICE_ID_NEW), any(User.class), eq(LifeCycleTransitionEnum.CHECKIN), any(LifecycleChangeInfoWithAction.class),
 133                 eq(false), eq(true));
 134
 135     }
 136
 137     @Override
 138     protected void configureClient(ClientConfig config) {
 139         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 140         config.register(jacksonJsonProvider);
 141     }
 142
 143     @Override
 144     protected ResourceConfig configure() {
 145         return super.configure(AutomatedUpgradeTestConfig.class).register(AutomatedUpgradeEndpoint.class);
 146     }
 147
 148     @Test
 149     public void upgradeVfInService_success() {
 150         List<UpgradeRequest> inputsToUpdate = new ArrayList<>();
 151         UpgradeRequest request = new UpgradeRequest(SERVICE_ID_PREV);
 152         inputsToUpdate.add(request);
 153
 154         Invocation.Builder builder = buildAutomatedUpgradeCall(RESOURCE_ID_NEW);
 155         UpgradeStatus status = builder.post(Entity.entity(inputsToUpdate, MediaType.APPLICATION_JSON), UpgradeStatus.class);
 156
 157         assertThat(status.getStatus()).isEqualTo(ActionStatus.OK);
 158         List<ServiceInfo> expected = new ArrayList<>();
 159         ServiceInfo serviceInfo = new ServiceInfo(serviceNewCheckIn.getUniqueId(), ActionStatus.OK);
 160         serviceInfo.setName(serviceNewCheckIn.getName());
 161         serviceInfo.setVersion(serviceNewCheckIn.getVersion());
 162         expected.add(serviceInfo);
 163         assertThat(status.getComponentToUpgradeStatus()).hasSameSizeAs(expected);
 164         assertThat(status.getComponentToUpgradeStatus()).hasSameElementsAs(expected);
 165
 166     }
 167
 168     @Test
 169     public void upgradeVfInService_IdNotExist() {
 170         List<UpgradeRequest> inputsToUpdate = new ArrayList<>();
 171         UpgradeRequest request = new UpgradeRequest(SERVICE_ID_PREV);
 172         inputsToUpdate.add(request);
 173         String wrongId = "1234";
 174         when(toscaOperationFacade.getToscaFullElement(eq(wrongId))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 175         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
 176         String[] variables = { wrongId };
 177         ServiceException serviceException = new ServiceException("SVC4063", "Error: Requested '%1' resource was not found.", variables);
 178         ResponseFormat expected = new ResponseFormat(HttpStatus.NOT_FOUND.value());
 179         expected.setServiceException(serviceException);
 180         when(componentsUtils.getResponseFormatByResource(eq(ActionStatus.RESOURCE_NOT_FOUND), eq(wrongId))).thenReturn(expected);
 181
 182         Response response = buildAutomatedUpgradeCall(wrongId).post(Entity.entity(inputsToUpdate, MediaType.APPLICATION_JSON), Response.class);
 183         assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
 184
 185         ResponseFormat actual = response.readEntity(ResponseFormat.class);
 186         assertThat(actual.getMessageId()).isEqualTo(expected.getMessageId());
 187         assertThat(actual.getFormattedMessage()).isEqualTo(expected.getFormattedMessage());
 188
 189     }
 190
 191     @Test
 192     public void upgradeVfInService_NotHihgestCertified() {
 193         List<UpgradeRequest> inputsToUpdate = new ArrayList<>();
 194         UpgradeRequest request = new UpgradeRequest(RESOURCE_ID_PREV);
 195         inputsToUpdate.add(request);
 196
 197         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
 198         String[] variables = { vfPrev.getName() };
 199         ServiceException serviceException = new ServiceException("SVC4699", "Error: Component %1 is not highest certified", variables);
 200         ResponseFormat expected = new ResponseFormat(HttpStatus.BAD_REQUEST.value());
 201         expected.setServiceException(serviceException);
 202         when(componentsUtils.getResponseFormat(eq(ActionStatus.COMPONENT_IS_NOT_HIHGEST_CERTIFIED), eq(vfPrev.getName()))).thenReturn(expected);
 203
 204         Response response = buildAutomatedUpgradeCall(RESOURCE_ID_PREV).post(Entity.entity(inputsToUpdate, MediaType.APPLICATION_JSON), Response.class);
 205         assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
 206
 207         ResponseFormat actual = response.readEntity(ResponseFormat.class);
 208         assertThat(actual.getMessageId()).isEqualTo(expected.getMessageId());
 209         assertThat(actual.getFormattedMessage()).isEqualTo(expected.getFormattedMessage());
 210     }
 211
 212 //    @Test
 213 //    public void upgradeProxyInService_successful() {
 214 //        List<UpgradeRequest> inputsToUpdate = new ArrayList<>();
 215 //        UpgradeRequest request = new UpgradeRequest(SERVICE_ID_PROXY_PREV);
 216 //        inputsToUpdate.add(request);
 217 //
 218 //        when(toscaOperationFacade.getToscaElement(eq(SERVICE_ID_PROXY))).thenReturn(Either.left(serviceProxy));
 219 //
 220 //        UpgradeStatus status = buildAutomatedUpgradeCall(SERVICE_ID_PROXY).post(Entity.entity(inputsToUpdate, MediaType.APPLICATION_JSON), UpgradeStatus.class);
 221 //        assertThat(status.getStatus()).isEqualTo(ActionStatus.OK);
 222 //    }
 223
 224     private Invocation.Builder buildAutomatedUpgradeCall(String id) {
 225         return target("/v1/catalog/resources/{id}/automatedupgrade").resolveTemplate("id", id).request(MediaType.APPLICATION_JSON).header(Constants.USER_ID_HEADER, USER_ID);
 226     }
 227
 228     private void prepareComponents() {
 229         createVF();
 230
 231         createService();
 232     }
 233
 234     private void createService() {
 235         servicePrev = createService("service1", SERVICE_ID_PREV, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 236
 237         ComponentInstance ci = new ComponentInstance();
 238         ci.setComponentUid(RESOURCE_ID_PREV);
 239         ci.setName("inst 1");
 240         List<ComponentInstance> resourceInstances = new ArrayList<>();
 241         resourceInstances.add(ci);
 242         servicePrev.setComponentInstances(resourceInstances);
 243
 244         serviceNew = createService("service1", SERVICE_ID_NEW, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 245         serviceNew.setComponentInstances(resourceInstances);
 246
 247         serviceNewCheckIn = createService("service1", SERVICE_ID_NEW, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 248
 249         serviceNewCheckIn.setComponentInstances(resourceInstances);
 250
 251         istanceNew = new ComponentInstance();
 252         istanceNew.setComponentUid(RESOURCE_ID_NEW);
 253         istanceNew.setName("inst 1");
 254
 255         serviceProxy = createService("serviceProxy", SERVICE_ID_PROXY, LifecycleStateEnum.CERTIFIED);
 256         serviceProxyContainerPrev = createService("serviceProxyContainer", SERVICE_ID_PROXY_PREV, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 257         serviceProxyContainerNew = createService("serviceProxyContainer", SERVICE_ID_PROXY_NEW, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 258
 259
 260
 261     }
 262
 263     private Service createService(String name, String id, LifecycleStateEnum state){
 264         Service service = new Service();
 265         service.setName(name);
 266         service.setUniqueId(id);
 267         service.setLifecycleState(state);
 268         service.setHighestVersion(true);
 269         return service;
 270     }
 271     private void createVF() {
 272         vfPrev = new Resource();
 273         vfPrev.setName("vf1");
 274         vfPrev.setUniqueId(RESOURCE_ID_PREV);
 275         vfPrev.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 276         vfPrev.setHighestVersion(false);
 277         vfPrev.setResourceType(ResourceTypeEnum.VF);
 278         vfPrev.setVersion("1.0");
 279         vfPrev.setInvariantUUID(INVARIANT_ID);
 280         vfPrev.setComponentType(ComponentTypeEnum.RESOURCE);
 281
 282         vfNew = new Resource();
 283         vfNew.setName("vf1");
 284         vfNew.setUniqueId(RESOURCE_ID_PREV);
 285         vfNew.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 286         vfNew.setHighestVersion(true);
 287         vfNew.setResourceType(ResourceTypeEnum.VF);
 288         vfNew.setVersion("2.0");
 289         vfNew.setInvariantUUID(INVARIANT_ID);
 290         vfNew.setComponentType(ComponentTypeEnum.RESOURCE);
 291
 292     }
 293 }