Add versioning, session and zusammen libs

Issue-ID: SDC-2486
Signed-off-by: talig <talig@amdocs.com>
Change-Id: I848edbcb84f424f949b646df04f04fa66d0f3bd2

2 files changed, 639 insertions, 0 deletions

diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java
new file mode 100644
index 0000000..fac3e0c
--- /dev/null
+++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java
@@ -0,0 +1,229 @@
+/*
+ * 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.onap.sdc.common.versioning.persistence.zusammen;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.UserInfo;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.Item;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.common.versioning.persistence.types.InternalItem;
+import org.onap.sdc.common.versioning.services.types.ItemStatus;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.onap.sdc.common.zusammen.services.ZusammenAdaptor;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ItemZusammenDaoTest {
+
+    private static final String ITEM_TYPE = "item_type";
+    private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses";
+    private static final String APP_PROP_1 = "app_prop1";
+    private static final String APP_PROP_2 = "app_prop2";
+    private static final SessionContext SESSION_CONTEXT = new SessionContext();
+
+    static {
+        SESSION_CONTEXT.setUser(new UserInfo("user"));
+        SESSION_CONTEXT.setTenant("tenant");
+    }
+
+    @Mock
+    private ZusammenSessionContextCreator contextCreatorMock;
+    @Mock
+    private ZusammenAdaptor zusammenAdaptorMock;
+    @InjectMocks
+    private ItemZusammenDao itemDao;
+
+    @Before
+    public void mockSessionContext() {
+        doReturn(SESSION_CONTEXT).when(contextCreatorMock).create();
+    }
+
+
+    @Test
+    public void testListWhenNone() {
+        doReturn(new ArrayList<>()).when(zusammenAdaptorMock).listItems(eq(SESSION_CONTEXT));
+
+        Collection<InternalItem> items = itemDao.list();
+
+        Assert.assertTrue(items.isEmpty());
+    }
+
+    @Test
+    public void testList() {
+        Map<String, Number> vlm1versionStatuses = new HashMap<>();
+        vlm1versionStatuses.put(VersionStatus.Draft.name(), 1);
+
+        Map<String, Number> vsp2versionStatuses = new HashMap<>();
+        vsp2versionStatuses.put(VersionStatus.Draft.name(), 3);
+        vsp2versionStatuses.put(VersionStatus.Certified.name(), 2);
+
+
+        List<Item> returnedItems =
+                Stream.of(createItem("1", "vsp1", "vsp 1", "vsp", new Date(), new Date(), new HashMap<>()),
+                        createItem("2", "vlm1", "vlm 1", "vlm", new Date(), new Date(), vlm1versionStatuses),
+                        createItem("3", "vsp2", "vsp 2", "vsp", new Date(), new Date(), vsp2versionStatuses))
+                        .collect(Collectors.toList());
+        doReturn(returnedItems).when(zusammenAdaptorMock).listItems(eq(SESSION_CONTEXT));
+
+        Collection<InternalItem> items = itemDao.list();
+        assertEquals(items.size(), 3);
+
+        Iterator<InternalItem> itemIterator = items.iterator();
+        assertItemEquals(itemIterator.next(), returnedItems.get(0));
+        assertItemEquals(itemIterator.next(), returnedItems.get(1));
+        assertItemEquals(itemIterator.next(), returnedItems.get(2));
+    }
+
+    @Test
+    public void testGetNonExisting() {
+        InternalItem item = itemDao.get("nonExisting");
+
+        Assert.assertNull(item);
+    }
+
+    @Test
+    public void testGet() {
+        String itemId = "1";
+
+        Map<String, Number> versionStatuses = new HashMap<>();
+        versionStatuses.put(VersionStatus.Draft.name(), 3);
+        versionStatuses.put(VersionStatus.Certified.name(), 2);
+
+        Item toBeReturned =
+                createItem("1", "vsp1", "vsp 1", "vsp", new Date(System.currentTimeMillis() - 100), new Date(),
+                        versionStatuses);
+        doReturn(toBeReturned).when(zusammenAdaptorMock).getItem(eq(SESSION_CONTEXT), eq(new Id(itemId)));
+
+        InternalItem item = itemDao.get(itemId);
+
+        Assert.assertNotNull(item);
+        assertItemEquals(item, toBeReturned);
+        assertEquals(item.getStatus(), ItemStatus.ACTIVE);
+
+    }
+
+    @Test
+    public void testCreate() {
+        InternalItem inputItem = new InternalItem();
+        inputItem.setName("vsp1");
+        inputItem.setDescription("VSP 1");
+        inputItem.setType("vsp");
+
+        ArgumentCaptor<Info> capturedZusammenInfo = ArgumentCaptor.forClass(Info.class);
+
+        String itemId = "1";
+        doReturn(new Id(itemId)).when(zusammenAdaptorMock)
+                .createItem(eq(SESSION_CONTEXT), capturedZusammenInfo.capture());
+
+        InternalItem item = itemDao.create(inputItem);
+
+        Info capturedInfo = capturedZusammenInfo.getValue();
+        assertEquals(capturedInfo.getName(), inputItem.getName());
+        assertEquals(capturedInfo.getDescription(), inputItem.getDescription());
+        assertEquals(capturedInfo.getProperty(ITEM_TYPE), inputItem.getType());
+        assertEquals(capturedInfo.getProperty(ITEM_VERSIONS_STATUSES), inputItem.getVersionStatusCounters());
+
+        assertEquals(item.getId(), itemId);
+        assertEquals(item.getName(), inputItem.getName());
+        assertEquals(item.getDescription(), inputItem.getDescription());
+        assertEquals(item.getType(), inputItem.getType());
+        assertEquals(item.getVersionStatusCounters(), inputItem.getVersionStatusCounters());
+    }
+
+    @Test
+    public void testUpdate() {
+        InternalItem item = new InternalItem();
+        item.setId("1");
+        item.setName("vsp1");
+        item.setDescription("VSP 1");
+        item.setType("vsp");
+        item.addVersionStatus(VersionStatus.Draft);
+        item.addVersionStatus(VersionStatus.Draft);
+        item.addVersionStatus(VersionStatus.Certified);
+
+        ArgumentCaptor<Info> capturedZusammenInfo = ArgumentCaptor.forClass(Info.class);
+
+        itemDao.update(item);
+
+        verify(zusammenAdaptorMock)
+                .updateItem(eq(SESSION_CONTEXT), eq(new Id(item.getId())), capturedZusammenInfo.capture());
+
+        Info capturedInfo = capturedZusammenInfo.getValue();
+        assertEquals(capturedInfo.getName(), item.getName());
+        assertEquals(capturedInfo.getDescription(), item.getDescription());
+        assertEquals(capturedInfo.getProperty(ITEM_TYPE), item.getType());
+        assertEquals(capturedInfo.getProperty(ITEM_VERSIONS_STATUSES), item.getVersionStatusCounters());
+    }
+
+    private Item createItem(String id, String name, String description, String type, Date creationTime,
+            Date modificationTime, Map<String, Number> versionStatusCounters) {
+        Item item = new Item();
+        item.setId(new Id(id));
+        Info info = new Info();
+        info.setName(name);
+        info.setDescription(description);
+        info.addProperty(ITEM_TYPE, type);
+        info.addProperty(ITEM_VERSIONS_STATUSES, versionStatusCounters);
+        info.addProperty(APP_PROP_1, "app_prop1_value");
+        info.addProperty(APP_PROP_2, 8);
+        item.setInfo(info);
+        item.setCreationTime(creationTime);
+        item.setModificationTime(modificationTime);
+        return item;
+    }
+
+    private void assertItemEquals(InternalItem item, Item zusammenItem) {
+        assertEquals(item.getId(), zusammenItem.getId().getValue());
+        assertEquals(item.getName(), zusammenItem.getInfo().getName());
+        assertEquals(item.getDescription(), zusammenItem.getInfo().getDescription());
+        assertEquals(item.getType(), zusammenItem.getInfo().getProperty(ITEM_TYPE));
+        assertEquals(item.getProperties().get(APP_PROP_1), zusammenItem.getInfo().getProperty(APP_PROP_1));
+        assertEquals(item.getProperties().get(APP_PROP_2), zusammenItem.getInfo().getProperty(APP_PROP_2));
+
+        Map<String, Number> zusammenStatusesMap = zusammenItem.getInfo().getProperty(ITEM_VERSIONS_STATUSES);
+        Map<VersionStatus, Integer> statusesMap = item.getVersionStatusCounters();
+
+        zusammenStatusesMap.forEach((key, value) -> assertEquals(statusesMap.get(VersionStatus.valueOf(key)), value));
+
+        assertEquals(item.getCreationTime(), zusammenItem.getCreationTime());
+        assertEquals(item.getModificationTime(), zusammenItem.getModificationTime());
+    }
+
+}
diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java
new file mode 100644
index 0000000..1db761b
--- /dev/null
+++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java
@@ -0,0 +1,410 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, InternalVersion 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.onap.sdc.common.versioning.persistence.zusammen;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.UserInfo;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
+import com.amdocs.zusammen.datatypes.item.SynchronizationStatus;
+import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
+import org.onap.sdc.common.versioning.services.types.Revision;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.onap.sdc.common.zusammen.services.ZusammenAdaptor;
+
+@RunWith(MockitoJUnitRunner.class)
+public class VersionZusammenDaoTest {
+
+    private static final String STATUS_PROPERTY = "status";
+    private static final SessionContext SESSION_CONTEXT = new SessionContext();
+
+    static {
+        SESSION_CONTEXT.setUser(new UserInfo("user"));
+        SESSION_CONTEXT.setTenant("tenant");
+    }
+
+    @Mock
+    private ZusammenSessionContextCreator contextCreatorMock;
+    @Mock
+    private ZusammenAdaptor zusammenAdaptorMock;
+    @InjectMocks
+    private VersionZusammenDao versionDao;
+
+    @Before
+    public void mockSessionContext() {
+        doReturn(SESSION_CONTEXT).when(contextCreatorMock).create();
+    }
+
+    @Test
+    public void testListWhenNone() {
+        String itemId = "itemId";
+
+        doReturn(new ArrayList<>()).when(zusammenAdaptorMock)
+                .listPublicVersions(eq(SESSION_CONTEXT), eq(new Id(itemId)));
+
+        List<InternalVersion> versions = versionDao.list(itemId);
+
+        Assert.assertTrue(versions.isEmpty());
+    }
+
+    @Test
+    public void testList() {
+        String itemId = "itemId";
+        Id versionId1 = new Id("v1_id");
+        Id versionId2 = new Id("v2_id");
+        Id versionId3 = new Id("v3_id");
+
+        List<ItemVersion> zusammenVersions =
+                Stream.of(createZusammenVersion(versionId1, null, "version desc", "1.0", VersionStatus.Certified),
+                        createZusammenVersion(versionId2, versionId1, "version desc", "2.0", VersionStatus.Certified),
+                        createZusammenVersion(versionId3, versionId2, "version desc", "3.0", VersionStatus.Draft))
+                        .collect(Collectors.toList());
+        doReturn(zusammenVersions).when(zusammenAdaptorMock)
+                .listPublicVersions(eq(SESSION_CONTEXT), eq(new Id(itemId)));
+
+        List<InternalVersion> versions = versionDao.list(itemId);
+        Assert.assertEquals(versions.size(), 3);
+
+        int zusammenVersionIndex;
+        for (InternalVersion version : versions) {
+            zusammenVersionIndex = versionId1.getValue().equals(version.getId()) ? 0 :
+                                           versionId2.getValue().equals(version.getId()) ? 1 : 2;
+            assetVersionEquals(version, zusammenVersions.get(zusammenVersionIndex), null);
+        }
+    }
+
+    @Test
+    public void testCreate() {
+        testCreate(null, null);
+    }
+
+    @Test
+    public void testCreateBasedOn() {
+        Map<String, Object> properties = new HashMap<>();
+        properties.put("key", "value");
+        testCreate("baseId", properties);
+    }
+
+    private void testCreate(String baseId, Map<String, Object> properties) {
+        String itemId = "itemId";
+        InternalVersion version = new InternalVersion();
+        version.setBaseId(baseId);
+        version.setName("1.0");
+        version.setDescription("version description");
+        version.setStatus(VersionStatus.Draft);
+        if (properties != null) {
+            properties.forEach(version::addProperty);
+        }
+        ArgumentCaptor<ItemVersionData> capturedZusammenVersion = ArgumentCaptor.forClass(ItemVersionData.class);
+
+        String versionId = "versionId";
+        doReturn(new Id(versionId)).when(zusammenAdaptorMock)
+                .createVersion(eq(SESSION_CONTEXT), eq(new Id(itemId)), baseId == null ? isNull() : eq(new Id(baseId)),
+                        capturedZusammenVersion.capture());
+
+
+        versionDao.create(itemId, version);
+
+        Assert.assertEquals(version.getId(), versionId);
+
+        Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
+        Assert.assertEquals(capturedInfo.getName(), version.getName());
+        Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
+        Assert.assertEquals(VersionStatus.valueOf(capturedInfo.getProperty(STATUS_PROPERTY)), version.getStatus());
+        String capturedInfoProperty = capturedInfo.getProperty("key");
+        Assert.assertEquals(capturedInfoProperty, version.getProperty("key"));
+    }
+
+    @Test
+    public void testUpdate() {
+        String itemId = "itemId";
+        InternalVersion version = new InternalVersion();
+        version.setId("versionId");
+        version.setBaseId("baseId");
+        version.setName("1.0");
+        version.setDescription("version description");
+        version.setStatus(VersionStatus.Certified);
+
+        ArgumentCaptor<ItemVersionData> capturedZusammenVersion = ArgumentCaptor.forClass(ItemVersionData.class);
+
+        versionDao.update(itemId, version);
+
+        verify(zusammenAdaptorMock).updateVersion(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(version.getId())),
+                capturedZusammenVersion.capture());
+
+        Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
+        Assert.assertEquals(capturedInfo.getName(), version.getName());
+        Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
+        Assert.assertEquals(VersionStatus.valueOf(capturedInfo.getProperty(STATUS_PROPERTY)), version.getStatus());
+    }
+
+    @Test
+    public void testGetNonExisting() {
+        Optional<InternalVersion> version = versionDao.get("itemId", "versionId");
+
+        Assert.assertEquals(version, Optional.empty());
+    }
+
+    @Test
+    public void testGetSynced() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        SessionContext zusammenContext = SESSION_CONTEXT;
+        Id itemIdObj = new Id(itemId);
+        Id versionIdObj = new Id(versionId);
+
+        ItemVersion zusammenPrivateVersion =
+                createZusammenVersion(versionIdObj, new Id("baseId"), "version desc  updated", "2.0",
+                        VersionStatus.Draft);
+        doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
+                .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        ItemVersionStatus zusammenVersionStatus = new ItemVersionStatus(SynchronizationStatus.UP_TO_DATE, true);
+        doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
+                .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        Optional<InternalVersion> version = versionDao.get(itemId, versionId);
+
+        Assert.assertTrue(version.isPresent());
+        assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
+    }
+
+    @Test
+    public void testGetOutOfSync() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        SessionContext zusammenContext = SESSION_CONTEXT;
+        Id itemIdObj = new Id(itemId);
+        Id versionIdObj = new Id(versionId);
+
+        ItemVersion zusammenPrivateVersion =
+                createZusammenVersion(versionIdObj, new Id("baseId"), "version desc updated", "2.0",
+                        VersionStatus.Draft);
+        doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
+                .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        ItemVersionStatus zusammenVersionStatus = new ItemVersionStatus(SynchronizationStatus.OUT_OF_SYNC, true);
+        doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
+                .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        VersionStatus statusOnPublic = VersionStatus.Certified;
+        ItemVersion zusammenPublicVersion =
+                createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0", statusOnPublic);
+        doReturn(zusammenPublicVersion).when(zusammenAdaptorMock)
+                .getPublicVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        Optional<InternalVersion> version = versionDao.get(itemId, versionId);
+
+        Assert.assertTrue(version.isPresent());
+        zusammenPrivateVersion.getData().getInfo().addProperty(STATUS_PROPERTY, statusOnPublic.name());
+        assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
+    }
+
+    @Test
+    public void testGetMerging() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        SessionContext zusammenContext = SESSION_CONTEXT;
+        Id itemIdObj = new Id(itemId);
+        Id versionIdObj = new Id(versionId);
+
+        ItemVersion zusammenPrivateVersion =
+                createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0", VersionStatus.Draft);
+        doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
+                .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        ItemVersionStatus zusammenVersionStatus = new ItemVersionStatus(SynchronizationStatus.MERGING, true);
+        doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
+                .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        ItemVersion zusammenPublicVersion =
+                createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0", VersionStatus.Draft);
+        doReturn(zusammenPublicVersion).when(zusammenAdaptorMock)
+                .getPublicVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+        Optional<InternalVersion> version = versionDao.get(itemId, versionId);
+
+        Assert.assertTrue(version.isPresent());
+        assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
+    }
+
+    @Test
+    public void testPublish() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+        String message = "publish message";
+
+        versionDao.publish(itemId, versionId, message);
+
+        verify(zusammenAdaptorMock)
+                .publishVersion(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(versionId)), eq(message));
+    }
+
+    @Test
+    public void testSync() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        versionDao.sync(itemId, versionId);
+
+        verify(zusammenAdaptorMock).syncVersion(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(versionId)));
+    }
+
+    @Test
+    public void testForceSync() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        versionDao.forceSync(itemId, versionId);
+
+        verify(zusammenAdaptorMock).forceSyncVersion(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(versionId)));
+    }
+
+    @Test
+    public void testRevert() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+        String revisionId = "revisionId";
+
+        versionDao.revert(itemId, versionId, revisionId);
+
+        verify(zusammenAdaptorMock)
+                .revert(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(versionId)), eq(new Id(revisionId)));
+    }
+
+    @Test
+    public void testListRevisionsWhenNone() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        List<Revision> revisions = versionDao.listRevisions(itemId, versionId);
+
+        Assert.assertTrue(revisions.isEmpty());
+    }
+
+    @Test
+    public void testListRevisions() {
+        String itemId = "itemId";
+        String versionId = "versionId";
+
+        long currentTime = System.currentTimeMillis();
+        Date rev4time = new Date(currentTime);            // latest
+        Date rev3time = new Date(currentTime - 1);
+        Date rev2time = new Date(currentTime - 2);
+        Date rev1time = new Date(currentTime - 3);  // oldest
+        List<com.amdocs.zusammen.datatypes.itemversion.Revision> zusammenRevisions =
+                Stream.of(createZusammenRevision("rev4", "forth rev", "user1", rev4time),
+                        createZusammenRevision("rev1", "first rev", "user2", rev1time),
+                        createZusammenRevision("rev3", "third rev", "user2", rev3time),
+                        createZusammenRevision("rev2", "second rev", "user1", rev2time)).collect(Collectors.toList());
+        ItemVersionRevisions toBeReturned = new ItemVersionRevisions();
+        toBeReturned.setItemVersionRevisions(zusammenRevisions);
+        doReturn(toBeReturned).when(zusammenAdaptorMock)
+                .listRevisions(eq(SESSION_CONTEXT), eq(new Id(itemId)), eq(new Id(versionId)));
+
+        List<Revision> revisions = versionDao.listRevisions(itemId, versionId);
+
+        Assert.assertEquals(revisions.size(), 4);
+        assertRevisionEquals(revisions.get(0), zusammenRevisions.get(0)); // rev4 - latest
+        assertRevisionEquals(revisions.get(1), zusammenRevisions.get(2)); // rev3
+        assertRevisionEquals(revisions.get(2), zusammenRevisions.get(3)); // rev2
+        assertRevisionEquals(revisions.get(3), zusammenRevisions.get(1)); // rev1 - oldest
+    }
+
+    private ItemVersion createZusammenVersion(Id id, Id baseId, String description, String name, VersionStatus status) {
+        ItemVersion version = new ItemVersion();
+        version.setId(id);
+        version.setBaseId(baseId);
+        Info info = new Info();
+        info.setName(name);
+        info.setDescription(description);
+        info.addProperty(STATUS_PROPERTY, status.name());
+        ItemVersionData data = new ItemVersionData();
+        data.setInfo(info);
+        version.setData(data);
+        version.setCreationTime(new Date());
+        version.setModificationTime(new Date());
+        return version;
+    }
+
+    private void assetVersionEquals(InternalVersion version, ItemVersion zusammenVersion,
+            ItemVersionStatus zusammenVersionStatus) {
+        Assert.assertEquals(version.getId(), zusammenVersion.getId().getValue());
+        Assert.assertEquals(version.getBaseId(),
+                zusammenVersion.getBaseId() == null ? null : zusammenVersion.getBaseId().getValue());
+        Info info = zusammenVersion.getData().getInfo();
+        Assert.assertEquals(version.getName(), info.getName());
+        Assert.assertEquals(version.getDescription(), info.getDescription());
+        Assert.assertEquals(version.getStatus(), VersionStatus.valueOf(info.getProperty(STATUS_PROPERTY)));
+        Assert.assertEquals(version.getCreationTime(), zusammenVersion.getCreationTime());
+        Assert.assertEquals(version.getModificationTime(), zusammenVersion.getModificationTime());
+
+        if (zusammenVersionStatus != null) {
+            Assert.assertEquals(version.getState().isDirty(), zusammenVersionStatus.isDirty());
+            Assert.assertEquals(version.getState().getSynchronizationState().toString(),
+                    zusammenVersionStatus.getSynchronizationStatus().toString());
+        }
+    }
+
+    private com.amdocs.zusammen.datatypes.itemversion.Revision createZusammenRevision(String id, String message,
+            String user, Date time) {
+        com.amdocs.zusammen.datatypes.itemversion.Revision revision =
+                new com.amdocs.zusammen.datatypes.itemversion.Revision();
+        revision.setRevisionId(new Id(id));
+        revision.setMessage(message);
+        revision.setUser(user);
+        revision.setTime(time);
+        return revision;
+    }
+
+    private void assertRevisionEquals(Revision revision,
+            com.amdocs.zusammen.datatypes.itemversion.Revision zusammenRevision) {
+        Assert.assertEquals(revision.getId(), zusammenRevision.getRevisionId().getValue());
+        Assert.assertEquals(revision.getMessage(), zusammenRevision.getMessage());
+        Assert.assertEquals(revision.getUser(), zusammenRevision.getUser());
+        Assert.assertEquals(revision.getTime(), zusammenRevision.getTime());
+    }
+}