openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import org.mockito.InjectMocks;
   4 import org.mockito.Mock;
   5 import org.mockito.MockitoAnnotations;
   6 import org.mockito.Spy;
   7 import org.openecomp.sdc.common.errors.CoreException;
   8 import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
   9 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  10 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
  11 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  12 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  13 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  14 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  15 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  16 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  17 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  18 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  19 import org.openecomp.sdc.versioning.dao.types.Version;
  20 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  21 import org.testng.Assert;
  22 import org.testng.annotations.BeforeMethod;
  23 import org.testng.annotations.Test;
  24
  25 import java.util.Arrays;
  26 import java.util.Collection;
  27
  28 import static org.mockito.Matchers.anyObject;
  29 import static org.mockito.Mockito.doReturn;
  30 import static org.mockito.Mockito.never;
  31 import static org.mockito.Mockito.verify;
  32
  33 public class NicManagerImplTest {
  34   private static final String NIC_NOT_EXIST_MSG =
  35       "Vendor Software Product NIC with Id nic1 does not exist for Vendor Software Product with " +
  36           "id VSP_ID and version 0.1";
  37
  38   private static final String USER = "nicTestUser";
  39   private static final String VSP_ID = "VSP_ID";
  40   private static final Version VERSION = new Version(0, 1);
  41   private static final String COMPONENT_ID = "COMPONENT_ID";
  42   private static final String NIC1_ID = "nic1";
  43   private static final String NIC2_ID = "nic2";
  44   private static final String NETWORK1_ID = "network1";
  45   private static final String NETWORK2_ID = "network2";
  46
  47   @Mock
  48   private NicDao nicDao;
  49   @Mock
  50   private CompositionEntityDataManager compositionEntityDataManagerMock;
  51   @Mock
  52   private NetworkManager networkManagerMock;
  53   @InjectMocks
  54   @Spy
  55   private NicManagerImpl nicManager;
  56
  57   @BeforeMethod
  58   public void setUp() throws Exception {
  59     MockitoAnnotations.initMocks(this);
  60   }
  61
  62   @Test
  63   public void testListWhenNone() {
  64     Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID, USER);
  65     Assert.assertEquals(nics.size(), 0);
  66   }
  67
  68   @Test
  69   public void testList() {
  70     doReturn(Arrays.asList(
  71         createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID),
  72         createNic(VSP_ID, VERSION, COMPONENT_ID, NIC2_ID, NETWORK2_ID)))
  73         .when(nicDao).list(anyObject());
  74
  75     NetworkEntity network1 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK1_ID);
  76     NetworkEntity network2 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK2_ID);
  77     doReturn(Arrays.asList(network1, network2))
  78         .when(networkManagerMock).listNetworks(VSP_ID, VERSION, USER);
  79
  80     Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID, USER);
  81     Assert.assertEquals(nics.size(), 2);
  82     for (NicEntity nic : nics) {
  83       Assert.assertEquals(nic.getNicCompositionData().getNetworkName(),
  84           NIC1_ID.equals(nic.getId())
  85               ? network1.getNetworkCompositionData().getName()
  86               : network2.getNetworkCompositionData().getName());
  87     }
  88   }
  89
  90 //    @Test(dependsOnMethods = "testListWhenNone")
  91 //    public void testCreate() {
  92 //        NIC1_ID = testCreate(VSP_ID, COMPONENT_ID, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
  93 //    }
  94
  95 /*    @Test(dependsOnMethods = {"testCreate"})
  96     public void testCreateWithExistingName_negative() {
  97         NicEntity nic = new NicEntity(VSP_ID, null, COMPONENT_ID, null);
  98         Nic nicData = new Nic();
  99         nicData.setName("nic1 name");
 100         nic.setNicCompositionData(nicData);
 101         testCreate_negative(nic, USER, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 102     }*/
 103
 104 //    @Test(dependsOnMethods = {"testCreate"})
 105 //    public void testCreateWithExistingNameUnderOtherComponent() {
 106 //        ComponentEntity component12 = new ComponentEntity(VSP_ID, null, null);
 107 //        ComponentData compData12 = new ComponentData();
 108 //        compData12.setName("comp12 name");
 109 //        compData12.setDescription("comp12 desc");
 110 //        component12.setComponentCompositionData(compData12);
 111 //
 112 //        String component12Id = nicManager.createComponent(component12, USER).getId();
 113 //        testCreate(VSP_ID, component12Id, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 114 //    }
 115
 116 //    @Test(dependsOnMethods = {"testCreate"})
 117 //    public void testCreateWithExistingNameUnderOtherVsp() {
 118 //        testCreate(vsp2Id, component21Id, network2.getId(), network2.getNetworkCompositionData().getName());
 119 //    }
 120
 121   @Test
 122   public void testCreateOnUploadVsp_negative() {
 123
 124     testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
 125         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 126   }
 127
 128   @Test
 129   public void testUpdateNonExistingNicId_negative() {
 130     doReturn(null).when(nicDao).get(anyObject());
 131
 132     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
 133         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 134   }
 135
 136   @Test
 137   public void testUpdateOnUploadVsp() {
 138     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 139         .when(nicDao).get(anyObject());
 140
 141     doReturn(new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID))
 142         .when(compositionEntityDataManagerMock)
 143         .validateEntity(anyObject(), anyObject(), anyObject());
 144
 145     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 146     Nic nicData = new Nic();
 147     nicData.setName(NIC1_ID + " name");
 148     nicData.setDescription(NIC1_ID + " desc updated");
 149     nicData.setNetworkId(NETWORK1_ID);
 150     nicEntity.setNicCompositionData(nicData);
 151
 152     CompositionEntityValidationData validationData =
 153         nicManager.updateNic(nicEntity, USER);
 154     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
 155     verify(nicDao).update(nicEntity);
 156   }
 157
 158   @Test
 159   public void testIllegalUpdateOnUploadVsp() {
 160     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
 161         .when(nicDao).get(anyObject());
 162
 163     CompositionEntityValidationData toBeReturned =
 164         new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
 165     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
 166     doReturn(toBeReturned)
 167         .when(compositionEntityDataManagerMock)
 168         .validateEntity(anyObject(), anyObject(), anyObject());
 169
 170     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 171     Nic nicData = new Nic();
 172     nicData.setName(NIC1_ID + " name updated");
 173     nicData.setDescription(NIC1_ID + " desc updated");
 174     nicData.setNetworkId(NETWORK1_ID);
 175     nicEntity.setNicCompositionData(nicData);
 176
 177     CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity, USER);
 178     Assert.assertNotNull(validationData);
 179     Assert.assertEquals(validationData.getErrors().size(), 2);
 180
 181     verify(nicDao, never()).update(nicEntity);
 182   }
 183
 184
 185   @Test
 186   public void testGetNonExistingNicId_negative() {
 187     testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id", USER,
 188         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 189   }
 190
 191
 192   @Test
 193   public void testGet() {
 194     NicEntity expected = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 195     doReturn(expected).when(nicDao).get(anyObject());
 196     String compositionSchema = "schema string";
 197     doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(anyObject());
 198
 199     CompositionEntityResponse<Nic> response =
 200         nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 201     Assert.assertEquals(response.getId(), expected.getId());
 202     Assert.assertEquals(response.getData(), expected.getNicCompositionData());
 203     Assert.assertEquals(response.getSchema(), compositionSchema);
 204   }
 205
 206 /*
 207     @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 208     public void testCreateWithRemovedName() {
 209         testCreate(VSP_ID, COMPONENT_ID);
 210     }
 211
 212     @Test
 213     public void testDeleteNonExistingNicId_negative() {
 214         testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 215     }
 216
 217     @Test(dependsOnMethods = "testList")
 218     public void testDeleteNonExistingComponentId_negative() {
 219         testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 220     }*/
 221
 222 /*
 223     @Test(dependsOnMethods = "testList")
 224     public void testDelete() {
 225         nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID, USER);
 226         NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 227         Assert.assertNull(actual);
 228     }*/
 229
 230   @Test
 231   public void testDeleteOnUploadVsp_negative() {
 232     testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
 233         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 234   }
 235
 236   @Test(expectedExceptions = CoreException.class,
 237       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 238   public void testGetNonExistingNicQuestionnaire() throws Exception {
 239     nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 240   }
 241
 242   @Test
 243   public void testGetQuestionnaire() throws Exception {
 244     NicEntity nic = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 245     nic.setQuestionnaireData("{}");
 246     doReturn(nic).when(nicDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 247
 248     String schema = "schema string";
 249     doReturn(schema).when(nicManager).getNicQuestionnaireSchema(anyObject());
 250
 251     QuestionnaireResponse questionnaire =
 252         nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
 253     Assert.assertNotNull(questionnaire);
 254     Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
 255     Assert.assertEquals(questionnaire.getSchema(), schema);
 256     Assert.assertNull(questionnaire.getErrorMessage());
 257   }
 258
 259   @Test(expectedExceptions = CoreException.class,
 260       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
 261   public void testUpdateNonExistingNicQuestionnaire() throws Exception {
 262     doReturn(null).when(nicDao).get(anyObject());
 263     nicManager
 264         .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data", USER);
 265   }
 266
 267   @Test
 268   public void testUpdateQuestionnaire() throws Exception {
 269
 270   }
 271
 272   private void testCreate_negative(NicEntity nic, String user, String expectedErrorCode) {
 273     try {
 274       nicManager.createNic(nic, user);
 275       Assert.fail();
 276     } catch (CoreException exception) {
 277       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 278     }
 279   }
 280
 281   private void testGet_negative(String vspId, Version version, String componentId, String nicId,
 282                                 String user, String expectedErrorCode) {
 283     try {
 284       nicManager.getNic(vspId, version, componentId, nicId, user);
 285       Assert.fail();
 286     } catch (CoreException exception) {
 287       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 288     }
 289   }
 290
 291   private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
 292                                    String user, String expectedErrorCode) {
 293     try {
 294       nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId), user);
 295       Assert.fail();
 296     } catch (CoreException exception) {
 297       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 298     }
 299   }
 300
 301   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
 302                                    String user,
 303                                    String expectedErrorCode) {
 304     try {
 305       nicManager.deleteNic(vspId, version, componentId, nicId, user);
 306       Assert.fail();
 307     } catch (CoreException exception) {
 308       Assert.assertEquals(exception.code().id(), expectedErrorCode);
 309     }
 310   }
 311
 312   static NicEntity createNic(String vspId, Version version, String compId, String nicId,
 313                              String networkId) {
 314     NicEntity nicEntity = new NicEntity(vspId, version, compId, nicId);
 315     Nic nicData = new Nic();
 316     nicData.setName(nicId + " name");
 317     nicData.setDescription(nicId + " desc");
 318     nicData.setNetworkId(networkId);
 319     nicEntity.setNicCompositionData(nicData);
 320     return nicEntity;
 321   }
 322
 323
 324 }