From 969a4e89e2363f76212623d9e563665804682fcf Mon Sep 17 00:00:00 2001 From: shrek2000 Date: Thu, 28 Mar 2019 16:29:17 +0200 Subject: Heal Vertex Data Enable healing of vertex information when reading it. Issue-ID: SDC-2213 Change-Id: I907beeb25bd231d9e05d3a5b8e070d6bdf9cb781 Signed-off-by: shrek2000 --- .../be/dao/cassandra/HealingPipelineDaoTest.java | 315 +++++++++++++++++++++ .../sdc/be/resources/HealVersionTest.java | 33 +++ 2 files changed, 348 insertions(+) create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/resources/HealVersionTest.java (limited to 'catalog-dao/src/test/java/org') diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java new file mode 100644 index 0000000000..83b68920b9 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java @@ -0,0 +1,315 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * 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. + */ + +package org.openecomp.sdc.be.dao.cassandra; + +import com.google.common.collect.ImmutableListMultimap; +import com.thinkaurelius.titan.core.TitanVertex; +import com.thinkaurelius.titan.graphdb.relations.StandardVertexProperty; +import com.thinkaurelius.titan.graphdb.types.system.EmptyVertex; +import com.thinkaurelius.titan.graphdb.types.system.ImplicitKey; +import java.util.HashMap; +import org.junit.Test; +import org.mockito.Mockito; +import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; +import org.openecomp.sdc.be.dao.impl.HealingPipelineDao; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.heal.*; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; + +import java.util.Map; +import java.util.Optional; + +import static org.junit.Assert.*; + +public class HealingPipelineDaoTest { + + + @Test + public void shouldUpgrade() { + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(3); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + final HealVersion version3 = HealVersionBuilder.build(3); + assertFalse(healingPipelineDao.shouldHeal(HealVersionBuilder.build(2), version3)); + assertFalse(healingPipelineDao.shouldHeal(version3, version3)); + assertTrue(healingPipelineDao.shouldHeal(HealVersionBuilder.build(2), HealVersionBuilder.build(1))); + } + + + @Test + public void testPipelineFilter3Attributes() { + // init data + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(7); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + healingPipelineDao.setHealingPipeline(createPipelineMap()); + + assertEquals(2, + healingPipelineDao.getHealersForVertex(EdgeLabelEnum.ATTRIBUTES.name(), HealVersionBuilder.build(5)).size()); + + GraphVertex graphVertex = new GraphVertex(); + final int version = 5; + graphVertex.addMetadataProperty(GraphPropertyEnum.HEALING_VERSION, Integer.valueOf(version)); + + // perform test + + Optional optional = healingPipelineDao.performGraphReadHealing(graphVertex, EdgeLabelEnum.ATTRIBUTES); + assertTrue(optional.isPresent()); + final GraphVertex changedVertex = (GraphVertex) optional.get(); + + //validate result + final Object healVersion = changedVertex.getMetadataProperties().get(GraphPropertyEnum.HEALING_VERSION); + assertNotNull(healVersion); + assertTrue(healVersion instanceof Integer); + assertEquals(healingPipelineDao.getCurrentHealVersion().getVersion().intValue(), ((Integer) healVersion).intValue()); + } + + @Test + public void testPipelineFilter3AttributesTitanVertex() { + // init data + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(7); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + healingPipelineDao.setHealingPipeline(createPipelineMap()); + + assertEquals(2, + healingPipelineDao.getHealersForVertex(GraphEdgeLabels.CAPABILITY.getProperty(), HealVersionBuilder.build(5)).size()); + TitanVertex titanVertex = Mockito.mock(TitanVertex.class); + final int version = 5; + StandardVertexProperty vertexProperty = new StandardVertexProperty(1, ImplicitKey.ID, new EmptyVertex(), version, (byte) 1); + Mockito.when(titanVertex.property(GraphPropertyEnum.HEALING_VERSION.getProperty())).thenReturn(vertexProperty); + + // perform test + + Optional optional = healingPipelineDao.performGraphReadHealing(titanVertex, GraphEdgeLabels.CAPABILITY); + assertTrue(optional.isPresent()); + final TitanVertex changedVertex = (TitanVertex) optional.get(); + + //validate result + assertNotNull(changedVertex); + + } + + @Test + public void testPipelineFilterGenericTitanDao() { + // init data + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(7); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + healingPipelineDao.setHealingPipeline(createPipelineMap()); + assertEquals(1, + + healingPipelineDao.getHealersForVertex(GraphEdgeLabels.ATTRIBUTE.getProperty(), HealVersionBuilder.build(6)).size()); + + GraphNode mockGraphNode = new MockGraphNode(NodeTypeEnum.Attribute); + final int version = 5; + mockGraphNode.setHealingVersion(Integer.valueOf(version)); + + // perform test + + Optional optional = healingPipelineDao.performGraphReadHealing(mockGraphNode,createGraphEdge(GraphEdgeLabels.ATTRIBUTE)); + assertTrue(optional.isPresent()); + final GraphNode changedVertex = (GraphNode) optional.get(); + + //validate result + final Integer healVersion = changedVertex.getHealingVersion(); + assertNotNull(healVersion); + assertEquals(healingPipelineDao.getCurrentHealVersion().getVersion(), healVersion); + } + + @Test + public void testPipelineFilterTitanGraph1Attributes() { + // init data + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(7); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + healingPipelineDao.setHealingPipeline(createPipelineMap()); + + assertEquals(2, + healingPipelineDao.getHealersForVertex(GraphEdgeLabels.ATTRIBUTE.getProperty(), HealVersionBuilder.build(5)).size()); + + } + + @Test + public void healTest() { + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(3); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + final HealVersion version3 = HealVersionBuilder.build(3); + assertFalse(healingPipelineDao.shouldHeal(HealVersionBuilder.build(2), version3)); + assertFalse(healingPipelineDao.shouldHeal(version3, version3)); + assertTrue(healingPipelineDao.shouldHeal(HealVersionBuilder.build(2), HealVersionBuilder.build(1))); + } + + + @Test + public void setCurrentVersion() { + //init data + GraphVertex graphVertex = new GraphVertex(); + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + final int healVersion = 7; + healingPipelineDao.setHealVersion(healVersion); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + + //execute code + healingPipelineDao.setHealingVersion(graphVertex); + + //validate result + final Object currentVersion = graphVertex.getMetadataProperties().get(GraphPropertyEnum.HEALING_VERSION); + assertNotNull(currentVersion); + assertTrue(currentVersion instanceof Integer); + assertEquals(healingPipelineDao.getCurrentHealVersion().getVersion().intValue(), ((Integer) currentVersion).intValue()); + } + + @Test(expected = IllegalStateException.class) + public void testMultilistValidation() { + // init data + HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); + healingPipelineDao.setHealVersion(7); + healingPipelineDao.initHealVersion(); + healingPipelineDao.initGraphHealers(); + + ImmutableListMultimap shouldFail = ImmutableListMultimap.builder().put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(3)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(4)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(5)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(6)) + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(3)) + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(3)) // this should cause exception + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(69)).build(); + + //performTest + healingPipelineDao.setHealingPipeline(shouldFail); + } + + private ImmutableListMultimap createPipelineMap() { + return ImmutableListMultimap.builder().put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(3)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(4)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(5)) + .put(EdgeLabelEnum.ATTRIBUTES.name(), new GraphVertexHealTestMock(6)) + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(3)) + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(6)) + .put(EdgeLabelEnum.CAPABILITIES.name(), new GraphVertexHealTestMock(69)) + .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(4)) + .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(5)) + .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(6)) + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(4)) + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(5)) + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(6)).build(); + } + + public GraphEdge createGraphEdge(GraphEdgeLabels graphEdgeLabels){ + return new GraphEdge(graphEdgeLabels, new HashMap<>()); + } + + + private class GraphVertexHealTestMock extends AbstractGraphVertexHeal { + + private HealVersion healVersion; + + public GraphVertexHealTestMock(int i) { + healVersion = HealVersionBuilder.build(i); + } + + @Override + public HealVersion fromVersion() { + return healVersion; + } + + @Override + public void healData(GraphVertex parentVertex) { + + } + + } + + private class GraphNodeHealTestMock extends AbstractTitanVertexHeal { + private HealVersion healVersion; + + public GraphNodeHealTestMock(int i) { + healVersion = HealVersionBuilder.build(i); + } + + @Override + public HealVersion fromVersion() { + return healVersion; + } + + @Override + public void healData(GraphNode parentV) { + + } + } + + + private class TitanVertexHealTestMock implements Heal { + private HealVersion healVersion; + + public TitanVertexHealTestMock(int i) { + healVersion = HealVersionBuilder.build(i); + } + + @Override + public HealVersion fromVersion() { + return healVersion; + } + + @Override + public void healData(TitanVertex parentV) { + + } + } + + private class MockGraphNode extends GraphNode { + private int healVersion; + + public MockGraphNode(NodeTypeEnum label) { + super(label); + } + + @Override + public String getUniqueId() { + return null; + } + + @Override + public Map toGraphMap() { + return null; + } + + @Override + public Integer getHealingVersion() { + return healVersion; + } + + @Override + public void setHealingVersion(Integer version) { + this.healVersion = version; + } + } + +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/HealVersionTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/HealVersionTest.java new file mode 100644 index 0000000000..01ac5c3e57 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/HealVersionTest.java @@ -0,0 +1,33 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * 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. + */ + +package org.openecomp.sdc.be.resources; + +import org.junit.Assert; +import org.junit.Test; +import org.openecomp.sdc.be.dao.jsongraph.heal.HealVersion; +import org.openecomp.sdc.be.dao.jsongraph.heal.HealVersionBuilder; + +public class HealVersionTest { + + @Test + public void buildVersions() { + final HealVersion version1 = HealVersionBuilder.build(1); + final HealVersion version2 = HealVersionBuilder.build(2); + Assert.assertTrue(version1.compareTo(version2) < 0); + } + +} -- cgit 1.2.3-korg