1 package org.openecomp.sdc.versioning;
4 import org.openecomp.sdc.common.errors.CoreException;
5 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
6 import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
7 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
8 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
9 import org.openecomp.sdc.versioning.dao.types.Version;
10 import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
11 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
12 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
13 import org.openecomp.sdc.versioning.types.VersionInfo;
14 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
15 import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
16 import org.openecomp.core.nosqldb.api.NoSqlDb;
17 import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
18 import com.datastax.driver.core.ResultSet;
19 import com.datastax.driver.mapping.UDTMapper;
21 import org.testng.Assert;
22 import org.testng.annotations.BeforeClass;
23 import org.testng.annotations.Test;
25 import java.util.HashSet;
29 public class VersioningManagerTest {
30 private static final VersioningManager versioningManager =
31 VersioningManagerFactory.getInstance().createInterface();
32 private static final VersionInfoDao versionInfoDao =
33 VersionInfoDaoFactory.getInstance().createInterface();
34 private static final VersionInfoDeletedDao versionInfoDeletedDao =
35 VersionInfoDeletedDaoFactory.getInstance().createInterface();
36 private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
37 private static final String USR1 = "usr1";
38 private static final String USR2 = "usr2";
39 private static final String USR3 = "usr3";
40 private static final String TYPE1 = "Type1";
41 private static final String TYPE2 = "Type2";
42 private static final String ID1 = "Id1";
43 private static final String ID2 = "Id2";
44 private static final String ID3 = "Id3";
45 private static final String TYPE1_TABLE_NAME = "vendor_license_model";
46 private static final String TYPE1_ID_NAME = "vlm_id";
47 private static final String TYPE1_VERSION_NAME = "version";
48 private static final String TYPE2_TABLE_NAME = "feature_group";
49 private static final String TYPE2_ID_NAME = "vlm_id";
50 private static final String TYPE2_VERSION_NAME = "version";
51 private static final Version VERSION01 = new Version(0, 1);
52 private static final Version VERSION02 = new Version(0, 2);
53 private static final Version VERSION10 = new Version(1, 0);
54 private static final Version VERSION11 = new Version(1, 1);
55 private static UDTMapper<Version> versionMapper =
56 noSqlDb.getMappingManager().udtMapper(Version.class);
57 private static Set<Version> expectedViewableVersionsType1Id1 = new HashSet<>();
59 private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
60 String entityId, Version activeVersion,
61 Version candidateVersion, String candidateUser,
62 VersionStatus status, Set<Version> viewbleVersions,
63 Version latestFinalVersion) {
64 Assert.assertNotNull(actual);
65 Assert.assertEquals(actual.getEntityType(), entityType);
66 Assert.assertEquals(actual.getEntityId(), entityId);
67 Assert.assertEquals(actual.getActiveVersion(), activeVersion);
68 if (candidateVersion != null && candidateUser != null) {
69 Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
70 Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
72 Assert.assertNull(actual.getCandidate());
74 Assert.assertEquals(actual.getStatus(), status);
75 Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
76 Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
77 Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
80 private static void assretVersionInfo(VersionInfo actual, Version activeVersion,
81 VersionStatus status, String lockingUser,
82 Set<Version> viewableVersions, Version latestFinalVersion) {
83 Assert.assertNotNull(actual);
84 Assert.assertEquals(actual.getActiveVersion(), activeVersion);
85 Assert.assertEquals(actual.getStatus(), status);
86 Assert.assertEquals(actual.getLockingUser(), lockingUser);
87 Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
88 Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
89 Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
94 versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID1));
95 versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID2));
96 versionInfoDao.delete(new VersionInfoEntity(TYPE2, ID3));
97 String deleteFromType1 = String
98 .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
100 noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
101 noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
102 noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
104 versioningManager.register(TYPE1,
105 new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
106 versioningManager.register(TYPE2,
107 new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
111 public void createTest() {
112 Version version = versioningManager.create(TYPE1, ID1, USR1);
113 createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
116 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
117 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
118 VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
121 // @Test(dependsOnMethods = "createTest")
122 public void checkinTest() {
123 Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
124 Assert.assertEquals(version, VERSION01);
126 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
127 expectedViewableVersionsType1Id1.add(VERSION01);
128 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
129 VersionStatus.Available, expectedViewableVersionsType1Id1, null);
132 // @Test(dependsOnMethods = "checkinTest")
133 public void getVersionInfoForReadOnAvailableTest() {
134 VersionInfo versionInfo =
135 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
136 assretVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
137 expectedViewableVersionsType1Id1, null);
140 // @Test(dependsOnMethods = "getVersionInfoForReadOnAvailableTest",
141 // expectedExceptions = CoreException.class)
142 public void getVersionInfoForWriteOnAvailableTest() {
143 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write);
146 // @Test(dependsOnMethods = "getVersionInfoForWriteOnAvailableTest",
147 // expectedExceptions = CoreException.class)
148 public void checkinOnAvailableTest() {
149 versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
152 // @Test(dependsOnMethods = "checkinOnAvailableTest", expectedExceptions = CoreException.class)
153 public void undoCheckoutOnAvailableTest() {
154 versioningManager.undoCheckout(TYPE1, ID1, USR1);
157 // @Test(dependsOnMethods = "undoCheckoutOnAvailableTest")
158 public void checkoutTest() {
159 Version version = versioningManager.checkout(TYPE1, ID1, USR2);
160 Assert.assertEquals(version, VERSION02);
162 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
163 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR2,
164 VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
167 loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
169 Assert.assertTrue(results.iterator().hasNext());
172 // @Test(dependsOnMethods = "checkoutTest")
173 public void getVersionInfoForReadOnLockedSameUserTest() {
174 VersionInfo versionInfo =
175 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
176 Set<Version> expectedViewableVersions = new HashSet<>();
177 expectedViewableVersions.addAll(expectedViewableVersionsType1Id1);
178 expectedViewableVersions.add(VERSION02);
179 assretVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR2, expectedViewableVersions,
183 // @Test(dependsOnMethods = "getVersionInfoForReadOnLockedSameUserTest")
184 public void getVersionInfoForReadOnLockedOtherUserTest() {
185 VersionInfo entityVersionInfo =
186 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
187 Assert.assertEquals(entityVersionInfo.getActiveVersion(), VERSION01);
190 // @Test(dependsOnMethods = "getVersionInfoForReadOnLockedOtherUserTest",
191 // expectedExceptions = CoreException.class)
192 public void getVersionInfoForWriteOnLockedOtherUserTest() {
193 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write)
197 // @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedOtherUserTest")
198 public void getVersionInfoForWriteOnLockedSameUserTest() {
199 Version activeVersion =
200 versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write)
202 Assert.assertEquals(activeVersion, VERSION02);
205 // @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedSameUserTest",
206 // expectedExceptions = CoreException.class)
207 public void checkoutOnLockedSameUserTest() {
208 versioningManager.checkout(TYPE1, ID1, USR2);
211 // @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
212 public void checkoutOnLockedOtherUserTest() {
213 versioningManager.checkout(TYPE1, ID1, USR1);
216 // @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
217 public void undoCheckoutOnLockedOtherUserTest() {
218 versioningManager.undoCheckout(TYPE1, ID1, USR1);
221 // @Test(dependsOnMethods = "undoCheckoutOnLockedOtherUserTest",
222 // expectedExceptions = CoreException.class)
223 public void submitOnLockedTest() {
224 versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
227 // @Test(dependsOnMethods = "submitOnLockedTest")
228 public void undoCheckoutTest() {
229 Version version = versioningManager.undoCheckout(TYPE1, ID1, USR2);
230 Assert.assertEquals(version, VERSION01);
232 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
233 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
234 VersionStatus.Available, expectedViewableVersionsType1Id1, null);
237 loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
239 Assert.assertFalse(results.iterator().hasNext());
242 // @Test(dependsOnMethods = "undoCheckoutTest")
243 public void submitTest() {
244 Version version = versioningManager.submit(TYPE1, ID1, USR3, "submit msg");
245 Assert.assertEquals(version, VERSION10);
246 expectedViewableVersionsType1Id1 = new HashSet<>();
247 expectedViewableVersionsType1Id1.add(version);
249 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
250 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, null, null,
251 VersionStatus.Final, expectedViewableVersionsType1Id1, VERSION10);
254 loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
256 Assert.assertTrue(results.iterator().hasNext());
259 // @Test(dependsOnMethods = "submitTest", expectedExceptions = CoreException.class)
260 public void checkinOnFinalizedTest() {
261 versioningManager.checkin(TYPE1, ID1, USR2, "failed checkin");
264 // @Test(dependsOnMethods = "checkinOnFinalizedTest", expectedExceptions = CoreException.class)
265 public void undoCheckouOnFinalizedTest() {
266 versioningManager.undoCheckout(TYPE1, ID1, USR2);
269 // @Test(dependsOnMethods = "undoCheckouOnFinalizedTest", expectedExceptions = CoreException.class)
270 public void submitOnFinalizedTest() {
271 versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
274 // @Test(dependsOnMethods = "submitOnFinalizedTest")
275 public void checkoutOnFinalizedTest() {
276 Version version = versioningManager.checkout(TYPE1, ID1, USR3);
277 Assert.assertEquals(version, VERSION11);
279 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
280 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR3,
281 VersionStatus.Locked, expectedViewableVersionsType1Id1, VERSION10);
284 loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
286 Assert.assertTrue(results.iterator().hasNext());
289 // @Test(dependsOnMethods = "checkoutOnFinalizedTest")
290 public void viewableVersionsTest() {
291 versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.1");
292 versioningManager.checkout(TYPE1, ID1, USR3);
293 versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.2");
294 versioningManager.submit(TYPE1, ID1, USR3, "submit in 2.0");
295 versioningManager.checkout(TYPE1, ID1, USR3);
296 versioningManager.checkin(TYPE1, ID1, USR3, "check in 2.1");
297 versioningManager.submit(TYPE1, ID1, USR3, "submit in 3.0");
298 versioningManager.checkout(TYPE1, ID1, USR3);
299 versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.1");
300 versioningManager.checkout(TYPE1, ID1, USR3);
301 versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.2");
302 versioningManager.checkout(TYPE1, ID1, USR2);
304 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
305 HashSet<Version> expectedViewableVersions = new HashSet<>();
306 expectedViewableVersions.add(VERSION10);
307 expectedViewableVersions.add(new Version(2, 0));
308 expectedViewableVersions.add(new Version(3, 0));
309 expectedViewableVersions.add(new Version(3, 1));
310 expectedViewableVersions.add(new Version(3, 2));
311 assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(3, 2), new Version(3, 3),
312 USR2, VersionStatus.Locked, expectedViewableVersions, new Version(3, 0));
315 // @Test(dependsOnMethods = "viewableVersionsTest")
316 public void listActiveVersionsTest() {
317 versioningManager.create(TYPE1, ID2, USR3);
318 versioningManager.checkin(TYPE1, ID2, USR3, "check in 0.1");
320 versioningManager.create(TYPE2, ID3, USR3);
321 versioningManager.checkin(TYPE2, ID3, USR3, "check in 0.1");
323 Map<String, VersionInfo> idToVersionInfo =
324 versioningManager.listEntitiesVersionInfo(TYPE1, USR2, VersionableEntityAction.Read);
325 Assert.assertEquals(idToVersionInfo.size(), 2);
326 Assert.assertEquals(idToVersionInfo.get(ID1).getActiveVersion(), new Version(3, 3));
327 Assert.assertEquals(idToVersionInfo.get(ID2).getActiveVersion(), VERSION01);
330 // @Test(dependsOnMethods = "listActiveVersionsTest")
331 public void deleteTest() {
332 versioningManager.checkin(TYPE1, ID1, USR2, "check in for delete");
333 versioningManager.delete(TYPE1, ID1, USR1);
335 VersionInfoDeletedEntity versionInfoDeletedEntity =
336 versionInfoDeletedDao.get(new VersionInfoDeletedEntity(TYPE1, ID1));
337 Assert.assertNotNull(versionInfoDeletedEntity);
339 Map<String, VersionInfo> entitiesInfoMap =
340 versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
341 Assert.assertEquals(entitiesInfoMap.size(), 1);
342 VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
343 Assert.assertNull(versionInfoEntity);
344 versioningManager.undoDelete(TYPE1, ID1, USR1);
345 versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
346 Assert.assertNotNull(versionInfoEntity);
351 private void createVersionableEntityRecord(String tableName, String idName, String versionName,
352 String id, Version version) {
354 String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
355 versionMapper.toUDT(version));
358 private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
359 String id, Version version) {
360 return noSqlDb.execute(
361 String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
362 versionMapper.toUDT(version));