gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdcrests.vsp.rest.services;
   2
   3 import org.apache.cxf.jaxrs.ext.multipart.Attachment;
   4 import org.apache.cxf.jaxrs.ext.multipart.ContentDisposition;
   5 import org.apache.http.HttpStatus;
   6 import org.junit.Assert;
   7 import org.junit.Before;
   8 import org.junit.Test;
   9 import org.junit.runner.RunWith;
  10 import org.mockito.ArgumentMatchers;
  11 import org.mockito.Mock;
  12 import org.openecomp.sdc.activitylog.ActivityLogManager;
  13 import org.openecomp.sdc.activitylog.ActivityLogManagerFactory;
  14 import org.openecomp.sdc.logging.api.Logger;
  15 import org.openecomp.sdc.logging.api.LoggerFactory;
  16 import org.openecomp.sdc.vendorsoftwareproduct.ComponentManager;
  17 import org.openecomp.sdc.vendorsoftwareproduct.ComponentManagerFactory;
  18 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManager;
  19 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManagerFactory;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
  21 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessType;
  22 import org.openecomp.sdc.versioning.dao.types.Version;
  23 import org.openecomp.sdcrests.vendorsoftwareproducts.types.*;
  24 import org.openecomp.sdcrests.wrappers.GenericCollectionWrapper;
  25 import org.openecomp.sdcrests.wrappers.StringWrapperResponse;
  26 import org.powermock.core.classloader.annotations.PrepareForTest;
  27 import org.powermock.modules.junit4.PowerMockRunner;
  28
  29 import javax.ws.rs.core.Response;
  30 import java.io.ByteArrayInputStream;
  31 import java.io.File;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.UUID;
  35
  36 import static org.mockito.MockitoAnnotations.initMocks;
  37 import static org.powermock.api.mockito.PowerMockito.*;
  38
  39 @RunWith(PowerMockRunner.class)
  40 @PrepareForTest({ComponentDependenciesImpl.class, ActivityLogManagerFactory.class, ComponentManagerFactory.class, ProcessManagerFactory.class})
  41 public class ComponentProcessesImplTest {
  42
  43   private Logger logger = LoggerFactory.getLogger(ComponentProcessesImplTest.class);
  44
  45   @Mock
  46   private ActivityLogManager activityLogManager;
  47   @Mock
  48   private ActivityLogManagerFactory activityLogManagerFactory;
  49
  50   @Mock
  51   private ProcessManagerFactory processManagerFactory;
  52
  53   @Mock
  54   private ProcessManager processManager;
  55
  56   @Mock
  57   private ComponentManagerFactory componentManagerFactory;
  58
  59   @Mock
  60   private ComponentManager componentManager;
  61
  62   private final String vspId = UUID.randomUUID().toString();
  63   private final String versionId = UUID.randomUUID().toString();
  64   private final String componentId = "" + System.currentTimeMillis();
  65   private final String processId = "" + System.currentTimeMillis();
  66   private final String user = "cs0008";
  67
  68   @Before
  69   public void setUp() {
  70     try {
  71       initMocks(this);
  72
  73       mockStatic(ProcessManagerFactory.class);
  74       when(ProcessManagerFactory.getInstance()).thenReturn(processManagerFactory);
  75       when(processManagerFactory.createInterface()).thenReturn(processManager);
  76
  77       mockStatic(ActivityLogManagerFactory.class);
  78       when(ActivityLogManagerFactory.getInstance()).thenReturn(activityLogManagerFactory);
  79       when(activityLogManagerFactory.createInterface()).thenReturn(activityLogManager);
  80
  81       mockStatic(ComponentManagerFactory.class);
  82       when(ComponentManagerFactory.getInstance()).thenReturn(componentManagerFactory);
  83       when(componentManagerFactory.createInterface()).thenReturn(componentManager);
  84
  85       ProcessEntity pe = new ProcessEntity();
  86       pe.setId(vspId);
  87       pe.setComponentId(componentId);
  88       pe.setVspId(vspId);
  89       pe.setVersion(new Version(versionId));
  90
  91       Collection<ProcessEntity> peList = Collections.singletonList(pe);
  92       when(processManager.listProcesses(
  93               ArgumentMatchers.eq(vspId),
  94               ArgumentMatchers.any(),
  95               ArgumentMatchers.eq(componentId))).thenReturn(peList);
  96
  97       when(processManager.createProcess(
  98               ArgumentMatchers.any())).thenReturn(pe);
  99
 100       when(processManager.getProcess(
 101               ArgumentMatchers.eq(vspId),
 102               ArgumentMatchers.any(),
 103               ArgumentMatchers.eq(componentId),
 104               ArgumentMatchers.eq(processId))).thenReturn(pe);
 105
 106       File processArtifact = new File(vspId);
 107       when(processManager.getProcessArtifact(
 108               ArgumentMatchers.eq(vspId),
 109               ArgumentMatchers.any(),
 110               ArgumentMatchers.eq(componentId),
 111               ArgumentMatchers.eq(processId))).thenReturn(processArtifact);
 112
 113     } catch (Exception e) {
 114       logger.error(e.getMessage(), e);
 115     }
 116   }
 117
 118   @Test
 119   public void testList() {
 120     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 121
 122     Response rsp = cpi.list(vspId, versionId, componentId, user);
 123     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 124     Object e = rsp.getEntity();
 125     Assert.assertNotNull(e);
 126     @SuppressWarnings("unchecked")
 127     GenericCollectionWrapper<ProcessEntityDto> results = (GenericCollectionWrapper<ProcessEntityDto>)e;
 128     Assert.assertEquals("result length", 1, results.getListCount());
 129   }
 130
 131   @Test
 132   public void testDeleteList() {
 133     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 134     Response rsp = cpi.deleteList(vspId, versionId, componentId, user);
 135     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 136     Assert.assertNull(rsp.getEntity());
 137   }
 138
 139
 140
 141   @Test
 142   public void testCreate() {
 143
 144     ProcessRequestDto dto = new ProcessRequestDto();
 145     dto.setDescription("hello");
 146     dto.setName("name");
 147     dto.setType(ProcessType.Other);
 148
 149     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 150     Response rsp = cpi.create(dto, vspId, versionId, componentId, user);
 151     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 152     Object e = rsp.getEntity();
 153     Assert.assertNotNull(e);
 154     try {
 155       StringWrapperResponse swr = (StringWrapperResponse)e;
 156       Assert.assertEquals(vspId, swr.getValue());
 157     } catch (ClassCastException ex) {
 158       Assert.fail("unexpected class for DTO " + e.getClass().getName());
 159     }
 160   }
 161
 162
 163   @Test
 164   public void testDelete() {
 165     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 166     Response rsp = cpi.delete(vspId, versionId, componentId, processId, user);
 167     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 168     Assert.assertNull(rsp.getEntity());
 169   }
 170
 171
 172   @Test
 173   public void testGet() {
 174     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 175     Response rsp = cpi.get(vspId, versionId, componentId, processId, user);
 176     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 177     Assert.assertNotNull(rsp.getEntity());
 178   }
 179
 180   @Test
 181   public void testUpdate() {
 182     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 183     ProcessRequestDto dto = new ProcessRequestDto();
 184     Response rsp = cpi.update(dto, vspId, versionId, componentId, processId, user);
 185     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 186     Assert.assertNull(rsp.getEntity());
 187   }
 188
 189   @Test
 190   public void testGetUploadedFile() {
 191     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 192     Response rsp = cpi.getUploadedFile(vspId, versionId, componentId, processId, user);
 193     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 194     Assert.assertNotEquals(rsp.getHeaderString("Content-Disposition").indexOf(vspId),-1);
 195   }
 196
 197
 198   @Test
 199   public void testDeleteUploadedFile() {
 200     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 201     Response rsp = cpi.deleteUploadedFile(vspId, versionId, componentId, processId, user);
 202     Assert.assertEquals("Response should be 200", HttpStatus.SC_OK, rsp.getStatus());
 203     Assert.assertNull(rsp.getEntity());
 204   }
 205
 206
 207   @Test
 208   public void testUploadFile() {
 209     ComponentProcessesImpl cpi = new ComponentProcessesImpl();
 210
 211     Attachment attachment = mock(Attachment.class);
 212     when(attachment.getContentDisposition()).thenReturn(new ContentDisposition("test"));
 213     byte[] bytes = "Hello World".getBytes();
 214     when(attachment.getObject(ArgumentMatchers.any())).thenReturn(new ByteArrayInputStream(bytes));
 215     Response rsp = cpi.uploadFile(attachment, vspId, versionId, componentId, processId, user);
 216     Assert.assertNull(rsp.getEntity());
 217   }
 218
 219 }