gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2020 Samsung Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.versioning.impl;
  22
  23
  24 import static org.hamcrest.CoreMatchers.is;
  25 import static org.hamcrest.CoreMatchers.isA;
  26 import static org.hamcrest.CoreMatchers.notNullValue;
  27 import static org.hamcrest.MatcherAssert.assertThat;
  28 import static org.junit.Assert.fail;
  29 import static org.mockito.ArgumentMatchers.any;
  30 import static org.mockito.ArgumentMatchers.anyString;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.when;
  33
  34 import java.util.ArrayList;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Optional;
  38 import java.util.Set;
  39 import mockit.Deencapsulation;
  40 import org.junit.Before;
  41 import org.junit.Test;
  42 import org.junit.runner.RunWith;
  43 import org.mockito.Mock;
  44 import org.mockito.junit.MockitoJUnitRunner;
  45 import org.openecomp.sdc.common.errors.CoreException;
  46 import org.openecomp.sdc.versioning.ActionVersioningManager;
  47 import org.openecomp.sdc.versioning.AsdcItemManager;
  48 import org.openecomp.sdc.versioning.VersionCalculator;
  49 import org.openecomp.sdc.versioning.dao.VersionDao;
  50 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
  51 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
  52 import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
  53 import org.openecomp.sdc.versioning.dao.types.Version;
  54 import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
  55 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  56 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  57 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  58 import org.openecomp.sdc.versioning.types.VersionInfo;
  59 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  60 import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
  61
  62 @RunWith(MockitoJUnitRunner.class)
  63 public class ActionVersioningManagerImplTest {
  64     @Mock
  65     private VersionInfoDao versionInfoDao;
  66     @Mock
  67     private VersionInfoDeletedDao versionInfoDeletedDao;
  68     @Mock
  69     private VersionDao versionDao;
  70     @Mock
  71     private VersionCalculator versionCalculator;
  72     @Mock
  73     private AsdcItemManager asdcItemManager;
  74
  75     private ActionVersioningManager actionVersioningManager;
  76     private VersionInfoEntity versionInfoEntity;
  77
  78     @Before
  79     public void setUp(){
  80         actionVersioningManager = createSUT();
  81
  82         versionInfoEntity = new VersionInfoEntity();
  83         versionInfoEntity.setActiveVersion(new Version());
  84         versionInfoEntity.setStatus(VersionStatus.Draft);
  85         versionInfoEntity.setCandidate(new UserCandidateVersion("mock-user", new Version()));
  86     }
  87
  88     private ActionVersioningManager createSUT() {
  89         return new ActionVersioningManagerImpl(
  90                 versionInfoDao,
  91                 versionInfoDeletedDao,
  92                 versionDao,
  93                 versionCalculator,
  94                 asdcItemManager
  95         );
  96     }
  97
  98     @Test
  99     public void testCtor() {
 100         assertThat(actionVersioningManager, isA(ActionVersioningManager.class));
 101     }
 102
 103     @Test
 104     public void testlistDeletedEntitiesVersionInfo() {
 105         when(versionInfoDeletedDao.list(any(VersionInfoDeletedEntity.class))).thenReturn(new ArrayList<>());
 106
 107         Map<String, VersionInfo> result = actionVersioningManager.listDeletedEntitiesVersionInfo(
 108                 "mock-type",
 109                 "mock-user",
 110                 VersionableEntityAction.Read
 111         );
 112
 113         assertThat(result, notNullValue());
 114     }
 115
 116     @Test
 117     public void testList() {
 118         when(versionDao.list(anyString())).thenReturn(new ArrayList<>());
 119
 120         List<Version> result = actionVersioningManager.list("mock-id");
 121
 122         assertThat(result, notNullValue());
 123     }
 124
 125     @Test
 126     public void testGet() {
 127         when(versionDao.get(anyString(), any(Version.class))).thenReturn(Optional.of(new Version()));
 128
 129         Version result = actionVersioningManager.get("mock-id", new Version());
 130
 131         assertThat(result, isA(Version.class));
 132     }
 133
 134     @Test
 135     public void testListEntitiesVersionInfo() {
 136         when(versionInfoDao.list(any(VersionInfoEntity.class))).thenReturn(new ArrayList<>());
 137
 138         Map<String, VersionInfo> result = actionVersioningManager.listEntitiesVersionInfo(
 139                 "mock-type",
 140                 "mock-user",
 141                 VersionableEntityAction.Read
 142         );
 143
 144         assertThat(result, notNullValue());
 145     }
 146
 147     @Test
 148     public void testGetEntityVersionInfo() {
 149         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 150
 151         VersionInfo result = actionVersioningManager.getEntityVersionInfo(
 152                 "mock-type",
 153                 "mock-id",
 154                 "mock-user",
 155                 VersionableEntityAction.Read
 156         );
 157
 158         assertThat(result, notNullValue());
 159     }
 160
 161     @Test
 162     public void testCreate() {
 163         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(null);
 164
 165         Version result = actionVersioningManager.create(
 166                 "mock-type",
 167                 "mock-id",
 168                 "mock-user"
 169         );
 170
 171         assertThat(result, notNullValue());
 172     }
 173
 174     @Test(expected = CoreException.class)
 175     public void testCreateFailed() {
 176         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(new VersionInfoEntity());
 177
 178         actionVersioningManager.create(
 179                 "mock-type",
 180                 "mock-id",
 181                 "mock-user"
 182         );
 183
 184         fail("Should throw CoreException");
 185     }
 186
 187     @Test
 188     public void testCreateAlt() {
 189         Version result = actionVersioningManager.create(
 190                 "mock-type",
 191                 new Version(),
 192                 VersionCreationMethod.minor
 193         );
 194
 195         assertThat(result, notNullValue());
 196     }
 197
 198     @Test
 199     public void testRegister() {
 200         actionVersioningManager.register(
 201                 "mock-type",
 202                 new VersionableEntityMetadata(
 203                         "mock-name",
 204                         "mock-id-name",
 205                         "mock-ver-id-name"
 206                 )
 207         );
 208         Map<String, Set<VersionableEntityMetadata>> entities = Deencapsulation.getField(actionVersioningManager, "VERSIONABLE_ENTITIES");
 209         assertThat(entities, notNullValue());
 210         assertThat(entities.size(), is(1));
 211     }
 212
 213     @Test
 214     public void testDelete() {
 215         versionInfoEntity.setStatus(VersionStatus.Certified);
 216
 217         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 218
 219         actionVersioningManager.delete(
 220                 "moct-type",
 221                 "mock-id",
 222                 "mock-user"
 223         );
 224
 225         verify(versionInfoDeletedDao).create(any(VersionInfoDeletedEntity.class));
 226         verify(versionInfoDao).delete(any(VersionInfoEntity.class));
 227     }
 228
 229     @Test(expected = CoreException.class)
 230     public void testDeleteLocked() {
 231         versionInfoEntity.setStatus(VersionStatus.Locked);
 232         UserCandidateVersion userCandidateVersion = new UserCandidateVersion("mock-user", new Version());
 233         versionInfoEntity.setCandidate(userCandidateVersion);
 234
 235         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 236
 237         actionVersioningManager.delete(
 238                 "moct-type",
 239                 "mock-id",
 240                 "mock-user"
 241         );
 242         fail("Should throw CoreException");
 243     }
 244
 245     @Test
 246     public void testUndoDelete() {
 247         when(versionInfoDeletedDao.get(any(VersionInfoDeletedEntity.class))).thenReturn(new VersionInfoDeletedEntity());
 248
 249         actionVersioningManager.undoDelete(
 250                 "mock-type",
 251                 "mock-id",
 252                 "mock-user"
 253         );
 254
 255         verify(versionInfoDao).create(any(VersionInfoEntity.class));
 256         verify(versionInfoDeletedDao).delete(any(VersionInfoDeletedEntity.class));
 257     }
 258
 259     @Test(expected = CoreException.class)
 260     public void testUndoDeleteFail() {
 261         when(versionInfoDeletedDao.get(any(VersionInfoDeletedEntity.class))).thenReturn(null);
 262
 263         actionVersioningManager.undoDelete(
 264                 "mock-type",
 265                 "mock-id",
 266                 "mock-user"
 267         );
 268
 269         fail("Should throw CoreException");
 270     }
 271
 272     @Test
 273     public void testCheckout() {
 274         versionInfoEntity.setStatus(VersionStatus.Certified);
 275
 276         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 277
 278         Version result = actionVersioningManager.checkout(
 279                 "moct-type",
 280                 "mock-id",
 281                 "mock-user"
 282         );
 283
 284         assertThat(result, notNullValue());
 285         assertThat(result.getStatus(), is(VersionStatus.Draft));
 286     }
 287
 288     @Test(expected = CoreException.class)
 289     public void testCheckoutFailNotFound() {
 290         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(null);
 291
 292         actionVersioningManager.checkout(
 293                 "moct-type",
 294                 "mock-id",
 295                 "mock-user"
 296         );
 297
 298         fail("Should throw CoreException");
 299     }
 300
 301     @Test(expected = CoreException.class)
 302     public void testCheckoutLockedFail() {
 303         versionInfoEntity.setStatus(VersionStatus.Locked);
 304
 305         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 306
 307         actionVersioningManager.checkout(
 308                 "mock-type",
 309                 "mock-id",
 310                 "mock-user"
 311         );
 312
 313         fail("Should throw CoreException");
 314     }
 315
 316     @Test
 317     public void testUndoCheckout() {
 318         versionInfoEntity.setStatus(VersionStatus.Locked);
 319
 320         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 321
 322         Version result = actionVersioningManager.undoCheckout(
 323                 "mock-type",
 324                 "mock-id",
 325                 "mock-user"
 326         );
 327         assertThat(result, notNullValue(Version.class));
 328     }
 329
 330     @Test
 331     public void testCheckin() {
 332         versionInfoEntity.setStatus(VersionStatus.Locked);
 333
 334         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 335
 336         Version result = actionVersioningManager.checkin(
 337                 "mock-type",
 338                 "mock-id",
 339                 "mock-user",
 340                 "mock-desc"
 341         );
 342         assertThat(result, notNullValue(Version.class));
 343     }
 344
 345     @Test(expected = CoreException.class)
 346     public void testCheckinDraft() {
 347         versionInfoEntity.setStatus(VersionStatus.Draft);
 348
 349         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 350
 351         Version result = actionVersioningManager.checkin(
 352                 "mock-type",
 353                 "mock-id",
 354                 "mock-user",
 355                 "mock-desc"
 356         );
 357         assertThat(result, notNullValue(Version.class));
 358     }
 359
 360     @Test
 361     public void testForceSync() {
 362         actionVersioningManager.forceSync("mock-id", new Version());
 363     }
 364
 365     @Test
 366     public void testSubmit() {
 367         when(versionDao.get(anyString(), any(Version.class))).thenReturn(Optional.of(new Version()));
 368
 369         actionVersioningManager.submit(
 370                 "mock-type",
 371                 new Version(),
 372                 "mock-desc"
 373         );
 374         verify(versionDao).update(anyString(), any(Version.class));
 375         verify(asdcItemManager).updateVersionStatus(anyString(), any(VersionStatus.class), any(VersionStatus.class));
 376     }
 377
 378     @Test
 379     public void testSubmitAlt() {
 380         versionInfoEntity.setStatus(VersionStatus.Draft);
 381         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 382
 383         Version result = actionVersioningManager.submit(
 384                 "mock-type",
 385                 "mock-id",
 386                 "mock-user",
 387                 "mock-desc"
 388         );
 389         assertThat(result, notNullValue(Version.class));
 390     }
 391
 392     @Test(expected = CoreException.class)
 393     public void testSubmitAltFailNotFound() {
 394         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(null);
 395
 396         actionVersioningManager.submit(
 397                 "mock-type",
 398                 "mock-id",
 399                 "mock-user",
 400                 "mock-desc"
 401         );
 402
 403         fail("Should throw CoreException");
 404     }
 405
 406     @Test(expected = CoreException.class)
 407     public void testSubmitAltFailCertified() {
 408         versionInfoEntity.setStatus(VersionStatus.Certified);
 409         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 410
 411         actionVersioningManager.submit(
 412                 "mock-type",
 413                 "mock-id",
 414                 "mock-user",
 415                 "mock-desc"
 416         );
 417
 418         fail("Should throw CoreException");
 419     }
 420
 421     @Test(expected = CoreException.class)
 422     public void testSubmitAltFailLocked() {
 423         versionInfoEntity.setStatus(VersionStatus.Locked);
 424         when(versionInfoDao.get(any(VersionInfoEntity.class))).thenReturn(versionInfoEntity);
 425
 426         actionVersioningManager.submit(
 427                 "mock-type",
 428                 "mock-id",
 429                 "mock-user",
 430                 "mock-desc"
 431         );
 432
 433         fail("Should throw CoreException");
 434     }
 435
 436     @Test
 437     public void testSync() {
 438         actionVersioningManager.sync("mock-id", new Version());
 439         verify(versionDao).sync(anyString(), any(Version.class));
 440     }
 441
 442     @Test
 443     public void testRevert() {
 444         actionVersioningManager.revert("mock-id", new Version(), "mock-rev-id");
 445         verify(versionDao).revert(anyString(), any(Version.class), anyString());
 446     }
 447
 448     @Test
 449     public void testListRevisions() {
 450         actionVersioningManager.listRevisions("mock-id", new Version());
 451         verify(versionDao).listRevisions(anyString(), any(Version.class));
 452     }
 453 }