openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/impl/ActionManagerImplTest.java

   1 /*
   2  *
   3  *  Copyright © 2017-2018 European Support Limited
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  * Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  */
  18
  19 package org.openecomp.sdc.action.impl;
  20
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.junit.runner.RunWith;
  25 import org.mockito.Matchers;
  26 import org.mockito.Mock;
  27 import org.mockito.Mockito;
  28 import org.mockito.MockitoAnnotations;
  29 import org.mockito.runners.MockitoJUnitRunner;
  30 import org.openecomp.core.dao.UniqueValueDao;
  31 import org.openecomp.sdc.action.ActionConstants;
  32 import org.openecomp.sdc.action.dao.ActionArtifactDao;
  33 import org.openecomp.sdc.action.dao.ActionDao;
  34 import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
  35 import org.openecomp.sdc.action.dao.types.ActionEntity;
  36 import org.openecomp.sdc.action.errors.ActionException;
  37 import org.openecomp.sdc.action.types.Action;
  38 import org.openecomp.sdc.action.types.ActionArtifact;
  39 import org.openecomp.sdc.action.types.ActionArtifactProtection;
  40 import org.openecomp.sdc.action.types.ActionStatus;
  41 import org.openecomp.sdc.action.types.OpenEcompComponent;
  42 import org.openecomp.sdc.common.errors.CoreException;
  43 import org.openecomp.sdc.common.errors.ErrorCode;
  44 import org.openecomp.sdc.versioning.ActionVersioningManager;
  45 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
  46 import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
  47 import org.openecomp.sdc.versioning.dao.types.Version;
  48 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  49 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
  50 import org.openecomp.sdc.versioning.types.VersionInfo;
  51
  52 import java.util.ArrayList;
  53 import java.util.Date;
  54 import java.util.HashMap;
  55 import java.util.List;
  56 import java.util.Map;
  57
  58 import static org.mockito.Matchers.any;
  59 import static org.mockito.Matchers.anyInt;
  60 import static org.mockito.Matchers.anyString;
  61 import static org.mockito.Mockito.doReturn;
  62 import static org.mockito.Mockito.times;
  63 import static org.mockito.Mockito.when;
  64
  65 @RunWith(MockitoJUnitRunner.class)
  66 public class ActionManagerImplTest {
  67
  68     @Mock
  69     private ActionDao actionDao;
  70     @Mock
  71     private ActionVersioningManager versioningManager;
  72     @Mock
  73     private  ActionArtifactDao actionArtifactDao;
  74     @Mock
  75     private VersionInfoDao versionInfoDao;
  76     @Mock
  77     private UniqueValueDao uniqueValueDao;
  78
  79     private ActionManagerImpl actionManager;
  80
  81     @Before
  82     public void init() {
  83         MockitoAnnotations.initMocks(this);
  84         actionManager = new ActionManagerImpl(actionDao, versioningManager, actionArtifactDao,
  85             versionInfoDao, uniqueValueDao);
  86     }
  87
  88     @Test
  89     public void testCreateAction() {
  90       Action action = createAction();
  91       Version version = createVersion();
  92       doReturn(version).when(versioningManager).create(anyString(), anyString(), anyString());
  93       doReturn(action).when(actionDao).createAction(any());
  94       actionManager.createAction(action, "USER");
  95       Mockito.verify(actionDao,times(1)).createAction(any());
  96     }
  97
  98     @Test
  99    public void testGetActionsByActionInvariantUuIdShouldPass() {
 100         String invariantId = "invariantId";
 101         Mockito.when(actionDao.getActionsByActionInvariantUuId(invariantId.toUpperCase())).thenReturn(mockActionsToReturn());
 102         List<Action> actions = actionManager.getActionsByActionInvariantUuId(invariantId);
 103         Assert.assertEquals(1, actions.size());
 104     }
 105
 106     @Test(expected = ActionException.class)
 107     public void testGetActionsByActionInvariantUuIdShouldThrowExceptionWhenReturnedActionsOrEmptyOrNull() {
 108         String invariantId = "invariantId";
 109         Mockito.when(actionDao.getActionsByActionInvariantUuId(invariantId.toUpperCase())).thenReturn(new ArrayList<>());
 110         actionManager.getActionsByActionInvariantUuId(invariantId);
 111
 112     }
 113
 114     @Test
 115     public void testGetFilteredActionsShouldPassForFilterTypeName() {
 116         Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
 117                 .thenReturn(mockActionsToReturn());
 118         List<Action> actions = actionManager.getFilteredActions("NAME", ActionConstants.FILTER_TYPE_NAME );
 119         Assert.assertEquals(1, actions.size());
 120     }
 121
 122     @Test(expected = ActionException.class)
 123     public void testGetFilteredActionsShouldThrowExceptionForFilterTypeNameWhenReturnedActionsOrEmptyOrNull() {
 124         Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
 125                 .thenReturn(new ArrayList<>());
 126         actionManager.getFilteredActions("NAME", ActionConstants.FILTER_TYPE_NAME );
 127     }
 128
 129     @Test
 130     public void testGetFilteredActionsByMajorMinorVersionShouldPassWithActiveVersion() {
 131         Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
 132                 .thenReturn(mockActionsToReturn());
 133
 134         Map<String, VersionInfo> actionVersionMap = new HashMap<>();
 135         VersionInfo versionInfo = createVersionInfo();
 136         actionVersionMap.put("uuid", versionInfo);
 137
 138         Mockito.when(versioningManager.listEntitiesVersionInfo(Matchers.anyString(),
 139                 Matchers.anyString(), Matchers.any())).thenReturn(actionVersionMap);
 140         List<Action> actions = actionManager.getFilteredActions("type", ActionConstants.FILTER_TYPE_NAME );
 141         Assert.assertEquals(1, actions.size());
 142     }
 143
 144     @Test
 145     public void testGetFilteredActionsByMajorMinorVersionShouldPassWithLatestFinalVersion() {
 146         Mockito.when(actionDao.getFilteredActions(Matchers.anyString(), Matchers.anyString()))
 147                 .thenReturn(mockActionsToReturn());
 148
 149         Map<String, VersionInfo> actionVersionMap = new HashMap<>();
 150         VersionInfo versionInfo = createVersionInfo();
 151         actionVersionMap.put("uuid", versionInfo);
 152
 153         Mockito.when(versioningManager.listEntitiesVersionInfo(Matchers.anyString(),
 154                 Matchers.anyString(), Matchers.any())).thenReturn(actionVersionMap);
 155         List<Action> actions = actionManager.getFilteredActions("type", ActionConstants.FILTER_TYPE_NAME );
 156         Assert.assertEquals(1, actions.size());
 157     }
 158
 159     @Test
 160     public void testGetActionsByActionUuIdShouldPassIfReturnedActionsAreNotNull() {
 161         String actionUuId = "actionUuId";
 162         Mockito.when(actionDao.getActionsByActionUuId(actionUuId.toUpperCase()))
 163                 .thenReturn(new Action());
 164         Assert.assertNotNull(actionManager.getActionsByActionUuId(actionUuId));
 165     }
 166
 167     @Test(expected = ActionException.class)
 168     public void testGetActionsByActionUuIdShouldThrowExceptionIfReturnedActionsAreNull() {
 169         String actionUuId = "actionUuId";
 170         Mockito.when(actionDao.getActionsByActionUuId(actionUuId.toUpperCase()))
 171                 .thenReturn(null);
 172         actionManager.getActionsByActionUuId(actionUuId);
 173     }
 174
 175     @Test
 176     public void testGetOpenEcompComponents() {
 177         ArrayList<OpenEcompComponent> ecompComponents = new ArrayList<>();
 178         ecompComponents.add(new OpenEcompComponent());
 179         Mockito.when(actionDao.getOpenEcompComponents())
 180                 .thenReturn(ecompComponents);
 181         Assert.assertEquals(1, actionManager.getOpenEcompComponents().size());
 182     }
 183
 184     @Test
 185     public void testDeleteActionShouldPassIfDeleteMethodGeCallsOneTime() {
 186         String actionInvariantUuId = "actionInvariantUuId";
 187         String user = "user";
 188
 189         actionManager.deleteAction(actionInvariantUuId, user);
 190
 191         Mockito.verify(versioningManager, times(1)).delete(anyString(), anyString(), anyString());
 192         Mockito.verify(actionDao, times(1)).deleteAction(anyString());
 193     }
 194
 195     @Test
 196     public void testUpdateActionShouldUpdateActionSuccessfully() {
 197         Action action = new Action();
 198         action.setActionInvariantUuId("actionInvId");
 199         action.setName("actionToupdate");
 200         action.setData("{actionInvariantUuId : actionInvariantUuId, name : actionToupdate}");
 201         VersionInfo versionInfo = createVersionInfo();
 202         Version activeVersion = new Version("2.1");
 203
 204         versionInfo.setActiveVersion(activeVersion);
 205         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 206                 .thenReturn(versionInfo);
 207
 208         ActionEntity actionEntity = createActionEntity();
 209
 210         when(actionDao.get(any())).thenReturn(actionEntity);
 211         actionManager.updateAction(action, "user");
 212         Mockito.verify(actionDao, times(1)).updateAction(any());
 213     }
 214
 215     @Test(expected = ActionException.class)
 216     public void testUpdateActionShouldThrowExceptionIfToUpdateAndExistingActionNameIsNotSame() {
 217         Action action = createAction();
 218         VersionInfo versionInfo = createVersionInfo();
 219         Version activeVersion = new Version("2.1");
 220
 221         versionInfo.setActiveVersion(activeVersion);
 222         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 223                 .thenReturn(versionInfo);
 224        actionManager.updateAction(action, "user");
 225     }
 226
 227     @Test
 228     public void testCheckoutShouldPassSuccessFully() {
 229         String invariantUuId = "invariantUuId";
 230         ActionEntity actionEntity = createActionEntity();
 231         when(actionDao.get(any())).thenReturn(actionEntity);
 232         Mockito.when(versioningManager.checkout(anyString(), anyString(),anyString())).thenReturn(createVersion());
 233         Action action = actionManager.checkout(invariantUuId, "user");
 234         Assert.assertNotNull(action);
 235         Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
 236
 237     }
 238
 239     @Test(expected = ActionException.class)
 240     public void testCheckoutShouldFailInCaseOfException() {
 241         String invariantUuId = "invariantUuId";
 242         Mockito.when(versioningManager.checkout(anyString(), anyString(),anyString()))
 243                 .thenThrow(new CoreException(new ErrorCode.ErrorCodeBuilder()
 244                         .withId(VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY).build()));
 245         VersionInfoEntity versionInfoEntity = createVersionInfoEntity();
 246         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 247         actionManager.checkout(invariantUuId, "user");
 248
 249     }
 250
 251     @Test
 252     public void testUndoCheckoutShouldPass() {
 253         VersionInfoEntity versionInfoEntity = createVersionInfoEntity();
 254         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 255         when(versioningManager.undoCheckout(anyString(), anyString(), anyString())).thenReturn(createVersion());
 256         ActionEntity actionEntity = createActionEntity();
 257
 258         when(actionDao.get(any(ActionEntity.class))).thenReturn(actionEntity);
 259
 260         actionManager.undoCheckout("invariantUuid", "user");
 261         Mockito.verify(actionArtifactDao, times(1)).delete(any(ActionArtifactEntity.class));
 262     }
 263
 264     @Test(expected = ActionException.class)
 265     public void testUndoCheckoutShouldThrowExceptionIfVersionInfoEntityIsNull() {
 266         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(null);
 267         actionManager.undoCheckout("invariantUuid", "user");
 268
 269     }
 270
 271     @Test
 272     public void testCheckinShouldPassForHappyScenario() {
 273         when(versioningManager.checkin(anyString(), anyString(), anyString(), Matchers.any()))
 274                 .thenReturn(createVersion());
 275         when(actionDao.get(any(ActionEntity.class))).thenReturn(createActionEntity());
 276         Assert.assertNotNull(actionManager.checkin("invariantUuid", "user"));
 277         Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
 278     }
 279
 280     @Test(expected = ActionException.class)
 281     public void testCheckinShouldShouldThrowExceptionInCaseOfAnyException() {
 282         when(versioningManager.checkin(anyString(), anyString(), anyString(), Matchers.any()))
 283                 .thenThrow((new CoreException(new ErrorCode.ErrorCodeBuilder()
 284                         .withId(VersioningErrorCodes.CHECKIN_ON_UNLOCKED_ENTITY).build())));
 285         actionManager.checkin("invariantUuid", "user");
 286     }
 287
 288     @Test
 289     public void testSubmitShouldPassForHappyScenario() {
 290         when(versioningManager.submit(anyString(), anyString(), anyString(), Matchers.any()))
 291                 .thenReturn(createVersion());
 292         when(actionDao.get(any(ActionEntity.class))).thenReturn(createActionEntity());
 293
 294         Assert.assertNotNull( actionManager.submit("invariantUuid", "user"));
 295
 296         Mockito.verify(actionDao, times(1)).update(Matchers.any(ActionEntity.class));
 297     }
 298
 299     @Test(expected = ActionException.class)
 300     public void testSubmitShouldThrowExceptionForAnyException() {
 301         when(versioningManager.submit(anyString(), anyString(), anyString(), Matchers.any()))
 302                 .thenThrow((new CoreException(new ErrorCode.ErrorCodeBuilder()
 303                         .withId(VersioningErrorCodes.SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED).build())));
 304         actionManager.submit("invariantUuid", "user");
 305     }
 306
 307
 308     @Test
 309     public void testDownloadArtifactShouldPassForHappyScenario() {
 310         Action action = createAction();
 311         action.setVersion("2.1");
 312         when(actionDao.getActionsByActionUuId(anyString())).thenReturn(action);
 313         when(actionArtifactDao.downloadArtifact(anyInt(), anyString())).thenReturn(new ActionArtifact());
 314         Assert.assertNotNull(actionManager.downloadArtifact("actionUuId", "artifactUuId"));
 315     }
 316
 317     @Test(expected = ActionException.class)
 318     public void testDownloadArtifactShouldThrowExceptionIfActionIsNull() {
 319
 320         when(actionDao.getActionsByActionUuId(anyString())).thenReturn(null);
 321         actionManager.downloadArtifact("actionUuId", "artifactUuId");
 322     }
 323
 324     @Test
 325     public void testUploadArtifactShouldPassForHappyScenario() {
 326         ActionArtifact artifact = createActionArtifact();
 327         artifact.setArtifactName("artifactNameToUpload");
 328         VersionInfo versionInfo = createVersionInfo();
 329         Version activeVersion = new Version("2.1");
 330         versionInfo.setActiveVersion(activeVersion);
 331         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 332                 .thenReturn(versionInfo);
 333         when(actionDao.get(any())).thenReturn(createActionEntity());
 334         Assert.assertNotNull(actionManager.uploadArtifact(artifact, "actionInvariantUuId", "user"));
 335
 336         Mockito.verify(actionArtifactDao, times(1)).uploadArtifact(any(ActionArtifact.class));
 337         Mockito.verify(actionDao, times(1)).updateAction(any(Action.class));
 338
 339     }
 340
 341     @Test(expected = ActionException.class)
 342     public void testUploadArtifactShouldThrowExceptionIfArtifactAlreadyExist() {
 343         ActionArtifact artifact = createActionArtifact();
 344         VersionInfo versionInfo = createVersionInfo();
 345         Version activeVersion = new Version("2.1");
 346         versionInfo.setActiveVersion(activeVersion);
 347         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 348                 .thenReturn(versionInfo);
 349         when(actionDao.get(any())).thenReturn(createActionEntity());
 350         actionManager.uploadArtifact(artifact, "actionInvariantUuId", "user");
 351
 352     }
 353
 354     @Test
 355     public void testDeleteArtifactShouldPassForHappyScenario() {
 356         Action action = createAction();
 357         action.setVersion("2.1");
 358         action.getArtifacts().forEach(actionArtifact -> {
 359             actionArtifact.setArtifactUuId("86B2B1049CC13B4E9275414DBB29485C");
 360             actionArtifact.setArtifactProtection(ActionArtifactProtection.readWrite.name());
 361         });
 362         when(actionDao.getLockedAction(anyString(), anyString())).thenReturn(action);
 363         actionManager.deleteArtifact("actionInvariantUuId", "86B2B1049CC13B4E9275414DBB29485C", "user" );
 364         Mockito.verify(actionDao, times(1)).update(any(ActionEntity.class));
 365         Mockito.verify(actionArtifactDao, times(1)).delete(any(ActionArtifactEntity.class));
 366     }
 367
 368     @Test(expected = ActionException.class)
 369     public void testDeleteArtifactShouldThrowExceptionIfArtifactMetaDataIsNull() {
 370         when(actionDao.getLockedAction(anyString(), anyString())).thenReturn(createAction());
 371         actionManager.deleteArtifact("actionInvariantUuId", "86B2B1049CC13B4E9275414DBB29485C", "user" );
 372     }
 373
 374     @Test
 375     public void testUpdateArtifactShouldPassForHappyScenario() {
 376         ActionArtifact artifact = createActionArtifact();
 377         VersionInfo versionInfo = createVersionInfo();
 378         Version activeVersion = new Version("2.1");
 379         versionInfo.setActiveVersion(activeVersion);
 380         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 381                 .thenReturn(versionInfo);
 382         when(actionDao.get(any())).thenReturn(createActionEntity());
 383         actionManager.updateArtifact(artifact, "actionInvariantUuId", "user");
 384         Mockito.verify(actionArtifactDao, times(1)).updateArtifact(any(ActionArtifact.class));
 385     }
 386
 387     @Test(expected = ActionException.class)
 388     public void testUpdateArtifactShouldThrowExceptionIfArtifactNotExist() {
 389         ActionArtifact artifact = createActionArtifact();
 390         artifact.setArtifactUuId("Uuid");
 391         VersionInfo versionInfo = createVersionInfo();
 392         Version activeVersion = new Version("2.1");
 393         versionInfo.setActiveVersion(activeVersion);
 394         when(actionDao.get(any())).thenReturn(createActionEntity());
 395         when(versioningManager.getEntityVersionInfo(anyString(), anyString(),anyString(), any()))
 396                 .thenReturn(versionInfo);
 397         actionManager.updateArtifact(artifact, "actionInvariantUuId", "user");
 398     }
 399
 400     private ActionArtifact createActionArtifact() {
 401         ActionArtifact artifact = new ActionArtifact();
 402         artifact.setArtifactUuId("artifactUuId");
 403         artifact.setArtifactName("artifactName");
 404         artifact.setArtifact(new byte[0]);
 405         return artifact;
 406     }
 407
 408     private List<Action> mockActionsToReturn() {
 409         List<Action> actionList = new ArrayList<>();
 410         Action action = new Action();
 411         action.setActionInvariantUuId("uuid");
 412         action.setVersion("1.1");
 413         action.setStatus(ActionStatus.Available);
 414         action.setData("action data");
 415         actionList.add(action);
 416         return actionList;
 417     }
 418
 419     private VersionInfo createVersionInfo() {
 420         VersionInfo versionInfo = new VersionInfo();
 421         Version version = createVersion();
 422         versionInfo.setActiveVersion(version);
 423         versionInfo.setLatestFinalVersion(version);
 424         return versionInfo;
 425     }
 426
 427     private Version createVersion() {
 428         Version version = new Version();
 429         version.setMajor(1);
 430         version.setMinor(1);
 431         return version;
 432     }
 433
 434     private ActionEntity createActionEntity() {
 435         ActionEntity actionEntity = new ActionEntity();
 436         actionEntity.setData("{actionUuId : actionUuId, actionInvariantUuId : actionInvariantUuId," +
 437                 " name : actionToupdate,version: 2.1 ," +
 438                 " artifacts : [{artifactUuId: artifactUuId ,artifactName : artifactName," +
 439                 "artifactLabel: artifactLabel, artifactProtection : readWrite, artifactCategory : artifactCategory," +
 440                 "artifactDescription: artifactDescription}] }");
 441         actionEntity.setUser("user");
 442         actionEntity.setTimestamp(new Date());
 443         return actionEntity;
 444     }
 445
 446     private Action createAction() {
 447         Action action = new Action();
 448         action.setActionUuId("uid");
 449         action.setActionInvariantUuId("uuid");
 450         action.setName("actionToupdate2");
 451         action.setData("{actionInvariantUuId : actionInvariantUuId," +
 452                 " name : actionToupdate, artifacts : [{artifactName : artifactName}] }");
 453
 454         List<ActionArtifact> actionArtifacts = new ArrayList<>();
 455         ActionArtifact actionArtifact = new ActionArtifact();
 456         actionArtifact.setArtifactName("artifactName");
 457         actionArtifact.setArtifactUuId("artifactUuId");
 458         actionArtifacts.add(actionArtifact);
 459         action.setArtifacts(actionArtifacts);
 460
 461         return action;
 462     }
 463
 464     private VersionInfoEntity createVersionInfoEntity() {
 465         VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
 466         UserCandidateVersion userCandidateVersion = new UserCandidateVersion();
 467         userCandidateVersion.setUser("user");
 468         userCandidateVersion.setVersion(createVersion());
 469         versionInfoEntity.setCandidate(userCandidateVersion);
 470         return versionInfoEntity;
 471     }
 472
 473 }