diff options
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-action-manager/src')
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 |