gerrit.onap Code Review - sdc.git/blob

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