openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/test/java/org/openecomp/sdc/versioning/VersioningUtilTest.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.versioning;
  20
  21 import org.junit.Assert;
  22 import org.junit.Test;
  23 import org.openecomp.sdc.common.errors.CoreException;
  24 import org.openecomp.sdc.versioning.dao.types.Version;
  25 import org.openecomp.sdc.versioning.types.VersionInfo;
  26
  27 import java.util.Arrays;
  28 import java.util.HashSet;
  29 import java.util.Set;
  30
  31 public class VersioningUtilTest {
  32
  33     @Test
  34     public void testResolveVersion() {
  35         Version version = new Version();
  36         version.setMajor(1);
  37         version.setMinor(1);
  38
  39         VersionInfo versionInfo = new VersionInfo();
  40         versionInfo.setActiveVersion(version);
  41         versionInfo.setViewableVersions(Arrays.asList(version));
  42         versionInfo.setLockingUser("user");
  43         Version resolveVersion = VersioningUtil.resolveVersion(version, versionInfo, "user");
  44         Assert.assertNotNull(resolveVersion);
  45         Assert.assertEquals(1,resolveVersion.getMajor());
  46         Assert.assertEquals(1,resolveVersion.getMinor());
  47
  48     }
  49
  50     @Test(expected = CoreException.class)
  51     public void testResolveVersionNegative() {
  52         Version version = new Version();
  53         version.setMajor(1);
  54         version.setMinor(1);
  55
  56         VersionInfo versionInfo = new VersionInfo();
  57         versionInfo.setActiveVersion(version);
  58         versionInfo.setViewableVersions(Arrays.asList(new Version()));
  59         versionInfo.setLockingUser("user");
  60         VersioningUtil.resolveVersion(null, versionInfo, "user");
  61
  62     }
  63
  64     @Test
  65     public void testResolveVersionFinalOnly() {
  66         Version version = new Version();
  67         VersionInfo versionInfo = new VersionInfo();
  68         versionInfo.setActiveVersion(version);
  69         versionInfo.setViewableVersions(Arrays.asList(version));
  70         versionInfo.setLatestFinalVersion(version);
  71         Assert.assertNotNull(VersioningUtil.resolveVersion(null, versionInfo, true));
  72
  73     }
  74
  75     @Test(expected = CoreException.class)
  76     public void testResolveVersionWithNonFinalVersions() {
  77         Version version = new Version();
  78         VersionInfo versionInfo = new VersionInfo();
  79         versionInfo.setActiveVersion(version);
  80         versionInfo.setViewableVersions(Arrays.asList(new Version()));
  81         versionInfo.setLatestFinalVersion(version);
  82         VersioningUtil.resolveVersion(version, versionInfo,true);
  83     }
  84
  85     @Test
  86     public void testResolveVersionWithoutFinal() {
  87         Version version = new Version();
  88         VersionInfo versionInfo = new VersionInfo();
  89         versionInfo.setActiveVersion(version);
  90         versionInfo.setViewableVersions(Arrays.asList(version));
  91         Assert.assertNotNull(VersioningUtil.resolveVersion(null, versionInfo, false));
  92
  93     }
  94
  95     @Test(expected = CoreException.class)
  96     public void testResolveVersionWithoutFinalVersion() {
  97         Version version = new Version();
  98         VersionInfo versionInfo = new VersionInfo();
  99         versionInfo.setActiveVersion(version);
 100         versionInfo.setViewableVersions(Arrays.asList(version));
 101         VersioningUtil.resolveVersion(null, versionInfo, true);
 102
 103     }
 104
 105     @Test(expected = CoreException.class)
 106     public void testResolveVersionFinalOnlyNegative() {
 107         Version version = new Version();
 108         VersionInfo versionInfo = new VersionInfo();
 109         versionInfo.setActiveVersion(version);
 110         versionInfo.setViewableVersions(Arrays.asList(version));
 111         versionInfo.setLatestFinalVersion(version);
 112         VersioningUtil.resolveVersion(version, versionInfo, true);
 113
 114     }
 115
 116     @Test(expected = CoreException.class)
 117     public void testValidateEntityExistence() {
 118         VersioningUtil.validateEntityExistence(null, new VersionableEntityImplStub(), "firstClassCitizenType");
 119     }
 120
 121     @Test(expected = CoreException.class)
 122     public void testValidateEntitiesExistence() {
 123         Set<String> entityIds = new HashSet<>();
 124         entityIds.add("id1");
 125         entityIds.add("id2");
 126         VersioningUtil.validateEntitiesExistence(entityIds, new VersionableEntityImplStub(),
 127                 new VersionInfoDaoImplStub(),"firstClassCitizenType");
 128     }
 129
 130     @Test(expected = CoreException.class)
 131     public void testValidateEntitiesExistenceSizeOne() {
 132         Set<String> entityIds = new HashSet<>();
 133         entityIds.add("id1");
 134         VersioningUtil.validateEntitiesExistence(entityIds, new VersionableEntityImplStub(),
 135                 new VersionInfoDaoImplStub(),"firstClassCitizenType");
 136     }
 137
 138     @Test(expected = CoreException.class)
 139     public void testValidateContainedEntitiesExistence() {
 140         Set<String> inputContainedEntityIds = new HashSet<>();
 141         inputContainedEntityIds.add("id1");
 142         inputContainedEntityIds.add("id2");
 143         Set<String> retrievedContainedEntityIds = new HashSet<>();
 144         VersioningUtil.validateContainedEntitiesExistence("containedEntityType",
 145                 inputContainedEntityIds, new VersionableEntityImplStub(), retrievedContainedEntityIds);
 146     }
 147
 148     @Test(expected = CoreException.class)
 149     public void testValidateContainedEntitiesExistenceWithIdOne() {
 150         Set<String> inputContainedEntityIds = new HashSet<>();
 151         inputContainedEntityIds.add("id1");
 152         inputContainedEntityIds.add("id2");
 153         Set<String> retrievedContainedEntityIds = new HashSet<>();
 154         retrievedContainedEntityIds.add("id1");
 155         VersioningUtil.validateContainedEntitiesExistence("containedEntityType",
 156                 inputContainedEntityIds, new VersionableEntityImplStub(), retrievedContainedEntityIds);
 157     }
 158 }