diff options
Diffstat (limited to 'versioning-lib/src')
27 files changed, 1849 insertions, 0 deletions
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java new file mode 100644 index 0000000..a47ce00 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.persistence; + +import java.util.Collection; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; + +public interface ItemDao { + + Collection<InternalItem> list(); + + InternalItem get(String itemId); + + InternalItem create(InternalItem item); + + void update(InternalItem item); + + void delete(String itemId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java new file mode 100644 index 0000000..17354e8 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java @@ -0,0 +1,31 @@ +package org.onap.sdc.common.versioning.persistence; + +import java.util.List; +import java.util.Optional; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.types.Revision; + +public interface VersionDao { + + List<InternalVersion> list(String itemId); + + InternalVersion create(String itemId, InternalVersion version); + + void update(String itemId, InternalVersion version); + + Optional<InternalVersion> get(String itemId, String versionId); + + void delete(String itemId, String versionId); + + void publish(String itemId, String versionId, String message); + + void sync(String itemId, String versionId); + + void forceSync(String itemId, String versionId); + + void clean(String itemId, String versionId); + + void revert(String itemId, String versionId, String revisionId); + + List<Revision> listRevisions(String itemId, String versionId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java new file mode 100644 index 0000000..3d6610b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java @@ -0,0 +1,77 @@ +/* + * + * Copyright © 2017-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.types; + +import java.util.Date; +import java.util.EnumMap; +import java.util.Map; +import lombok.Getter; +import lombok.Setter; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + + +@Setter +@Getter +public class InternalItem extends Item { + + private Map<VersionStatus, Integer> versionStatusCounters = new EnumMap<>(VersionStatus.class); + + public void setId(String id) { + this.id = id; + } + + public void setCreationTime(Date creationTime) { + this.creationTime = creationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + public void setStatus(ItemStatus status) { + this.status = status; + } + + public void addVersionStatus(VersionStatus versionStatus) { + Integer counter = versionStatusCounters.get(versionStatus); + versionStatusCounters.put(versionStatus, counter == null ? 1 : counter + 1); + } + + public void removeVersionStatus(VersionStatus versionStatus) { + Integer counter = versionStatusCounters.get(versionStatus); + if (counter == null) { + return; + } + if (counter == 1) { + versionStatusCounters.remove(versionStatus); + } else { + versionStatusCounters.put(versionStatus, counter - 1); + } + } + + public void populateExternalFields(Item item) { + setType(item.getType()); + setName(item.getName()); + setOwner(item.getOwner()); + setDescription(item.getDescription()); + item.getProperties().forEach(this::addProperty); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java new file mode 100644 index 0000000..d48400b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java @@ -0,0 +1,42 @@ +package org.onap.sdc.common.versioning.persistence.types; + +import java.util.Date; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionState; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + +public class InternalVersion extends Version { + + public void setId(String id) { + this.id = id; + } + + public void setBaseId(String baseId) { + this.baseId = baseId; + } + + public void setName(String name) { + this.name = name; + } + + public void setStatus(VersionStatus status) { + this.status = status; + } + + public void setState(VersionState state) { + this.state = state; + } + + public void setCreationTime(Date creationTime) { + this.creationTime = creationTime; + } + + public void setModificationTime(Date modificationTime) { + this.modificationTime = modificationTime; + } + + public void populateExternalFields(Version version) { + setDescription(version.getDescription()); + version.getProperties().forEach(this::addProperty); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java new file mode 100644 index 0000000..8530697 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java @@ -0,0 +1,126 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.item.Info; +import com.amdocs.zusammen.datatypes.item.Item; +import java.util.Collection; +import java.util.Map; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +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; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; + +@Repository +public class ItemZusammenDao implements ItemDao { + + private final ZusammenSessionContextCreator contextCreator; + private final ZusammenAdaptor zusammenAdaptor; + + @Autowired + public ItemZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) { + this.contextCreator = contextCreator; + this.zusammenAdaptor = zusammenAdaptor; + } + + @Override + public Collection<InternalItem> list() { + return zusammenAdaptor.listItems(contextCreator.create()).stream().map(this::mapFromZusammenItem) + .collect(Collectors.toList()); + } + + @Override + public InternalItem get(String itemId) { + return mapFromZusammenItem(zusammenAdaptor.getItem(contextCreator.create(), new Id(itemId))); + } + + @Override + public InternalItem create(InternalItem item) { + Id itemId = zusammenAdaptor.createItem(contextCreator.create(), mapToZusammenItemInfo(item)); + item.setId(itemId.getValue()); + return item; + } + + @Override + public void delete(String itemId) { + zusammenAdaptor.deleteItem(contextCreator.create(), new Id(itemId)); + } + + @Override + public void update(InternalItem item) { + zusammenAdaptor.updateItem(contextCreator.create(), new Id(item.getId()), mapToZusammenItemInfo(item)); + } + + private InternalItem mapFromZusammenItem(Item zusammenItem) { + if (zusammenItem == null) { + return null; + } + InternalItem item = new InternalItem(); + item.setId(zusammenItem.getId().getValue()); + item.setName(zusammenItem.getInfo().getName()); + item.setDescription(zusammenItem.getInfo().getDescription()); + + zusammenItem.getInfo().getProperties().forEach((key, value) -> addPropertyToItem(key, value, item)); + + item.setCreationTime(zusammenItem.getCreationTime()); + item.setModificationTime(zusammenItem.getModificationTime()); + + if (item.getStatus() == null) { + item.setStatus(ItemStatus.ACTIVE); + update(item); + } + + return item; + } + + private void addPropertyToItem(String propertyKey, Object propertyValue, InternalItem item) { + switch (propertyKey) { + case InfoPropertyName.ITEM_TYPE: + item.setType((String) propertyValue); + break; + case InfoPropertyName.ITEM_OWNER: + item.setOwner((String) propertyValue); + break; + case InfoPropertyName.ITEM_STATUS: + item.setStatus(ItemStatus.valueOf((String) propertyValue)); + break; + case InfoPropertyName.ITEM_VERSIONS_STATUSES: + for (Map.Entry<String, Number> statusCounter : ((Map<String, Number>) propertyValue).entrySet()) { + item.getVersionStatusCounters() + .put(VersionStatus.valueOf(statusCounter.getKey()), statusCounter.getValue().intValue()); + } + break; + default: + item.addProperty(propertyKey, propertyValue); + } + } + + private Info mapToZusammenItemInfo(InternalItem item) { + Info info = new Info(); + info.setName(item.getName()); + info.setDescription(item.getDescription()); + info.addProperty(InfoPropertyName.ITEM_TYPE, item.getType()); + info.addProperty(InfoPropertyName.ITEM_OWNER, item.getOwner()); + if (item.getStatus() != null) { + info.addProperty(InfoPropertyName.ITEM_STATUS, item.getStatus()); + } + info.addProperty(InfoPropertyName.ITEM_VERSIONS_STATUSES, item.getVersionStatusCounters()); + item.getProperties().forEach(info::addProperty); + return info; + } + + private static final class InfoPropertyName { + + private static final String ITEM_TYPE = "item_type"; + private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses"; + private static final String ITEM_OWNER = "Owner"; + private static final String ITEM_STATUS = "status"; + + private InfoPropertyName() { + throw new IllegalStateException("Constants class"); + } + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java new file mode 100644 index 0000000..cb062c7 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java @@ -0,0 +1,202 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + + +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +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.List; +import java.util.Optional; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.VersionDao; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.SynchronizationState; +import org.onap.sdc.common.versioning.services.types.VersionState; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.onap.sdc.common.zusammen.services.ZusammenAdaptor; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; + +@Repository +public class VersionZusammenDao implements VersionDao { + + private static final String STATUS_PROPERTY = "status"; + + private final ZusammenSessionContextCreator contextCreator; + private final ZusammenAdaptor zusammenAdaptor; + + @Autowired + public VersionZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) { + this.contextCreator = contextCreator; + this.zusammenAdaptor = zusammenAdaptor; + } + + @Override + public List<InternalVersion> list(String itemId) { + return zusammenAdaptor.listPublicVersions(contextCreator.create(), new Id(itemId)).stream() + .map(VersionZusammenDao::convertFromZusammen).collect(Collectors.toList()); + } + + @Override + public InternalVersion create(String itemId, InternalVersion version) { + Id versionId = zusammenAdaptor.createVersion(contextCreator.create(), new Id(itemId), + version.getBaseId() == null ? null : new Id(version.getBaseId()), mapToZusammenVersion(version)); + + version.setId(versionId.getValue()); + return version; + } + + @Override + public void update(String itemId, InternalVersion version) { + zusammenAdaptor.updateVersion(contextCreator.create(), new Id(itemId), new Id(version.getId()), + mapToZusammenVersion(version)); + } + + @Override + public Optional<InternalVersion> get(String itemId, String versionId) { + SessionContext context = contextCreator.create(); + Id itemIdObj = new Id(itemId); + Id versionIdObj = new Id(versionId); + ItemVersion itemVersion = zusammenAdaptor.getVersion(context, itemIdObj, versionIdObj); + + if (itemVersion == null) { + return Optional.empty(); + } + + VersionState versionState = convertState(zusammenAdaptor.getVersionStatus(context, itemIdObj, versionIdObj)); + updateVersionStatus(context, itemIdObj, versionIdObj, versionState, itemVersion); + + InternalVersion result = convertFromZusammen(itemVersion); + result.setState(versionState); + return Optional.of(result); + } + + @Override + public void delete(String itemId, String versionId) { + throw new UnsupportedOperationException("Delete version operation is not yet supported."); + } + + @Override + public void publish(String itemId, String versionId, String message) { + zusammenAdaptor.publishVersion(contextCreator.create(), new Id(itemId), new Id(versionId), message); + } + + @Override + public void sync(String itemId, String versionId) { + zusammenAdaptor.syncVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void forceSync(String itemId, String versionId) { + zusammenAdaptor.forceSyncVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void clean(String itemId, String versionId) { + zusammenAdaptor.cleanVersion(contextCreator.create(), new Id(itemId), new Id(versionId)); + } + + @Override + public void revert(String itemId, String versionId, String revisionId) { + zusammenAdaptor.revert(contextCreator.create(), new Id(itemId), new Id(versionId), new Id(revisionId)); + } + + @Override + public List<Revision> listRevisions(String itemId, String versionId) { + ItemVersionRevisions itemVersionRevisions = + zusammenAdaptor.listRevisions(contextCreator.create(), new Id(itemId), new Id(versionId)); + + return itemVersionRevisions == null || itemVersionRevisions.getItemVersionRevisions() == null + || itemVersionRevisions.getItemVersionRevisions().isEmpty() ? new ArrayList<>() : + itemVersionRevisions.getItemVersionRevisions().stream().map(this::convertRevision) + .sorted(this::compareRevisionsTime).collect(Collectors.toList()); + } + + private void updateVersionStatus(SessionContext context, Id itemId, Id versionId, VersionState versionState, + ItemVersion itemVersion) { + if (versionState.getSynchronizationState() != SynchronizationState.UpToDate) { + String versionStatus = zusammenAdaptor.getPublicVersion(context, itemId, versionId).getData().getInfo() + .getProperty(STATUS_PROPERTY); + itemVersion.getData().getInfo().addProperty(STATUS_PROPERTY, versionStatus); + } + } + + private ItemVersionData mapToZusammenVersion(InternalVersion version) { + Info info = new Info(); + info.addProperty(STATUS_PROPERTY, version.getStatus().name()); + info.setName(version.getName()); + info.setDescription(version.getDescription()); + version.getProperties().forEach(info::addProperty); + ItemVersionData itemVersionData = new ItemVersionData(); + itemVersionData.setInfo(info); + return itemVersionData; + } + + private VersionState convertState(ItemVersionStatus versionStatus) { + VersionState state = new VersionState(); + state.setSynchronizationState(getSyncState(versionStatus.getSynchronizationStatus())); + state.setDirty(versionStatus.isDirty()); + return state; + } + + private SynchronizationState getSyncState(SynchronizationStatus synchronizationStatus) { + switch (synchronizationStatus) { + case UP_TO_DATE: + return SynchronizationState.UpToDate; + case OUT_OF_SYNC: + return SynchronizationState.OutOfSync; + case MERGING: + return SynchronizationState.Merging; + default: + throw new VersioningException("Version state is unknown"); + } + } + + private Revision convertRevision(com.amdocs.zusammen.datatypes.itemversion.Revision zusammenRevision) { + Revision revision = new Revision(); + revision.setId(zusammenRevision.getRevisionId().getValue()); + revision.setTime(zusammenRevision.getTime()); + revision.setUser(zusammenRevision.getUser()); + revision.setMessage(zusammenRevision.getMessage()); + return revision; + } + + private int compareRevisionsTime(Revision revision1, Revision revision2) { + return revision1.getTime().before(revision2.getTime()) ? 1 : -1; + } + + private static InternalVersion convertFromZusammen(ItemVersion itemVersion) { + if (itemVersion == null) { + return null; + } + InternalVersion version = new InternalVersion(); + version.setId(itemVersion.getId().getValue()); + if (itemVersion.getBaseId() != null) { + version.setBaseId(itemVersion.getBaseId().getValue()); + } + version.setName(itemVersion.getData().getInfo().getName()); + version.setDescription(itemVersion.getData().getInfo().getDescription()); + version.setCreationTime(itemVersion.getCreationTime()); + version.setModificationTime(itemVersion.getModificationTime()); + + itemVersion.getData().getInfo().getProperties() + .forEach((key, value) -> addPropertyToVersion(key, value, version)); + + return version; + } + + private static void addPropertyToVersion(String propertyKey, Object propertyValue, InternalVersion version) { + if (STATUS_PROPERTY.equals(propertyKey)) { + version.setStatus(VersionStatus.valueOf((String) propertyValue)); + } else { + version.addProperty(propertyKey, propertyValue); + } + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java new file mode 100644 index 0000000..f8a677a --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java @@ -0,0 +1,28 @@ +package org.onap.sdc.common.versioning.persistence.zusammen; + +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.UserInfo; +import org.onap.sdc.common.session.SessionContextProvider; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class ZusammenSessionContextCreator { + + private final SessionContextProvider sessionContextProvider; + + @Autowired + public ZusammenSessionContextCreator(SessionContextProvider sessionContextProvider) { + this.sessionContextProvider = sessionContextProvider; + } + + + public SessionContext create() { + org.onap.sdc.common.session.SessionContext sdcSessionContext = sessionContextProvider.get(); + + SessionContext sessionContext = new SessionContext(); + sessionContext.setUser(new UserInfo(sdcSessionContext.getUserId())); + sessionContext.setTenant(sdcSessionContext.getTenant()); + return sessionContext; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java new file mode 100644 index 0000000..de91f2e --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java @@ -0,0 +1,37 @@ +/* + * 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.services; + +import java.util.Collection; +import java.util.function.Predicate; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; + +public interface ItemManager { + + Collection<Item> list(Predicate<Item> predicate); + + Item get(String itemId); + + Item create(Item item); + + Item update(String itemId, Item item); + + void delete(String itemId); + + void updateStatus(String itemId, ItemStatus status); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java new file mode 100644 index 0000000..f522077 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java @@ -0,0 +1,48 @@ +/* + * 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.services; + +import java.util.List; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; + +public interface VersioningManager { + + List<Version> list(String itemId); // TODO: 5/24/2017 filter (by status for example) + + Version get(String itemId, String versionId); + + Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod); + + Version update(String itemId, String versionId, Version version); + + void updateStatus(String itemId, String versionId, VersionStatus status, String message); + + void publish(String itemId, String versionId, String message); + + void sync(String itemId, String versionId); + + void forceSync(String itemId, String versionId); + + void revert(String itemId, String versionId, String revisionId); + + List<Revision> listRevisions(String itemId, String versionId); + + void clean(String itemId, String versionId); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java new file mode 100644 index 0000000..88405e5 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.services.convertors; + +import org.onap.sdc.common.versioning.services.types.Item; + +public interface ItemConvertor<T> { + + String getItemType(); + + //Item toItem(T model); + + void toItem(T source, Item target); + + // void fromItem(Item source, T target); + + T fromItem(Item item); + +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java new file mode 100644 index 0000000..beab1d9 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java @@ -0,0 +1,16 @@ +package org.onap.sdc.common.versioning.services.convertors; + +import org.onap.sdc.common.versioning.services.types.Version; + +public interface VersionConvertor<T> { + + String getItemType(); + + //Version toVersion(T model); + + void toVersion(T source, Version target); + + //void fromVersion(Version source, T target); + + T fromVersion(Version version); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java new file mode 100644 index 0000000..6440ccc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java @@ -0,0 +1,8 @@ +package org.onap.sdc.common.versioning.services.exceptions; + +public class VersioningException extends RuntimeException { + + public VersioningException(String message) { + super(message); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java new file mode 100644 index 0000000..47acabc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java @@ -0,0 +1,91 @@ +/* + * 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.services.impl; + +import java.util.Collection; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; +import org.onap.sdc.common.versioning.services.ItemManager; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Item; +import org.onap.sdc.common.versioning.services.types.ItemStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class ItemManagerImpl implements ItemManager { + + private final ItemDao itemDao; + + @Autowired + public ItemManagerImpl(ItemDao itemDao) { + this.itemDao = itemDao; + + } + + @Override + public Collection<Item> list(Predicate<Item> predicate) { + return itemDao.list().stream().filter(predicate).collect(Collectors.toList()); + } + + @Override + public Item get(String itemId) { + return itemDao.get(itemId); + } + + @Override + public Item create(Item item) { + InternalItem internalItem = new InternalItem(); + internalItem.populateExternalFields(item); + return itemDao.create(internalItem); + } + + @Override + public Item update(String itemId, Item item) { + InternalItem internalItem = getItem(itemId); + internalItem.populateExternalFields(item); + itemDao.update(internalItem); + return internalItem; + } + + @Override + public void delete(String itemId) { + itemDao.delete(itemId); + } + + @Override + public void updateStatus(String itemId, ItemStatus status) { + InternalItem item = getItem(itemId); + if (item.getStatus() == status) { + throw new VersioningException( + String.format("Update status of item %s failed, it is already in status %s", item.getId(), status)); + } + + item.setStatus(status); + itemDao.update(item); + } + + private InternalItem getItem(String itemId) { + InternalItem item = itemDao.get(itemId); + if (item == null) { + throw new VersioningException(String.format("Item with Id %s does not exist", itemId)); + } + return item; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java new file mode 100644 index 0000000..a98fa58 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java @@ -0,0 +1,46 @@ +package org.onap.sdc.common.versioning.services.impl; + +import java.util.HashSet; +import java.util.Set; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.springframework.stereotype.Service; + +@Service +public class MajorVersionCalculatorImpl implements VersionCalculator { + + private static final String INITIAL_VERSION = "1.0"; + private static final String VERSION_STRING_VIOLATION_MSG = + "Version string must be in the format of: {integer}.{integer}"; + + @Override + public String calculate(String baseVersion, VersionCreationMethod creationMethod) { + + if (baseVersion == null) { + return INITIAL_VERSION; + } + + String[] versionLevels = baseVersion.split("\\."); + if (versionLevels.length != 2) { + throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG); + } + + int index = Integer.parseInt(versionLevels[0]); + index++; + + return index + ".0"; + } + + @Override + public void injectAdditionalInfo(Version version, Set<String> existingVersions) { + Set<VersionCreationMethod> optionalCreationMethods = new HashSet<>(); + if (version.getStatus().equals(VersionStatus.Certified)) { + String nextVersion = calculate(version.getName(), VersionCreationMethod.major); + if (!existingVersions.contains(nextVersion)) { + optionalCreationMethods.add(VersionCreationMethod.major); + } + } + version.addProperty("OptionalCreationMethods", optionalCreationMethods); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java new file mode 100644 index 0000000..203dfbb --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java @@ -0,0 +1,12 @@ +package org.onap.sdc.common.versioning.services.impl; + +import java.util.Set; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; + +public interface VersionCalculator { + + String calculate(String baseVersion, VersionCreationMethod creationMethod); + + void injectAdditionalInfo(Version version, Set<String> existingVersions); +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java new file mode 100644 index 0000000..601f517 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java @@ -0,0 +1,202 @@ +/* + * 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.services.impl; + + +import static org.onap.sdc.common.versioning.services.types.VersionStatus.Certified; +import static org.onap.sdc.common.versioning.services.types.VersionStatus.Draft; + +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.onap.sdc.common.versioning.persistence.VersionDao; +import org.onap.sdc.common.versioning.persistence.types.InternalItem; +import org.onap.sdc.common.versioning.persistence.types.InternalVersion; +import org.onap.sdc.common.versioning.services.VersioningManager; +import org.onap.sdc.common.versioning.services.exceptions.VersioningException; +import org.onap.sdc.common.versioning.services.types.Revision; +import org.onap.sdc.common.versioning.services.types.SynchronizationState; +import org.onap.sdc.common.versioning.services.types.Version; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; +import org.onap.sdc.common.versioning.services.types.VersionStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class VersioningManagerImpl implements VersioningManager { + + //private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class); + + private final ItemDao itemDao; + private final VersionDao versionDao; + private final VersionCalculator versionCalculator; + + @Autowired + public VersioningManagerImpl(VersionDao versionDao, VersionCalculator versionCalculator, ItemDao itemDao) { + this.itemDao = itemDao; + this.versionDao = versionDao; + this.versionCalculator = versionCalculator; + } + + + @Override + public List<Version> list(String itemId) { + List<InternalVersion> versions = versionDao.list(itemId); + Set<String> versionsNames = versions.stream().map(Version::getName).collect(Collectors.toSet()); + versions.forEach(version -> versionCalculator.injectAdditionalInfo(version, versionsNames)); + return versions.stream().map(version -> (Version) version).collect(Collectors.toList()); + } + + @Override + public Version get(String itemId, String versionId) { + return getVersion(itemId, versionId); + } + + @Override + public Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod) { + InternalVersion internalVersion = new InternalVersion(); + internalVersion.setBaseId(baseVersionId); + internalVersion.populateExternalFields(version); + + String baseVersionName = null; + if (baseVersionId != null) { + Version baseVersion = getVersion(itemId, baseVersionId); + validateBaseVersion(itemId, baseVersion); + baseVersionName = baseVersion.getName(); + } + String versionName = versionCalculator.calculate(baseVersionName, creationMethod); + validateVersionName(itemId, versionName); + internalVersion.setName(versionName); + + InternalVersion createdVersion = versionDao.create(itemId, internalVersion); + + updateStatusOnItem(itemId, Draft, null); + + publish(itemId, createdVersion.getId(), String.format("Create version: %s", versionName)); + return createdVersion; + } + + @Override + public Version update(String itemId, String versionId, Version version) { + InternalVersion internalVersion = getVersion(itemId, versionId); + internalVersion.populateExternalFields(version); + versionDao.update(itemId, internalVersion); + return internalVersion; + } + + @Override + public void updateStatus(String itemId, String versionId, VersionStatus status, String message) { + InternalVersion version = getVersion(itemId, versionId); + + VersionStatus prevStatus = version.getStatus(); + if (prevStatus == status) { + throw new VersioningException( + String.format("Item %s: update version status failed, version %s is already in status %s", itemId, + version.getId(), status)); + } + + version.setStatus(status); + versionDao.update(itemId, version); + + publish(itemId, versionId, message); + + updateStatusOnItem(itemId, status, prevStatus); + } + + @Override + public void publish(String itemId, String versionId, String message) { + versionDao.publish(itemId, versionId, message); + } + + @Override + public void sync(String itemId, String versionId) { + versionDao.sync(itemId, versionId); + } + + @Override + public void forceSync(String itemId, String versionId) { + versionDao.forceSync(itemId, versionId); + } + + @Override + public void revert(String itemId, String versionId, String revisionId) { + versionDao.revert(itemId, versionId, revisionId); + } + + @Override + public List<Revision> listRevisions(String itemId, String versionId) { + return versionDao.listRevisions(itemId, versionId); + } + + @Override + public void clean(String itemId, String versionId) { + versionDao.clean(itemId, versionId); + } + + private InternalVersion getVersion(String itemId, String versionId) { + return versionDao.get(itemId, versionId) + .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion)) + .orElseGet(() -> getSyncedVersion(itemId, versionId)); + } + + private InternalVersion getUpdateRetrievedVersion(String itemId, InternalVersion version) { + if (version.getStatus() == Certified + && version.getState().getSynchronizationState() == SynchronizationState.OutOfSync) { + forceSync(itemId, version.getId()); + //LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId()); + version = versionDao.get(itemId, version.getId()).orElseThrow(() -> new IllegalStateException( + "Get version after a successful force sync must return the version")); + } + return version; + } + + private InternalVersion getSyncedVersion(String itemId, String versionId) { + sync(itemId, versionId); + //LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId()); + return versionDao.get(itemId, versionId).orElseThrow( + () -> new IllegalStateException("Get version after a successful sync must return the version")); + } + + private void validateBaseVersion(String itemId, Version baseVersion) { + if (Certified != baseVersion.getStatus()) { + throw new VersioningException( + String.format("Item %s: base version %s must be Certified", itemId, baseVersion.getId())); + } + } + + private void validateVersionName(String itemId, String versionName) { + if (versionDao.list(itemId).stream().anyMatch(version -> versionName.equals(version.getName()))) { + throw new VersioningException( + String.format("Item %s: create version failed, a version with the name %s already exist", itemId, + versionName)); + } + } + + private void updateStatusOnItem(String itemId, VersionStatus addedVersionStatus, + VersionStatus removedVersionStatus) { + InternalItem item = itemDao.get(itemId); + if (item == null) { + throw new VersioningException(String.format("Item with Id %s does not exist", itemId)); + } + item.addVersionStatus(addedVersionStatus); + if (removedVersionStatus != null) { + item.removeVersionStatus(removedVersionStatus); + } + itemDao.update(item); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java new file mode 100644 index 0000000..796fc1a --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java @@ -0,0 +1,55 @@ +/* + * + * Copyright © 2017-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.services.types; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import lombok.Getter; +import lombok.Setter; + +@Getter +public class Item { + + protected String id; + protected Date creationTime; + protected Date modificationTime; + protected ItemStatus status; + @Setter + private String type; + @Setter + private String name; + @Setter + private String owner; + @Setter + private String description; + private Map<String, Object> properties = new HashMap<>(); + + public boolean isNew() { + return id == null; + } + + public void addProperty(String key, Object value) { + properties.put(key, value); + } + + public <T> T getProperty(String key) { + return (T) properties.get(key); + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java new file mode 100644 index 0000000..57b5f23 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java @@ -0,0 +1,5 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum ItemStatus { + ACTIVE, ARCHIVED +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java new file mode 100644 index 0000000..10cadb5 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java @@ -0,0 +1,15 @@ +package org.onap.sdc.common.versioning.services.types; + +import java.util.Date; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class Revision { + + private String id; + private String message; + private Date time; + private String user; +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java new file mode 100644 index 0000000..dd2efcc --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java @@ -0,0 +1,17 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum SynchronizationState { + UpToDate("Up to date"), + OutOfSync("Out of sync"), + Merging("Merging"); + + private final String displayName; + + SynchronizationState(String displayName) { + this.displayName = displayName; + } + + public String toString() { + return this.displayName; + } +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java new file mode 100644 index 0000000..5cb0b69 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java @@ -0,0 +1,56 @@ +/*- + * ============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.onap.sdc.common.versioning.services.types; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@NoArgsConstructor +public class Version { + + protected String id; + protected String baseId; + protected String name; + protected VersionStatus status = VersionStatus.Draft; + protected VersionState state; + protected Date creationTime; + protected Date modificationTime; + @Setter + private String description; + private Map<String, Object> properties = new HashMap<>(); + + public boolean isNew() { + return id == null; + } + + public void addProperty(String key, Object value) { + properties.put(key, value); + } + + public <T> T getProperty(String key) { + return (T) properties.get(key); + } +}
\ No newline at end of file diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java new file mode 100644 index 0000000..3e18c28 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java @@ -0,0 +1,5 @@ +package org.onap.sdc.common.versioning.services.types; + +public enum VersionCreationMethod { + major, minor +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java new file mode 100644 index 0000000..755c671 --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java @@ -0,0 +1,11 @@ +package org.onap.sdc.common.versioning.services.types; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class VersionState { + private SynchronizationState synchronizationState; + private boolean dirty; +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java new file mode 100644 index 0000000..53c2e8f --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java @@ -0,0 +1,21 @@ +/* + * 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.services.types; + +public enum VersionStatus { + Draft, Certified, Deprecated, Deleted +} diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java new file mode 100644 index 0000000..771959b --- /dev/null +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java @@ -0,0 +1,25 @@ +/*- + * ============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.onap.sdc.common.versioning.services.types; + +public enum VersionType { + Draft, Finalized +} 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()); + } +} |