summaryrefslogtreecommitdiffstats
path: root/openecomp-be/backend/openecomp-sdc-action-manager
diff options
context:
space:
mode:
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-action-manager')
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java22
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/impl/ActionManagerImplTest.java459
2 files changed, 474 insertions, 7 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
index 69a1024e1f..458883ebb0 100644
--- a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
@@ -63,20 +63,28 @@ import static org.openecomp.sdc.versioning.dao.types.Version.VERSION_STRING_VIOL
*/
public class ActionManagerImpl implements ActionManager {
- private static final ActionDao actionDao = ActionDaoFactory.getInstance().createInterface();
- private static final ActionVersioningManager versioningManager =
- ActionVersioningManagerFactory.getInstance().createInterface();
- private static final ActionArtifactDao actionArtifactDao =
- ActionArtifactDaoFactory.getInstance().createInterface();
- private static VersionInfoDao versionInfoDao =
- VersionInfoDaoFactory.getInstance().createInterface();
+ private final ActionDao actionDao;
+ private final ActionVersioningManager versioningManager;
+ private final ActionArtifactDao actionArtifactDao;
+ private final VersionInfoDao versionInfoDao;
private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
public ActionManagerImpl() {
+ actionDao = ActionDaoFactory.getInstance().createInterface();
+ versioningManager = ActionVersioningManagerFactory.getInstance().createInterface();
+ actionArtifactDao = ActionArtifactDaoFactory.getInstance().createInterface();
+ versionInfoDao = VersionInfoDaoFactory.getInstance().createInterface();
actionDao.registerVersioning(ACTION_VERSIONABLE_TYPE);
}
+ public ActionManagerImpl(ActionDao actionDao, ActionVersioningManager versioningManager,
+ ActionArtifactDao actionArtifactDao, VersionInfoDao versionInfoDao) {
+ this.actionDao = actionDao;
+ this.versioningManager = versioningManager;
+ this.actionArtifactDao = actionArtifactDao;
+ this.versionInfoDao = versionInfoDao;
+ }
/**
* List All Major, Last Minor and Candidate version (if any) for Given Action Invariant UUID
*
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/impl/ActionManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/impl/ActionManagerImplTest.java
new file mode 100644
index 0000000000..40cf107c53
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/impl/ActionManagerImplTest.java
@@ -0,0 +1,459 @@
+/*
+ *
+ * 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.openecomp.sdc.action.impl;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.openecomp.sdc.action.ActionConstants;
+import org.openecomp.sdc.action.dao.ActionArtifactDao;
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
+import org.openecomp.sdc.action.dao.types.ActionEntity;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.types.Action;
+import org.openecomp.sdc.action.types.ActionArtifact;
+import org.openecomp.sdc.action.types.ActionArtifactProtection;
+import org.openecomp.sdc.action.types.ActionStatus;
+import org.openecomp.sdc.action.types.OpenEcompComponent;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.versioning.ActionVersioningManager;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ActionManagerImplTest {
+
+ @Mock
+ private ActionDao actionDao;
+ @Mock
+ private ActionVersioningManager versioningManager;
+ @Mock
+ private ActionArtifactDao actionArtifactDao;
+ @Mock
+ private VersionInfoDao versionInfoDao;
+
+ private ActionManagerImpl actionManager;
+
+
+ @Before
+ public void init() {
+ MockitoAnnotations.initMocks(this);
+ actionManager = new ActionManagerImpl(actionDao, versioningManager, actionArtifactDao, versionInfoDao);
+ }
+
+ @Test
+ public void testGetActionsByActionInvariantUuIdShouldPass() {
+ String invariantId = "invariantId";
+ Mockito.when(actionDao.getActionsByActionInvariantUuId(invariantId.toUpperCase())).thenReturn(mockActionsToReturn());
+ List<Action> actions = actionManager.getActionsByActionInvariantUuId(invariantId);
+ Assert.assertEquals(1, actions.size());
+ }
+
+ @Test(expected = ActionException.class)
+ public void testGetActionsByActionInvariantUuIdShouldThrowExceptionWhenReturnedActionsOrEmptyOrNull() {
+ String invariantId = "invariantId";
+ Mockito.when(actionDao.getActionsByActionInvariantUuId(invariantId.toUpperCase())).thenReturn(new ArrayList<>());
+ actionManager.getActionsByActionInvariantUuId(invariantId);
+
+ }
+
+ @Test
+ public void testGetFilteredActionsShouldPassForFilterTypeName() {
+ Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
+ .thenReturn(mockActionsToReturn());
+ List<Action> actions = actionManager.getFilteredActions("NAME", ActionConstants.FILTER_TYPE_NAME );
+ Assert.assertEquals(1, actions.size());
+ }
+
+ @Test(expected = ActionException.class)
+ public void testGetFilteredActionsShouldThrowExceptionForFilterTypeNameWhenReturnedActionsOrEmptyOrNull() {
+ Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
+ .thenReturn(new ArrayList<>());
+ actionManager.getFilteredActions("NAME", ActionConstants.FILTER_TYPE_NAME );
+ }
+
+ @Test
+ public void testGetFilteredActionsByMajorMinorVersionShouldPassWithActiveVersion() {
+ Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
+ .thenReturn(mockActionsToReturn());
+
+ Map<String, VersionInfo> actionVersionMap = new HashMap<>();
+ VersionInfo versionInfo = createVersionInfo();
+ actionVersionMap.put("uuid", versionInfo);
+
+ Mockito.when(versioningManager.listEntitiesVersionInfo(Matchers.anyString(),
+ Matchers.anyString(), Matchers.any())).thenReturn(actionVersionMap);
+ List<Action> actions = actionManager.getFilteredActions("type", ActionConstants.FILTER_TYPE_NAME );
+ Assert.assertEquals(1, actions.size());
+ }
+
+ @Test
+ public void testGetFilteredActionsByMajorMinorVersionShouldPassWithLatestFinalVersion() {
+ Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
+ .thenReturn(mockActionsToReturn());
+
+ Map<String, VersionInfo> actionVersionMap = new HashMap<>();
+ VersionInfo versionInfo = createVersionInfo();
+ actionVersionMap.put("uuid", versionInfo);
+
+ Mockito.when(versioningManager.listEntitiesVersionInfo(Matchers.anyString(),
+ Matchers.anyString(), Matchers.any())).thenReturn(actionVersionMap);
+ List<Action> actions = actionManager.getFilteredActions("type", ActionConstants.FILTER_TYPE_NAME );
+ Assert.assertEquals(1, actions.size());
+ }
+
+ @Test
+ public void testGetActionsByActionUuIdShouldPassIfReturnedActionsAreNotNull() {
+ String actionUuId = "actionUuId";
+ Mockito.when(actionDao.getActionsByActionUuId(actionUuId.toUpperCase()))
+ .thenReturn(new Action());
+ Assert.assertNotNull(actionManager.getActionsByActionUuId(actionUuId));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testGetActionsByActionUuIdShouldThrowExceptionIfReturnedActionsAreNull() {
+ String actionUuId = "actionUuId";
+ Mockito.when(actionDao.getActionsByActionUuId(actionUuId.toUpperCase()))
+ .thenReturn(null);
+ actionManager.getActionsByActionUuId(actionUuId);
+ }
+
+ @Test
+ public void testGetOpenEcompComponents() {
+ ArrayList<OpenEcompComponent> ecompComponents = new ArrayList<>();
+ ecompComponents.add(new OpenEcompComponent());
+ Mockito.when(actionDao.getOpenEcompComponents())
+ .thenReturn(ecompComponents);
+ Assert.assertEquals(1, actionManager.getOpenEcompComponents().size());
+ }
+
+ @Test
+ public void testDeleteActionShouldPassIfDeleteMethodGeCallsOneTime() {
+ String actionInvariantUuId = "actionInvariantUuId";
+ String user = "user";
+
+ actionManager.deleteAction(actionInvariantUuId, user);
+
+ Mockito.verify(versioningManager, times(1)).delete(anyString(), anyString(), anyString());
+ Mockito.verify(actionDao, times(1)).deleteAction(anyString());
+ }
+
+ @Test
+ public void testUpdateActionShouldUpdateActionSuccessfully() {
+ Action action = new Action();
+ action.setActionInvariantUuId("actionInvId");
+ action.setName("actionToupdate");
+ action.setData("{actionInvariantUuId : actionInvariantUuId, name : actionToupdate}");
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+
+ versionInfo.setActiveVersion(activeVersion);
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+
+ ActionEntity actionEntity = createActionEntity();
+
+ when(actionDao.get(any())).thenReturn(actionEntity);
+ actionManager.updateAction(action, "user");
+ Mockito.verify(actionDao, times(1)).updateAction(any());
+ }
+
+ @Test(expected = ActionException.class)
+ public void testUpdateActionShouldThrowExceptionIfToUpdateAndExistingActionNameIsNotSame() {
+ Action action = createAction();
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+
+ versionInfo.setActiveVersion(activeVersion);
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+ actionManager.updateAction(action, "user");
+ }
+
+ @Test
+ public void testCheckoutShouldPassSuccessFully() {
+ String invariantUuId = "invariantUuId";
+ ActionEntity actionEntity = createActionEntity();
+ when(actionDao.get(any())).thenReturn(actionEntity);
+ Mockito.when(versioningManager.checkout(anyString(), anyString(),anyString())).thenReturn(createVersion());
+ Action action = actionManager.checkout(invariantUuId, "user");
+ Assert.assertNotNull(action);
+ Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
+
+ }
+
+ @Test(expected = ActionException.class)
+ public void testCheckoutShouldFailInCaseOfException() {
+ String invariantUuId = "invariantUuId";
+ Mockito.when(versioningManager.checkout(anyString(), anyString(),anyString()))
+ .thenThrow(new CoreException(new ErrorCode.ErrorCodeBuilder()
+ .withId(VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY).build()));
+ VersionInfoEntity versionInfoEntity = createVersionInfoEntity();
+ when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
+ actionManager.checkout(invariantUuId, "user");
+
+ }
+
+ @Test
+ public void testUndoCheckoutShouldPass() {
+ VersionInfoEntity versionInfoEntity = createVersionInfoEntity();
+ when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
+ when(versioningManager.undoCheckout(anyString(), anyString(), anyString())).thenReturn(createVersion());
+ ActionEntity actionEntity = createActionEntity();
+
+ when(actionDao.get(any(ActionEntity.class))).thenReturn(actionEntity);
+
+ actionManager.undoCheckout("invariantUuid", "user");
+ Mockito.verify(actionArtifactDao, times(1)).delete(any(ActionArtifactEntity.class));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testUndoCheckoutShouldThrowExceptionIfVersionInfoEntityIsNull() {
+ when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(null);
+ actionManager.undoCheckout("invariantUuid", "user");
+
+ }
+
+ @Test
+ public void testCheckinShouldPassForHappyScenario() {
+ when(versioningManager.checkin(anyString(), anyString(), anyString(), Matchers.any()))
+ .thenReturn(createVersion());
+ when(actionDao.get(any(ActionEntity.class))).thenReturn(createActionEntity());
+ Assert.assertNotNull(actionManager.checkin("invariantUuid", "user"));
+ Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testCheckinShouldShouldThrowExceptionInCaseOfAnyException() {
+ when(versioningManager.checkin(anyString(), anyString(), anyString(), Matchers.any()))
+ .thenThrow((new CoreException(new ErrorCode.ErrorCodeBuilder()
+ .withId(VersioningErrorCodes.CHECKIN_ON_UNLOCKED_ENTITY).build())));
+ actionManager.checkin("invariantUuid", "user");
+ }
+
+ @Test
+ public void testSubmitShouldPassForHappyScenario() {
+ when(versioningManager.submit(anyString(), anyString(), anyString(), Matchers.any()))
+ .thenReturn(createVersion());
+ when(actionDao.get(any(ActionEntity.class))).thenReturn(createActionEntity());
+
+ Assert.assertNotNull( actionManager.submit("invariantUuid", "user"));
+
+ Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testSubmitShouldThrowExceptionForAnyException() {
+ when(versioningManager.submit(anyString(), anyString(), anyString(), Matchers.any()))
+ .thenThrow((new CoreException(new ErrorCode.ErrorCodeBuilder()
+ .withId(VersioningErrorCodes.SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED).build())));
+ actionManager.submit("invariantUuid", "user");
+ }
+
+
+ @Test
+ public void testDownloadArtifactShouldPassForHappyScenario() {
+ Action action = createAction();
+ action.setVersion("2.1");
+ when(actionDao.getActionsByActionUuId(anyString())).thenReturn(action);
+ when(actionArtifactDao.downloadArtifact(anyInt(), anyString())).thenReturn(new ActionArtifact());
+ Assert.assertNotNull(actionManager.downloadArtifact("actionUuId", "artifactUuId"));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testDownloadArtifactShouldThrowExceptionIfActionIsNull() {
+
+ when(actionDao.getActionsByActionUuId(anyString())).thenReturn(null);
+ actionManager.downloadArtifact("actionUuId", "artifactUuId");
+ }
+
+ @Test
+ public void testUploadArtifactShouldPassForHappyScenario() {
+ ActionArtifact artifact = createActionArtifact();
+ artifact.setArtifactName("artifactNameToUpload");
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+ versionInfo.setActiveVersion(activeVersion);
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+ when(actionDao.get(any())).thenReturn(createActionEntity());
+ Assert.assertNotNull(actionManager.uploadArtifact(artifact, "actionInvariantUuId", "user"));
+
+ Mockito.verify(actionArtifactDao, times(1)).uploadArtifact(any(ActionArtifact.class));
+ Mockito.verify(actionDao, times(1)).updateAction(any(Action.class));
+
+ }
+
+ @Test(expected = ActionException.class)
+ public void testUploadArtifactShouldThrowExceptionIfArtifactAlreadyExist() {
+ ActionArtifact artifact = createActionArtifact();
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+ versionInfo.setActiveVersion(activeVersion);
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+ when(actionDao.get(any())).thenReturn(createActionEntity());
+ actionManager.uploadArtifact(artifact, "actionInvariantUuId", "user");
+
+ }
+
+ @Test
+ public void testDeleteArtifactShouldPassForHappyScenario() {
+ Action action = createAction();
+ action.setVersion("2.1");
+ action.getArtifacts().forEach(actionArtifact -> {
+ actionArtifact.setArtifactUuId("86B2B1049CC13B4E9275414DBB29485C");
+ actionArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ });
+ when(actionDao.getLockedAction(anyString(), anyString())).thenReturn(action);
+ actionManager.deleteArtifact("actionInvariantUuId", "86B2B1049CC13B4E9275414DBB29485C", "user" );
+ Mockito.verify(actionDao, times(1)).update(any(ActionEntity.class));
+ Mockito.verify(actionArtifactDao, times(1)).delete(any(ActionArtifactEntity.class));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testDeleteArtifactShouldThrowExceptionIfArtifactMetaDataIsNull() {
+ when(actionDao.getLockedAction(anyString(), anyString())).thenReturn(createAction());
+ actionManager.deleteArtifact("actionInvariantUuId", "86B2B1049CC13B4E9275414DBB29485C", "user" );
+ }
+
+ @Test
+ public void testUpdateArtifactShouldPassForHappyScenario() {
+ ActionArtifact artifact = createActionArtifact();
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+ versionInfo.setActiveVersion(activeVersion);
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+ when(actionDao.get(any())).thenReturn(createActionEntity());
+ actionManager.updateArtifact(artifact, "actionInvariantUuId", "user");
+ Mockito.verify(actionArtifactDao, times(1)).updateArtifact(any(ActionArtifact.class));
+ }
+
+ @Test(expected = ActionException.class)
+ public void testUpdateArtifactShouldThrowExceptionIfArtifactNotExist() {
+ ActionArtifact artifact = createActionArtifact();
+ artifact.setArtifactUuId("Uuid");
+ VersionInfo versionInfo = createVersionInfo();
+ Version activeVersion = new Version("2.1");
+ versionInfo.setActiveVersion(activeVersion);
+ when(actionDao.get(any())).thenReturn(createActionEntity());
+ when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
+ .thenReturn(versionInfo);
+ actionManager.updateArtifact(artifact, "actionInvariantUuId", "user");
+ }
+
+ private ActionArtifact createActionArtifact() {
+ ActionArtifact artifact = new ActionArtifact();
+ artifact.setArtifactUuId("artifactUuId");
+ artifact.setArtifactName("artifactName");
+ artifact.setArtifact(new byte[0]);
+ return artifact;
+ }
+
+ private List<Action> mockActionsToReturn() {
+ List<Action> actionList = new ArrayList<>();
+ Action action = new Action();
+ action.setActionInvariantUuId("uuid");
+ action.setVersion("1.1");
+ action.setStatus(ActionStatus.Available);
+ action.setData("action data");
+ actionList.add(action);
+ return actionList;
+ }
+
+ private VersionInfo createVersionInfo() {
+ VersionInfo versionInfo = new VersionInfo();
+ Version version = createVersion();
+ versionInfo.setActiveVersion(version);
+ versionInfo.setLatestFinalVersion(version);
+ return versionInfo;
+ }
+
+ private Version createVersion() {
+ Version version = new Version();
+ version.setMajor(1);
+ version.setMinor(1);
+ return version;
+ }
+
+ private ActionEntity createActionEntity() {
+ ActionEntity actionEntity = new ActionEntity();
+ actionEntity.setData("{actionUuId : actionUuId, actionInvariantUuId : actionInvariantUuId," +
+ " name : actionToupdate,version: 2.1 ," +
+ " artifacts : [{artifactUuId: artifactUuId ,artifactName : artifactName," +
+ "artifactLabel: artifactLabel, artifactProtection : readWrite, artifactCategory : artifactCategory," +
+ "artifactDescription: artifactDescription}] }");
+ actionEntity.setUser("user");
+ actionEntity.setTimestamp(new Date());
+ return actionEntity;
+ }
+
+ private Action createAction() {
+ Action action = new Action();
+ action.setActionUuId("uid");
+ action.setActionInvariantUuId("uuid");
+ action.setName("actionToupdate2");
+ action.setData("{actionInvariantUuId : actionInvariantUuId," +
+ " name : actionToupdate, artifacts : [{artifactName : artifactName}] }");
+
+ List<ActionArtifact> actionArtifacts = new ArrayList<>();
+ ActionArtifact actionArtifact = new ActionArtifact();
+ actionArtifact.setArtifactName("artifactName");
+ actionArtifact.setArtifactUuId("artifactUuId");
+ actionArtifacts.add(actionArtifact);
+ action.setArtifacts(actionArtifacts);
+
+ return action;
+ }
+
+ private VersionInfoEntity createVersionInfoEntity() {
+ VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
+ UserCandidateVersion userCandidateVersion = new UserCandidateVersion();
+ userCandidateVersion.setUser("user");
+ userCandidateVersion.setVersion(createVersion());
+ versionInfoEntity.setCandidate(userCandidateVersion);
+ return versionInfoEntity;
+ }
+
+} \ No newline at end of file