aboutsummaryrefslogtreecommitdiffstats
path: root/openecomp-be/backend/openecomp-sdc-action-manager/src
diff options
context:
space:
mode:
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-action-manager/src')
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/ActionManager.java66
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java1217
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java1207
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_file.txt2
-rw-r--r--openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_update_file.txt2
5 files changed, 2494 insertions, 0 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/ActionManager.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/ActionManager.java
new file mode 100644
index 0000000000..52b0b2a851
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/ActionManager.java
@@ -0,0 +1,66 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action;
+
+
+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.EcompComponent;
+
+import java.util.List;
+
+public interface ActionManager {
+ public Action createAction(Action action, String user) throws ActionException;
+
+ public Action updateAction(Action action, String user) throws ActionException;
+
+ public void deleteAction(String actionInvariantUuId, String user) throws ActionException;
+
+ public List<Action> getFilteredActions(String filterType, String filterValue)
+ throws ActionException;
+
+ public List<EcompComponent> getEcompComponents() throws ActionException;
+
+ public List<Action> getActionsByActionInvariantUuId(String invariantId) throws ActionException;
+
+ public Action getActionsByActionUuId(String actionUuId) throws ActionException;
+
+ public Action checkout(String invariantUuId, String user) throws ActionException;
+
+ public void undoCheckout(String invariantUuId, String user) throws ActionException;
+
+ public Action checkin(String invariantUuId, String user) throws ActionException;
+
+ public Action submit(String invariantUuId, String user) throws ActionException;
+
+ public ActionArtifact uploadArtifact(ActionArtifact data, String actionInvariantUuId,
+ String user);
+
+ public ActionArtifact downloadArtifact(String actionUuId, String artifactUuId)
+ throws ActionException;
+
+ public void deleteArtifact(String actionInvariantUuId, String artifactUuId, String user)
+ throws ActionException;
+
+ public void updateArtifact(ActionArtifact data, String actionInvariantUuId, String user);
+}
+
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
new file mode 100644
index 0000000000..53ab943765
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
@@ -0,0 +1,1217 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action.impl;
+
+import static org.openecomp.sdc.action.ActionConstants.SERVICE_INSTANCE_ID;
+import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_API;
+import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_DB;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY_MSG;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_NAME_INVALID;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKIN_ON_UNLOCKED_ENTITY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY_OTHER_USER;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_DELETE_ON_LOCKED_ENTITY_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_ERROR;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_MSG;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_REQUESTED_VERSION_INVALID;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_SUBMIT_LOCKED_ENTITY_NOT_ALLOWED;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UNDO_CHECKOUT_ON_UNLOCKED_ENTITY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_INVALID_VERSION;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE_NAME;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_FOR_NAME;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_ON_UNLOCKED_ENTITY;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_PARAM_INVALID;
+import static org.openecomp.sdc.action.util.ActionUtil.actionLogPostProcessor;
+import static org.openecomp.sdc.action.util.ActionUtil.actionLogPreProcessor;
+import static org.openecomp.sdc.versioning.dao.types.Version.VERSION_STRING_VIOLATION_MSG;
+
+import org.apache.commons.lang.StringUtils;
+import org.openecomp.core.logging.api.Logger;
+import org.openecomp.core.logging.api.LoggerFactory;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.core.utilities.json.JsonUtil;
+import org.openecomp.sdc.action.ActionConstants;
+import org.openecomp.sdc.action.ActionManager;
+import org.openecomp.sdc.action.dao.ActionArtifactDao;
+import org.openecomp.sdc.action.dao.ActionArtifactDaoFactory;
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.ActionDaoFactory;
+import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
+import org.openecomp.sdc.action.dao.types.ActionEntity;
+import org.openecomp.sdc.action.errors.ActionErrorConstants;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.logging.StatusCode;
+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.ActionSubOperation;
+import org.openecomp.sdc.action.types.EcompComponent;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+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.EntityNotExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.slf4j.MDC;
+
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+
+/**
+ * Manager Implementation for {@link ActionManager Action Library Operations}. <br> Handles Business
+ * layer validations and acts as an interface between the REST and DAO layers.
+ */
+public class ActionManagerImpl implements ActionManager {
+
+ private static final ActionDao actionDao = ActionDaoFactory.getInstance().createInterface();
+ private static final VersioningManager versioningManager =
+ VersioningManagerFactory.getInstance().createInterface();
+ private static final ActionArtifactDao actionArtifactDao =
+ ActionArtifactDaoFactory.getInstance().createInterface();
+ private static VersionInfoDao versionInfoDao =
+ VersionInfoDaoFactory.getInstance().createInterface();
+
+ private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+
+ public ActionManagerImpl() {
+ actionDao.registerVersioning(ActionConstants.ACTION_VERSIONABLE_TYPE);
+ }
+
+ /**
+ * Get Current Timestamp in UTC format.
+ *
+ * @return Current Timestamp in UTC format.
+ */
+ public static Date getCurrentTimeStampUtc() {
+ return Date.from(java.time.ZonedDateTime.now(ZoneOffset.UTC).toInstant());
+ }
+
+ /**
+ * List All Major, Last Minor and Candidate version (if any) for Given Action Invariant UUID.
+ *
+ * @param invariantId Invariant UUID of the action for which the information is required.
+ * @return List of All Major, Last Minor and Candidate version if any Of {@link Action} with given
+ actionInvariantUuId.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred during the operation.
+ */
+ @Override
+ public List<Action> getActionsByActionInvariantUuId(String invariantId) throws ActionException {
+ log.debug(" entering getActionsByActionInvariantUUID with invariantID = " + invariantId);
+ List<Action> actions = actionDao
+ .getActionsByActionInvariantUuId(invariantId != null ? invariantId.toUpperCase() : null);
+ if (actions != null && actions.isEmpty()) {
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST);
+ }
+ log.debug(" exit getActionsByActionInvariantUUID with invariantID = " + invariantId);
+ return actions;
+ }
+
+ /**
+ * Get list of actions based on a filter criteria. If no filter is sent all actions will be
+ * returned.
+ *
+ * @param filterType Filter by Vendor/Category/Model/Component/None.
+ * @param filterValue Filter Parameter Value (Vendor ID/Category ID/Model ID/Component ID).
+ * @return List of {@link Action} objects based on a filter criteria <br> Empty List if no records
+ match the provided filter criteria.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public List<Action> getFilteredActions(String filterType, String filterValue)
+ throws ActionException {
+ log.debug(" entering getFilteredActions By filterType = " + filterType + " With value = "
+ + filterValue);
+ List<Action> actions;
+ switch (filterType) {
+ case ActionConstants.FILTER_TYPE_NONE:
+ //Business validation for ECOMP Component type fetch (if any)
+ break;
+ case ActionConstants.FILTER_TYPE_VENDOR:
+ //Business validation for vendor type fetch (if any)
+ break;
+ case ActionConstants.FILTER_TYPE_CATEGORY:
+ //Business validation for Category type fetch (if any)
+ break;
+ case ActionConstants.FILTER_TYPE_MODEL:
+ //Business validation for model type fetch (if any)
+ break;
+ case ActionConstants.FILTER_TYPE_ECOMP_COMPONENT:
+ //Business validation for ECOMP Component type fetch (if any)
+ break;
+ case ActionConstants.FILTER_TYPE_NAME:
+ actions = actionDao
+ .getFilteredActions(filterType, filterValue != null ? filterValue.toLowerCase() : null);
+ if (actions != null && actions.isEmpty()) {
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST);
+ }
+ log.debug(" exit getFilteredActions By filterType = " + filterType + " With value = "
+ + filterValue);
+ return actions;
+ default:
+ break;
+ }
+ actions = actionDao
+ .getFilteredActions(filterType, filterValue != null ? filterValue.toLowerCase() : null);
+ List<Action> majorMinorVersionList = getMajorMinorVersionActions(actions);
+ Collections.sort(majorMinorVersionList);
+ log.debug(
+ " exit getFilteredActions By filterType = " + filterType + " With value = " + filterValue);
+ return majorMinorVersionList;
+ }
+
+ /**
+ * Get the properties of an action version by its UUID.
+ *
+ * @param actionUuId UUID of the specific action version.
+ * @return {@link Action} object corresponding the version represented by the UUID.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action getActionsByActionUuId(String actionUuId) throws ActionException {
+ log.debug(" entering getActionsByActionUUID with actionUUID = " + actionUuId);
+ Action action =
+ actionDao.getActionsByActionUuId(actionUuId != null ? actionUuId.toUpperCase() : null);
+
+ if (action == null) {
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST);
+ }
+ log.debug(" exit getActionsByActionUUID with actionUUID = " + actionUuId);
+ return action;
+ }
+
+ /**
+ * List ECOMP Components supported by Action Library
+ *
+ * @return List of {@link EcompComponent} objects supported by Action Library <br> Empty List if
+ no components are found.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public List<EcompComponent> getEcompComponents() throws ActionException {
+ return actionDao.getEcompComponents();
+ }
+
+
+ /**
+ * Delete an action.
+ *
+ * @param actionInvariantUuId Invariant UUID of the action to be deleted.
+ * @param user User id of the user performing the operation.
+ */
+ @Override
+ public void deleteAction(String actionInvariantUuId, String user) throws ActionException {
+ try {
+ log.debug("entering deleteAction with actionInvariantUUID = " + actionInvariantUuId
+ + " and user = " + user);
+ actionLogPreProcessor(ActionSubOperation.DELETE_ACTION, TARGET_ENTITY_API);
+ versioningManager.delete(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ actionDao.deleteAction(actionInvariantUuId);
+ } catch (CoreException ce) {
+ formAndThrowException(ce);
+ }
+ }
+
+ /**
+ * Create a new Action.
+ *
+ * @param action Action object model of the user request for creating an action.
+ * @param user AT&T id of the user sending the create request.
+ * @return {@link Action} model object for the created action.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action createAction(Action action, String user) throws ActionException {
+ try {
+ actionLogPreProcessor(ActionSubOperation.VALIDATE_ACTION_UNIQUE_NAME, TARGET_ENTITY_API);
+ UniqueValueUtil
+ .validateUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName());
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ } catch (CoreException ce) {
+ String errorDesc = String
+ .format(ACTION_ENTITY_UNIQUE_VALUE_MSG, ActionConstants.UniqueValues.ACTION_NAME,
+ action.getName());
+ actionLogPostProcessor(StatusCode.ERROR, ACTION_ENTITY_UNIQUE_VALUE_ERROR, errorDesc, false);
+ throw new ActionException(ACTION_ENTITY_UNIQUE_VALUE_ERROR, errorDesc);
+ } finally {
+ log.metrics("");
+ }
+
+ action.setUser(user);
+ action.setTimestamp(getCurrentTimeStampUtc());
+ action.setActionInvariantUuId(CommonMethods.nextUuId());
+ action.setActionUuId(CommonMethods.nextUuId());
+
+ actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_VERSION, TARGET_ENTITY_API);
+ Version version = versioningManager
+ .create(ActionConstants.ACTION_VERSIONABLE_TYPE, action.getActionInvariantUuId(), user);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ action.setVersion(version.toString());
+ action.setStatus(ActionStatus.Locked);
+ action = updateData(action);
+ action = actionDao.createAction(action);
+ actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_UNIQUE_VALUE, TARGET_ENTITY_API);
+ UniqueValueUtil.createUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName());
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ return action;
+ }
+
+ /**
+ * Update an existing action.
+ *
+ * @param action Action object model of the user request for creating an action.
+ * @param user AT&T id of the user sending the update request.
+ * @return {@link Action} model object for the update action.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action updateAction(Action action, String user) throws ActionException {
+ try {
+ log.debug("entering updateAction to update action with invariantUUID = "
+ + action.getActionInvariantUuId() + " by user = " + user);
+ String invariantUuId = action.getActionInvariantUuId();
+ actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_API);
+ VersionInfo versionInfo = versioningManager
+ .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user,
+ VersionableEntityAction.Write);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ Version activeVersion = versionInfo.getActiveVersion();
+ validateActions(action, activeVersion);
+ action.setStatus(ActionStatus.Locked); //Status will be Checkout for update
+ updateData(action);
+ action.setUser(user);
+ action.setTimestamp(getCurrentTimeStampUtc());
+ actionDao.updateAction(action);
+ } catch (CoreException ce) {
+ formAndThrowException(ce);
+ }
+ log.debug("exit updateAction");
+ return action;
+ }
+
+ /**
+ * Checkout an existing action.
+ *
+ * @param invariantUuId actionInvariantUuId of the action to be checked out.
+ * @param user AT&T id of the user sending the checkout request.
+ * @return {@link Action} model object for the checkout action.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action checkout(String invariantUuId, String user) throws ActionException {
+ Version version = null;
+ ActionEntity actionEntity = null;
+ try {
+ log.debug(
+ "entering checkout for Action with invariantUUID= " + invariantUuId + " by user = "
+ + user);
+ actionLogPreProcessor(ActionSubOperation.CHECKOUT_ACTION, TARGET_ENTITY_API);
+ version =
+ versioningManager.checkout(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ actionEntity =
+ updateUniqueIdForVersion(invariantUuId, version, ActionStatus.Locked.name(), user);
+ } catch (CoreException e0) {
+ if (e0.code() != null
+ && e0.code().id().equals(VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY)) {
+ actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB);
+ VersionInfoEntity versionInfoEntity = versionInfoDao
+ .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId));
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ String checkoutUser = versionInfoEntity.getCandidate().getUser();
+ log.debug(
+ "Actual checkout user for Action with invariantUUID= " + invariantUuId + " is = "
+ + checkoutUser);
+ if (!checkoutUser.equals(user)) {
+ throw new ActionException(ACTION_CHECKOUT_ON_LOCKED_ENTITY_OTHER_USER, e0.getMessage());
+ }
+ }
+ formAndThrowException(e0);
+ }
+ log.debug(
+ "exit checkout for Action with invariantUUID= " + invariantUuId + " by user = " + user);
+ return actionEntity != null ? actionEntity.toDto() : new Action();
+ }
+
+ /**
+ * Undo an already checked out action.
+ *
+ * @param invariantUuId actionInvariantUuId of the checked out action.
+ * @param user AT&T id of the user sending the request.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public void undoCheckout(String invariantUuId, String user) throws ActionException {
+ Version version;
+ try {
+ log.debug(
+ "entering undoCheckout for Action with invariantUUID= " + invariantUuId + " by user = "
+ + user);
+ actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB);
+ //Get list of uploaded artifacts in this checked out version
+ VersionInfoEntity versionInfoEntity = versionInfoDao
+ .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId));
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ if (versionInfoEntity == null) {
+ throw new CoreException(
+ new EntityNotExistErrorBuilder(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId)
+ .build());
+ }
+ UserCandidateVersion candidate = versionInfoEntity.getCandidate();
+ Version activeVersion;
+ if (candidate != null) {
+ activeVersion = candidate.getVersion();
+ } else {
+ activeVersion = versionInfoEntity.getActiveVersion();
+ }
+ actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VERSION, TARGET_ENTITY_DB);
+ Action action = actionDao.get(new ActionEntity(invariantUuId, activeVersion)).toDto();
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ //Perform undo checkout on the action
+ actionLogPreProcessor(ActionSubOperation.UNDO_CHECKOUT_ACTION, TARGET_ENTITY_API);
+ version = versioningManager
+ .undoCheckout(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ if (version.equals(new Version(0, 0))) {
+ actionLogPreProcessor(ActionSubOperation.DELETE_UNIQUEVALUE, TARGET_ENTITY_API);
+ UniqueValueUtil
+ .deleteUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName());
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ actionLogPreProcessor(ActionSubOperation.DELETE_ACTIONVERSION, TARGET_ENTITY_DB );
+ //Added for the case where Create->Undo_Checkout->Checkout should not get the action
+ versionInfoDao
+ .delete(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId));
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ }
+ List<ActionArtifact> currentVersionArtifacts = action.getArtifacts();
+
+ //Delete the artifacts from action_artifact table (if any)
+ if (currentVersionArtifacts != null && currentVersionArtifacts.size() > 0) {
+ for (ActionArtifact artifact : currentVersionArtifacts) {
+ ActionArtifactEntity artifactDeleteEntity =
+ new ActionArtifactEntity(artifact.getArtifactUuId(),
+ getEffectiveVersion(activeVersion.toString()));
+ actionLogPreProcessor(ActionSubOperation.DELETE_ARTIFACT, TARGET_ENTITY_DB);
+ actionArtifactDao.delete(artifactDeleteEntity);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ }
+ }
+ } catch (CoreException e0) {
+ formAndThrowException(e0);
+ }
+ log.debug(
+ "exit undoCheckout for Action with invariantUUID= " + invariantUuId + " by user = " + user);
+ }
+
+ /**
+ * Checkin a checked out action.
+ *
+ * @param invariantUuId actionInvariantUuId of the checked out action.
+ * @param user AT&T id of the user sending the request.
+ * @return {@link Action} model object for the updated action.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action checkin(String invariantUuId, String user) throws ActionException {
+ Version version = null;
+ ActionEntity actionEntity = null;
+ try {
+ log.debug("entering checkin for Action with invariantUUID= " + invariantUuId + " by user = "
+ + user);
+ actionLogPreProcessor(ActionSubOperation.CHECKIN_ACTION, TARGET_ENTITY_API);
+ version = versioningManager
+ .checkin(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user, null);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ actionEntity =
+ updateStatusForVersion(invariantUuId, version, ActionStatus.Available.name(), user);
+ } catch (CoreException e0) {
+ formAndThrowException(e0);
+ }
+ log.debug(
+ "exit checkin for Action with invariantUUID= " + invariantUuId + " by user = " + user);
+ return actionEntity != null ? actionEntity.toDto() : new Action();
+ }
+
+ /**
+ * Submit a checked in action.
+ *
+ * @param invariantUuId actionInvariantUuId of the checked in action.
+ * @param user AT&T id of the user sending the request.
+ * @return {@link Action} model object for the updated action.
+ * @throws ActionException Exception with an action library specific code, short description and
+ * detailed message for the error occurred for the error occurred during
+ * the operation.
+ */
+ @Override
+ public Action submit(String invariantUuId, String user) throws ActionException {
+ Version version = null;
+ ActionEntity actionEntity = null;
+ try {
+ log.debug("entering checkin for Action with invariantUUID= " + invariantUuId + " by user = "
+ + user);
+ actionLogPreProcessor(ActionSubOperation.CHECKIN_ACTION, TARGET_ENTITY_API);
+ version = versioningManager
+ .submit(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user, null);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ actionEntity =
+ updateUniqueIdForVersion(invariantUuId, version, ActionStatus.Final.name(), user);
+ } catch (CoreException e0) {
+ formAndThrowException(e0);
+ }
+ log.debug(
+ "exit checkin for Action with invariantUUID= " + invariantUuId + " by user = " + user);
+ return actionEntity != null ? actionEntity.toDto() : new Action();
+ }
+
+ /**
+ * Download an artifact of an action.
+ *
+ * @param artifactUuId {@link ActionArtifact} object representing the artifact and its metadata.
+ * @param actionUuId UUID of the action for which the artifact has to be downloaded.
+ * @return downloaded action artifact object.
+ */
+ @Override
+ public ActionArtifact downloadArtifact(String actionUuId, String artifactUuId)
+ throws ActionException {
+ log.debug(" entering downloadArtifact with actionUUID= " + actionUuId + " and artifactUUID= "
+ + artifactUuId);
+ Action action = actionDao.getActionsByActionUuId(actionUuId);
+ ActionArtifact actionArtifact;
+ if (action != null) {
+ MDC.put(SERVICE_INSTANCE_ID, action.getActionInvariantUuId());
+ List<ActionArtifact> artifacts = action.getArtifacts();
+ String actionVersion = action.getVersion();
+ int effectiveVersion = getEffectiveVersion(actionVersion);
+ ActionArtifact artifactMetadata =
+ getArtifactMetadataFromAction(artifacts, ActionConstants.ARTIFACT_METADATA_ATTR_UUID,
+ artifactUuId);
+ if (artifactMetadata != null) {
+ String artifactName = artifactMetadata.getArtifactName();
+ actionArtifact = actionArtifactDao.downloadArtifact(effectiveVersion, artifactUuId);
+ actionArtifact.setArtifactName(artifactName);
+
+ } else {
+ throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE,
+ ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ } else {
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE,
+ ACTION_ENTITY_NOT_EXIST);
+ }
+ log.debug(" exit downloadArtifact with actionUUID= " + actionUuId + " and artifactUUID= "
+ + artifactUuId);
+ return actionArtifact;
+ }
+
+ /**
+ * Upload an artifact to an action.
+ *
+ * @param artifact {@link ActionArtifact} object representing the artifact and its
+ * metadata.
+ * @param actionInvariantUuId Invariant UUID of the action to which the artifact has to be
+ * uploaded.
+ * @param user User ID of the user sending the request.
+ * @return Uploaded action artifact object.
+ */
+ @Override
+ public ActionArtifact uploadArtifact(ActionArtifact artifact, String actionInvariantUuId,
+ String user) {
+ ActionArtifact uploadArtifactResponse = new ActionArtifact();
+ try {
+ log.debug("entering uploadArtifact with actionInvariantUUID= " + actionInvariantUuId
+ + "artifactName= " + artifact.getArtifactName());
+ actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB);
+ VersionInfo versionInfo = versioningManager
+ .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user,
+ VersionableEntityAction.Write);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ Version activeVersion = versionInfo.getActiveVersion();
+ actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID, TARGET_ENTITY_DB);
+ Action action = actionDao.get(new ActionEntity(actionInvariantUuId, activeVersion)).toDto();
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ String artifactUuId = generateActionArtifactUuId(action, artifact.getArtifactName());
+ //Check for Unique document name
+ List<ActionArtifact> actionArtifacts = action.getArtifacts();
+ ActionArtifact artifactMetadata = getArtifactMetadataFromAction(actionArtifacts,
+ ActionConstants.ARTIFACT_METADATA_ATTR_NAME, artifact.getArtifactName());
+ if (artifactMetadata != null) {
+ throw new ActionException(ACTION_ARTIFACT_ALREADY_EXISTS_CODE,
+ String.format(ACTION_ARTIFACT_ALREADY_EXISTS, actionInvariantUuId));
+ }
+
+ //Create the artifact
+ artifact.setArtifactUuId(artifactUuId);
+ artifact.setTimestamp(getCurrentTimeStampUtc());
+ artifact.setEffectiveVersion(getEffectiveVersion(activeVersion.toString()));
+ actionArtifactDao.uploadArtifact(artifact);
+
+ //Update the action data field and timestamp
+ addArtifactMetadataInActionData(action, artifact);
+
+ //Set the response object
+ uploadArtifactResponse.setArtifactUuId(artifact.getArtifactUuId());
+ } catch (CoreException ce) {
+ formAndThrowException(ce);
+ }
+ log.debug(
+ "exit uploadArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactName= "
+ + artifact.getArtifactName());
+ return uploadArtifactResponse;
+ }
+
+ @Override
+ public void deleteArtifact(String actionInvariantUuId, String artifactUuId, String user)
+ throws ActionException {
+ log.debug(
+ "enter deleteArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactUUID= "
+ + artifactUuId + " and user = " + user);
+ Action action = actionDao.getLockedAction(actionInvariantUuId, user);
+ List<ActionArtifact> actionArtifacts = action.getArtifacts();
+ ActionArtifact artifactMetadata =
+ getArtifactMetadataFromAction(actionArtifacts, ActionConstants.ARTIFACT_METADATA_ATTR_UUID,
+ artifactUuId);
+ if (artifactMetadata == null) {
+ throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE,
+ ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ if (artifactMetadata.getArtifactProtection().equals(ActionArtifactProtection.readOnly.name())) {
+ throw new ActionException(ACTION_ARTIFACT_DELETE_READ_ONLY,
+ ACTION_ARTIFACT_DELETE_READ_ONLY_MSG);
+ } else {
+
+ //Update action by removing artifact metadata
+ String jsonData = action.getData();
+ List<ActionArtifact> artifacts = action.getArtifacts();//action.getArtifacts();
+ ActionArtifact artifact = null;
+ Iterator<ActionArtifact> it = artifacts.iterator();
+ while (it.hasNext()) {
+ artifact = it.next();
+ String artifactId = artifact.getArtifactUuId();
+ if (artifactId.equals(artifactUuId)) {
+ it.remove();
+ }
+ }
+
+ Map dataMap = JsonUtil.json2Object(jsonData, LinkedHashMap.class);
+ dataMap.put("artifacts", artifacts);
+ String data = JsonUtil.object2Json(dataMap);
+ ActionEntity actionEntity = action.toEntity();
+ actionEntity.setData(data);
+ actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB);
+ actionDao.update(actionEntity);
+ actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+ log.metrics("");
+ // delete Artifact if it's upload and delete action on same checkout version
+ String artifactName = artifactMetadata.getArtifactName();
+ String generatedArtifactUuId = generateActionArtifactUuId(action, artifactName);
+ if (generatedArtifactUuId.equals(artifactUuId)) {
+ ActionArtifactEntity artifactDeleteEntity =
+ new ActionArtifactEntity(artifact.getArtifactUuId(),
+ getEffectiveVersion(action.getVersion()));
+ actionLogPreProcessor(ActionSubOperation.DELETE_ACTION_ARTIFACT, TARGET_ENTITY_DB);
+ actionArtifactDao.delete(artifactDeleteEntity);
+ actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+ log.metrics("");
+ }
+
+ }
+ log.debug(
+ "exit deleteArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactUUID= "
+ + artifactUuId + " and user = " + user);
+ }
+
+ /**
+ * Update an existing artifact.
+ *
+ * @param artifact {@link ActionArtifact} object representing the artifact and its
+ * metadata.
+ * @param actionInvariantUuId Invariant UUID of the action to which the artifact has to be
+ * uploaded.
+ * @param user User ID of the user sending the request.
+ */
+ public void updateArtifact(ActionArtifact artifact, String actionInvariantUuId, String user) {
+ try {
+ log.debug("Enter updateArtifact with actionInvariantUUID= " + actionInvariantUuId
+ + "artifactUUID= " + artifact.getArtifactUuId() + " and user = " + user);
+ actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_API);
+ VersionInfo versionInfo = versioningManager
+ .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user,
+ VersionableEntityAction.Write);
+ actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+ log.metrics("");
+ Version activeVersion = versionInfo.getActiveVersion();
+ actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID, TARGET_ENTITY_DB);
+ Action action = actionDao.get(new ActionEntity(actionInvariantUuId, activeVersion)).toDto();
+ actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+ log.metrics("");
+ List<ActionArtifact> actionArtifacts = action.getArtifacts();
+ ActionArtifact artifactMetadataByUuId = getArtifactMetadataFromAction(actionArtifacts,
+ ActionConstants.ARTIFACT_METADATA_ATTR_UUID, artifact.getArtifactUuId());
+ //Check if artifact is already in action or not
+ if (artifactMetadataByUuId == null) {
+ throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE,
+ ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ //If user tries to change artifact name
+ if (artifact.getArtifactName() != null
+ && !artifactMetadataByUuId.getArtifactName()
+ .equalsIgnoreCase(artifact.getArtifactName())) {
+ throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE,
+ ACTION_ARTIFACT_UPDATE_NAME_INVALID);
+ }
+
+ byte[] payload = artifact.getArtifact();
+ String artifactLabel = artifact.getArtifactLabel();
+ String artifactCategory = artifact.getArtifactCategory();
+ String artifactDescription = artifact.getArtifactDescription();
+ String artifactProtection = artifact.getArtifactProtection();
+ String artifactName = artifact.getArtifactName();
+ //If artifact read only
+ if (artifactMetadataByUuId.getArtifactProtection()
+ .equals(ActionArtifactProtection.readOnly.name())) {
+ if (artifactName != null || artifactLabel != null || artifactCategory != null
+ || artifactDescription != null || payload != null) {
+ throw new ActionException(ACTION_ARTIFACT_UPDATE_READ_ONLY,
+ ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG);
+ }
+ //Changing value from readOnly to readWrite
+ if (artifactProtection != null
+ && artifactProtection.equals(ActionArtifactProtection.readWrite.name())) {
+ artifactMetadataByUuId.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ artifactMetadataByUuId.setTimestamp(getCurrentTimeStampUtc());
+ updateArtifactMetadataInActionData(action, artifactMetadataByUuId);
+ }
+ } else {
+ int effectiveVersion = getEffectiveVersion(activeVersion.toString());
+ if (artifactLabel != null) {
+ artifactMetadataByUuId.setArtifactLabel(artifactLabel);
+ }
+ if (artifactCategory != null) {
+ artifactMetadataByUuId.setArtifactCategory(artifactCategory);
+ }
+ if (artifactDescription != null) {
+ artifactMetadataByUuId.setArtifactDescription(artifactDescription);
+ }
+ if (artifactProtection != null) {
+ artifactMetadataByUuId.setArtifactProtection(artifactProtection);
+ }
+ if (payload != null) {
+ //get artifact data from action_artifact table for updating the content
+ ActionArtifact artifactContent = new ActionArtifact();
+ artifactContent.setArtifactUuId(artifact.getArtifactUuId());
+ artifactContent.setArtifact(payload);
+ artifactContent.setEffectiveVersion(effectiveVersion);
+ actionArtifactDao.updateArtifact(artifactContent);
+ }
+ //Update the action data field and timestamp
+ artifactMetadataByUuId.setTimestamp(getCurrentTimeStampUtc());
+ updateArtifactMetadataInActionData(action, artifactMetadataByUuId);
+ }
+ log.debug("exit updateArtifact with actionInvariantUUID= " + actionInvariantUuId
+ + "artifactUUID= " + artifact.getArtifactUuId() + " and user = " + user);
+ } catch (CoreException coreException) {
+ formAndThrowException(coreException);
+ }
+ }
+
+ /**
+ * Generate artifact UUID at runtime using action name and effective version.
+ *
+ * @param action {@link Action} for which the artifact is being uploaded/updated/downloaded.
+ * @param artifactName Artifact name.
+ * @return Generated UUID string.
+ */
+ private String generateActionArtifactUuId(Action action, String artifactName) {
+ int effectiveVersion = getEffectiveVersion(action.getVersion());
+ //Upper case for maintaining case-insensitive behavior for the artifact names
+ String artifactUuIdString
+ = action.getName().toUpperCase() + effectiveVersion + artifactName.toUpperCase();
+ String generateArtifactUuId
+ = UUID.nameUUIDFromBytes((artifactUuIdString).getBytes()).toString();
+ String artifactUuId = generateArtifactUuId.replace("-", "");
+ return artifactUuId.toUpperCase();
+ }
+
+ /**
+ * Generate the effective action version for artifact operations.
+ *
+ * @param actionVersion Version of the action as a string.
+ * @return Effective version to be used for artifact operations.
+ */
+ private int getEffectiveVersion(String actionVersion) {
+ Version version = Version.valueOf(actionVersion);
+ return version.getMajor() * 10000 + version.getMinor();
+ }
+
+ /**
+ * Update the data field of the Action object with the modified/generated fields after an
+ * operation.
+ *
+ * @param action Action object whose data field has to be updated.
+ * @return Updated {@link Action} object.
+ */
+ private Action updateData(Action action) {
+ log.debug("entering updateData to update data json for action with actionuuid= "
+ + action.getActionUuId());
+ Map<String, String> dataMap = new LinkedHashMap<>();
+ dataMap.put(ActionConstants.UNIQUE_ID, action.getActionUuId());
+ dataMap.put(ActionConstants.VERSION, action.getVersion());
+ dataMap.put(ActionConstants.INVARIANTUUID, action.getActionInvariantUuId());
+ dataMap.put(ActionConstants.STATUS, action.getStatus().name());
+
+ String data = action.getData();
+ Map<String, String> currentDataMap = JsonUtil.json2Object(data, LinkedHashMap.class);
+ dataMap.putAll(currentDataMap);
+ data = JsonUtil.object2Json(dataMap);
+ action.setData(data);
+ log.debug("exit updateData");
+ return action;
+ }
+
+ /**
+ * Method to add the artifact metadata in the data attribute of action table.
+ *
+ * @param action Action to which artifact is uploaded.
+ * @param artifact Uploaded artifact object.
+ */
+ private void addArtifactMetadataInActionData(Action action, ActionArtifact artifact) {
+
+ ActionArtifact artifactMetadata = new ActionArtifact();
+ artifactMetadata.setArtifactUuId(artifact.getArtifactUuId());
+ artifactMetadata.setArtifactName(artifact.getArtifactName());
+ artifactMetadata.setArtifactProtection(artifact.getArtifactProtection());
+ artifactMetadata.setArtifactLabel(artifact.getArtifactLabel());
+ artifactMetadata.setArtifactDescription(artifact.getArtifactDescription());
+ artifactMetadata.setArtifactCategory(artifact.getArtifactCategory());
+ artifactMetadata.setTimestamp(artifact.getTimestamp());
+ List<ActionArtifact> actionArtifacts = action.getArtifacts();
+ if (actionArtifacts == null) {
+ actionArtifacts = new ArrayList<>();
+ }
+ actionArtifacts.add(artifactMetadata);
+ action.setArtifacts(actionArtifacts);
+ String currentData = action.getData();
+ Map<String, Object> currentDataMap = JsonUtil.json2Object(currentData, LinkedHashMap.class);
+ currentDataMap.put(ActionConstants.ARTIFACTS, actionArtifacts);
+ String updatedActionData = JsonUtil.object2Json(currentDataMap);
+ action.setData(updatedActionData);
+ action.setTimestamp(artifact.getTimestamp());
+ actionDao.updateAction(action);
+ }
+
+ /**
+ * Get a list of last major and last minor version (no candidate) of action from a list of
+ * actions.
+ *
+ * @param actions Exhaustive list of the action versions.
+ * @return List {@link Action} of last major and last minor version (no candidate) of action from
+ a list of actions.
+ */
+ private List<Action> getMajorMinorVersionActions(List<Action> actions) {
+ log.debug(" entering getMajorMinorVersionActions for actions ");
+ List<Action> list = new LinkedList<>();
+ actionLogPreProcessor(ActionSubOperation.GET_VERSIONINFO_FOR_ALL_ACTIONS, TARGET_ENTITY_API);
+ Map<String, VersionInfo> actionVersionMap = versioningManager
+ .listEntitiesVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, "",
+ VersionableEntityAction.Read);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ for (Action action : actions) {
+ if (action.getStatus() == ActionStatus.Deleted) {
+ continue;
+ }
+ VersionInfo actionVersionInfo = actionVersionMap.get(action.getActionInvariantUuId());
+ if (actionVersionInfo.getActiveVersion() != null
+ && actionVersionInfo.getActiveVersion().equals(Version.valueOf(action.getVersion()))) {
+ list.add(action);
+ } else if (actionVersionInfo.getLatestFinalVersion() != null
+ && actionVersionInfo.getLatestFinalVersion().equals(Version.valueOf(action.getVersion()))
+ &&
+ !actionVersionInfo.getLatestFinalVersion().equals(actionVersionInfo.getActiveVersion())) {
+ list.add(action);
+ }
+ }
+ log.debug(" exit getMajorMinorVersionActions for actions ");
+ return list;
+ }
+
+ /**
+ * CoreException object wrapper from Version library to Action Library Exception.
+ *
+ * @param exception CoreException object from version library.
+ */
+ private void formAndThrowException(CoreException exception) {
+ log.debug(
+ "entering formAndThrowException with input CoreException =" + exception.code().id() + " "
+ + exception.getMessage());
+ String errorDescription = exception.getMessage();
+ String errorCode = exception.code().id();
+ ActionException actionException = new ActionException();
+ switch (errorCode) {
+ case VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST:
+ actionException.setErrorCode(ACTION_ENTITY_NOT_EXIST_CODE);
+ actionException.setDescription(ACTION_ENTITY_NOT_EXIST);
+ break;
+ case VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY:
+ actionException.setErrorCode(ACTION_CHECKOUT_ON_LOCKED_ENTITY);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.CHECKIN_ON_UNLOCKED_ENTITY:
+ actionException.setErrorCode(ACTION_CHECKIN_ON_UNLOCKED_ENTITY);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED:
+ actionException.setErrorCode(ACTION_SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.SUBMIT_LOCKED_ENTITY_NOT_ALLOWED:
+ actionException.setErrorCode(ACTION_SUBMIT_LOCKED_ENTITY_NOT_ALLOWED);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.UNDO_CHECKOUT_ON_UNLOCKED_ENTITY:
+ actionException.setErrorCode(ACTION_UNDO_CHECKOUT_ON_UNLOCKED_ENTITY);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER:
+ actionException.setErrorCode(ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ actionException.setDescription(errorDescription.replace("edit", "updat"));
+ break;
+ case VersioningErrorCodes.CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER:
+ actionException.setErrorCode(ACTION_CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER:
+ actionException.setErrorCode(ACTION_UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ actionException.setDescription(errorDescription);
+ break;
+ case VersioningErrorCodes.EDIT_ON_UNLOCKED_ENTITY:
+ actionException.setErrorCode(ACTION_UPDATE_ON_UNLOCKED_ENTITY);
+ actionException.setDescription(errorDescription.replace("edit", "update"));
+ break;
+ case VersioningErrorCodes.DELETE_ON_LOCKED_ENTITY:
+ actionException.setErrorCode(ACTION_DELETE_ON_LOCKED_ENTITY_CODE);
+ actionException.setDescription(errorDescription);
+ break;
+ default:
+ actionException.setErrorCode(ACTION_INTERNAL_SERVER_ERR_CODE);
+ actionException.setDescription(exception.getMessage());
+
+ }
+ log.debug(
+ "exit formAndThrowException with ActionException =" + actionException.getErrorCode() + " "
+ + actionException.getDescription());
+ throw actionException;
+ }
+
+ /**
+ * Validates an action object for business layer validations before an update operation.
+ *
+ * @param action Action object to be validated.
+ * @param activeVersion Active version of the actoin object.
+ */
+ private void validateActions(Action action, Version activeVersion) {
+ try {
+ //Set version if not already available in input request
+ //If version set in input compare it with version from DB
+ if (StringUtils.isEmpty(action.getVersion())) {
+ action.setVersion(activeVersion.toString());
+ } else {
+ if (!activeVersion.equals(Version.valueOf(action.getVersion()))) {
+ throw new ActionException(ACTION_UPDATE_INVALID_VERSION,
+ String.format(ACTION_REQUESTED_VERSION_INVALID, action.getVersion()));
+ }
+ }
+ String invariantUuId = action.getActionInvariantUuId();
+ Version version = Version.valueOf(action.getVersion());
+ Action existingAction = getActions(invariantUuId, version);
+ if (existingAction == null || existingAction.getActionInvariantUuId() == null) {
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST);
+ }
+ List<String> invalidParameters = new LinkedList<>();
+ //Prevent update of name, version and id fields
+ if (!existingAction.getName().equals(action.getName())) {
+ throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE_NAME,
+ ACTION_UPDATE_NOT_ALLOWED_FOR_NAME);
+ }
+ if (!StringUtils.isEmpty(action.getActionUuId())
+ && !existingAction.getActionUuId().equals(action.getActionUuId())) {
+ invalidParameters.add(ActionConstants.UNIQUE_ID);
+ }
+ if (action.getStatus() != null && (existingAction.getStatus() != action.getStatus())) {
+ invalidParameters.add(ActionConstants.STATUS);
+ }
+
+ if (!invalidParameters.isEmpty()) {
+ throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE,
+ String.format(ACTION_UPDATE_PARAM_INVALID, StringUtils.join(invalidParameters, ", ")));
+ }
+ action.setActionUuId(existingAction.getActionUuId());
+ } catch (IllegalArgumentException iae) {
+ String message = iae.getMessage();
+ switch (message) {
+ case VERSION_STRING_VIOLATION_MSG:
+ throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE, message);
+ default:
+ throw iae;
+ }
+ }
+ }
+
+ /**
+ * Get an action version entity object.
+ *
+ * @param invariantUuId Invariant UUID of the action.
+ * @param version Version of the action.
+ * @return {@link ActionEntity} object of the action version.
+ */
+ private ActionEntity getActionsEntityByVersion(String invariantUuId, Version version) {
+ log.debug(
+ "entering getActionsEntityByVersion with invariantUUID= " + invariantUuId + " and version"
+ + version);
+ ActionEntity entity = null;
+ if (version != null) {
+ actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VERSION, TARGET_ENTITY_DB);
+ entity = actionDao.get(
+ new ActionEntity(invariantUuId != null ? invariantUuId.toUpperCase() : null, version));
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ }
+ log.debug(
+ "exit getActionsEntityByVersion with invariantUUID= " + invariantUuId + " and version"
+ + version);
+ return entity;
+ }
+
+ /**
+ * Get an action version object.
+ *
+ * @param invariantUuId Invariant UUID of the action.
+ * @param version Version of the action.
+ * @return {@link Action} object of the action version.
+ */
+ private Action getActions(String invariantUuId, Version version) {
+ ActionEntity actionEntity =
+ getActionsEntityByVersion(invariantUuId != null ? invariantUuId.toUpperCase() : null,
+ version);
+ return actionEntity != null ? actionEntity.toDto() : new Action();
+ }
+
+ /**
+ * Create and set the Unique ID in for an action version row.
+ *
+ * @param invariantUuId Invariant UUID of the action.
+ * @param version Version of the action.
+ * @param status Status of the action.
+ * @param user AT&T id of the user sending the request.
+ * @return {@link ActionEntity} object of the action version.
+ */
+ private ActionEntity updateUniqueIdForVersion(String invariantUuId, Version version,
+ String status, String user) {
+ log.debug(
+ "entering updateUniqueIdForVersion to update action with invariantUUID= " + invariantUuId
+ + " with version,status and user as ::" + version + " " + status + " " + user);
+ //generate UUID AND update for newly created entity row
+ ActionEntity actionEntity = getActionsEntityByVersion(invariantUuId, version);
+ if (actionEntity != null) {
+ log.debug("Found action to be updated");
+ String data = actionEntity.getData();
+ String uniqueId = CommonMethods.nextUuId();
+ Map<String, String> dataMap = JsonUtil.json2Object(data, LinkedHashMap.class);
+ dataMap.put(ActionConstants.UNIQUE_ID, uniqueId);
+ dataMap.put(ActionConstants.VERSION, version.toString());
+ dataMap.put(ActionConstants.STATUS, status);
+ data = JsonUtil.object2Json(dataMap);
+
+ actionEntity.setData(data);
+ actionEntity.setActionUuId(uniqueId);
+ actionEntity.setStatus(status);
+ actionEntity.setUser(user);
+ actionEntity.setTimestamp(getCurrentTimeStampUtc());
+ actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB);
+ actionDao.update(actionEntity);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ }
+ log.debug(
+ "exit updateUniqueIdForVersion to update action with invariantUUID= " + invariantUuId);
+ return actionEntity;
+ }
+
+ /**
+ * Set the status for an action version row.
+ *
+ * @param invariantUuId Invariant UUID of the action.
+ * @param version Version of the action.
+ * @param status Status of the action.
+ * @param user AT&T id of the user sending the request.
+ * @return {@link ActionEntity} object of the action version.
+ */
+ private ActionEntity updateStatusForVersion(String invariantUuId, Version version, String status,
+ String user) {
+ log.debug(
+ "entering updateStatusForVersion with invariantUUID= " + invariantUuId + " and version"
+ + version + " for updating status " + status + " by user " + user);
+ ActionEntity actionEntity = getActionsEntityByVersion(invariantUuId, version);
+ if (actionEntity != null) {
+ String data = actionEntity.getData();
+ Map<String, String> dataMap = JsonUtil.json2Object(data, LinkedHashMap.class);
+ dataMap.put(ActionConstants.STATUS, status);
+ data = JsonUtil.object2Json(dataMap);
+ actionEntity.setData(data);
+ actionEntity.setStatus(status);
+ actionEntity.setUser(user);
+ actionEntity.setTimestamp(getCurrentTimeStampUtc());
+ actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB);
+ actionDao.update(actionEntity);
+ actionLogPostProcessor(StatusCode.COMPLETE);
+ log.metrics("");
+ }
+ log.debug("exit updateStatusForVersion with invariantUUID= " + invariantUuId + " and version"
+ + version + " for updating status " + status + " by user " + user);
+ return actionEntity;
+
+ }
+
+ /**
+ * Gets an artifact from the action artifact metadata by artifact name.
+ *
+ * @param actionArtifactList Action's existing artifact list.
+ * @param artifactFilterType Search criteria for artifact in action artifact metadata.
+ * @param artifactFilterValue Value of Search parameter.
+ * @return Artifact metadata object if artifact is present in action and null otherwise.
+ */
+ private ActionArtifact getArtifactMetadataFromAction(List<ActionArtifact> actionArtifactList,
+ String artifactFilterType,
+ String artifactFilterValue) {
+ ActionArtifact artifact = null;
+ if (actionArtifactList != null && !actionArtifactList.isEmpty()) {
+ for (ActionArtifact entry : actionArtifactList) {
+ switch (artifactFilterType) {
+ case ActionConstants.ARTIFACT_METADATA_ATTR_UUID:
+ String artifactUuId = entry.getArtifactUuId();
+ if (artifactUuId != null && artifactUuId.equals(artifactFilterValue)) {
+ artifact = entry;
+ break;
+ }
+ break;
+ case ActionConstants.ARTIFACT_METADATA_ATTR_NAME:
+ String existingArtifactName = entry.getArtifactName().toLowerCase();
+ if (existingArtifactName.equals(artifactFilterValue.toLowerCase())) {
+ artifact = entry;
+ break;
+ }
+ break;
+ default:
+ }
+ }
+ }
+ return artifact;
+ }
+
+ /**
+ * Method to update the artifact metadata in the data attribute of action table.
+ *
+ * @param action Action to which artifact is uploaded.
+ * @param updatedArtifact updated artifact object.
+ */
+ private void updateArtifactMetadataInActionData(Action action, ActionArtifact updatedArtifact) {
+ for (ActionArtifact entry : action.getArtifacts()) {
+ if (entry.getArtifactUuId().equals(updatedArtifact.getArtifactUuId())) {
+ entry.setArtifactLabel(updatedArtifact.getArtifactLabel());
+ entry.setArtifactCategory(updatedArtifact.getArtifactCategory());
+ entry.setArtifactDescription(updatedArtifact.getArtifactDescription());
+ entry.setArtifactProtection(updatedArtifact.getArtifactProtection());
+ entry.setTimestamp(updatedArtifact.getTimestamp());
+ break;
+ }
+ }
+ String data = action.getData();
+ Map<String, Object> map = JsonUtil.json2Object(data, LinkedHashMap.class);
+ map.put(ActionConstants.ARTIFACTS, action.getArtifacts());
+ String updatedActionData = JsonUtil.object2Json(map);
+ action.setData(updatedActionData);
+ action.setTimestamp(updatedArtifact.getTimestamp());
+ actionDao.updateAction(action);
+ }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java
new file mode 100644
index 0000000000..6d4b422154
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java
@@ -0,0 +1,1207 @@
+package org.openecomp.sdc.action;
+
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.ActionDaoFactory;
+import org.openecomp.sdc.action.dao.types.ActionEntity;
+import org.openecomp.sdc.action.errors.ActionErrorConstants;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.impl.ActionManagerImpl;
+
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.core.utilities.json.JsonUtil;
+
+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.EcompComponent;
+import org.testng.Assert;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.*;
+
+
+@SuppressWarnings("Duplicates")
+public class ActionTest {
+ private static final Version VERSION01 = new Version(0, 1);
+ private static final String USER1 = "actionTestUser1";
+ private static final String USER2 = "actionTestUser2";
+ private static final String ACTION_1 =
+ "{\"name\":\"Test_Action1_name\", \"endpointUri\":\"/test/action/uri\"}";
+ private static final String ACTION_2 =
+ "{\"name\":\"Test_Action2_list\", \"endpointUri\":\"/test/action/uri\", \"categoryList\":[\"Cat-test\", \"Cat-2\"], \"supportedModels\":[{\"versionId\" : \"Model-test\"}], \"supportedComponents\":[{\"Id\":\"APP-C\"}]}";
+ private static final String ACTION_3 =
+ "{\"name\":\"Test_Action3_list\", \"endpointUri\":\"/test/action/uri\", \"vendorList\":[\"Vendor-test\", \"Vendor-2\"], \"supportedModels\":[{\"versionId\" : \"Model-2\"}], \"supportedComponents\":[{\"Id\":\"MSO\"}]}";
+ private static final String ACTION_4 =
+ "{\"name\":\"Test_Action4_list\", \"endpointUri\":\"/test/action/uri\", \"categoryList\":[\"Cat-test\", \"Cat-2\"], \"supportedModels\":[{\"versionId\" : \"Model-test\"}], \"supportedComponents\":[{\"Id\":\"APP-C\"}]}";
+ private static final String ACTION_5 =
+ "{\"name\":\"Test_Action5_list\", \"endpointUri\":\"/test/action/uri\", \"vendorList\":[\"Vendor-test\", \"Vendor-2\"], \"supportedModels\":[{\"versionId\" : \"Model-2\"}], \"supportedComponents\":[{\"Id\":\"MSO\"}]}";
+ private static final String ACTION_6 =
+ "{\"name\":\"Test_Action6_name\", \"endpointUri\":\"/test/action/uri\"}";
+ private static final String ARTIFACT_TEST_ACTION =
+ "{\"name\":\"Test_Artifact_Action\", \"endpointUri\":\"/test/artifact/action/uri\", \"vendorList\":[\"Vendor-test\", \"Vendor-2\"], \"supportedModels\":[{\"versionId\" : \"Model-2\"}], \"supportedComponents\":[{\"Id\":\"MSO\"}]}";
+ private static final String ACTION_TEST_DELETE =
+ "{\"name\":\"Test_Delete_Action\", \"endpointUri\":\"/test/delete/action/uri\", \"categoryList\":[\"Cat-Delete-test\"], \"vendorList\":[\"Vendor-Delete\"], \"supportedModels\":[{\"versionId\" : \"Model-Delete\"}], \"supportedComponents\":[{\"Id\":\"MSO-Delete\"}]}";
+ private static final String ACTION_TEST_ARTIFACT_FILE_NAME = "test_artifact_file.txt";
+ private static final String ACTION_TEST_UPDATE_ARTIFACT_FILE_NAME =
+ "test_artifact_update_file.txt";
+ private static ActionManager actionManager = new ActionManagerImpl();
+ private static ActionDao actionDao = ActionDaoFactory.getInstance().createInterface();
+
+ private static NoSqlDb noSqlDb;
+
+ private static String action1Id;
+ private static String action2Id;
+
+ private static String actionUUId;
+ private static Action testArtifactAction;
+ private static String expectedArtifactUUID;
+ private static ActionArtifact actionArtifact;
+ private Action deleteAction;
+
+ private static String testCreate() {
+ Action action1 = createAction(ACTION_1);
+ Action actionCreated = actionManager.createAction(action1, USER1);
+ action1Id = actionCreated.getActionInvariantUuId();
+ actionUUId = actionCreated.getActionUuId();
+ action1.setVersion(VERSION01.toString());
+ ActionEntity loadedAction = actionDao.get(action1.toEntity());
+ assertActionEquals(actionCreated, loadedAction.toDto());
+ return action1Id;
+ }
+
+ private static Action createAction(String requestJSON) {
+ Action action = JsonUtil.json2Object(requestJSON, Action.class);
+ action.setData(requestJSON);
+ return action;
+ }
+
+ private static void assertActionEquals(Action actual, Action expected) {
+ Assert.assertEquals(actual.getActionUuId(), expected.getActionUuId());
+ Assert.assertEquals(actual.getVersion(), expected.getVersion());
+ Assert.assertEquals(actual.getName(), expected.getName());
+ //Assert.assertEquals(actual.getDescription(), expected.getDescription());
+ Assert.assertEquals(actual.getData(), expected.getData());
+ Assert.assertEquals(actual.getActionInvariantUuId(), expected.getActionInvariantUuId());
+ //Assert.assertEquals(actual.getEndpointUri(), expected.getEndpointUri());
+ Assert.assertEquals(actual.getStatus(), expected.getStatus());
+ Assert.assertEquals(actual.getSupportedComponents(), expected.getSupportedComponents());
+ Assert.assertEquals(actual.getSupportedModels(), expected.getSupportedModels());
+ }
+
+ @BeforeTest
+ private void init() {
+ this.noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ this.noSqlDb.execute("TRUNCATE dox.action;");
+ this.noSqlDb.execute("TRUNCATE dox.ecompcomponent;");
+ this.noSqlDb.execute("TRUNCATE dox.unique_value;");
+ this.noSqlDb.execute("TRUNCATE dox.action_artifact;");
+ this.noSqlDb.execute("insert into dox.ecompcomponent(id, name) values ('COMP-1','MSO');");
+ this.noSqlDb.execute("insert into dox.ecompcomponent(id, name) values ('COMP-2','APP-C');");
+ }
+
+ @Test
+ public void createTest() {
+ action1Id = testCreate();
+ }
+
+ @Test
+ public void testGetByInvIdOnCreate() {
+ String input =
+ "{\"name\":\"Action_2.0\",\"endpointUri\":\"new/action/uri\",\"categoryList\":[\"Cat-1\", \"Cat-2\"],\"displayName\":\"Updated Action\",\"vendorList\":[\"Vendor-1\", \"Vendor-2\"]," +
+ "\"supportedModels\":[{\"versionId\":\"AA56B177-9383-4934-8543-0F91A7A04971\"," +
+ "\"invariantID\":\"CC87B177-9383-4934-8543-0F91A7A07193\", \"name\":\"vABC\"," +
+ "\"version\":\"2.1\",\"vendor\":\"cisco\"}]," +
+ "\"supportedComponents\":[{\"Id\":\"BB47B177-9383-4934-8543-0F91A7A06448\", \"name\":\"appc\"}]}";
+ Action action1 = createAction(input);
+ Action action = actionManager.createAction(action1, USER1);
+ action2Id = action.getActionInvariantUuId();
+ List<Action> actions =
+ actionManager.getActionsByActionInvariantUuId(action.getActionInvariantUuId());
+ Assert.assertEquals(1, actions.size());
+ Assert.assertEquals("0.1", actions.get(0).getVersion());
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdOnCreate"})
+ public void testGetByIgnoreCaseName() {
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_NAME, "acTion_2.0");
+ List<String> actualVersionList = new ArrayList<String>();
+ List<String> expectedVersionList = new ArrayList<String>();
+ expectedVersionList.add("0.1");
+ for (Action action : actions) {
+ System.out.println("action by testGetByIgnoreCaseName is::::");
+ System.out.println(action.getActionInvariantUuId() + " " + action.getVersion());
+ actualVersionList.add(action.getVersion());
+ }
+ Assert.assertEquals(1, actions.size());
+ Assert.assertEquals(expectedVersionList, actualVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdOnCreate"})
+ public void testGetByInvIdManyVersionWithoutSubmit() {
+ for (int i = 0; i < 11; i++) {
+ actionManager.checkin(action2Id, USER1);
+ actionManager.checkout(action2Id, USER1);
+ }
+
+ List<Action> actions = actionManager.getActionsByActionInvariantUuId(action2Id);
+ List<String> actualVersionList = new ArrayList<String>();
+ List<String> expectedVersionList = new ArrayList<String>();
+ expectedVersionList.add("0.11");
+ expectedVersionList.add("0.12");
+ System.out.println(actions.size());
+ for (Action action : actions) {
+ System.out.println("testGetByInvIdManyVersionWithoutSubmit is::::");
+ System.out.println(action.getActionInvariantUuId() + " " + action.getVersion());
+ actualVersionList.add(action.getVersion());
+ }
+ Assert.assertEquals(2, actions.size());
+ Assert.assertEquals(expectedVersionList, actualVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdManyVersionWithoutSubmit"})
+ public void testGetByInvIdManyVersionWithFirstSubmit() {
+ actionManager.checkin(action2Id, USER1);//Checkin 0.12
+ actionManager.submit(action2Id, USER1); //1.0
+ for (int i = 0; i < 11; i++) {
+ actionManager.checkout(action2Id, USER1);
+ actionManager.checkin(action2Id, USER1);
+ }
+
+ List<Action> actions = actionManager.getActionsByActionInvariantUuId(action2Id);
+ List<String> actualVersionList = new ArrayList<String>();
+ List<String> expectedVersionList = new ArrayList<String>();
+ expectedVersionList.add("1.0");
+ expectedVersionList.add("1.11");
+ System.out.println(actions.size());
+ for (Action action : actions) {
+ System.out.println("testGetByInvIdManyVersionWithFirstSubmit is::::");
+ System.out.println(action.getActionInvariantUuId() + " " + action.getVersion());
+ actualVersionList.add(action.getVersion());
+ }
+ Assert.assertEquals(2, actions.size());
+ Assert.assertEquals(expectedVersionList, actualVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdManyVersionWithFirstSubmit"})
+ public void testGetByInvIdManyVersionWithMultSubmit() {
+ actionManager.submit(action2Id, USER1); //2.0
+ for (int i = 0; i < 11; i++) {
+ actionManager.checkout(action2Id, USER1);
+ actionManager.checkin(action2Id, USER1);
+ }
+ actionManager.checkout(action2Id, USER1); //2.12
+
+ List<Action> actions = actionManager.getActionsByActionInvariantUuId(action2Id);
+ List<String> actualVersionList = new ArrayList<String>();
+ List<String> expectedVersionList = new ArrayList<String>();
+ expectedVersionList.add("1.0");
+ expectedVersionList.add("2.0");
+ expectedVersionList.add("2.11");
+ expectedVersionList.add("2.12");
+ System.out.println(actions.size());
+ for (Action action : actions) {
+ System.out.println("testGetByInvIdManyVersionWithMultSubmit is::::");
+ System.out.println(action.getActionInvariantUuId() + " " + action.getVersion());
+ actualVersionList.add(action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedVersionList, actualVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdManyVersionWithMultSubmit"})
+ public void testGetByInvIdOnName() {
+ for (int i = 0; i < 9; i++) {
+ actionManager.checkin(action2Id, USER1);
+ actionManager.checkout(action2Id, USER1); //2.21
+ }
+
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_NAME, "Action_2.0");
+ List<String> actualVersionList = new ArrayList<String>();
+ List<String> expectedVersionList = new ArrayList<String>();
+ expectedVersionList.add("1.0");
+ expectedVersionList.add("2.0");
+ expectedVersionList.add("2.20");
+ expectedVersionList.add("2.21");
+ for (Action action : actions) {
+ System.out.println("action by testGetByInvIdOnName is::::");
+ System.out.println(action.getActionInvariantUuId() + " " + action.getVersion());
+ actualVersionList.add(action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedVersionList, actualVersionList);
+ }
+
+ @Test(dependsOnMethods = {"createTest"})
+ public void testCreateWithExistingActionName_negative() {
+ try {
+ actionManager.createAction(createAction(ACTION_1), USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_ERROR);
+ }
+ }
+
+ @Test(groups = "updateTestGroup",
+ dependsOnMethods = {"testCreateWithExistingActionName_negative", "createTest"})
+ public void updateTest() {
+ List<String> newSupportedComponents = new LinkedList<>();
+ newSupportedComponents.add("Updated MSO");
+ newSupportedComponents.add("Updated APPC");
+
+ List<String> newSupportedModels = new LinkedList<>();
+ newSupportedModels.add("Updated Model-1");
+ newSupportedModels.add("Updated Model-2");
+
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ existingActionEntity
+ .setSupportedComponents(newSupportedComponents); //Updating Supported components
+ existingActionEntity.setSupportedModels(newSupportedModels); //Updating supported models
+ //Persisting the updated entity
+ Action updatedAction = actionManager.updateAction(existingActionEntity.toDto(), USER1);
+
+ //Create expected response template
+ ActionEntity expectedActionEntity = new ActionEntity(action1Id, VERSION01);
+ expectedActionEntity.setName(existingActionEntity.getName());
+ expectedActionEntity.setActionUuId(existingActionEntity.getActionUuId());
+ expectedActionEntity.setActionInvariantUuId(existingActionEntity.getActionInvariantUuId());
+ expectedActionEntity.setData(existingActionEntity.getData());
+ expectedActionEntity.setStatus(ActionStatus.Locked.name());
+ expectedActionEntity.setSupportedComponents(newSupportedComponents);
+ expectedActionEntity.setSupportedModels(newSupportedModels);
+ Action expectedAction = updateData(expectedActionEntity.toDto());
+
+ assertActionEquals(updatedAction, expectedAction);
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateName_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ action = existingActionEntity.toDto();
+ action.setName("Update - New Action Name");
+ //Persisting the updated entity
+ actionManager.updateAction(action, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert
+ .assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE_NAME);
+ }
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateVersion_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ action = existingActionEntity.toDto();
+ action.setVersion("0.3");
+ //Persisting the updated entity
+ actionManager.updateAction(action, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_INVALID_VERSION);
+ }
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateInvalidVersion_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ //existingActionEntity.setDisplayName("Display Name Updated");
+ Action updatedAction = existingActionEntity.toDto();
+ updatedAction.setVersion("invalid_version_format");
+ //Persisting the updated entity
+ actionManager.updateAction(updatedAction, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE);
+ }
+ }
+
+ /*@Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateStatusInvalidEnum_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ existingActionEntity.setStatus("invalid_status_string");
+ //Persisting the updated entity
+ actionManager.updateAction(existingActionEntity.toDto(),USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE);
+ } catch (IllegalArgumentException ie){
+ String message = ie.getMessage();
+ boolean result = message.contains("No enum constant");
+ Assert.assertEquals(true, result);
+ }
+ }*/
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateInvariantId_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ action = existingActionEntity.toDto();
+ action.setActionInvariantUuId(UUID.randomUUID().toString());
+ //Persisting the updated entity
+ actionManager.updateAction(action, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ }
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateUniqueId_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ //existingActionEntity.setActionUuId(UUID.randomUUID().toString());
+
+ action = existingActionEntity.toDto();
+ action.setActionUuId(UUID.randomUUID().toString());
+ //Persisting the updated entity
+ //actionManager.updateAction(existingActionEntity.toDto(),USER1);
+ actionManager.updateAction(action, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE);
+ }
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateStatus_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ action = existingActionEntity.toDto();
+ action.setStatus(ActionStatus.Final);
+ //Persisting the updated entity
+ actionManager.updateAction(action, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE);
+ } catch (IllegalArgumentException ie) {
+ String message = ie.getMessage();
+ boolean result = message.contains("No enum constant");
+ Assert.assertEquals(true, result);
+ }
+ }
+
+ @Test(groups = "updateTestGroup", dependsOnMethods = {"updateTest"})
+ public void testUpdateOtherUser_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ action = existingActionEntity.toDto();
+ //existingActionEntity.setDescription("Testing Update using other user");
+ //Persisting the updated entity
+ actionManager.updateAction(action, USER2);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(),
+ ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ }
+ }
+
+ @Test(dependsOnMethods = {"createTest"})
+ public void testCheckOutOnCheckOut() {
+ try {
+ actionManager.checkout(action1Id, USER1);
+ } catch (ActionException wae) {
+ Assert
+ .assertEquals(wae.getErrorCode(), ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY);
+ Assert.assertEquals(wae.getDescription(),
+ "Can not check out versionable entity Action with id " + action1Id +
+ " since it is checked out by other user: " + USER1 + ".");
+ }
+ }
+
+ @Test(dependsOnMethods = {"createTest"})
+ public void testCheckOutOnCheckOutWithOtherUser() {
+ try {
+ actionManager.checkout(action1Id, "invlaiduser");
+ } catch (ActionException wae) {
+ Assert.assertEquals(wae.getErrorCode(),
+ ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY_OTHER_USER);
+ Assert.assertEquals(wae.getDescription(),
+ "Can not check out versionable entity Action with id " + action1Id +
+ " since it is checked out by other user: " + USER1 + ".");
+ }
+ }
+
+ @Test(dependsOnGroups = {"updateTestGroup"})
+ public void testCheckIn() {
+ Action action = actionManager.checkin(action1Id, USER1);
+ Assert.assertEquals(action.getActionInvariantUuId(), action1Id);
+ Assert.assertEquals(action.getStatus(), ActionStatus.Available);
+ Assert.assertEquals(action.getVersion(), VERSION01.toString());
+ Assert.assertNotNull(action.getActionUuId());
+ }
+
+ @Test(dependsOnMethods = {"testCheckIn"})
+ public void testUpdateOnCheckedInAction_negative() {
+ try {
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION01.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ //existingActionEntity.setDescription("Testing Update On Checked In Action");
+ //Persisting the updated entity
+ actionManager.updateAction(existingActionEntity.toDto(), USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_ON_UNLOCKED_ENTITY);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUpdateOnCheckedInAction_negative"})
+ public void testSubmit() {
+ Action action = actionManager.submit(action1Id, USER1);
+ ActionEntity loadedAction = actionDao.get(action.toEntity());
+ assertActionEquals(action, loadedAction.toDto());
+ }
+
+ @Test(dependsOnMethods = {"testSubmit"})
+ public void testCheckInWithoutCheckout() {
+ try {
+ actionManager.checkin(action1Id, "invaliduser");
+ } catch (ActionException wae) {
+ Assert
+ .assertEquals(wae.getErrorCode(), ActionErrorConstants.ACTION_CHECKIN_ON_UNLOCKED_ENTITY);
+ Assert.assertEquals(wae.getDescription(),
+ "Can not check in versionable entity Action with id " + action1Id +
+ " since it is not checked out.");
+ }
+ }
+
+ @Test(dependsOnMethods = {"testSubmit"})
+ public void testCheckOut() {
+ final Version VERSION02 = new Version(1, 1);
+ Action action = null;
+ action = actionManager.checkout(action1Id, USER1);
+ ActionEntity loadedAction = actionDao.get(action.toEntity());
+ assertActionEquals(action, loadedAction.toDto());
+ }
+
+ @Test(dependsOnMethods = {"testCheckOut"})
+ public void testCheckInWithOtherUser() {
+ try {
+ actionManager.checkin(action1Id, "invaliduser");
+ } catch (ActionException wae) {
+ Assert.assertEquals(wae.getErrorCode(),
+ ActionErrorConstants.ACTION_CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ Assert.assertEquals(wae.getDescription(),
+ "Can not check in versionable entity Action with id " + action1Id +
+ " since it is checked out by other user: " + USER1 + ".");
+ }
+ }
+
+ @Test(dependsOnMethods = {"testCheckOut"})
+ public void testSubmitOnCheckout() {
+ try {
+ actionManager.submit(action1Id, USER1);
+ } catch (ActionException wae) {
+ Assert.assertEquals(wae.getErrorCode(),
+ ActionErrorConstants.ACTION_SUBMIT_LOCKED_ENTITY_NOT_ALLOWED);
+ Assert.assertEquals(wae.getDescription(), "Versionable entity Action with id " + action1Id +
+ " can not be submitted since it is currently locked by user " + USER1 + ".");
+ }
+ }
+
+ @Test(dependsOnMethods = {"testCheckOut"})
+ public void testUndoCheckout() {
+ final Version VERSION11 = new Version(1, 1);
+ actionManager.undoCheckout(action1Id, USER1);
+ Action action = new Action();
+ action.setActionInvariantUuId(action1Id);
+ action.setVersion(VERSION11.toString());
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ Assert.assertNull(existingActionEntity);
+ }
+
+ @Test
+ public void testUndoCheckoutOnCreate() {
+ Action action = actionManager.createAction(createAction(ACTION_6), USER1);
+ actionManager.undoCheckout(action.getActionInvariantUuId(), USER1);
+ ActionEntity existingActionEntity = actionDao.get(action.toEntity());
+ Assert.assertNull(existingActionEntity);
+ }
+
+ @Test
+ public void testGetECOMPComponents() {
+ List<EcompComponent> componentList = actionManager.getEcompComponents();
+ List<EcompComponent> expectedComponentList = new ArrayList<>();
+ expectedComponentList.add(new EcompComponent("MSO", "COMP-1"));
+ expectedComponentList.add(new EcompComponent("APP-C", "COMP-2"));
+ for (EcompComponent e : componentList) {
+ boolean res = expectedComponentList.contains(e);
+ Assert.assertEquals(res, true);
+ }
+ }
+
+ @Test
+ public void testgetActionsByActionUUID_Negative() {
+ try {
+ Action action = actionManager.getActionsByActionUuId("");
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ }
+ }
+
+ @Test(dependsOnMethods = {"createTest"})
+ public void testgetActionsByActionUUID() {
+ Action action = actionManager.getActionsByActionUuId(actionUUId);
+ Assert.assertNotNull(action.getData());
+ }
+
+ @Test
+ public void testGetByCategory() {
+ createActionVersions(ACTION_2);
+ createActionVersions(ACTION_3);
+ createActionVersions(ACTION_4);
+ createActionVersions(ACTION_5);
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_CATEGORY, "CAT-teSt");
+
+ List<String> actualNameVersionList = new ArrayList<String>();
+ List<String> expectedNameVersionList = new ArrayList<String>();
+ expectedNameVersionList.add("Test_Action4_list:2.2");
+ expectedNameVersionList.add("Test_Action4_list:2.0");
+ expectedNameVersionList.add("Test_Action2_list:2.2");
+ expectedNameVersionList.add("Test_Action2_list:2.0");
+ for (Action action : actions) {
+ System.out.println("action by category is::::");
+ System.out.println(action.getName() + " " + action.getVersion());
+ actualNameVersionList.add(action.getName() + ":" + action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedNameVersionList, actualNameVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByCategory"})
+ public void testGetByVendor() {
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_VENDOR, "VendOr-tESt");
+
+ List<String> actualNameVersionList = new ArrayList<String>();
+ List<String> expectedNameVersionList = new ArrayList<String>();
+ expectedNameVersionList.add("Test_Action5_list:2.2");
+ expectedNameVersionList.add("Test_Action5_list:2.0");
+ expectedNameVersionList.add("Test_Action3_list:2.2");
+ expectedNameVersionList.add("Test_Action3_list:2.0");
+ for (Action action : actions) {
+ System.out.println("action by category is::::");
+ System.out.println(action.getName() + " " + action.getVersion());
+ actualNameVersionList.add(action.getName() + ":" + action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedNameVersionList, actualNameVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByCategory"})
+ public void testGetBySupportedModel() {
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_MODEL, "MODEL-tEst");
+
+ List<String> actualNameVersionList = new ArrayList<>();
+ List<String> expectedNameVersionList = new ArrayList<>();
+ expectedNameVersionList.add("Test_Action4_list:2.2");
+ expectedNameVersionList.add("Test_Action4_list:2.0");
+ expectedNameVersionList.add("Test_Action2_list:2.2");
+ expectedNameVersionList.add("Test_Action2_list:2.0");
+ for (Action action : actions) {
+ actualNameVersionList.add(action.getName() + ":" + action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedNameVersionList, actualNameVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByCategory"})
+ public void testGetBySupportedComponent() {
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_ECOMP_COMPONENT, "mso");
+
+ List<String> actualNameVersionList = new ArrayList<>();
+ List<String> expectedNameVersionList = new ArrayList<>();
+ expectedNameVersionList.add("Test_Action5_list:2.2");
+ expectedNameVersionList.add("Test_Action5_list:2.0");
+ expectedNameVersionList.add("Test_Action3_list:2.2");
+ expectedNameVersionList.add("Test_Action3_list:2.0");
+ for (Action action : actions) {
+ actualNameVersionList.add(action.getName() + ":" + action.getVersion());
+ }
+ Assert.assertEquals(4, actions.size());
+ Assert.assertEquals(expectedNameVersionList, actualNameVersionList);
+ }
+
+ @Test(dependsOnMethods = {"testGetByCategory"})
+ public void testGetAllActions() {
+ List<Action> actions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_NONE, "MSO");
+
+ List<String> actualNameVersionList = new ArrayList<>();
+ List<String> expectedNameVersionList = new ArrayList<>();
+
+ expectedNameVersionList.add("Test_Action5_list:2.2");
+ expectedNameVersionList.add("Test_Action5_list:2.0");
+ expectedNameVersionList.add("Test_Action3_list:2.2");
+ expectedNameVersionList.add("Test_Action3_list:2.0");
+ expectedNameVersionList.add("Test_Action4_list:2.2");
+ expectedNameVersionList.add("Test_Action4_list:2.0");
+ expectedNameVersionList.add("Test_Action2_list:2.2");
+ expectedNameVersionList.add("Test_Action2_list:2.0");
+ for (Action action : actions) {
+ actualNameVersionList.add(action.getName() + ":" + action.getVersion());
+ }
+ Assert.assertEquals(8, actions.size());
+
+ for (String s : actualNameVersionList) {
+ boolean res = expectedNameVersionList.contains(s);
+ Assert.assertEquals(res, true);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testGetAllActions"})
+ public void testDeleteCheckedOutAction_Negative() {
+ try {
+ initDeleteActionTest();
+ String deleteActionInvariantId = deleteAction.getActionInvariantUuId();
+ actionManager.deleteAction(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_DELETE_ON_LOCKED_ENTITY_CODE);
+ Assert.assertEquals(e.getDescription(), String.format(
+ "Can not delete versionable entity Action with id %s since it is checked out by other user: %s",
+ deleteAction.getActionInvariantUuId(), USER1 + "."));
+ }
+ }
+
+ @Test(dependsOnMethods = {"testDeleteCheckedOutAction_Negative"})
+ public void testDeleteAction() {
+ try {
+ String deleteActionInvariantId = deleteAction.getActionInvariantUuId();
+ actionManager.checkin(deleteActionInvariantId, USER1);
+ actionManager.deleteAction(deleteActionInvariantId, USER1);
+ } catch (ActionException e) {
+ Assert.fail("Delete action test failed with exception : " + e.getDescription());
+ }
+ }
+
+ @Test(dependsOnMethods = {"testDeleteAction"})
+ public void testDeletedActionVersioningOperations_Negative() {
+ String deleteActionInvariantId = deleteAction.getActionInvariantUuId();
+ try {
+ actionManager.checkout(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ try {
+ actionManager.checkin(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ try {
+ actionManager.submit(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ try {
+ actionManager.undoCheckout(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ try {
+ actionManager.deleteAction(deleteActionInvariantId, USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testDeleteAction"})
+ public void testCreateActionWithDeletedActionName_Negative() {
+ try {
+ actionManager.createAction(createAction(ACTION_TEST_DELETE), USER1);
+ Assert.fail();
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_ERROR);
+ Assert.assertEquals(e.getDescription(), String
+ .format(ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_MSG, ActionConstants.UniqueValues.ACTION_NAME,
+ deleteAction.getName()));
+ }
+ }
+
+ @Test(dependsOnMethods = {"testDeleteAction"})
+ public void testDeletedActionGetQueries() {
+ String deleteActionInvariantId = deleteAction.getActionInvariantUuId();
+ List<Action> invariantFetchResults =
+ actionManager.getActionsByActionInvariantUuId(deleteActionInvariantId);
+ Assert.assertEquals(invariantFetchResults.size(), 3);
+ for (Action a : invariantFetchResults) {
+ Assert.assertEquals(a.getStatus(), ActionStatus.Deleted);
+ }
+
+ Action actionUUIDFetchResult =
+ actionManager.getActionsByActionUuId(deleteAction.getActionUuId());
+ Assert.assertEquals(actionUUIDFetchResult.getStatus(), ActionStatus.Deleted);
+
+ List<Action> nameFetchResults =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_NAME, "Test_Delete_Action");
+ Assert.assertEquals(nameFetchResults.size(), 3);
+ for (Action a : nameFetchResults) {
+ Assert.assertEquals(a.getStatus(), ActionStatus.Deleted);
+ }
+
+ List<Action> filteredActions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_VENDOR, "Vendor-Delete");
+ Assert.assertEquals(filteredActions.size(), 0);
+ filteredActions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_CATEGORY, "Cat-Delete-test");
+ Assert.assertEquals(filteredActions.size(), 0);
+ filteredActions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_ECOMP_COMPONENT, "MSO-delete");
+ Assert.assertEquals(filteredActions.size(), 0);
+ filteredActions =
+ actionManager.getFilteredActions(ActionConstants.FILTER_TYPE_MODEL, "Model-Delete");
+ Assert.assertEquals(filteredActions.size(), 0);
+ }
+
+ /***
+ * ACTION ARTIFACT OPERATION TEST CASES
+ ***/
+
+ @Test
+ public void testUploadArtifact() {
+ actionArtifact = new ActionArtifact();
+ File resourceFile = new File(
+ this.getClass().getClassLoader().getResource(ACTION_TEST_ARTIFACT_FILE_NAME).getPath());
+ FileInputStream fileInputStream;
+ //Create payload from the test resource file
+ byte[] payload = new byte[(int) resourceFile.length()];
+ try {
+ fileInputStream = new FileInputStream(resourceFile);
+ fileInputStream.read(payload);
+ fileInputStream.close();
+ actionArtifact.setArtifact(payload);
+ actionArtifact.setArtifactName(ACTION_TEST_ARTIFACT_FILE_NAME);
+ actionArtifact.setArtifactLabel("Test Artifact Label");
+ actionArtifact.setArtifactDescription("Test Artifact Description");
+ actionArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ //Create action for artifact upload test
+ testArtifactAction = actionManager.createAction(createAction(ARTIFACT_TEST_ACTION), USER1);
+ //Generate Expected artifact UUID
+ expectedArtifactUUID =
+ generateActionArtifactUUID(testArtifactAction, ACTION_TEST_ARTIFACT_FILE_NAME);
+ //Upload the artifact
+ ActionArtifact response = actionManager
+ .uploadArtifact(actionArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ //Validate if generated and the expected artifact UUID is same
+ Assert.assertEquals(expectedArtifactUUID, response.getArtifactUuId());
+ //Fetch the data field of the updated action version
+ Action updatedAction = actionManager.getActionsByActionUuId(testArtifactAction.getActionUuId());
+ List<ActionArtifact> updatedArtifactList = updatedAction.getArtifacts();
+ for (ActionArtifact artifact : updatedArtifactList) {
+ //Validate the artifact metadata
+ Assert.assertEquals(artifact.getArtifactName(), actionArtifact.getArtifactName());
+ Assert.assertEquals(artifact.getArtifactLabel(), actionArtifact.getArtifactLabel());
+ Assert
+ .assertEquals(artifact.getArtifactDescription(), actionArtifact.getArtifactDescription());
+ Assert.assertEquals(artifact.getArtifactProtection(), actionArtifact.getArtifactProtection());
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUploadArtifactInvalidActionInvId_negative() {
+ ActionArtifact testArtifact = new ActionArtifact();
+ testArtifact.setArtifact("testData".getBytes());
+ testArtifact.setArtifactName(ACTION_TEST_ARTIFACT_FILE_NAME);
+ try {
+ actionManager.uploadArtifact(testArtifact, "INVALID_UUID", USER1);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(ae.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUploadArtifactSameName_negative() {
+ try {
+ actionManager
+ .uploadArtifact(actionArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS_CODE);
+ Assert.assertEquals(ae.getDescription(), String
+ .format(ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS, testArtifactAction.getActionInvariantUuId()));
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUploadArtifactCheckedOutOtherUser_negative() {
+ try {
+ actionManager
+ .uploadArtifact(actionArtifact, testArtifactAction.getActionInvariantUuId(), USER2);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ Assert.assertEquals(ae.getDescription(),
+ "Versionable entity Action with id " + testArtifactAction.getActionInvariantUuId() +
+ " can not be updated since it is locked by other user " + USER1 + ".");
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUploadArtifactUnlockedAction_negative() {
+ try {
+ testArtifactAction =
+ actionManager.checkin(testArtifactAction.getActionInvariantUuId(), USER1);
+ actionManager
+ .uploadArtifact(actionArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_UPDATE_ON_UNLOCKED_ENTITY);
+ Assert.assertEquals(ae.getDescription(), "Can not update versionable entity Action with id " +
+ testArtifactAction.getActionInvariantUuId() + " since it is not checked out.");
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testDownloadArtifact() {
+ String actionUUID = testArtifactAction.getActionUuId();
+ ActionArtifact response = actionManager.downloadArtifact(actionUUID, expectedArtifactUUID);
+ Assert.assertEquals(actionArtifact.getArtifactName(), response.getArtifactName());
+ Assert.assertEquals(actionArtifact.getArtifact(), response.getArtifact());
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testDownloadArtifactNegativeInvalidArtifact() {
+ String actionUUID = testArtifactAction.getActionUuId();
+ String artifactUUID = "negativeArtifact";
+ try {
+ ActionArtifact response = actionManager.downloadArtifact(actionUUID, artifactUUID);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE);
+ }
+
+ }
+
+ @Test
+ public void testDownloadArtifactNegativeInvalidAction() {
+ String actionUUID = "NegativeAction";
+ try {
+ ActionArtifact response = actionManager.downloadArtifact(actionUUID, expectedArtifactUUID);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ }
+
+ }
+
+ @Test
+ public void testDeleteArtifactInvalidActInvId() {
+ try {
+ actionManager.deleteArtifact("action2Id", "1234", USER1);
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE);
+ Assert.assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testGetByInvIdOnCreate"})
+ public void testDeleteArtifactInvalidArtifactUUID() {
+ try {
+ actionManager.deleteArtifact(action2Id, "1234", USER1);
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(),
+ ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE);
+ Assert
+ .assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testDeleteReadOnlyArtifact() {
+ ActionArtifact testArtifact = null;
+ String artifactUUID = null;
+ try {
+ testArtifact = new ActionArtifact();
+ testArtifact.setArtifact("testData".getBytes());
+ testArtifact.setArtifactProtection(ActionArtifactProtection.readOnly.name());
+ testArtifact.setArtifactName("TestRO.txt");
+ actionManager
+ .uploadArtifact(testArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ artifactUUID = testArtifact.getArtifactUuId();
+ actionManager.deleteArtifact(testArtifactAction.getActionInvariantUuId(),
+ testArtifact.getArtifactUuId(), USER1);
+
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(), ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY);
+ Assert.assertEquals(e.getDescription(),
+ ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY_MSG);
+ }
+
+ //cleanup uploaded document after test
+ testArtifact = new ActionArtifact();
+ testArtifact.setArtifactUuId(artifactUUID);
+ testArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ actionManager.updateArtifact(testArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ actionManager
+ .deleteArtifact(testArtifactAction.getActionInvariantUuId(), testArtifact.getArtifactUuId(),
+ USER1);
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testDeleteArtifactLockedByOtherUser() {
+ try {
+ actionManager.deleteArtifact(testArtifactAction.getActionInvariantUuId(),
+ actionArtifact.getArtifactUuId(), USER2);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER_CODE);
+ Assert.assertEquals(ae.getDescription(),
+ String.format(ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER, USER1));
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifactUnlockedAction_negative"})
+ public void testDeleteArtifactOnUnlockedAction() {
+ try {
+ actionManager.deleteArtifact(testArtifactAction.getActionInvariantUuId(),
+ actionArtifact.getArtifactUuId(), USER1);
+ } catch (ActionException ae) {
+ Assert.assertEquals(ae.getErrorCode(), ActionErrorConstants.ACTION_NOT_LOCKED_CODE);
+ Assert.assertEquals(ae.getDescription(), ActionErrorConstants.ACTION_NOT_LOCKED_MSG);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testDeleteArtifact() {
+ try {
+ ActionArtifact testArtifact = new ActionArtifact();
+ testArtifact.setArtifact("testData".getBytes());
+ testArtifact.setArtifactName("Test_ToBeDel.txt");
+ testArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ actionManager
+ .uploadArtifact(testArtifact, testArtifactAction.getActionInvariantUuId(), USER1);
+ actionManager.deleteArtifact(testArtifactAction.getActionInvariantUuId(),
+ testArtifact.getArtifactUuId(), USER1);
+ ActionArtifact response = actionManager
+ .downloadArtifact(testArtifactAction.getActionUuId(), testArtifact.getArtifactUuId());
+ } catch (ActionException e) {
+ Assert.assertEquals(e.getErrorCode(),
+ ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE);
+ Assert
+ .assertEquals(e.getDescription(), ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUpdateArtifact() {
+ ActionArtifact updatedArtifact = new ActionArtifact();
+ File resourceFile = new File(
+ this.getClass().getClassLoader().getResource(ACTION_TEST_UPDATE_ARTIFACT_FILE_NAME)
+ .getPath());
+ FileInputStream fileInputStream;
+ //Create payload from the test resource file
+ byte[] payload = new byte[(int) resourceFile.length()];
+ try {
+ fileInputStream = new FileInputStream(resourceFile);
+ fileInputStream.read(payload);
+ fileInputStream.close();
+ updatedArtifact.setArtifactUuId(
+ generateActionArtifactUUID(testArtifactAction, ACTION_TEST_ARTIFACT_FILE_NAME));
+ updatedArtifact.setArtifact(payload);
+ updatedArtifact.setArtifactName(ACTION_TEST_ARTIFACT_FILE_NAME);
+ updatedArtifact.setArtifactLabel("Test Artifact Update Label");
+ updatedArtifact.setArtifactDescription("Test Artifact Update Description");
+ updatedArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ String actionInvarientUUID = testArtifactAction.getActionInvariantUuId();
+ actionManager.updateArtifact(updatedArtifact, actionInvarientUUID, USER1);
+
+ String actionUUID = testArtifactAction.getActionUuId();
+ Action action = actionManager.getActionsByActionUuId(actionUUID);
+ List<ActionArtifact> artifacts = action.getArtifacts();
+ for (ActionArtifact actionArtifact : artifacts) {
+ Assert.assertEquals(actionArtifact.getArtifactName(), updatedArtifact.getArtifactName());
+ Assert.assertEquals(actionArtifact.getArtifactLabel(), updatedArtifact.getArtifactLabel());
+ Assert.assertEquals(actionArtifact.getArtifactDescription(),
+ updatedArtifact.getArtifactDescription());
+ Assert.assertEquals(actionArtifact.getArtifactProtection(),
+ updatedArtifact.getArtifactProtection());
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUpdateArtifact_ArtifactNotPresent_Negative() {
+ ActionArtifact invalidActionArtifact = new ActionArtifact();
+ String artifactUUID = generateActionArtifactUUID(testArtifactAction, "ArtifactNotPresent");
+ invalidActionArtifact.setArtifactUuId(artifactUUID);
+ try {
+ actionManager
+ .updateArtifact(invalidActionArtifact, testArtifactAction.getActionInvariantUuId(),
+ USER1);
+ } catch (ActionException actionException) {
+ Assert.assertEquals(actionException.getDescription(), ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ public void testUpdateArtifact_ArtifactNameUpdate_Negative() {
+ String invariantUUID = testArtifactAction.getActionInvariantUuId();
+ ActionArtifact artifactToUpdate = new ActionArtifact();
+ artifactToUpdate.setArtifactUuId(actionArtifact.getArtifactUuId());
+ artifactToUpdate.setArtifactName("UpdatingName");
+
+ try {
+ actionManager.updateArtifact(artifactToUpdate, invariantUUID, USER1);
+ } catch (ActionException actionException) {
+ Assert.assertEquals(actionException.getDescription(), ActionErrorConstants.ACTION_ARTIFACT_UPDATE_NAME_INVALID);
+ }
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ void testUpdateArtifact_CheckoutByOtherUser_Negative() {
+ String invariantUUID = testArtifactAction.getActionInvariantUuId();
+ ActionArtifact artifactToUpdate = new ActionArtifact();
+ artifactToUpdate.setArtifactUuId(actionArtifact.getArtifactUuId());
+ artifactToUpdate.setArtifactLabel("CheckoutbyOtherUser label");
+
+ try {
+ actionManager.updateArtifact(artifactToUpdate, invariantUUID, USER2);
+ } catch (ActionException actionException) {
+ Assert
+ .assertEquals(actionException.getErrorCode(), ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER);
+ Assert.assertEquals(actionException.getDescription(),
+ "Versionable entity Action with id " + invariantUUID +
+ " can not be updated since it is locked by other user " + USER1 + ".");
+ }
+ System.out.println("asdf");
+ }
+
+ @Test(dependsOnMethods = {"testUploadArtifact"})
+ void testUpdateArtifact_ArtifactProtectionReadOnly_CanNotUpdate_Negative() {
+ String invariantUUID = testArtifactAction.getActionInvariantUuId();
+ ActionArtifact artifactToUpdate = new ActionArtifact();
+ artifactToUpdate.setArtifactUuId(actionArtifact.getArtifactUuId());
+ artifactToUpdate.setArtifactProtection(ActionArtifactProtection.readOnly.name());
+ actionManager.updateArtifact(artifactToUpdate, invariantUUID, USER1);
+
+ artifactToUpdate.setArtifactLabel("test label");
+ artifactToUpdate.setArtifactDescription("test description");
+ artifactToUpdate.setArtifactProtection(ActionArtifactProtection.readWrite.name());
+ try {
+ actionManager.updateArtifact(artifactToUpdate, invariantUUID, USER1);
+ } catch (ActionException actionExecption) {
+ Assert.assertEquals(actionExecption.getDescription(), ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG);
+ }
+ }
+
+ // Function which will take action as input string and create action
+ // After create multiple versions of same action
+ // Final versions :1.0, 2.0
+ // Last minor version :2.2
+ // Candidate version :2.3
+ private void createActionVersions(String input) {
+ Action action1 = createAction(input);
+ Action action = actionManager.createAction(action1, USER1);
+ String Id = action.getActionInvariantUuId();
+
+ actionManager.checkin(Id, USER1);
+ actionManager.submit(Id, USER1); // 1.0
+ actionManager.checkout(Id, USER1);
+ actionManager.checkin(Id, USER1);
+ actionManager.submit(Id, USER1);//2.0
+ actionManager.checkout(Id, USER1);
+ actionManager.checkin(Id, USER1);
+ actionManager.checkout(Id, USER1);
+ actionManager.checkin(Id, USER1); //2.2
+ actionManager.checkout(Id, USER1); //2.3 candidate
+ }
+
+ private Action updateData(Action action) {
+ Map<String, String> dataMap = new LinkedHashMap<>();
+ dataMap.put(ActionConstants.UNIQUE_ID, action.getActionUuId());
+ dataMap.put(ActionConstants.VERSION, action.getVersion());
+ dataMap.put(ActionConstants.INVARIANTUUID, action.getActionInvariantUuId());
+ dataMap.put(ActionConstants.STATUS, ActionStatus.Locked.name());
+
+ String data = action.getData();
+ Map<String, String> currentDataMap = JsonUtil.json2Object(data, LinkedHashMap.class);
+ dataMap.putAll(currentDataMap);
+ data = JsonUtil.object2Json(dataMap);
+ action.setData(data);
+ return action;
+ }
+
+ private void initDeleteActionTest() {
+ deleteAction = actionManager.createAction(createAction(ACTION_TEST_DELETE), USER1);
+ String deleteActionInvariantId = deleteAction.getActionInvariantUuId();
+ actionManager.checkin(deleteActionInvariantId, USER1);
+ actionManager.submit(deleteActionInvariantId, USER1); // 1.0
+ actionManager.checkout(deleteActionInvariantId, USER1);
+ actionManager.checkin(deleteActionInvariantId, USER1);
+ actionManager.submit(deleteActionInvariantId, USER1);//2.0
+ actionManager.checkout(deleteActionInvariantId, USER1);
+ }
+
+ private int getEffectiveVersion(String actionVersion) {
+ Version version = Version.valueOf(actionVersion);
+ return version.getMajor() * 10000 + version.getMinor();
+ }
+
+ private String generateActionArtifactUUID(Action action, String artifactName) {
+ int effectiveVersion = getEffectiveVersion(action.getVersion());
+ //Upper case for maintaining case-insensitive behavior for the artifact names
+ String artifactUUIDString =
+ action.getName().toUpperCase() + effectiveVersion + artifactName.toUpperCase();
+ String generateArtifactUUID =
+ UUID.nameUUIDFromBytes((artifactUUIDString).getBytes()).toString();
+ String artifactUUID = generateArtifactUUID.replace("-", "");
+ return artifactUUID.toUpperCase();
+ }
+
+}
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_file.txt b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_file.txt
new file mode 100644
index 0000000000..15752ea310
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_file.txt
@@ -0,0 +1,2 @@
+Upload_Artifacts.
+The test verifies uploading an artifact when action status is locked. \ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_update_file.txt b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_update_file.txt
new file mode 100644
index 0000000000..940aedfc85
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/resources/test_artifact_update_file.txt
@@ -0,0 +1,2 @@
+Update_Artifacts.
+The test verifies updating an artifact when action status is locked. \ No newline at end of file