diff options
Diffstat (limited to 'catalog-dao/src/test/java')
5 files changed, 1899 insertions, 0 deletions
diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java new file mode 100644 index 0000000000..aa9d30cb12 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java @@ -0,0 +1,577 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.resources; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import javax.annotation.Resource; + +import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; +import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.api.IGenericSearchDAO; +import org.openecomp.sdc.be.dao.api.ResourceUploadStatus; +import org.openecomp.sdc.be.dao.es.ElasticSearchClient; +import org.openecomp.sdc.be.resources.api.IResourceUploader; +import org.openecomp.sdc.be.resources.data.ESArtifactData; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestExecutionListeners; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; +import org.springframework.test.context.support.DirtiesContextTestExecutionListener; +import org.springframework.test.context.transaction.TransactionalTestExecutionListener; + +import fj.data.Either; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class, + DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) // , + // CassandraUnitTestExecutionListener.class}) +// @EmbeddedCassandra(host ="localhost", port=9042) +public class ArtifactDaoTest { + private static final String TEST_IMAGES_DIRECTORY = "src/test/resources/images"; + + @Resource + ElasticSearchClient esclient; + + /* + * @Resource(name = "artifact-dao") private IArtifactDAO artifactDAO; + */ + + @Resource(name = "resource-upload") + private IResourceUploader daoUploader; + ESArtifactData arData; + + @Resource(name = "resource-dao") + private IGenericSearchDAO resourceDAO; + + private String nodeType = "NodeType1"; + private String nodeTypeVersion = "1.0.0"; + + private String nodeType2 = "NodeType2"; + private String nodeTypeVersion2 = "1.0.1"; + + private String nodeType3 = "NodeType3"; + private String nodeNypeVersion3 = "1.1.1"; + + private String topologyId = "topology"; + private String topologyTemplateName = "topologyTemplate"; + private String topologyTemplateVersion = "1.1.1"; + + private String nodeTypeTemplate1 = "NodeTypeTemplate1"; + private String nodeTypeTemplate2 = "NodeTypeTemplate2"; + private String nodeTypeTemplate3 = "NodeTypeTemplate3"; + + private static ConfigurationManager configurationManager; + + @Before + public void before() { + // try { + // clearIndex(ICatalogDAO.RESOURCES_INDEX, ArtifactData.class); + // clearIndex(ICatalogDAO.RESOURCES_INDEX, ServiceArtifactData.class); + // } catch (InterruptedException e) { + // TODO Auto-generated catch block + // e.printStackTrace(); + // } + + } + + @BeforeClass + public static void setupBeforeClass() { + ExternalConfiguration.setAppName("catalog-dao"); + String appConfigDir = "src/test/resources/config/catalog-dao"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), + appConfigDir); + configurationManager = new ConfigurationManager(configurationSource); + } + + // @Before + // public void createSchema(){ + // SdcSchemaBuilder.createSchema(); + // } + // + + @Test + public void testSaveNewArtifact() { + // daoUploader = new ArtifactUploader(artifactDAO); + if (daoUploader == null) { + assertTrue(false); + } + String strData = "qweqwqweqw34e4wrwer"; + + String myNodeType = "MyNewNodeType"; + + ESArtifactData arData = new ESArtifactData("artifactNewMarina11", strData.getBytes()); + + ResourceUploadStatus status = daoUploader.saveArtifact(arData, true); + + assertEquals(status, ResourceUploadStatus.OK); + + daoUploader.deleteArtifact(arData.getId()); + + } + + /* + * @Test public void testSaveNewImage(){ + * + * Path iconPath = Paths.get(TEST_IMAGES_DIRECTORY, "apache.png"); + * + * ImageData imageData = new ImageData(); try { + * imageData.setData(Files.readAllBytes(iconPath)); + * imageData.setComponentName("ComponentMarina"); + * imageData.setComponentVersion("v.1.0"); + * imageData.setArtifactName("apache.png"); + * imageData.setResourceCreator("Marina"); + * imageData.setResourceLastUpdater("Marina"); ResourceUploadStatus status = + * daoUploader.saveImage(imageData, true); assertEquals(status, + * ResourceUploadStatus.OK); } catch (IOException e) { // TODO + * Auto-generated catch block e.printStackTrace(); } + * + * + * } + */ + + // @Test + // public void testGetArtifactsList() { + // //daoUploader = new ArtifactUploader(artifactDAO); + // if(daoUploader==null){ + // assertTrue(false); + // } + // String myNodeType = "MyListNodeType"; + // + // + // + // //resourceDAO.save(indexedNodeType); + // + // String strData = "qweqwqweqw34e4wrwer"; + // ESArtifactData arData1 = new ESArtifactData("artifactNewMarina_1", + // strData.getBytes()); + // + // + // ResourceUploadStatus status = daoUploader.saveArtifact(arData1, true); + // assertEquals(status, ResourceUploadStatus.OK); + // + // ESArtifactData arData2 = new ESArtifactData("artifactNewMarina_2", + // strData.getBytes()); + // + // + // status = daoUploader.saveArtifact(arData2, true); + // assertEquals(status, ResourceUploadStatus.OK); + // + // ESArtifactData arData3 = new ESArtifactData("artifactNewMarina_3", + // strData.getBytes()); + // + // + // status = daoUploader.saveArtifact(arData3, true); + // assertEquals(status, ResourceUploadStatus.OK); + // + // + // + // Either<List<ESArtifactData>, ResourceUploadStatus> arrArray = + // daoUploader.getArtifacts(myNodeType, nodeTypeVersion); + // assertTrue(arrArray.isLeft()); + // + // assertEquals(3, arrArray.left().value().size()); + // + // daoUploader.deleteArtifact(arData1.getId()); + // daoUploader.deleteArtifact(arData2.getId()); + // daoUploader.deleteArtifact(arData3.getId()); + // + // //resourceDAO.delete(IndexedNodeType.class, indexedNodeType.getId()); + // + // } + // + + /* + * @Test public void testGetSeviceArtifactsList() { + * + * if(daoUploader==null){ assertTrue(false); } String strData = + * "qweqwqweqw34e4wrwer"; + * + * ServiceArtifactData serviceArData = new + * ServiceArtifactData("serviceArData", topologyTemplateName, + * topologyTemplateVersion, nodeTypeTemplate1, nodeType, nodeTypeVersion, + * "YANG", strData.getBytes(), strData.getBytes(), "Marina", null); + * //serviceArData.setRefArtifactId(arData.getId()); ResourceUploadStatus + * status = daoUploader.saveServiceArtifact(serviceArData, true); + * + * ServiceArtifactData serviceArData1 = new + * ServiceArtifactData("serviceArData1", topologyTemplateName, + * topologyTemplateVersion, nodeTypeTemplate2, nodeType2, nodeTypeVersion2, + * "YANG", strData.getBytes(), strData.getBytes(), "Marina", null); + * //serviceArData1.setRefArtifactId(arData4.getId()); status = + * daoUploader.saveServiceArtifact(serviceArData1, true); + * ServiceArtifactData getServiceData = + * daoUploader.getServiceArtifact(serviceArData.getId()).left().value(); + * + * List<ServiceArtifactData> arrArray = + * daoUploader.getServiceArtifacts(topologyTemplateName, + * topologyTemplateVersion).left().value(); + * + * assertEquals(2, arrArray.size()); + * + * daoUploader.deleteArtifact(serviceArData.getId()); + * daoUploader.deleteArtifact(serviceArData1.getId()); + * + * + * } + */ + + @Test + public void testGetArtifact() { + + String myNodeType = "MyNodeType"; + + // resourceDAO.save(indexedNodeType); + ESArtifactData arData = getArtifactData(myNodeType, nodeTypeVersion); + + ESArtifactData getData = null; + Either<ESArtifactData, ResourceUploadStatus> getArtifactStatus = daoUploader + .getArtifact(myNodeType + "- dassasd" + ":" + nodeTypeVersion + ":updatedArtifact"); + if (getArtifactStatus.isRight()) { + daoUploader.saveArtifact(arData, true); + getArtifactStatus = daoUploader.getArtifact(arData.getId()); + } + assertNotNull(getArtifactStatus.left().value()); + + } + + /* + * @Test public void testGetSeviceArtifact() { + * + * ServiceArtifactData servArData = getServiceArtifactData(); + * + * Either<ServiceArtifactData, ResourceUploadStatus> + * getServiceArtifactStatus = + * daoUploader.getServiceArtifact("MyService:v.1.1:updatedServiceArtifact"); + * if (!getServiceArtifactStatus.isLeft()){ + * daoUploader.saveServiceArtifact(servArData, true); + * getServiceArtifactStatus = + * daoUploader.getServiceArtifact(servArData.getId()); } + * + * assertNotNull(getServiceArtifactStatus.left().value()); + * + * daoUploader.deleteArtifact(getServiceArtifactStatus.left().value().getId( + * )); + * + * + * } + */ + + /* + * @Test public void testGetSeviceArtifactsCollection() { + * + * prepareTopolgyService(); prepareTestTopolgyService(); + * Either<ServiceArtifactsDataCollection, ResourceUploadStatus> + * getServiceArtifactsCollectionStatus = + * daoUploader.getServiceArtifactsCollection(topologyTemplateName, + * topologyTemplateVersion); ServiceArtifactsDataCollection serviceAtrifacts + * = getServiceArtifactsCollectionStatus.left().value(); + * + * Map<String, List<ArtifactData>> map = + * serviceAtrifacts.getServiceArtifactDataMap(); + * + * List<ArtifactData> list = map.get(nodeType); assertNotNull(list); + * assertEquals(2, list.size()); + * + * + * list = map.get(nodeTypeTemplate1 ); assertNotNull(list); assertEquals(1, + * list.size()); + * + * list = map.get(nodeTypeTemplate2 ); assertNotNull(list); assertEquals(1, + * list.size()); + * + * + * } + */ + + @Test + public void testUpdateArtifact() { + // daoUploader = new ArtifactUploader(artifactDAO); + if (daoUploader == null) { + assertTrue(false); + } + ResourceUploadStatus status = ResourceUploadStatus.OK; + + String myNodeType = "MyUpdatedNodeType"; + + // resourceDAO.save(indexedNodeType); + + ESArtifactData arData = getArtifactData(myNodeType, nodeTypeVersion); + Either<ESArtifactData, ResourceUploadStatus> getArtifactStatus = daoUploader.getArtifact(arData.getId()); + + if (!getArtifactStatus.isLeft()) + status = daoUploader.saveArtifact(arData, false); + + String payload1 = "new payloadjfdsgh"; + arData.setDataAsArray(payload1.getBytes()); + + status = daoUploader.updateArtifact(arData); + + assertEquals(status, ResourceUploadStatus.OK); + // resourceDAO.delete(IndexedNodeType.class, indexedNodeType.getId()); + + } + + private ESArtifactData getArtifactData(String componentName, String componentVersion) { + String strData = "qweqwqweqw34e4wrwer"; + ESArtifactData arData = new ESArtifactData("updatedArtifact", strData.getBytes()); + + return arData; + } + + /* + * private ServiceArtifactData getServiceArtifactData(){ String strData = + * "qweqwqweqw34e4wrwer"; ServiceArtifactData arData = new + * ServiceArtifactData("updatedServiceArtifact", "MyService", "v.1.1", + * "MyComponentTemplate", "MyComponent", "v.1.1", "YANG", + * strData.getBytes(), strData.getBytes(), "Marina", null); + * + * return arData; } + */ + + /* + * private void prepareTopolgyService(){ + * + * List<String> listCap = new ArrayList<String>(); listCap.add("very_evil"); + * List<String> listCap1 = new ArrayList<String>(); listCap.add("evil"); + * try{ // Initialize test data IndexedNodeType indexedNodeType = new + * IndexedNodeType(); CSARDependency dep = new CSARDependency(); + * dep.setName(nodeType); dep.setVersion(nodeTypeVersion); + * indexedNodeType.setElementId(nodeType); + * indexedNodeType.setArchiveName(nodeType); + * indexedNodeType.setArchiveVersion(nodeTypeVersion); + * indexedNodeType.setCreationDate(new Date()); + * indexedNodeType.setLastUpdateDate(new Date()); + * indexedNodeType.setDefaultCapabilities(listCap); + * resourceDAO.save(indexedNodeType); + * + * + * IndexedNodeType indexedNodeType1 = new IndexedNodeType(); + * indexedNodeType1.setElementId(nodeType2); + * indexedNodeType1.setArchiveName(nodeType2); + * indexedNodeType1.setArchiveVersion(nodeTypeVersion2); CSARDependency dep1 + * = new CSARDependency(); dep1.setName(nodeType2); + * dep1.setVersion(nodeTypeVersion2); indexedNodeType1.setCreationDate(new + * Date()); indexedNodeType1.setLastUpdateDate(new Date()); + * indexedNodeType1.setDefaultCapabilities(listCap1); + * resourceDAO.save(indexedNodeType1); + * + * + * indexedNodeType.setElementId(nodeType3); + * indexedNodeType.setArchiveName(nodeType3); + * indexedNodeType.setArchiveVersion(nodeNypeVersion3); CSARDependency dep2 + * = new CSARDependency(); dep2.setName(nodeType3); + * dep2.setVersion(nodeNypeVersion3); indexedNodeType.setCreationDate(new + * Date()); indexedNodeType.setLastUpdateDate(new Date()); + * indexedNodeType.setDefaultCapabilities(null); + * resourceDAO.save(indexedNodeType); String osgiliath100Id = + * indexedNodeType.getId(); + * + * Topology topology = new Topology(); topology.setId(topologyId); + * Set<CSARDependency> dependencies = new HashSet<CSARDependency>(); + * dependencies.add(dep); dependencies.add(dep2); dependencies.add(dep1); + * topology.setDependencies(dependencies); Map<String, NodeTemplate> + * nodeTemplates = new HashMap <String, NodeTemplate>(); + * + * NodeTemplate template1 = new NodeTemplate(nodeType, null, null, null, + * null, null, null); template1.setName(nodeTypeTemplate1); + * nodeTemplates.put(nodeTypeTemplate1, template1 ); + * + * NodeTemplate template2 = new NodeTemplate(nodeType2, null, null, null, + * null, null, null); template2.setName(nodeTypeTemplate2 ); + * nodeTemplates.put(nodeTypeTemplate2, template2 ); + * + * NodeTemplate template3 = new NodeTemplate(nodeType, null, null, null, + * null, null, null); template3.setName(nodeTypeTemplate3 ); + * nodeTemplates.put(nodeTypeTemplate3, template3); + * + * topology.setNodeTemplates(nodeTemplates); resourceDAO.save(topology); + * + * TopologyTemplate topologyTemplate = new TopologyTemplate(); + * topologyTemplate.setId(topologyTemplateName); + * topologyTemplate.setName(topologyTemplateName); + * topologyTemplate.setTopologyId(topology.getId()); + * topologyTemplate.setDescription("my topology template"); + * resourceDAO.save(topologyTemplate); + * + * String strData = "qweqwqweqw34e4wrwer"; ArtifactData arData = new + * ArtifactData("artifact1", nodeType, nodeTypeVersion, "YANG", + * strData.getBytes(), strData.getBytes(), "Marina"); ArtifactData arData1 = + * new ArtifactData("artifact2", nodeType, nodeTypeVersion, "YANG", + * strData.getBytes(), strData.getBytes(), "Marina"); ResourceUploadStatus + * status = daoUploader.saveArtifact(arData, true); status = + * daoUploader.saveArtifact(arData1, true); + * + * ArtifactData arData3 = new ArtifactData("artifact1", nodeType2, + * nodeTypeVersion2, "YANG", strData.getBytes(), strData.getBytes(), + * "Marina"); status = daoUploader.saveArtifact(arData3, true); + * + * ArtifactData arData4 = new ArtifactData("artifact2", nodeType2, + * nodeTypeVersion2, "YANG", strData.getBytes(), strData.getBytes(), + * "Marina"); status = daoUploader.saveArtifact(arData4, true); + * + * ServiceArtifactData serviceArData = new + * ServiceArtifactData("serviceArData", topologyTemplateName, + * topologyTemplateVersion, nodeTypeTemplate1, nodeType, nodeTypeVersion, + * "YANG", strData.getBytes(), strData.getBytes(), "Marina", + * arData.getId()); + * + * status = daoUploader.saveServiceArtifact(serviceArData, true); + * + * ServiceArtifactData serviceArData1 = new + * ServiceArtifactData("serviceArData1", topologyTemplateName, + * topologyTemplateVersion, nodeTypeTemplate2, nodeType2, nodeTypeVersion2, + * "YANG", strData.getBytes(), strData.getBytes(), "Marina", + * arData4.getId()); + * + * status = daoUploader.saveServiceArtifact(serviceArData1, true); + * + * + * } catch (Exception e) { // TODO Auto-generated catch block + * e.printStackTrace(); } + * + * } + * + * private void prepareTestTopolgyService(){ + * + * List<String> listCap = new ArrayList<String>(); + * listCap.add("very_evil test"); List<String> listCap1 = new + * ArrayList<String>(); listCap.add("evil test"); try{ // Initialize test + * data IndexedNodeType indexedNodeType = new IndexedNodeType(); + * CSARDependency dep = new CSARDependency(); dep.setName(nodeType + + * " test"); dep.setVersion(nodeTypeVersion); + * indexedNodeType.setElementId(nodeType + " test"); + * indexedNodeType.setArchiveName(nodeType + " test"); + * indexedNodeType.setArchiveVersion(nodeTypeVersion); + * indexedNodeType.setCreationDate(new Date()); + * indexedNodeType.setLastUpdateDate(new Date()); + * indexedNodeType.setDefaultCapabilities(listCap); + * resourceDAO.save(indexedNodeType); + * + * + * IndexedNodeType indexedNodeType1 = new IndexedNodeType(); + * indexedNodeType1.setElementId(nodeType2 + " test"); + * indexedNodeType1.setArchiveName(nodeType2 + " test"); + * indexedNodeType1.setArchiveVersion(nodeTypeVersion2); CSARDependency dep1 + * = new CSARDependency(); dep1.setName(nodeType2 + " test"); + * dep1.setVersion(nodeTypeVersion2); indexedNodeType1.setCreationDate(new + * Date()); indexedNodeType1.setLastUpdateDate(new Date()); + * indexedNodeType1.setDefaultCapabilities(listCap1); + * resourceDAO.save(indexedNodeType1); + * + * + * indexedNodeType.setElementId(nodeType3 + " test"); + * indexedNodeType.setArchiveName(nodeType3 + " test"); + * indexedNodeType.setArchiveVersion(nodeNypeVersion3); CSARDependency dep2 + * = new CSARDependency(); dep2.setName(nodeType3 + " test"); + * dep2.setVersion(nodeNypeVersion3); indexedNodeType.setCreationDate(new + * Date()); indexedNodeType.setLastUpdateDate(new Date()); + * indexedNodeType.setDefaultCapabilities(null); + * resourceDAO.save(indexedNodeType); String osgiliath100Id = + * indexedNodeType.getId(); + * + * Topology topology = new Topology(); topology.setId(topologyId + " test"); + * Set<CSARDependency> dependencies = new HashSet<CSARDependency>(); + * dependencies.add(dep); dependencies.add(dep2); dependencies.add(dep1); + * topology.setDependencies(dependencies); Map<String, NodeTemplate> + * nodeTemplates = new HashMap <String, NodeTemplate>(); + * + * NodeTemplate template1 = new NodeTemplate(nodeType + " test", null, null, + * null, null, null, null); template1.setName(nodeTypeTemplate1 + " test"); + * nodeTemplates.put(nodeTypeTemplate1 + " test", template1 ); + * + * NodeTemplate template2 = new NodeTemplate(nodeType2 + " test", null, + * null, null, null, null, null); template2.setName(nodeTypeTemplate2 + + * " test" ); nodeTemplates.put(nodeTypeTemplate2 + " test", template2 ); + * + * NodeTemplate template3 = new NodeTemplate(nodeType, null, null, null, + * null, null, null); template3.setName(nodeTypeTemplate3 + " test" ); + * nodeTemplates.put(nodeTypeTemplate3 + " test", template3); + * + * topology.setNodeTemplates(nodeTemplates); resourceDAO.save(topology); + * + * TopologyTemplate topologyTemplate = new TopologyTemplate(); + * topologyTemplate.setId(topologyTemplateName + " test"); + * topologyTemplate.setName(topologyTemplateName + " test"); + * topologyTemplate.setTopologyId(topology.getId()); + * topologyTemplate.setDescription("my topology template"); + * resourceDAO.save(topologyTemplate); + * + * String strData = "qweqwqweqw34e4wrwer"; ArtifactData arData = new + * ArtifactData("artifact1 test", nodeType + " test", nodeTypeVersion, + * "YANG", strData.getBytes(), strData.getBytes(), "Marina"); ArtifactData + * arData1 = new ArtifactData("artifact2 test", nodeType + " test", + * nodeTypeVersion, "YANG", strData.getBytes(), strData.getBytes(), + * "Marina"); ResourceUploadStatus status = daoUploader.saveArtifact(arData, + * true); status = daoUploader.saveArtifact(arData1, true); + * + * ArtifactData arData3 = new ArtifactData("artifact1 test", nodeType2 + + * " test", nodeTypeVersion2, "YANG", strData.getBytes(), + * strData.getBytes(), "Marina"); status = daoUploader.saveArtifact(arData3, + * true); + * + * ArtifactData arData4 = new ArtifactData("artifact2 test", nodeType2 + + * " test", nodeTypeVersion2, "YANG", strData.getBytes(), + * strData.getBytes(), "Marina"); status = daoUploader.saveArtifact(arData4, + * true); + * + * ServiceArtifactData serviceArData = new + * ServiceArtifactData("serviceArData test" , topologyTemplateName + + * " test", topologyTemplateVersion, nodeTypeTemplate1 + " test", nodeType + + * " test", nodeTypeVersion, "YANG", strData.getBytes(), strData.getBytes(), + * "Marina", arData.getId()); + * + * status = daoUploader.saveServiceArtifact(serviceArData, true); + * + * ServiceArtifactData serviceArData1 = new + * ServiceArtifactData("serviceArData1 test", topologyTemplateName + + * " test", topologyTemplateVersion, nodeTypeTemplate2 + " test", nodeType2 + * + " test", nodeTypeVersion2, "YANG", strData.getBytes(), + * strData.getBytes(), "Marina", arData4.getId()); + * + * status = daoUploader.saveServiceArtifact(serviceArData1, true); + * + * + * } catch (Exception e) { // TODO Auto-generated catch block + * e.printStackTrace(); } + * + * } + */ + + private void clearIndex(String indexName, Class<?> clazz) throws InterruptedException { + + DeleteIndexResponse actionGet = esclient.getClient().admin().indices().delete(new DeleteIndexRequest(indexName)) + .actionGet(); + assertTrue(actionGet.isAcknowledged()); + } + +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java new file mode 100644 index 0000000000..06d26f79f9 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java @@ -0,0 +1,463 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.resources; + +import fj.data.Either; +import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse; +import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.index.query.MatchAllQueryBuilder; +import org.elasticsearch.search.SearchHit; +import org.elasticsearch.search.SearchHits; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.Configuration.ElasticSearchConfig.IndicesTimeFrequencyEntry; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.es.ElasticSearchClient; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.*; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.datastructure.ESTimeBasedEvent; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestExecutionListeners; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; +import org.springframework.test.context.support.DirtiesContextTestExecutionListener; +import org.springframework.test.context.transaction.TransactionalTestExecutionListener; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class, + DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) +public class AuditingDaoTest { + private static Logger log = LoggerFactory.getLogger(AuditingDaoTest.class.getName()); + @Resource(name = "elasticsearch-client") + private ElasticSearchClient esclient; + + @Resource(name = "auditingDao") + private AuditingDao auditingDao; + + private static ConfigurationManager configurationManager; + // private static Map<AuditingFieldsKeysEnum, String> auditField2esField; + + @BeforeClass + public static void setupBeforeClass() { + + ExternalConfiguration.setAppName("catalog-dao"); + String appConfigDir = "src/test/resources/config/catalog-dao"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), + appConfigDir); + configurationManager = new ConfigurationManager(configurationSource); + // initAudit2EsMap(); + } + + @After + public void tearDown() { + deleteOldIndexes(); + } + + @Before + public void setup() { + auditingDao.setConfigurationManager(configurationManager); + deleteOldIndexes(); + } + + private void deleteOldIndexes() { + DeleteIndexResponse deleteResponse = esclient.getClient().admin().indices() + .prepareDelete(auditingDao.getIndexPrefix() + "*").execute().actionGet(); + if (!deleteResponse.isAcknowledged()) { + log.debug("Couldn't delete old auditing indexes!"); + assertTrue(false); + } + } + + // @Test + public void testAddUpdateAdminEventMinute() { + + String timestamp = "2015-06-23 13:34:53.123"; + + String creationPeriod = Constants.MINUTE; + String expectedIndexName = auditingDao.getIndexPrefix() + "-2015-06-23-13-34"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params = getUserAdminEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class); + params = getUserAccessEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class); + params = getResourceAdminEventParams(timestamp, "addResource"); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); + } + + // @Test + public void testAddUpdateAdminEventYearly() { + + String timestamp = "2016-06-23 13:34:53.123"; + String creationPeriod = Constants.YEAR; + String expectedIndexName = auditingDao.getIndexPrefix() + "-2016"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params = getUserAdminEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class); + params = getUserAccessEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class); + params = getResourceAdminEventParams(timestamp, "addResource"); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); + } + + @Test + public void testGetDistributionStatusEvent() { + + String timestamp1 = "2016-06-23 13:34:53.123"; + String creationPeriod = Constants.MONTH; + String expectedIndexName1 = auditingDao.getIndexPrefix() + "-2016-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName1).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params = getDistributionStatusEventParams(timestamp1); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName1, DistributionStatusEvent.class); + String timestamp2 = "2015-06-23 13:34:53.123"; + + String expectedIndexName2 = auditingDao.getIndexPrefix() + "-2015-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName2).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params2 = getDistributionStatusEventParams(timestamp2); + testCreationPeriodScenario(params2, creationPeriod, expectedIndexName2, DistributionStatusEvent.class); + Either<List<ESTimeBasedEvent>, ActionStatus> status = auditingDao.getListOfDistributionStatuses("123-456"); + assertEquals(2, status.left().value().size()); + } + + @Test + public void testGetCountAdminEventMonthly() { + + String timestamp1 = "2016-06-23 13:34:53.123"; + String timestamp2 = "2015-06-23 13:34:53.123"; + String creationPeriod = Constants.MONTH; + String expectedIndexName1 = auditingDao.getIndexPrefix() + "-2016-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName1).execute().actionGet() + .isExists()); + String expectedIndexName2 = auditingDao.getIndexPrefix() + "-2015-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName2).execute().actionGet() + .isExists()); + + Map<AuditingFieldsKeysEnum, Object> params1 = getUserAdminEventParams(timestamp1); + testCreationPeriodScenario(params1, creationPeriod, expectedIndexName1, UserAdminEvent.class); + Map<AuditingFieldsKeysEnum, Object> params2 = getUserAdminEventParams(timestamp2); + testCreationPeriodScenario(params2, creationPeriod, expectedIndexName2, UserAdminEvent.class); + + long count = auditingDao.count(UserAdminEvent.class, new MatchAllQueryBuilder()); + log.debug("Testing auditing count {}", count); + assertEquals(2, count); + } + + @Test + public void testServiceDistributionStatuses() { + + String timestamp = "2016-06-23 13:34:53.123"; + String creationPeriod = Constants.MONTH; + String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params = getUserAdminEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class); + params = getUserAccessEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class); + params = getResourceAdminEventParams(timestamp, "DRequest"); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); + params = getDistributionNotificationEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, DistributionNotificationEvent.class); + Either<List<ESTimeBasedEvent>, ActionStatus> status = auditingDao + .getServiceDistributionStatusesList("SeviceId"); + log.debug("Testing auditing count {}", status); + } + + @Test + public void testAddUpdateAdminEventMonthly() { + + String timestamp = "2016-06-23 13:34:53.123"; + String creationPeriod = Constants.MONTH; + String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + Map<AuditingFieldsKeysEnum, Object> params = getUserAdminEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class); + params = getUserAccessEventParams(timestamp); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class); + params = getResourceAdminEventParams(timestamp, "addResource"); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); + } + + private SearchResponse testCreationPeriodScenario(Map<AuditingFieldsKeysEnum, Object> params, String creationPeriod, + String expectedIndexName, Class<? extends AuditingGenericEvent> clazz) { + + String typeName = clazz.getSimpleName().toLowerCase(); + log.debug("Testing auditing type {}", typeName); + setCreationPeriod(creationPeriod); + ActionStatus saveUserAdminEvent = auditingDao.addRecord(params, typeName); + assertEquals(ActionStatus.OK, saveUserAdminEvent); + assertTrue(esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + MatchAllQueryBuilder matchAllQueryBuilder = new MatchAllQueryBuilder(); + + SearchResponse searchResponse = esclient.getClient().prepareSearch(expectedIndexName).setTypes(typeName) + .setQuery(matchAllQueryBuilder).execute().actionGet(); + + SearchHits hits = searchResponse.getHits(); + assertEquals(1, hits.getTotalHits()); + log.debug("Checking that all expected fields are properly persisted"); + validateHitValues(params, hits.getAt(0)); + log.debug("testCreationPeriodScenario successful"); + return searchResponse; + } + + private void validateHitValues(Map<AuditingFieldsKeysEnum, Object> params, SearchHit searchHit) { + Map<String, Object> source = searchHit.getSource(); + log.debug("Hit source is {}", searchHit.sourceAsString()); + for (Entry<AuditingFieldsKeysEnum, Object> paramsEntry : params.entrySet()) { + AuditingFieldsKeysEnum key = paramsEntry.getKey(); + log.debug("Testing auditing field {}", key.name()); + Object value = paramsEntry.getValue(); + // assertEquals(value, source.get(auditField2esField.get(key))); + assertEquals(value, source.get(key.getDisplayName())); + } + } + + private void setCreationPeriod(String creationPeriod) { + Configuration configuration = configurationManager.getConfiguration(); + List<IndicesTimeFrequencyEntry> indicesTimeFrequencyEntries = new ArrayList<>(); + IndicesTimeFrequencyEntry indicesTimeFrequencyEntry = new IndicesTimeFrequencyEntry(); + indicesTimeFrequencyEntry.setIndexPrefix("auditingevents"); + indicesTimeFrequencyEntry.setCreationPeriod(creationPeriod); + configuration.getElasticSearch().setIndicesTimeFrequency(indicesTimeFrequencyEntries); + } + + private Map<AuditingFieldsKeysEnum, Object> getUserAdminEventParams(String timestamp) { + + Map<AuditingFieldsKeysEnum, Object> params = new HashMap<AuditingFieldsKeysEnum, Object>(); + String action = "updateUser"; + String modifierName = "moshe moshe"; + String modifierUid = "mosheUid"; + String userUid = "mosheUid"; + String userBeforeName = "moshe moshe"; + String userBeforeEmail = "moshe@moshe1.com"; + String userBeforeRole = "TESTER"; + String userAfterName = "moshe moshe"; + String userAfterEmail = "moshe@moshe2.com"; + String userAfterRole = "TESTER"; + String userStatus = "200"; + String userDesc = "OK"; + + params.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifierName + '(' + modifierUid + ')'); + params.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, userUid); + params.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, + userUid + ", " + userBeforeName + ", " + userBeforeEmail + ", " + userBeforeRole); + params.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, + userUid + ", " + userAfterName + ", " + userAfterEmail + ", " + userAfterRole); + params.put(AuditingFieldsKeysEnum.AUDIT_STATUS, userStatus); + params.put(AuditingFieldsKeysEnum.AUDIT_DESC, userDesc); + params.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, timestamp); + + return params; + } + + private Map<AuditingFieldsKeysEnum, Object> getUserAccessEventParams(String timestamp) { + + Map<AuditingFieldsKeysEnum, Object> params = new HashMap<AuditingFieldsKeysEnum, Object>(); + String action = "userAccess"; + String userUid = "mosheUid"; + String userName = "moshe moshe"; + String userStatus = "200"; + String userDesc = "OK"; + + params.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action); + params.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, userName + '(' + userUid + ')'); + params.put(AuditingFieldsKeysEnum.AUDIT_STATUS, userStatus); + params.put(AuditingFieldsKeysEnum.AUDIT_DESC, userDesc); + params.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, timestamp); + + return params; + } + + private Map<AuditingFieldsKeysEnum, Object> getResourceAdminEventParams(String timestamp, String action) { + + Map<AuditingFieldsKeysEnum, Object> params = new HashMap<AuditingFieldsKeysEnum, Object>(); + + String modifierName = "moshe moshe"; + String modifierUid = "mosheUid"; + String resourceName = "Centos"; + String resourceType = "Resource"; + String currState = "READY_FOR_CERTIFICATION"; + String prevState = "CHECKED_OUT"; + String currVersion = "1.1.4"; + String prevVersion = "1.1.3"; + String status = "200"; + String desc = "OK"; + String distributionId = "123-456"; + String serviceId = "SeviceId"; + + params.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifierName); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifierUid); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceName); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, resourceType); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, currState); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, prevState); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, currVersion); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, prevVersion); + params.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status); + params.put(AuditingFieldsKeysEnum.AUDIT_DESC, desc); + params.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, timestamp); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId); + params.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, serviceId); + + return params; + } + + private Map<AuditingFieldsKeysEnum, Object> getDistributionStatusEventParams(String timestamp) { + + Map<AuditingFieldsKeysEnum, Object> params = new HashMap<AuditingFieldsKeysEnum, Object>(); + String action = "DStatus"; + String modifierName = "moshe moshe"; + String modifierUid = "mosheUid"; + String topicName = "Centos"; + String serviceId = "SeviceId"; + String resourceUrl = "resourceUrl"; + String distributionId = "123-456"; + + String status = "200"; + String desc = "OK"; + + params.put(AuditingFieldsKeysEnum.AUDIT_DESC, desc); + params.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, timestamp); + params.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status); + params.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, modifierUid); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, resourceUrl); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, timestamp); + params.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, serviceId); + + return params; + } + + // @Test + public void getListOfDistributionByActionTest() { + + String timestamp = "2016-06-23 13:34:53.123"; + String distributionId = "123-456"; + + String creationPeriod = Constants.MONTH; + String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06"; + assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet() + .isExists()); + + // Client client = esclient.getClient(); + // final CreateIndexRequestBuilder createIndexRequestBuilder = + // client.admin().indices().prepareCreate(expectedIndexName); + // final XContentBuilder mappingBuilder = + // jsonBuilder().startObject().startObject("resourceadminevent") + // .startObject("_ttl").field("enabled", "true").field("default", + // "1s").endObject().endObject() + // .endObject(); + // System.out.println(mappingBuilder.string()); + // createIndexRequestBuilder.addMapping(documentType, mappingBuilder); + // + // // MAPPING DONE + // createIndexRequestBuilder.execute().actionGet(); + // + // + + Map<AuditingFieldsKeysEnum, Object> params = getResourceAdminEventParams(timestamp, "DRequest"); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId); + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); + params = getDistributionNotificationEventParams(timestamp); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, distributionId); + + testCreationPeriodScenario(params, creationPeriod, expectedIndexName, DistributionNotificationEvent.class); + + Either<List<ESTimeBasedEvent>, ActionStatus> distributionByAction = auditingDao + .getListOfDistributionByAction(distributionId, "DRequest", "200", ResourceAdminEvent.class); + assertTrue(distributionByAction.isLeft()); + assertFalse(distributionByAction.left().value().isEmpty()); + + distributionByAction = auditingDao.getListOfDistributionByAction(distributionId, "DNotify", "200", + DistributionNotificationEvent.class); + assertTrue(distributionByAction.isLeft()); + assertFalse(distributionByAction.left().value().isEmpty()); + + } + + private Map<AuditingFieldsKeysEnum, Object> getDistributionNotificationEventParams(String timestamp) { + + Map<AuditingFieldsKeysEnum, Object> params = new HashMap<AuditingFieldsKeysEnum, Object>(); + + String action = "DNotify"; + String modifierName = "moshe moshe"; + String modifierUid = "mosheUid"; + String resourceName = "Centos"; + String resourceType = "Resource"; + + String currVersion = "1.1.4"; + String currState = "READY_FOR_CERTIFICATION"; + String status = "200"; + String desc = "OK"; + String did = "1027"; + String topicName = "Centos"; + String serviceId = "SeviceId"; + String requestId = "12364"; + + params.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, requestId); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifierUid); + params.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifierName); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, resourceName); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, resourceType); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, currState); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName); + params.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, currVersion); + params.put(AuditingFieldsKeysEnum.AUDIT_STATUS, status); + params.put(AuditingFieldsKeysEnum.AUDIT_DESC, desc); + params.put(AuditingFieldsKeysEnum.AUDIT_TIMESTAMP, timestamp); + params.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, did); + params.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, serviceId); + return params; + } + +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/CassandraTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/CassandraTest.java new file mode 100644 index 0000000000..caaf0702a5 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/CassandraTest.java @@ -0,0 +1,74 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.resources; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.Session; +import com.datastax.driver.mapping.Mapper; +import com.datastax.driver.mapping.MappingManager; + +import org.openecomp.sdc.be.dao.Account; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class CassandraTest { + private static Logger log = LoggerFactory.getLogger(CassandraTest.class.getName()); + private Cluster cluster; + + // #\@Test + public void testCrud() { + String node = "mtanjv9sdcg44"; + + cluster = Cluster.builder().addContactPoint(node).build(); + + // Query + String query = "CREATE KEYSPACE IF NOT EXISTS dstest WITH replication " + + "= {'class':'SimpleStrategy', 'replication_factor':1};"; + + String queryTable = "CREATE TABLE IF NOT EXISTS accounts(email varchar PRIMARY KEY, name varchar);"; + + Session session = cluster.connect(); + // Executing the query + session.execute(query); + // //using the KeySpace + session.execute("USE dstest"); + session.execute(queryTable); + + Mapper<Account> mapper = new MappingManager(session).mapper(Account.class); + Account account = new Account("John Doe", "jd@example.com"); + // Class<? extends Account> class1 = account.getClass(); + // Class class2 = Account.class; + mapper.save(account); + + Account whose = mapper.get("jd@example.com"); + log.debug("Account name: {}", whose.getName()); + + account.setName("Samanta Smit"); + mapper.save(account); + whose = mapper.get("jd@example.com"); + log.debug("Account name: {}", whose.getName()); + + mapper.delete(account); + whose = mapper.get("jd@example.com"); + + cluster.close(); + } +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ESUsersDAOTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ESUsersDAOTest.java new file mode 100644 index 0000000000..a99acbe2b7 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ESUsersDAOTest.java @@ -0,0 +1,64 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.resources; + +//@RunWith(SpringJUnit4ClassRunner.class) +//@ContextConfiguration("classpath:application-context-test.xml") +//@TestExecutionListeners(listeners = {DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class}) +public class ESUsersDAOTest { + + // @Resource + // ElasticSearchClient esclient; + // + //// @Resource(name = "users-dao") + // private IUsersDAO usersDao; + + // @Test + public void testNewUserStub() { + + } + + // @Test + public void testNewUser() { + // if( usersDao == null ){ + // assertTrue(false); + // } + // + // String id = "yhufksd57834601"; + // UserData userData = new UserData("Myname", "Mylastname", id, "email", + // "Tester"); + // + // ActionStatus saveUserData = usersDao.saveUserData(userData); + // assertEquals(saveUserData, ActionStatus.OK); + // + // Either<UserData, ActionStatus> statusFromEs = + // usersDao.getUserData(id); + // assertTrue(statusFromEs.isLeft() ); + // UserData fromEs = statusFromEs.left().value(); + // assertNotNull(fromEs); + // assertEquals(userData, fromEs); + // + // + // usersDao.deleteUserData(id); + + } + +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java new file mode 100644 index 0000000000..a4110f5be3 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java @@ -0,0 +1,721 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.resources; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.annotation.Resource; + +import org.apache.commons.configuration.BaseConfiguration; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.utils.UserStatusEnum; +import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.resources.data.AdditionalInfoParameterData; +import org.openecomp.sdc.be.resources.data.ArtifactData; +import org.openecomp.sdc.be.resources.data.ComponentInstanceData; +import org.openecomp.sdc.be.resources.data.GraphNodeLock; +import org.openecomp.sdc.be.resources.data.ResourceMetadataData; +import org.openecomp.sdc.be.resources.data.UserData; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.UserRoleEnum; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestExecutionListeners; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; +import org.springframework.test.context.support.DirtiesContextTestExecutionListener; +import org.springframework.test.context.transaction.TransactionalTestExecutionListener; + +import com.google.gson.Gson; +import com.thinkaurelius.titan.core.PropertyKey; +import com.thinkaurelius.titan.core.TitanEdge; +import com.thinkaurelius.titan.core.TitanFactory; +import com.thinkaurelius.titan.core.TitanGraph; +import com.thinkaurelius.titan.core.TitanVertex; +import com.thinkaurelius.titan.core.attribute.Text; +import com.thinkaurelius.titan.core.schema.TitanManagement; + +import fj.data.Either; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class, + DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) +public class TitanGenericDaoTest { + private static Logger log = LoggerFactory.getLogger(TitanGenericDaoTest.class.getName()); + private static ConfigurationManager configurationManager; + + @Resource(name = "titan-generic-dao") + private TitanGenericDao titanDao; + + @BeforeClass + public static void setupBeforeClass() { + ExternalConfiguration.setAppName("catalog-dao"); + String appConfigDir = "src/test/resources/config/catalog-dao"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), + appConfigDir); + configurationManager = new ConfigurationManager(configurationSource); + configurationManager.getConfiguration() + .setTitanCfgFile("../catalog-be/src/main/resources/config/titan.properties"); + configurationManager.getConfiguration().setTitanInMemoryGraph(true); + } + + // @Test + public void testcheckEdgeProps() { + TitanGraph graph = titanDao.getGraph().left().value(); + TitanVertex v1 = graph.addVertex(); + v1.property("prop1", 123); + TitanVertex v2 = graph.addVertex(); + v2.property("prop1", 456); + TitanEdge addEdge = v1.addEdge("label11", v2); + addEdge.property("edgeProp", "my prop edge"); + graph.tx().commit(); + + Either<TitanVertex, TitanOperationStatus> v11 = titanDao.getVertexByProperty("prop1", 123); + Iterator<Edge> edges = v11.left().value().edges(Direction.OUT, "label11"); + Edge edge = edges.next(); + // String value = (String)edge.value("edgeProp"); + String value = (String) titanDao.getProperty(edge, "edgeProp"); + log.debug(value); + + } + + @Test + public void testCrudNode() { + + String id = "user12345abc"; + UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester", + UserStatusEnum.ACTIVE.name(), null); + + Either<UserData, TitanOperationStatus> newNode = titanDao.createNode(userData, UserData.class); + + assertTrue(newNode.isLeft()); + + log.debug("{}", newNode.left().value()); + + titanDao.commit(); + + ImmutablePair<String, Object> keyValueId = userData.getKeyValueId(); + Either<UserData, TitanOperationStatus> node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(), + UserData.class); + titanDao.commit(); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + + userData.setRole("Designer"); + node = titanDao.updateNode(userData, UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + assertEquals(null, "Designer", node.left().value().getRole()); + titanDao.commit(); + + node = titanDao.deleteNode(userData, UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + titanDao.commit(); + + node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class); + assertTrue(node.isRight()); + log.debug("{}", node.right().value()); + + } + + @Test + public void testGetByCategoryAndAll() { + + // create 2 nodes + String id = "user12345abc"; + UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester", + UserStatusEnum.ACTIVE.name(), null); + + Either<UserData, TitanOperationStatus> node1 = titanDao.createNode(userData1, UserData.class); + assertTrue(node1.isLeft()); + log.debug("{}", node1.left().value()); + + id = "userdfkoer45abc"; + UserData userData2 = new UserData("Mynadyhme123", "Mylasghtname", id, "emaighdl123", "Designer", + UserStatusEnum.ACTIVE.name(), null); + Either<UserData, TitanOperationStatus> node2 = titanDao.createNode(userData2, UserData.class); + assertTrue(node2.isLeft()); + log.debug("{}", node2.left().value()); + + titanDao.commit(); + + ImmutablePair<String, Object> keyValueId1 = userData1.getKeyValueId(); + // get first node + Either<UserData, TitanOperationStatus> node = titanDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(), + UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + titanDao.commit(); + + // get all must be 2 + 1 default user = 3 + Either<List<UserData>, TitanOperationStatus> all = titanDao.getAll(NodeTypeEnum.User, UserData.class); + assertTrue(all.isLeft()); + assertTrue(all.left().value().size() > 0); + + log.debug("{}", all.left().value()); + + Map<String, Object> props = new HashMap<String, Object>(); + + props.put(keyValueId1.getKey(), keyValueId1.getValue()); + + // get by criteria. must be 1 + Either<List<UserData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.User, props, + UserData.class); + assertTrue(byCriteria.isLeft()); + assertEquals(1, byCriteria.left().value().size()); + + log.debug("{}", byCriteria.left().value()); + + // delete all nodes + node = titanDao.deleteNode(userData1, UserData.class); + assertTrue(node.isLeft()); + node = titanDao.deleteNode(userData2, UserData.class); + assertTrue(node.isLeft()); + } + + @Test + public void testGetEdgesForNode() { + String id = "user12345abc"; + UserData userData = new UserData("Myname123", "Mylastname", id, "email123", UserRoleEnum.ADMIN.name(), + UserStatusEnum.ACTIVE.name(), null); + titanDao.createNode(userData, UserData.class); + ResourceMetadataData resourceData = new ResourceMetadataData(); + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + titanDao.createNode(resourceData, ResourceMetadataData.class); + titanDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null); + titanDao.commit(); + + Either<List<Edge>, TitanOperationStatus> eitherEdges = titanDao.getEdgesForNode(userData, Direction.OUT); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 1); + + eitherEdges = titanDao.getEdgesForNode(userData, Direction.IN); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 0); + + eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.OUT); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 0); + + eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.IN); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 1); + + eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.BOTH); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 1); + + eitherEdges = titanDao.getEdgesForNode(userData, Direction.BOTH); + assertTrue(eitherEdges.isLeft()); + assertTrue(eitherEdges.left().value().size() == 1); + + titanDao.deleteNode(userData, UserData.class); + titanDao.deleteNode(resourceData, ResourceMetadataData.class); + titanDao.commit(); + } + + @Test + public void testLockElement() { + + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + titanDao.commit(); + String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); + + Either<GraphNodeLock, TitanOperationStatus> nodeLock = titanDao + .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); + + TitanOperationStatus status = titanDao.lockElement(resourceData); + assertEquals(TitanOperationStatus.OK, status); + + nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + + titanDao.commit(); + + status = titanDao.lockElement(resourceData); + assertEquals(TitanOperationStatus.ALREADY_LOCKED, status); + + status = titanDao.releaseElement(resourceData); + assertEquals(TitanOperationStatus.OK, status); + + nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); + titanDao.deleteNode(resourceData, ResourceMetadataData.class); + titanDao.commit(); + + } + + @Test + public void testReLockElement() throws InterruptedException { + + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForReLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + titanDao.commit(); + String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); + + Either<GraphNodeLock, TitanOperationStatus> nodeLock = titanDao + .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); + + // lock + TitanOperationStatus status = titanDao.lockElement(resourceData); + assertEquals(TitanOperationStatus.OK, status); + + nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + long time1 = nodeLock.left().value().getTime(); + + titanDao.commit(); + + // timeout + configurationManager.getConfiguration().setTitanLockTimeout(2L); + Thread.sleep(5001); + + // relock + status = titanDao.lockElement(resourceData); + assertEquals(TitanOperationStatus.OK, status); + + nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + + long time2 = nodeLock.left().value().getTime(); + + assertTrue(time2 > time1); + + status = titanDao.releaseElement(resourceData); + assertEquals(TitanOperationStatus.OK, status); + + nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); + + titanDao.deleteNode(resourceData, ResourceMetadataData.class); + titanDao.commit(); + + } + + @Test + public void testBoolean() { + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); + resourceData.getMetadataDataDefinition().setHighestVersion(true); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either<ResourceMetadataData, TitanOperationStatus> resource1 = titanDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + + resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.2"); + resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); + resourceData.getMetadataDataDefinition().setHighestVersion(false); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either<ResourceMetadataData, TitanOperationStatus> resource2 = titanDao.createNode(resourceData, + ResourceMetadataData.class); + titanDao.commit(); + + Map<String, Object> props = new HashMap<String, Object>(); + + props.put(GraphPropertiesDictionary.STATE.getProperty(), "NOT_CERTIFIED_CHECKOUT"); + props.put("name", "resourceForLock"); + props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false); + + // get by criteria. must be 1 + Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + + titanDao.deleteNode(resource1.left().value(), ResourceMetadataData.class); + + titanDao.deleteNode(resource2.left().value(), ResourceMetadataData.class); + titanDao.commit(); + } + + // @Test + public void testStringSearch() { + TitanGraph graph; + + BaseConfiguration conf = new BaseConfiguration(); + conf.setProperty("storage.backend", "inmemory"); + graph = TitanFactory.open(conf); + + // TitanManagement graphMgt = graph.getManagementSystem(); + TitanManagement graphMgt = graph.openManagement(); + PropertyKey propKey = graphMgt.makePropertyKey("string1").dataType(String.class).make(); + graphMgt.buildIndex("string1", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); + + propKey = graphMgt.makePropertyKey("string2").dataType(String.class).make(); + + // graphMgt.buildIndex("string2", Vertex.class).addKey(propKey, + // Mapping.TEXT.getParameter()).buildMixedIndex("search"); + graphMgt.buildIndex("string2", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); + graphMgt.commit(); + + // TitanVertex v = graph.addVertex(); + // v.addProperty("string1", "My new String 1"); + // v.addProperty("string2", "String11"); + // graph.commit(); + // + // v = graph.addVertex(); + // v.addProperty("string1", "my new string 1"); + // v.addProperty("string2", "string11"); + // graph.commit(); + // + // System.out.println("First index search - case"); + // + // Iterable<Vertex> vertices = graph.getVertices("string1", "My new + // String 1"); + // Iterator<Vertex> iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + // System.out.println("First index search non case"); + // + // vertices = graph.getVertices("string1", "my new string 1"); + // iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + // System.out.println("Second index search case"); + // + // vertices = graph.getVertices("string2", "String11"); + // iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + // System.out.println("second index search non case"); + // + // vertices = graph.getVertices("string2", "string11"); + // iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + // System.out.println("Query index search case"); + // vertices = graph.query().has("string1", "My new String + // 1").vertices(); + // iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + // System.out.println("Query index search non case"); + // vertices = graph.query().has("string1", "my new string + // 1").vertices(); + // iter = vertices.iterator(); + // while ( iter.hasNext() ){ + // Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + // } + + log.debug("**** predicat index search non case"); + Iterable<TitanVertex> vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices(); + Iterator<TitanVertex> iter = vertices.iterator(); + while (iter.hasNext()) { + Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + log.debug("{}", titanDao.getProperties(ver)); + } + + } + + @Test + public void testDuplicateResultDueToTitanBug() { + + // TitanGraph titanGraph = titanDao.getGraph().left().value(); + // TitanManagement managementSystem = titanGraph.getManagementSystem(); + + // GraphPropertiesDictionary[] properties = { + // GraphPropertiesDictionary.IS_ABSTRACT, + // GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY, + // GraphPropertiesDictionary.POSITION_X, + // GraphPropertiesDictionary.ARTIFACT_TIMEOUT }; + // + // for (GraphPropertiesDictionary property : properties) { + // if (false == + // managementSystem.containsGraphIndex(property.getProperty())) { + // PropertyKey propKey1 = + // managementSystem.makePropertyKey(property.getProperty()).dataType(property.getClazz()).make(); + // managementSystem.buildIndex(property.getProperty(), + // Vertex.class).addKey(propKey1).unique().buildCompositeIndex(); + // } + // } + + // managementSystem.commit(); + + ResourceMetadataData resourceData1 = new ResourceMetadataData(); + resourceData1.getMetadataDataDefinition().setUniqueId("A"); + ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); + resourceData1.getMetadataDataDefinition().setName("aaaa"); + + Either<ResourceMetadataData, TitanOperationStatus> newNode1 = titanDao.createNode(resourceData1, + ResourceMetadataData.class); + assertTrue(newNode1.isLeft()); + log.debug("{}", newNode1.left().value()); + // titanDao.commit(); + + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); + Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + // titanDao.commit(); + + ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); + ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); + resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); + Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceToUpdate, + ResourceMetadataData.class); + assertTrue(updateNode.isLeft()); + // titanDao.commit(); + + byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + AdditionalInfoParameterData infoParameterData = new AdditionalInfoParameterData(); + infoParameterData.getAdditionalInfoParameterDataDefinition().setUniqueId("123"); + Map<String, String> idToKey = new HashMap<>(); + idToKey.put("key1", "value1"); + infoParameterData.setIdToKey(idToKey); + + Either<AdditionalInfoParameterData, TitanOperationStatus> newNode2 = titanDao.createNode(infoParameterData, + AdditionalInfoParameterData.class); + assertTrue(newNode2.isLeft()); + log.debug("{}", newNode2.left().value()); + // titanDao.commit(); + + Map<String, String> idToKey2 = new HashMap<>(); + idToKey2.put("key1", "value2"); + + Map<String, Object> props2 = new HashMap<>(); + props2.put(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), "123"); + Gson gson = new Gson(); + props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), gson.toJson(idToKey2)); + // props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), + // idToKey2); + + Either<List<AdditionalInfoParameterData>, TitanOperationStatus> byCriteria2 = titanDao + .getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, AdditionalInfoParameterData.class); + assertTrue(byCriteria2.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria2.right().value()); + + infoParameterData.setIdToKey(idToKey2); + + Either<AdditionalInfoParameterData, TitanOperationStatus> updateNode2 = titanDao.updateNode(infoParameterData, + AdditionalInfoParameterData.class); + assertTrue(updateNode2.isLeft()); + // titanDao.commit(); + + props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), idToKey); + byCriteria2 = titanDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, + AdditionalInfoParameterData.class); + assertTrue(byCriteria2.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria2.right().value()); + + ComponentInstanceData resourceInstanceData = new ComponentInstanceData(); + resourceInstanceData.getComponentInstDataDefinition().setUniqueId("ri123"); + resourceInstanceData.getComponentInstDataDefinition().setPosX("22"); + resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1"); + + Either<ComponentInstanceData, TitanOperationStatus> newNode3 = titanDao.createNode(resourceInstanceData, + ComponentInstanceData.class); + assertTrue(newNode3.isLeft()); + log.debug("{}", newNode3.left().value()); + // titanDao.commit(); + + resourceInstanceData.getComponentInstDataDefinition().setPosX("50"); + Either<ComponentInstanceData, TitanOperationStatus> updateNode3 = titanDao.updateNode(resourceInstanceData, + ComponentInstanceData.class); + assertTrue(updateNode3.isLeft()); + // titanDao.commit(); + + resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2"); + updateNode3 = titanDao.updateNode(resourceInstanceData, ComponentInstanceData.class); + assertTrue(updateNode3.isLeft()); + // titanDao.commit(); + + Map<String, Object> props3 = new HashMap<>(); + props3.put("positionX", "22"); + Either<List<ComponentInstanceData>, TitanOperationStatus> byCriteria3 = titanDao + .getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); + assertTrue(byCriteria3.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria3.right().value()); + + props3.put("positionX", "50"); + byCriteria3 = titanDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); + assertTrue(byCriteria3.isLeft()); + + /////////////////////////// check integer //////////////////////// + + ArtifactData artifactData = new ArtifactData(); + artifactData.getArtifactDataDefinition().setUniqueId("ad234"); + artifactData.getArtifactDataDefinition().setTimeout(100); + + Either<ArtifactData, TitanOperationStatus> newNode4 = titanDao.createNode(artifactData, ArtifactData.class); + assertTrue(newNode4.isLeft()); + log.debug("{}", newNode4.left().value()); + // titanDao.commit(); + + artifactData.getArtifactDataDefinition().setTimeout(50); + Either<ArtifactData, TitanOperationStatus> updateNode4 = titanDao.updateNode(artifactData, ArtifactData.class); + assertTrue(updateNode4.isLeft()); + // titanDao.commit(); + + Map<String, Object> props4 = new HashMap<>(); + props4.put("timeout", 100); + Either<List<ArtifactData>, TitanOperationStatus> byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef, + props4, ArtifactData.class); + assertTrue(byCriteria4.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria4.right().value()); + + props4.put("timeout", 50); + byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class); + assertTrue(byCriteria4.isLeft()); + + titanDao.rollback(); + } + + @Test + public void testDuplicateResultUSeHasNotQueryDueToTitanBug() { + + String name = "bbbb"; + + ResourceMetadataData resourceData1 = new ResourceMetadataData(); + resourceData1.getMetadataDataDefinition().setUniqueId("A"); + ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); + resourceData1.getMetadataDataDefinition().setName(name); + + Either<ResourceMetadataData, TitanOperationStatus> newNode1 = titanDao.createNode(resourceData1, + ResourceMetadataData.class); + assertTrue(newNode1.isLeft()); + log.debug("{}", newNode1.left().value()); + // titanDao.commit(); + + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); + Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + // titanDao.commit(); + + ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); + ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); + resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); + Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceToUpdate, + ResourceMetadataData.class); + assertTrue(updateNode.isLeft()); + // titanDao.commit(); + + // no result where isAbstract = true + byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + // one result where isAbstract != true + byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false); + byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + titanDao.rollback(); + + } + +} |