import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
import org.openecomp.sdc.vendorsoftwareproduct.NetworkManagerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionEntityDataManagerFactory;
public class NetworkManagerFactoryImpl extends NetworkManagerFactory {
private static final NetworkManager INSTANCE =
new NetworkManagerImpl(
NetworkDaoFactory.getInstance().createInterface(),
- CompositionEntityDataManagerFactory.getInstance().createInterface());
+ CompositionEntityDataManagerFactory.getInstance().createInterface(),
+ VendorSoftwareProductInfoDaoFactory.getInstance().createInterface());
@Override
public NetworkManager createInterface() {
import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
import org.openecomp.sdc.vendorsoftwareproduct.errors.CompositionEditNotAllowedErrorBuilder;
private final NetworkDao networkDao;
private final CompositionEntityDataManager compositionEntityDataManager;
- private static final VendorSoftwareProductInfoDao VSP_INFO_DAO
- = VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
+ private final VendorSoftwareProductInfoDao VSPInfoDao;
+
private static final String VSP_ID = "VSP id";
private static final String VSP_ID_NETWORK_ID = "VSP id, network id";
public NetworkManagerImpl(NetworkDao networkDao,
- CompositionEntityDataManager compositionEntityDataManager) {
+ CompositionEntityDataManager compositionEntityDataManager,
+ VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao) {
this.networkDao = networkDao;
this.compositionEntityDataManager = compositionEntityDataManager;
+ this.VSPInfoDao = vendorSoftwareProductInfoDao;
}
@Override
public NetworkEntity createNetwork(NetworkEntity network) {
MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(VSP_ID, network.getVspId());
- if (!VSP_INFO_DAO.isManual(network.getVspId(), network.getVersion())) {
+ if (!VSPInfoDao.isManual(network.getVspId(), network.getVersion())) {
MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
LoggerTragetServiceName.CREATE_NETWORK, ErrorLevel.ERROR.name(),
LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't create network");
NetworkEntity retrieved = getValidatedNetwork(network.getVspId(), network.getVersion(), network.getId());
NetworkCompositionSchemaInput schemaInput = new NetworkCompositionSchemaInput();
- schemaInput.setManual(!VSP_INFO_DAO.isManual(network.getVspId(), network.getVersion()));
+ schemaInput.setManual(!VSPInfoDao.isManual(network.getVspId(), network.getVersion()));
schemaInput.setNetwork(retrieved.getNetworkCompositionData());
CompositionEntityValidationData validationData = compositionEntityDataManager
Network network = networkEntity.getNetworkCompositionData();
NetworkCompositionSchemaInput schemaInput = new NetworkCompositionSchemaInput();
- schemaInput.setManual(!VSP_INFO_DAO.isManual(vspId, version));
+ schemaInput.setManual(!VSPInfoDao.isManual(vspId, version));
schemaInput.setNetwork(network);
CompositionEntityResponse<Network> response = new CompositionEntityResponse<>();
public void deleteNetwork(String vspId, Version version, String networkId) {
MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(VSP_ID_NETWORK_ID, vspId, networkId);
- if (!VSP_INFO_DAO.isManual(vspId, version)) {
+ if (!VSPInfoDao.isManual(vspId, version)) {
MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
LoggerTragetServiceName.DELETE_NETWORK, ErrorLevel.ERROR.name(),
LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't delete network");
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ componentManager = null;
+ }
+
@Test
public void testListWhenNone() {
Collection<ComponentEntity> components = componentManager.listComponents(VSP_ID, VERSION);
VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
}
- /* @Test
- public void testCreate() {
- COMP1_ID = testCreate(VSP_ID);
- }*/
@Test
public void testCreate() {
ComponentEntity expected = new ComponentEntity(VSP_ID, null, null);
doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
try {
- ComponentEntity created = componentManager.createComponent(expected);
+ componentManager.createComponent(expected);
} catch (CoreException exception) {
Assert.assertEquals("Creation of only one VFC per VSP allowed.", exception.code().message());
Assert.assertEquals(VendorSoftwareProductErrorCodes.VSP_VFC_COUNT_EXCEED,
.validateEntity(anyObject(), anyObject(), anyObject());
try {
- CompositionEntityValidationData created = componentManager.updateComponent(expected);
+ componentManager.updateComponent(expected);
} catch (CoreException exception) {
Assert.assertEquals("VFC with specified name already present in given VSP.",
exception.code().message());
}
@Test
- public void testComponentNullQuestionnaire() throws Exception {
+ public void testComponentNullQuestionnaire() {
doReturn(new ComponentEntity(VSP_ID, VERSION, COMP1_ID)).when(componentDaoMock)
.getQuestionnaireData(VSP_ID, VERSION, COMP1_ID);
String schema = "schema string";
QuestionnaireResponse questionnaire =
componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID);
Assert.assertNotNull(questionnaire);
- Assert.assertEquals(questionnaire.getData(), null);
+ Assert.assertNull(questionnaire.getData());
Assert.assertEquals(questionnaire.getSchema(), schema);
Assert.assertNull(questionnaire.getErrorMessage());
}
.updateQuestionnaireData(VSP_ID, VERSION, COMP1_ID, "questionnaire data");
}
-/*
- @Test(dependsOnMethods = "testDelete")
- public void testDeleteList() {
- ComponentEntity comp3 = new ComponentEntity(VSP_ID, null, null);
- comp3.setName("comp3 name");
- comp3.setDescription("comp3 desc");
- componentManager.createComponent(comp3, USER);
-
- componentManager.deleteComponents(VSP_ID, USER);
-
- Collection<ComponentEntity> actual = componentManager.listComponents(VSP_ID, null, USER);
- Assert.assertEquals(actual.size(), 0);
- }*/
-
private void testGet(String vspId, Version version, String componentId,
ComponentEntity expected) {
}
}
- private void testList_negative(String vspId, Version version,
- String expectedErrorCode) {
- try {
- componentManager.listComponents(vspId, version);
- Assert.fail();
- } catch (CoreException exception) {
- Assert.assertEquals(exception.code().id(), expectedErrorCode);
- }
- }
-
private void testDeleteList_negative(String vspId, Version version,
String expectedErrorCode) {
try {
}
- public static ComponentEntity createComponent(String vspId, Version version, String compId) {
+ private static ComponentEntity createComponent(String vspId, Version version, String compId) {
ComponentEntity componentEntity = new ComponentEntity(vspId, version, compId);
ComponentData compData = new ComponentData();
compData.setName(compId + " name");
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.common.errors.ErrorCategory;
import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ computeManager = null;
+ }
+
@Test
public void testListWhenNone() {
Collection<ListComputeResponse> computes =
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ deploymentFlavorManager = null;
+ }
+
@Test
public void testListWhenNone() {
final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ imageManager = null;
+ }
+
+
@Test
public void testListWhenNone() {
final Collection<ImageEntity> imageEntities =
package org.openecomp.sdc.vendorsoftwareproduct.impl;
+
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.NetworkDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
private static final String VSP_ID = "vsp";
+ private static final String USER_ID = "test_user1";
private static final Version VERSION = new Version("version_id");
private static final String NETWORK1_ID = "network1";
private static final String NETWORK2_ID = "network2";
private NetworkDao networkDaoMock;
@Mock
private CompositionEntityDataManager compositionEntityDataManagerMock;
+ @Mock
+ private VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao;
+
@InjectMocks
@Spy
private NetworkManagerImpl networkManager;
@BeforeMethod
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
+ SessionContextProviderFactory.getInstance().createInterface().create(USER_ID);
+ }
+
+ @AfterMethod
+ public void tearDown() {
+ networkManager = null;
+ SessionContextProviderFactory.getInstance().createInterface().close();
}
@Test
Assert.assertEquals(actual.size(), 2);
}
-/* @Test(dependsOnMethods = "testListWhenNone")
- public void testCreate() {
- NETWORK1_ID = testCreate(VSP_ID);
- }
-
- private String testCreate(String vspId) {
- NetworkEntity expected = new NetworkEntity(vspId, null, null);
- Network networkData = new Network();
- networkData.setName("network1 name");
- networkData.setDhcp(true);
- expected.setNetworkCompositionData(networkData);
-
-
- NetworkEntity created = networkManager.createNetwork(expected);
- Assert.assertNotNull(created);
- expected.setId(created.getId());
- expected.setVersion(VERSION01);
-
- NetworkEntity actual = networkDaoMock.getNetwork(vspId, VERSION01, created.getId());
-
- Assert.assertEquals(actual, expected);
- return created.getId();
- }
-
- @Test(dependsOnMethods = {"testCreate"})
- public void testCreateWithExistingName_negative() {
- NetworkEntity network = new NetworkEntity(VSP_ID, null, null);
- Network networkData = new Network();
- networkData.setName("network1 name");
- networkData.setDhcp(true);
- network.setNetworkCompositionData(networkData);
- testCreate_negative(network, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
- }*/
-
@Test
public void testCreateOnUploadVsp_negative() {
testCreate_negative(new NetworkEntity(VSP_ID, VERSION, null),
VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
}
- /* @Test(dependsOnMethods = {"testCreate"})
- public void testCreateWithExistingNameUnderOtherVsp() {
- testCreate(vsp2Id);
- }
- */
-
@Test
public void testUpdateNonExistingNetworkId_negative() {
testUpdate_negative(VSP_ID, VERSION, NETWORK1_ID,
doReturn(toBeReturned)
.when(compositionEntityDataManagerMock)
.validateEntity(anyObject(), anyObject(), anyObject());
+ doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
NetworkEntity networkEntity = new NetworkEntity(VSP_ID, VERSION, NETWORK1_ID);
Network networkData = new Network();
doReturn(network)
.when(networkDaoMock).get(anyObject());
doReturn("schema string").when(networkManager).getCompositionSchema(anyObject());
+ doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
CompositionEntityResponse<Network> response =
networkManager.getNetwork(VSP_ID, VERSION, NETWORK1_ID);
Assert.assertNotNull(response.getSchema());
}
- /*
- @Test(dependsOnMethods = {"testUpdateOnUploadVsp", "testList"})
- public void testCreateWithERemovedName() {
- testCreate(VSP_ID);
- }
-
- @Test(dependsOnMethods = "testList")
- public void testDeleteNonExistingNetworkId_negative() {
- testDelete_negative(VSP_ID, "non existing network id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
- }*/
-
-/*
- @Test(dependsOnMethods = "testList")
- public void testDelete() {
- networkManager.deleteNetwork(VSP_ID, NETWORK1_ID);
- NetworkEntity actual = networkDaoMock.getNetwork(VSP_ID, VERSION01, NETWORK1_ID);
- Assert.assertNull(actual);
- }
-
-
-
- @Test(dependsOnMethods = "testDelete")
- public void testDeleteList() {
- NetworkEntity network3 = new NetworkEntity(VSP_ID, null, null);
- network3.setName("network3 name");
- network3.setDescription("network3 desc");
- networkManager.createNetwork(network3);
-
- networkManager.deleteNetworks(VSP_ID);
-
- Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, null);
- Assert.assertEquals(actual.size(), 0);
- }*/
-
@Test(dependsOnMethods = "testList")
public void testDeleteOnUploadVsp_negative() {
testDelete_negative(VSP_ID, VERSION, NETWORK1_ID,
private void testCreate_negative(NetworkEntity network, String expectedErrorCode) {
try {
+ doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
networkManager.createNetwork(network);
Assert.fail();
} catch (CoreException exception) {
private void testDelete_negative(String vspId, Version version, String networkId,
String expectedErrorCode) {
try {
+ doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(),anyObject());
networkManager.deleteNetwork(vspId, version, networkId);
Assert.fail();
} catch (CoreException exception) {
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ nicManager = null;
+ }
+
@Test
public void testListWhenNone() {
Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
MockitoAnnotations.initMocks(this);
}
+ @AfterMethod
+ public void tearDown() {
+ processManager = null;
+ }
+
+
@Test
public void testListWhenNone() {
Collection<ProcessEntity> processes =
import org.openecomp.sdc.versioning.types.VersionInfo;
import org.openecomp.sdc.versioning.types.VersionableEntityAction;
import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
}
+
+ @AfterMethod
+ public void tearDown(){
+ vendorSoftwareProductManager = null;
+ }
/*
@Test
public void testListWhenNone() {