summaryrefslogtreecommitdiffstats
path: root/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src
diff options
context:
space:
mode:
authorMichael Lando <ml636r@att.com>2017-02-19 12:35:04 +0200
committerMichael Lando <ml636r@att.com>2017-02-19 12:35:04 +0200
commitf5f13c4f6b6fe3b4d98e349dfd7db59339803436 (patch)
tree72caffc93fab394ffa3b761505775331f1c559b9 /openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src
parent451a3400b76511393c62a444f588a4ed15f4a549 (diff)
push addional code
Change-Id: Ia427bb3460cda3a896f8faced2de69eaf3807b74 Signed-off-by: Michael Lando <ml636r@att.com>
Diffstat (limited to 'openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src')
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java69
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java33
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java33
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java66
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java34
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java65
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java159
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java33
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java33
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java468
-rw-r--r--openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java364
11 files changed, 1357 insertions, 0 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java
new file mode 100644
index 0000000000..a50a8b7beb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java
@@ -0,0 +1,69 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import com.datastax.driver.core.UDTValue;
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.UDTMapper;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.dao.impl.CassandraBaseDao;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.sdc.versioning.dao.VersionHistoryDao;
+import org.openecomp.sdc.versioning.dao.types.VersionHistoryEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionableEntityId;
+
+import java.util.Collection;
+
+public class VersionHistoryCassandraDaoImpl extends CassandraBaseDao<VersionHistoryEntity>
+ implements VersionHistoryDao {
+
+ private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static Mapper<VersionHistoryEntity> mapper =
+ noSqlDb.getMappingManager().mapper(VersionHistoryEntity.class);
+ private static VersionHistoryAccessor accessor =
+ noSqlDb.getMappingManager().createAccessor(VersionHistoryAccessor.class);
+ private static UDTMapper<VersionableEntityId> versionedEntityIdMapper =
+ noSqlDb.getMappingManager().udtMapper(VersionableEntityId.class);
+
+ @Override
+ protected Mapper<VersionHistoryEntity> getMapper() {
+ return mapper;
+ }
+
+ @Override
+ protected Object[] getKeys(VersionHistoryEntity entity) {
+ return new Object[]{versionedEntityIdMapper.toUDT(entity.getEntityId())};
+ }
+
+ @Override
+ public Collection<VersionHistoryEntity> list(VersionHistoryEntity entity) {
+ return accessor.getAll(versionedEntityIdMapper.toUDT(entity.getEntityId())).all();
+ }
+
+ @Accessor
+ interface VersionHistoryAccessor {
+ @Query("select * from version_history where entity_id=?")
+ Result<VersionHistoryEntity> getAll(UDTValue entityId);
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java
new file mode 100644
index 0000000000..ac1c7e9634
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import org.openecomp.sdc.versioning.dao.VersionHistoryDao;
+import org.openecomp.sdc.versioning.dao.VersionHistoryDaoFactory;
+
+public class VersionHistoryDaoFactoryImpl extends VersionHistoryDaoFactory {
+ private static final VersionHistoryDao INSTANCE = new VersionHistoryCassandraDaoImpl();
+
+ @Override
+ public VersionHistoryDao createInterface() {
+ return INSTANCE;
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
new file mode 100644
index 0000000000..46c6a9d795
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+
+public class VersionInfoDaoFactoryImpl extends VersionInfoDaoFactory {
+ private static VersionInfoDao INSTANCE = new VersionInfoDaoImpl();
+
+ @Override
+ public VersionInfoDao createInterface() {
+ return INSTANCE;
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
new file mode 100644
index 0000000000..a45c211f94
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
@@ -0,0 +1,66 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.dao.impl.CassandraBaseDao;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+
+import java.util.Collection;
+
+public class VersionInfoDaoImpl extends CassandraBaseDao<VersionInfoEntity>
+ implements VersionInfoDao {
+
+ private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static Mapper<VersionInfoEntity> mapper =
+ noSqlDb.getMappingManager().mapper(VersionInfoEntity.class);
+ private static VersionInfoAccessor accessor =
+ noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
+ //private static UDTMapper<VersionableEntityId> versionedEntityIdMapper = noSqlDb
+ //.getMappingManager().udtMapper(VersionableEntityId.class);
+
+ @Override
+ protected Mapper<VersionInfoEntity> getMapper() {
+ return mapper;
+ }
+
+ @Override
+ protected Object[] getKeys(VersionInfoEntity entity) {
+ return new Object[]{entity.getEntityType(), entity.getEntityId()};
+ }
+
+ @Override
+ public Collection<VersionInfoEntity> list(VersionInfoEntity entity) {
+ return accessor.getAll(entity.getEntityType()).all();
+ }
+
+ @Accessor
+ interface VersionInfoAccessor {
+ @Query("select * from version_info where entity_type=?")
+ Result<VersionInfoEntity> getAll(String entityType);
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java
new file mode 100644
index 0000000000..9163018a85
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java
@@ -0,0 +1,34 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+
+public class VersionInfoDeletedDaoFactoryImpl extends VersionInfoDeletedDaoFactory {
+ private static VersionInfoDeletedDao INSTANCE = new VersionInfoDeletedDaoImpl();
+
+ @Override
+ public VersionInfoDeletedDao createInterface() {
+ return INSTANCE;
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java
new file mode 100644
index 0000000000..82e4edcd80
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java
@@ -0,0 +1,65 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.dao.impl.CassandraBaseDao;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+
+import java.util.Collection;
+
+public class VersionInfoDeletedDaoImpl extends CassandraBaseDao<VersionInfoDeletedEntity>
+ implements VersionInfoDeletedDao {
+
+ private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static Mapper<VersionInfoDeletedEntity> mapper =
+ noSqlDb.getMappingManager().mapper(VersionInfoDeletedEntity.class);
+ private static VersionInfoAccessor accessor =
+ noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
+
+
+ @Override
+ protected Mapper<VersionInfoDeletedEntity> getMapper() {
+ return mapper;
+ }
+
+ @Override
+ protected Object[] getKeys(VersionInfoDeletedEntity entity) {
+ return new Object[]{entity.getEntityType(), entity.getEntityId()};
+ }
+
+ @Override
+ public Collection<VersionInfoDeletedEntity> list(VersionInfoDeletedEntity entity) {
+ return accessor.getAll(entity.getEntityType()).all();
+ }
+
+ @Accessor
+ interface VersionInfoAccessor {
+ @Query("select * from version_info_deleted where entity_type=?")
+ Result<VersionInfoDeletedEntity> getAll(String entityType);
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java
new file mode 100644
index 0000000000..f02ea89e34
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java
@@ -0,0 +1,159 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import com.datastax.driver.core.ColumnDefinitions;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.mapping.UDTMapper;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.types.UniqueValueMetadata;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+class VersionableEntityDaoCassandraImpl implements VersionableEntityDao {
+
+ private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static org.slf4j.Logger Logger =
+ LoggerFactory.getLogger(VersionableEntityDaoCassandraImpl.class);
+ private static UDTMapper<Version> versionMapper =
+ noSqlDb.getMappingManager().udtMapper(Version.class);
+
+ private static String commaSeparatedQuestionMarks(int size) {
+ StringBuilder sb = new StringBuilder(size * 2 - 1);
+ for (int i = 0; i < size; i++) {
+ if (i > 0) {
+ sb.append(',');
+ }
+ sb.append('?');
+ }
+ return sb.toString();
+
+ }
+
+ @Override
+ public void initVersion(VersionableEntityMetadata metadata, String entityId, Version baseVersion,
+ Version newVersion) {
+ ResultSet rows = loadVersionRows(metadata, entityId, baseVersion);
+ List<String> columnNames =
+ rows.getColumnDefinitions().asList().stream().map(ColumnDefinitions.Definition::getName)
+ .collect(Collectors.toList());
+
+ String insertCql = String.format("insert into %s (%s) values (%s)", metadata.getName(),
+ CommonMethods.listToSeparatedString(columnNames, ','),
+ commaSeparatedQuestionMarks(columnNames.size()));
+ Logger.debug("insertCql", insertCql);
+
+ for (Row row : rows) {
+ List<Object> columnValues = new ArrayList<>();
+ Map<String, Object> columnNameToValue = new HashMap<>();
+
+ for (String columnName : columnNames) {
+ if (metadata.getVersionIdentifierName().equals(columnName)) {
+ columnValues.add(versionMapper.toUDT(newVersion));
+ columnNameToValue.put(columnName, newVersion.toString());
+ } else {
+ Object value = row.getObject(columnName);
+ columnValues.add(value);
+ columnNameToValue.put(columnName, value);
+ }
+ }
+
+ initRowUniqueValues(metadata.getUniqueValuesMetadata(), columnNameToValue);
+
+ noSqlDb.execute(insertCql, columnValues.toArray());
+ }
+ }
+
+ private ResultSet loadVersionRows(VersionableEntityMetadata metadata, String entityId,
+ Version version) {
+ String selectCql = String.format("select * from %s where %s=? and %s=?", metadata.getName(),
+ metadata.getIdentifierName(), metadata.getVersionIdentifierName());
+ Logger.debug("selectCql", selectCql);
+ Logger.debug("entityId", entityId);
+ Logger.debug("version", version);
+
+ return noSqlDb.execute(selectCql, entityId, versionMapper.toUDT(version));
+ }
+
+ @Override
+ public void deleteVersion(VersionableEntityMetadata metadata, String entityId,
+ Version versionToDelete) {
+ deleteRowsUniqueValues(metadata, entityId, versionToDelete);
+
+ String deleteCql = String.format("delete from %s where %s=? and %s=?", metadata.getName(),
+ metadata.getIdentifierName(), metadata.getVersionIdentifierName());
+ noSqlDb.execute(deleteCql, entityId, versionMapper.toUDT(versionToDelete));
+ }
+
+ private void initRowUniqueValues(List<UniqueValueMetadata> metadata,
+ Map<String, Object> columnNameToValue) {
+ for (UniqueValueMetadata uniqueMetadata : metadata) {
+ List<String> uniqueValueCombination = uniqueMetadata.getUniqueConstraintIdentifiers().stream()
+ .map(colName -> (String) columnNameToValue.get(colName)).collect(Collectors.toList());
+ UniqueValueUtil.createUniqueValue(uniqueMetadata.getType(),
+ uniqueValueCombination.toArray(new String[uniqueValueCombination.size()]));
+ }
+ }
+
+ private void deleteRowUniqueValues(List<UniqueValueMetadata> metadata,
+ Map<String, Object> columnNameToValue) {
+ for (UniqueValueMetadata uniqueMetadata : metadata) {
+ List<String> uniqueValueCombination = uniqueMetadata.getUniqueConstraintIdentifiers().stream()
+ .map(colName -> (String) columnNameToValue.get(colName)).collect(Collectors.toList());
+ UniqueValueUtil.deleteUniqueValue(uniqueMetadata.getType(),
+ uniqueValueCombination.toArray(new String[uniqueValueCombination.size()]));
+ }
+ }
+
+ private void deleteRowsUniqueValues(VersionableEntityMetadata metadata, String entityId,
+ Version version) {
+ if (metadata.getUniqueValuesMetadata().isEmpty()) {
+ return;
+ }
+ ResultSet rows = loadVersionRows(metadata, entityId, version);
+ List<String> columnNames =
+ rows.getColumnDefinitions().asList().stream().map(ColumnDefinitions.Definition::getName)
+ .collect(Collectors.toList());
+
+ for (Row row : rows) {
+ Map<String, Object> columnNameToValue =
+ columnNames.stream().filter(name -> row.getObject(name) != null).collect(Collectors
+ .toMap(Function.identity(),
+ columnName -> metadata.getVersionIdentifierName().equals(columnName) ? version
+ .toString() : row.getObject(columnName)));
+ deleteRowUniqueValues(metadata.getUniqueValuesMetadata(), columnNameToValue);
+ }
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java
new file mode 100644
index 0000000000..8ec0814fc9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============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.versioning.dao.impl;
+
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
+
+public class VersionableEntityDaoFactoryImpl extends VersionableEntityDaoFactory {
+ private static VersionableEntityDao INSTANCE = new VersionableEntityDaoCassandraImpl();
+
+ @Override
+ public VersionableEntityDao createInterface() {
+ return INSTANCE;
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
new file mode 100644
index 0000000000..f7065cfda4
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============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.versioning.impl;
+
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+
+public class VersioningManagerFactoryImpl extends VersioningManagerFactory {
+ private static final VersioningManager INSTANCE = new VersioningManagerImpl();
+
+ @Override
+ public VersioningManager createInterface() {
+ return INSTANCE;
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
new file mode 100644
index 0000000000..6aa2a9f63c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
@@ -0,0 +1,468 @@
+/*-
+ * ============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.versioning.impl;
+
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionHistoryEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.dao.types.VersionType;
+import org.openecomp.sdc.versioning.dao.types.VersionableEntityId;
+import org.openecomp.sdc.versioning.errors.CheckinOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.CheckinOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.CheckoutOnLockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.DeleteOnLockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EditOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EditOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityAlreadyExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityAlreadyFinalizedErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.SubmitLockedEntityNotAllowedErrorBuilder;
+import org.openecomp.sdc.versioning.errors.UndoCheckoutOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.UndoCheckoutOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class VersioningManagerImpl implements VersioningManager {
+
+ private static final Version INITIAL_ACTIVE_VERSION = new Version(0, 0);
+ private static VersionInfoDao versionInfoDao =
+ VersionInfoDaoFactory.getInstance().createInterface();
+ private static VersionInfoDeletedDao versionInfoDeletedDao =
+ VersionInfoDeletedDaoFactory.getInstance().createInterface();
+ private static VersionableEntityDao versionableEntityDao =
+ VersionableEntityDaoFactory.getInstance().createInterface();
+
+ private static Map<String, Set<VersionableEntityMetadata>> versionableEntities = new HashMap<>();
+
+ private static VersionInfo getVersionInfo(VersionInfoEntity versionInfoEntity, String user,
+ VersionableEntityAction action) {
+ return getVersionInfo(versionInfoEntity.getEntityId(),
+ versionInfoEntity.getEntityType(),
+ versionInfoEntity.getActiveVersion(),
+ versionInfoEntity.getCandidate(),
+ versionInfoEntity.getStatus(),
+ versionInfoEntity.getLatestFinalVersion(),
+ versionInfoEntity.getViewableVersions(),
+ action,
+ user);
+ }
+
+ private static VersionInfo getVersionInfo(VersionInfoDeletedEntity versionInfoEntity, String user,
+ VersionableEntityAction action) {
+ return getVersionInfo(versionInfoEntity.getEntityId(),
+ versionInfoEntity.getEntityType(),
+ versionInfoEntity.getActiveVersion(),
+ versionInfoEntity.getCandidate(),
+ versionInfoEntity.getStatus(),
+ versionInfoEntity.getLatestFinalVersion(),
+ versionInfoEntity.getViewableVersions(),
+ action,
+ user);
+ }
+
+ private static VersionInfo getVersionInfo(String entityId, String entityType, Version activeVer,
+ UserCandidateVersion candidate, VersionStatus status,
+ Version latestFinalVersion,
+ Set<Version> viewableVersions,
+ VersionableEntityAction action, String user) {
+ Version activeVersion;
+
+ if (action == VersionableEntityAction.Write) {
+ if (candidate != null) {
+ if (user.equals(candidate.getUser())) {
+ activeVersion = candidate.getVersion();
+ } else {
+ throw new CoreException(
+ new EditOnEntityLockedByOtherErrorBuilder(entityType, entityId, candidate.getUser())
+ .build());
+ }
+ } else {
+ throw new CoreException(new EditOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+ }
+ } else {
+ if (candidate != null && user.equals(candidate.getUser())) {
+ activeVersion = candidate.getVersion();
+ } else {
+ activeVersion = activeVer;
+ }
+ }
+
+ VersionInfo versionInfo = new VersionInfo();
+ versionInfo.setActiveVersion(activeVersion);
+ versionInfo.setLatestFinalVersion(latestFinalVersion);
+ versionInfo.setViewableVersions(toSortedList(viewableVersions));
+ versionInfo.setFinalVersions(getFinalVersions(viewableVersions));
+ versionInfo.setStatus(status);
+ if (candidate != null) {
+ versionInfo.setLockingUser(candidate.getUser());
+ if (user.equals(candidate.getUser())) {
+ versionInfo.getViewableVersions().add(candidate.getVersion());
+ }
+ }
+ return versionInfo;
+ }
+
+ private static List<Version> toSortedList(
+ Set<Version> versions) { // changing the Set to List in DB will require migration...
+ return versions.stream().sorted((o1, o2) -> {
+ return o1.getMajor() > o2.getMajor() ? 1
+ : o1.getMajor() == o2.getMajor() ? (o1.getMinor() > o2.getMinor() ? 1
+ : o1.getMinor() == o2.getMinor() ? 0 : -1) : -1;
+ }).collect(Collectors.toList());
+ }
+
+ private static List<Version> getFinalVersions(Set<Version> versions) {
+ return versions.stream().filter(version -> version.isFinal()).collect(Collectors.toList());
+ }
+
+ @Override
+ public void register(String entityType, VersionableEntityMetadata entityMetadata) {
+ Set<VersionableEntityMetadata> entitiesMetadata = versionableEntities.get(entityType);
+ if (entitiesMetadata == null) {
+ entitiesMetadata = new HashSet<>();
+ versionableEntities.put(entityType, entitiesMetadata);
+ }
+ entitiesMetadata.add(entityMetadata);
+ }
+
+ @Override
+ public Version create(String entityType, String entityId, String user) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity != null) {
+ throw new CoreException(new EntityAlreadyExistErrorBuilder(entityType, entityId).build());
+ }
+
+ versionInfoEntity = new VersionInfoEntity(entityType, entityId);
+ versionInfoEntity.setActiveVersion(INITIAL_ACTIVE_VERSION);
+ markAsCheckedOut(versionInfoEntity, user);
+ versionInfoDao.create(versionInfoEntity);
+
+ return versionInfoEntity.getCandidate().getVersion();
+ }
+
+ @Override
+ public Version checkout(String entityType, String entityId, String user) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ Version checkoutVersion = null;
+ switch (versionInfoEntity.getStatus()) {
+ case Locked:
+ throw new CoreException(new CheckoutOnLockedEntityErrorBuilder(entityType, entityId,
+ versionInfoEntity.getCandidate().getUser()).build());
+ case Final:
+ case Available:
+ checkoutVersion = doCheckout(versionInfoEntity, user);
+ break;
+ default:
+ }
+ return checkoutVersion;
+ }
+
+ @Override
+ public Version undoCheckout(String entityType, String entityId, String user) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ Version activeVersion = null;
+ switch (versionInfoEntity.getStatus()) {
+ case Locked:
+ if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
+ throw new CoreException(
+ new UndoCheckoutOnEntityLockedByOtherErrorBuilder(entityType, entityId,
+ versionInfoEntity.getCandidate().getUser()).build());
+ }
+ activeVersion = undoCheckout(versionInfoEntity);
+ break;
+ case Final:
+ case Available:
+ throw new CoreException(
+ new UndoCheckoutOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+ default:
+ }
+ return activeVersion;
+ }
+
+ private Version undoCheckout(VersionInfoEntity versionInfoEntity) {
+ deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+ versionInfoEntity.getCandidate().getVersion());
+
+ versionInfoEntity.setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Final
+ : VersionStatus.Available);
+ versionInfoEntity.setCandidate(null);
+ versionInfoDao.update(versionInfoEntity);
+ return versionInfoEntity.getActiveVersion();
+ }
+
+ @Override
+ public Version checkin(String entityType, String entityId, String user,
+ String checkinDescription) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ Version checkedInVersion = null;
+ switch (versionInfoEntity.getStatus()) {
+ case Available:
+ case Final:
+ throw new CoreException(
+ new CheckinOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+ case Locked:
+ if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
+ throw new CoreException(new CheckinOnEntityLockedByOtherErrorBuilder(entityType, entityId,
+ versionInfoEntity.getCandidate().getUser()).build());
+ }
+ checkedInVersion = doCheckin(versionInfoEntity, checkinDescription);
+ break;
+ default:
+ }
+ return checkedInVersion;
+ }
+
+ @Override
+ public Version submit(String entityType, String entityId, String user, String submitDescription) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ Version submitVersion = null;
+ switch (versionInfoEntity.getStatus()) {
+ case Final:
+ throw new CoreException(
+ new EntityAlreadyFinalizedErrorBuilder(entityType, entityId).build());
+ case Locked:
+ throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
+ versionInfoEntity.getCandidate().getUser()).build());
+ case Available:
+ submitVersion = doSubmit(versionInfoEntity, user, submitDescription);
+ break;
+ default:
+ }
+ return submitVersion;
+ }
+
+ @Override
+ public VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
+ VersionableEntityAction action) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+ return getVersionInfo(versionInfoEntity, user, action);
+ }
+
+ @Override
+ public Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
+ VersionableEntityAction action) {
+ Collection<VersionInfoEntity> versionInfoEntities =
+ versionInfoDao.list(new VersionInfoEntity(entityType, null));
+ Map<String, VersionInfo> activeVersions = new HashMap<>();
+ for (VersionInfoEntity versionInfoEntity : versionInfoEntities) {
+ activeVersions
+ .put(versionInfoEntity.getEntityId(), getVersionInfo(versionInfoEntity, user, action));
+ }
+ return activeVersions;
+ }
+
+ @Override
+ public Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
+ VersionableEntityAction action) {
+ Collection<VersionInfoDeletedEntity> versionInfoDeletedEntities =
+ versionInfoDeletedDao.list(new VersionInfoDeletedEntity(entityType, null));
+ Map<String, VersionInfo> activeVersions = new HashMap<>();
+
+
+ for (VersionInfoDeletedEntity versionInfoDeletedEntity : versionInfoDeletedEntities) {
+ activeVersions.put(versionInfoDeletedEntity.getEntityId(),
+ getVersionInfo(versionInfoDeletedEntity, user, action));
+ }
+ return activeVersions;
+ }
+
+ @Override
+ public void delete(String entityType, String entityId, String user) {
+ VersionInfoEntity versionInfoEntity =
+ versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+ if (versionInfoEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ switch (versionInfoEntity.getStatus()) {
+ case Locked:
+ throw new CoreException(new DeleteOnLockedEntityErrorBuilder(entityType, entityId,
+ versionInfoEntity.getCandidate().getUser()).build());
+ default:
+ }
+
+ doDelete(versionInfoEntity, user);
+ }
+
+ @Override
+ public void undoDelete(String entityType, String entityId, String user) {
+ VersionInfoDeletedEntity versionInfoDeletedEntity =
+ versionInfoDeletedDao.get(new VersionInfoDeletedEntity(entityType, entityId));
+ if (versionInfoDeletedEntity == null) {
+ throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+ }
+
+ doUndoDelete(versionInfoDeletedEntity, user);
+ }
+
+ private void markAsCheckedOut(VersionInfoEntity versionInfoEntity, String checkingOutUser) {
+ versionInfoEntity.setStatus(VersionStatus.Locked);
+ versionInfoEntity.setCandidate(new UserCandidateVersion(checkingOutUser,
+ versionInfoEntity.getActiveVersion().calculateNextCandidate()));
+ }
+
+ private Version doCheckout(VersionInfoEntity versionInfoEntity, String user) {
+ markAsCheckedOut(versionInfoEntity, user);
+ versionInfoDao.update(versionInfoEntity);
+
+ initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+ versionInfoEntity.getActiveVersion(), versionInfoEntity.getCandidate().getVersion());
+
+ return versionInfoEntity.getCandidate().getVersion();
+ }
+
+ private void doDelete(VersionInfoEntity versionInfoEntity, String user) {
+
+ VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
+ versionInfoDeletedEntity.setStatus(versionInfoEntity.getStatus());
+ versionInfoDeletedEntity.setViewableVersions(versionInfoEntity.getViewableVersions());
+ versionInfoDeletedEntity.setActiveVersion(versionInfoEntity.getActiveVersion());
+ versionInfoDeletedEntity.setCandidate(versionInfoEntity.getCandidate());
+ versionInfoDeletedEntity.setEntityId(versionInfoEntity.getEntityId());
+ versionInfoDeletedEntity.setEntityType(versionInfoEntity.getEntityType());
+ versionInfoDeletedEntity.setLatestFinalVersion(versionInfoEntity.getLatestFinalVersion());
+ versionInfoDeletedDao.create(versionInfoDeletedEntity);
+ versionInfoDao.delete(versionInfoEntity);
+
+ }
+
+ private void doUndoDelete(VersionInfoDeletedEntity versionInfoDeletedEntity, String user) {
+
+ VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
+ versionInfoEntity.setStatus(versionInfoDeletedEntity.getStatus());
+ versionInfoEntity.setViewableVersions(versionInfoDeletedEntity.getViewableVersions());
+ versionInfoEntity.setActiveVersion(versionInfoDeletedEntity.getActiveVersion());
+ versionInfoEntity.setCandidate(versionInfoDeletedEntity.getCandidate());
+ versionInfoEntity.setEntityId(versionInfoDeletedEntity.getEntityId());
+ versionInfoEntity.setEntityType(versionInfoDeletedEntity.getEntityType());
+ versionInfoEntity.setLatestFinalVersion(versionInfoDeletedEntity.getLatestFinalVersion());
+ versionInfoDao.create(versionInfoEntity);
+ versionInfoDeletedDao.delete(versionInfoDeletedEntity);
+
+ }
+
+ private Version doCheckin(VersionInfoEntity versionInfoEntity, String checkinDescription) {
+ UserCandidateVersion userCandidateVersion = versionInfoEntity.getCandidate();
+ versionInfoEntity.setCandidate(null);
+ versionInfoEntity.setActiveVersion(userCandidateVersion.getVersion());
+ versionInfoEntity.getViewableVersions().add(versionInfoEntity.getActiveVersion());
+ versionInfoEntity.setStatus(VersionStatus.Available);
+ versionInfoDao.update(versionInfoEntity);
+
+ return versionInfoEntity.getActiveVersion();
+ }
+
+ private Version doSubmit(VersionInfoEntity versionInfoEntity, String submittingUser,
+ String submitDescription) {
+ Version finalVersion = versionInfoEntity.getActiveVersion().calculateNextFinal();
+ initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+ versionInfoEntity.getActiveVersion(), finalVersion);
+
+ Set<Version> viewableVersions = new HashSet<>();
+ for (Version version : versionInfoEntity.getViewableVersions()) {
+ if (version.isFinal()) {
+ viewableVersions.add(version);
+ }
+ }
+ viewableVersions.add(finalVersion);
+ versionInfoEntity.setViewableVersions(viewableVersions);
+ versionInfoEntity.setActiveVersion(finalVersion);
+ versionInfoEntity.setLatestFinalVersion(finalVersion);
+ versionInfoEntity.setStatus(VersionStatus.Final);
+ versionInfoDao.update(versionInfoEntity);
+
+ return finalVersion;
+ }
+
+ private void createVersionHistory(VersionableEntityId entityId, Version version, String user,
+ String description, VersionType type) {
+ VersionHistoryEntity versionHistory = new VersionHistoryEntity(entityId);
+ versionHistory.setVersion(version);
+ versionHistory.setUser(user);
+ versionHistory.setDescription(description);
+ versionHistory.setType(type);
+ }
+
+ private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
+ Version newVersion) {
+ Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
+ if (entityMetadatas != null) {
+ for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+ versionableEntityDao.initVersion(entityMetadata, entityId, baseVersion, newVersion);
+ }
+ }
+ }
+
+ private void deleteVersionFromEntity(String entityType, String entityId,
+ Version versionToDelete) {
+ Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
+ if (entityMetadatas != null) {
+ for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+ versionableEntityDao.deleteVersion(entityMetadata, entityId, versionToDelete);
+ }
+ }
+ }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java
new file mode 100644
index 0000000000..3695f9ef2d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java
@@ -0,0 +1,364 @@
+package org.openecomp.sdc.versioning;
+
+
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.mapping.UDTMapper;
+
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class VersioningManagerTest {
+ private static final VersioningManager versioningManager =
+ VersioningManagerFactory.getInstance().createInterface();
+ private static final VersionInfoDao versionInfoDao =
+ VersionInfoDaoFactory.getInstance().createInterface();
+ private static final VersionInfoDeletedDao versionInfoDeletedDao =
+ VersionInfoDeletedDaoFactory.getInstance().createInterface();
+ private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static final String USR1 = "usr1";
+ private static final String USR2 = "usr2";
+ private static final String USR3 = "usr3";
+ private static final String TYPE1 = "Type1";
+ private static final String TYPE2 = "Type2";
+ private static final String ID1 = "Id1";
+ private static final String ID2 = "Id2";
+ private static final String ID3 = "Id3";
+ private static final String TYPE1_TABLE_NAME = "vendor_license_model";
+ private static final String TYPE1_ID_NAME = "vlm_id";
+ private static final String TYPE1_VERSION_NAME = "version";
+ private static final String TYPE2_TABLE_NAME = "feature_group";
+ private static final String TYPE2_ID_NAME = "vlm_id";
+ private static final String TYPE2_VERSION_NAME = "version";
+ private static final Version VERSION01 = new Version(0, 1);
+ private static final Version VERSION02 = new Version(0, 2);
+ private static final Version VERSION10 = new Version(1, 0);
+ private static final Version VERSION11 = new Version(1, 1);
+ private static UDTMapper<Version> versionMapper =
+ noSqlDb.getMappingManager().udtMapper(Version.class);
+ private static Set<Version> expectedViewableVersionsType1Id1 = new HashSet<>();
+
+ private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
+ String entityId, Version activeVersion,
+ Version candidateVersion, String candidateUser,
+ VersionStatus status, Set<Version> viewbleVersions,
+ Version latestFinalVersion) {
+ Assert.assertNotNull(actual);
+ Assert.assertEquals(actual.getEntityType(), entityType);
+ Assert.assertEquals(actual.getEntityId(), entityId);
+ Assert.assertEquals(actual.getActiveVersion(), activeVersion);
+ if (candidateVersion != null && candidateUser != null) {
+ Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
+ Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
+ } else {
+ Assert.assertNull(actual.getCandidate());
+ }
+ Assert.assertEquals(actual.getStatus(), status);
+ Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
+ Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
+ Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
+ }
+
+ private static void assretVersionInfo(VersionInfo actual, Version activeVersion,
+ VersionStatus status, String lockingUser,
+ Set<Version> viewableVersions, Version latestFinalVersion) {
+ Assert.assertNotNull(actual);
+ Assert.assertEquals(actual.getActiveVersion(), activeVersion);
+ Assert.assertEquals(actual.getStatus(), status);
+ Assert.assertEquals(actual.getLockingUser(), lockingUser);
+ Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
+ Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
+ Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
+ }
+
+// @BeforeClass
+ private void init() {
+ versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID1));
+ versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID2));
+ versionInfoDao.delete(new VersionInfoEntity(TYPE2, ID3));
+ String deleteFromType1 = String
+ .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
+ TYPE1_VERSION_NAME);
+ noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
+ noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
+ noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
+
+ versioningManager.register(TYPE1,
+ new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
+ versioningManager.register(TYPE2,
+ new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
+ }
+
+// @Test
+ public void createTest() {
+ Version version = versioningManager.create(TYPE1, ID1, USR1);
+ createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+ version);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
+ VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
+ }
+
+// @Test(dependsOnMethods = "createTest")
+ public void checkinTest() {
+ Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
+ Assert.assertEquals(version, VERSION01);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ expectedViewableVersionsType1Id1.add(VERSION01);
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
+ VersionStatus.Available, expectedViewableVersionsType1Id1, null);
+ }
+
+// @Test(dependsOnMethods = "checkinTest")
+ public void getVersionInfoForReadOnAvailableTest() {
+ VersionInfo versionInfo =
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
+ assretVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
+ expectedViewableVersionsType1Id1, null);
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForReadOnAvailableTest",
+// expectedExceptions = CoreException.class)
+ public void getVersionInfoForWriteOnAvailableTest() {
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write);
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForWriteOnAvailableTest",
+// expectedExceptions = CoreException.class)
+ public void checkinOnAvailableTest() {
+ versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
+ }
+
+// @Test(dependsOnMethods = "checkinOnAvailableTest", expectedExceptions = CoreException.class)
+ public void undoCheckoutOnAvailableTest() {
+ versioningManager.undoCheckout(TYPE1, ID1, USR1);
+ }
+
+// @Test(dependsOnMethods = "undoCheckoutOnAvailableTest")
+ public void checkoutTest() {
+ Version version = versioningManager.checkout(TYPE1, ID1, USR2);
+ Assert.assertEquals(version, VERSION02);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR2,
+ VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
+
+ ResultSet results =
+ loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+ VERSION02);
+ Assert.assertTrue(results.iterator().hasNext());
+ }
+
+// @Test(dependsOnMethods = "checkoutTest")
+ public void getVersionInfoForReadOnLockedSameUserTest() {
+ VersionInfo versionInfo =
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
+ Set<Version> expectedViewableVersions = new HashSet<>();
+ expectedViewableVersions.addAll(expectedViewableVersionsType1Id1);
+ expectedViewableVersions.add(VERSION02);
+ assretVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR2, expectedViewableVersions,
+ null);
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForReadOnLockedSameUserTest")
+ public void getVersionInfoForReadOnLockedOtherUserTest() {
+ VersionInfo entityVersionInfo =
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
+ Assert.assertEquals(entityVersionInfo.getActiveVersion(), VERSION01);
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForReadOnLockedOtherUserTest",
+// expectedExceptions = CoreException.class)
+ public void getVersionInfoForWriteOnLockedOtherUserTest() {
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write)
+ .getActiveVersion();
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedOtherUserTest")
+ public void getVersionInfoForWriteOnLockedSameUserTest() {
+ Version activeVersion =
+ versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write)
+ .getActiveVersion();
+ Assert.assertEquals(activeVersion, VERSION02);
+ }
+
+// @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedSameUserTest",
+// expectedExceptions = CoreException.class)
+ public void checkoutOnLockedSameUserTest() {
+ versioningManager.checkout(TYPE1, ID1, USR2);
+ }
+
+// @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
+ public void checkoutOnLockedOtherUserTest() {
+ versioningManager.checkout(TYPE1, ID1, USR1);
+ }
+
+// @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
+ public void undoCheckoutOnLockedOtherUserTest() {
+ versioningManager.undoCheckout(TYPE1, ID1, USR1);
+ }
+
+// @Test(dependsOnMethods = "undoCheckoutOnLockedOtherUserTest",
+// expectedExceptions = CoreException.class)
+ public void submitOnLockedTest() {
+ versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
+ }
+
+// @Test(dependsOnMethods = "submitOnLockedTest")
+ public void undoCheckoutTest() {
+ Version version = versioningManager.undoCheckout(TYPE1, ID1, USR2);
+ Assert.assertEquals(version, VERSION01);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
+ VersionStatus.Available, expectedViewableVersionsType1Id1, null);
+
+ ResultSet results =
+ loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+ VERSION02);
+ Assert.assertFalse(results.iterator().hasNext());
+ }
+
+// @Test(dependsOnMethods = "undoCheckoutTest")
+ public void submitTest() {
+ Version version = versioningManager.submit(TYPE1, ID1, USR3, "submit msg");
+ Assert.assertEquals(version, VERSION10);
+ expectedViewableVersionsType1Id1 = new HashSet<>();
+ expectedViewableVersionsType1Id1.add(version);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, null, null,
+ VersionStatus.Final, expectedViewableVersionsType1Id1, VERSION10);
+
+ ResultSet results =
+ loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+ VERSION10);
+ Assert.assertTrue(results.iterator().hasNext());
+ }
+
+// @Test(dependsOnMethods = "submitTest", expectedExceptions = CoreException.class)
+ public void checkinOnFinalizedTest() {
+ versioningManager.checkin(TYPE1, ID1, USR2, "failed checkin");
+ }
+
+// @Test(dependsOnMethods = "checkinOnFinalizedTest", expectedExceptions = CoreException.class)
+ public void undoCheckouOnFinalizedTest() {
+ versioningManager.undoCheckout(TYPE1, ID1, USR2);
+ }
+
+// @Test(dependsOnMethods = "undoCheckouOnFinalizedTest", expectedExceptions = CoreException.class)
+ public void submitOnFinalizedTest() {
+ versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
+ }
+
+// @Test(dependsOnMethods = "submitOnFinalizedTest")
+ public void checkoutOnFinalizedTest() {
+ Version version = versioningManager.checkout(TYPE1, ID1, USR3);
+ Assert.assertEquals(version, VERSION11);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR3,
+ VersionStatus.Locked, expectedViewableVersionsType1Id1, VERSION10);
+
+ ResultSet results =
+ loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+ VERSION11);
+ Assert.assertTrue(results.iterator().hasNext());
+ }
+
+// @Test(dependsOnMethods = "checkoutOnFinalizedTest")
+ public void viewableVersionsTest() {
+ versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.1");
+ versioningManager.checkout(TYPE1, ID1, USR3);
+ versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.2");
+ versioningManager.submit(TYPE1, ID1, USR3, "submit in 2.0");
+ versioningManager.checkout(TYPE1, ID1, USR3);
+ versioningManager.checkin(TYPE1, ID1, USR3, "check in 2.1");
+ versioningManager.submit(TYPE1, ID1, USR3, "submit in 3.0");
+ versioningManager.checkout(TYPE1, ID1, USR3);
+ versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.1");
+ versioningManager.checkout(TYPE1, ID1, USR3);
+ versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.2");
+ versioningManager.checkout(TYPE1, ID1, USR2);
+
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ HashSet<Version> expectedViewableVersions = new HashSet<>();
+ expectedViewableVersions.add(VERSION10);
+ expectedViewableVersions.add(new Version(2, 0));
+ expectedViewableVersions.add(new Version(3, 0));
+ expectedViewableVersions.add(new Version(3, 1));
+ expectedViewableVersions.add(new Version(3, 2));
+ assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(3, 2), new Version(3, 3),
+ USR2, VersionStatus.Locked, expectedViewableVersions, new Version(3, 0));
+ }
+
+// @Test(dependsOnMethods = "viewableVersionsTest")
+ public void listActiveVersionsTest() {
+ versioningManager.create(TYPE1, ID2, USR3);
+ versioningManager.checkin(TYPE1, ID2, USR3, "check in 0.1");
+
+ versioningManager.create(TYPE2, ID3, USR3);
+ versioningManager.checkin(TYPE2, ID3, USR3, "check in 0.1");
+
+ Map<String, VersionInfo> idToVersionInfo =
+ versioningManager.listEntitiesVersionInfo(TYPE1, USR2, VersionableEntityAction.Read);
+ Assert.assertEquals(idToVersionInfo.size(), 2);
+ Assert.assertEquals(idToVersionInfo.get(ID1).getActiveVersion(), new Version(3, 3));
+ Assert.assertEquals(idToVersionInfo.get(ID2).getActiveVersion(), VERSION01);
+ }
+
+// @Test(dependsOnMethods = "listActiveVersionsTest")
+ public void deleteTest() {
+ versioningManager.checkin(TYPE1, ID1, USR2, "check in for delete");
+ versioningManager.delete(TYPE1, ID1, USR1);
+
+ VersionInfoDeletedEntity versionInfoDeletedEntity =
+ versionInfoDeletedDao.get(new VersionInfoDeletedEntity(TYPE1, ID1));
+ Assert.assertNotNull(versionInfoDeletedEntity);
+
+ Map<String, VersionInfo> entitiesInfoMap =
+ versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
+ Assert.assertEquals(entitiesInfoMap.size(), 1);
+ VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ Assert.assertNull(versionInfoEntity);
+ versioningManager.undoDelete(TYPE1, ID1, USR1);
+ versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+ Assert.assertNotNull(versionInfoEntity);
+
+
+ }
+
+ private void createVersionableEntityRecord(String tableName, String idName, String versionName,
+ String id, Version version) {
+ noSqlDb.execute(
+ String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
+ versionMapper.toUDT(version));
+ }
+
+ private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
+ String id, Version version) {
+ return noSqlDb.execute(
+ String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
+ versionMapper.toUDT(version));
+ }
+}