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

   1 package org.openecomp.sdc.vendorsoftwareproduct;
   2
   3 import org.openecomp.sdc.common.errors.CoreException;
   4 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
   5 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
   6 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
   7 import org.openecomp.sdc.vendorsoftwareproduct.impl.VendorSoftwareProductManagerImpl;
   8 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
   9 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityValidationData;
  10 import org.openecomp.sdc.versioning.dao.types.Version;
  11 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  12 import org.openecomp.core.utilities.CommonMethods;
  13
  14 import org.testng.Assert;
  15 import org.testng.annotations.BeforeClass;
  16 import org.testng.annotations.Test;
  17
  18 import java.util.Collection;
  19
  20 public class NetworksTest {
  21
  22   private static final String USER1 = "networksTestUser1";
  23   private static final String USER2 = "networksTestUser2";
  24   private static final Version VERSION01 = new Version(0, 1);
  25   private static final VendorSoftwareProductManager vendorSoftwareProductManager =
  26       new VendorSoftwareProductManagerImpl();
  27   private static final org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao
  28       vendorSoftwareProductDao =
  29       VendorSoftwareProductDaoFactory.getInstance().createInterface();
  30
  31   private static String vsp1Id;
  32   private static String vsp2Id;
  33   private static String networkId = "1";
  34
  35   static org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity createNetwork(String vspId, Version version, String networkId) {
  36     org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity
  37         networkEntity = new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity(vspId, version, networkId);
  38     org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network
  39         networkData = new org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network();
  40     networkData.setName(networkId + " name");
  41     networkData.setDhcp(true);
  42     networkEntity.setNetworkCompositionData(networkData);
  43     vendorSoftwareProductDao.createNetwork(networkEntity);
  44     return networkEntity;
  45   }
  46
  47   @BeforeClass
  48   private void init() {
  49     VspDetails vsp1 = vendorSoftwareProductManager.createNewVsp(VSPCommon
  50         .createVspDetails(null, null, "VSP_" + CommonMethods.nextUuId(), "Test-vsp1", "vendorName",
  51             "vlm1Id", "icon", "category", "subCategory", "123", null), USER1);
  52     vsp1Id = vsp1.getId();
  53
  54     VspDetails vsp2 = vendorSoftwareProductManager.createNewVsp(VSPCommon
  55         .createVspDetails(null, null, "VSP_" + CommonMethods.nextUuId(), "Test-vsp2", "vendorName",
  56             "vlm1Id", "icon", "category", "subCategory", "123", null), USER1);
  57     vsp2Id = vsp2.getId();
  58   }
  59
  60   @Test
  61   public void testListWhenNone() {
  62     Collection<org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity> networks =
  63         vendorSoftwareProductManager.listNetworks(vsp1Id, null, USER1);
  64     Assert.assertEquals(networks.size(), 0);
  65   }
  66
  67   @Test
  68   public void testCreateNonExistingVspId_negative() {
  69     testCreate_negative(new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity("non existing vsp id", null, null), USER1,
  70         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
  71   }
  72
  73   @Test
  74   public void testCreateOnLockedVsp_negative() {
  75     testCreate_negative(new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity(vsp1Id, null, null), USER2,
  76         VersioningErrorCodes.EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER);
  77   }
  78
  79 /*    @Test(dependsOnMethods = "testListWhenNone")
  80     public void testCreate() {
  81         networkId = testCreate(vsp1Id);
  82     }
  83
  84     private String testCreate(String vspId) {
  85         NetworkEntity expected = new NetworkEntity(vspId, null, null);
  86         Network networkData = new Network();
  87         networkData.setName("network1 name");
  88         networkData.setDhcp(true);
  89         expected.setNetworkCompositionData(networkData);
  90
  91
  92         NetworkEntity created = vendorSoftwareProductManager.createNetwork(expected, USER1);
  93         Assert.assertNotNull(created);
  94         expected.setId(created.getId());
  95         expected.setVersion(VERSION01);
  96
  97         NetworkEntity actual = vendorSoftwareProductDao.getNetwork(vspId, VERSION01, created.getId());
  98
  99         Assert.assertEquals(actual, expected);
 100         return created.getId();
 101     }
 102
 103     @Test(dependsOnMethods = {"testCreate"})
 104     public void testCreateWithExistingName_negative() {
 105         NetworkEntity network = new NetworkEntity(vsp1Id, null, null);
 106         Network networkData = new Network();
 107         networkData.setName("network1 name");
 108         networkData.setDhcp(true);
 109         network.setNetworkCompositionData(networkData);
 110         testCreate_negative(network, USER1, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 111     }*/
 112
 113   @Test
 114   public void testCreateOnUploadVsp_negative() {
 115     testCreate_negative(new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity(vsp1Id, null, null), USER1,
 116         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 117   }
 118
 119   /*    @Test(dependsOnMethods = {"testCreate"})
 120       public void testCreateWithExistingNameUnderOtherVsp() {
 121           testCreate(vsp2Id);
 122       }
 123   */
 124   @Test(dependsOnMethods = "testListWhenNone")//"testCreate")
 125   public void testGetNonExistingNetworkId_negative() {
 126     testGet_negative(vsp1Id, null, "non existing network id", USER1,
 127         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 128   }
 129
 130   @Test(dependsOnMethods = "testListWhenNone")//"testCreate")
 131   public void testGetNonExistingVspId_negative() {
 132     testGet_negative("non existing vsp id", null, networkId, USER1,
 133         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
 134   }
 135
 136   @Test(dependsOnMethods = "testListWhenNone")//"testCreate")
 137   public void testGet() {
 138     org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity
 139         expected = createNetwork(vsp1Id, VERSION01, networkId);
 140     testGet(vsp1Id, VERSION01, networkId, USER1, expected);
 141   }
 142
 143   @Test(dependsOnMethods = "testListWhenNone")//"testCreate")
 144   public void testUpdateNonExistingNetworkId_negative() {
 145     testUpdate_negative(vsp1Id, "non existing network id", USER1,
 146         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 147   }
 148
 149   @Test(dependsOnMethods = "testListWhenNone")//"testCreate")
 150   public void testUpdateNonExistingVspId_negative() {
 151     testUpdate_negative("non existing vsp id", networkId, USER1,
 152         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
 153   }
 154
 155   @Test(dependsOnMethods = {"testGet"})
 156   public void testIllegalUpdateOnUploadVsp() {
 157     org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity
 158         expected = new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity(vsp1Id, null, networkId);
 159     org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network
 160         networkData = new org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network();
 161     networkData.setName(networkId + " name updated");
 162     networkData.setDhcp(false);
 163     expected.setNetworkCompositionData(networkData);
 164
 165     CompositionEntityValidationData validationData =
 166         vendorSoftwareProductManager.updateNetwork(expected, USER1);
 167     Assert.assertNotNull(validationData);
 168     Assert.assertTrue(validationData.getErrors().size() > 0);
 169   }
 170
 171   @Test(dependsOnMethods = {"testGet"})
 172   public void testListNonExistingVspId_negative() {
 173     testList_negative("non existing vsp id", null, USER1,
 174         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
 175   }
 176
 177     /*
 178            @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
 179            public void testCreateWithERemovedName() {
 180                testCreate(vsp1Id);
 181            }
 182
 183     @Test(dependsOnMethods = "testList")
 184     public void testDeleteNonExistingNetworkId_negative() {
 185         testDelete_negative(vsp1Id, "non existing network id", USER1, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
 186     }*/
 187
 188   @Test(dependsOnMethods = {"testGet"})
 189   public void testList() {
 190     createNetwork(vsp1Id, VERSION01, "2");
 191
 192     Collection<org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity> actual =
 193         vendorSoftwareProductManager.listNetworks(vsp1Id, null, USER1);
 194     Assert.assertEquals(actual.size(), 2);
 195   }
 196
 197   @Test(dependsOnMethods = "testList")
 198   public void testDeleteNonExistingVspId_negative() {
 199     testDelete_negative("non existing vsp id", networkId, USER1,
 200         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
 201   }
 202 /*
 203            @Test(dependsOnMethods = "testList")
 204            public void testDelete() {
 205                vendorSoftwareProductManager.deleteNetwork(vsp1Id, networkId, USER1);
 206                NetworkEntity actual = vendorSoftwareProductDao.getNetwork(vsp1Id, VERSION01, networkId);
 207                Assert.assertNull(actual);
 208            }
 209
 210            @Test
 211            public void testDeleteListNonExistingVspId_negative() {
 212                testDeleteList_negative("non existing vsp id", USER1, VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST);
 213            }
 214
 215            @Test(dependsOnMethods = "testDelete")
 216            public void testDeleteList() {
 217                NetworkEntity network3 = new NetworkEntity(vsp1Id, null, null);
 218                network3.setName("network3 name");
 219                network3.setDescription("network3 desc");
 220                vendorSoftwareProductManager.createNetwork(network3, USER1);
 221
 222                vendorSoftwareProductManager.deleteNetworks(vsp1Id, USER1);
 223
 224                Collection<NetworkEntity> actual = vendorSoftwareProductManager.listNetworks(vsp1Id, null, USER1);
 225                Assert.assertEquals(actual.size(), 0);
 226            }*/
 227
 228   @Test(dependsOnMethods = "testList")
 229   public void testDeleteOnUploadVsp_negative() {
 230     testDelete_negative(vsp1Id, networkId, USER1,
 231         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
 232   }
 233
 234   private void testGet(String vspId, Version version, String networkId, String user,
 235                        org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity expected) {
 236     CompositionEntityResponse<org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network> response =
 237         vendorSoftwareProductManager.getNetwork(vspId, null, networkId, user);
 238     Assert.assertEquals(response.getId(), expected.getId());
 239     Assert.assertEquals(response.getData(), expected.getNetworkCompositionData());
 240     Assert.assertNotNull(response.getSchema());
 241   }
 242
 243   private void testCreate_negative(
 244       org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity network, String user, String expectedErrorCode) {
 245     try {
 246       vendorSoftwareProductManager.createNetwork(network, user);
 247       Assert.fail();
 248     } catch (CoreException e) {
 249       Assert.assertEquals(e.code().id(), expectedErrorCode);
 250     }
 251   }
 252
 253   private void testGet_negative(String vspId, Version version, String networkId, String user,
 254                                 String expectedErrorCode) {
 255     try {
 256       vendorSoftwareProductManager.getNetwork(vspId, version, networkId, user);
 257       Assert.fail();
 258     } catch (CoreException e) {
 259       Assert.assertEquals(e.code().id(), expectedErrorCode);
 260     }
 261   }
 262
 263   private void testUpdate_negative(String vspId, String networkId, String user,
 264                                    String expectedErrorCode) {
 265     try {
 266       vendorSoftwareProductManager.updateNetwork(new org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity(vspId, null, networkId), user);
 267       Assert.fail();
 268     } catch (CoreException e) {
 269       Assert.assertEquals(e.code().id(), expectedErrorCode);
 270     }
 271   }
 272
 273   private void testList_negative(String vspId, Version version, String user,
 274                                  String expectedErrorCode) {
 275     try {
 276       vendorSoftwareProductManager.listNetworks(vspId, version, user);
 277       Assert.fail();
 278     } catch (CoreException e) {
 279       Assert.assertEquals(e.code().id(), expectedErrorCode);
 280     }
 281   }
 282
 283   private void testDelete_negative(String vspId, String networkId, String user,
 284                                    String expectedErrorCode) {
 285     try {
 286       vendorSoftwareProductManager.deleteNetwork(vspId, networkId, user);
 287       Assert.fail();
 288     } catch (CoreException e) {
 289       Assert.assertEquals(e.code().id(), expectedErrorCode);
 290     }
 291   }
 292 }