catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/PolicyUtilsTest.java

   1 /*
   2  * Copyright © 2016-2019 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 package org.openecomp.sdc.be.components.validation;
  19
  20 import fj.data.Either;
  21 import mockit.Deencapsulation;
  22 import org.junit.Test;
  23 import org.openecomp.sdc.be.components.BeConfDependentTest;
  24 import org.openecomp.sdc.be.components.utils.ComponentInstancePropertyBuilder;
  25 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  26 import org.openecomp.sdc.be.components.utils.ServiceBuilder;
  27 import org.openecomp.sdc.be.config.ConfigurationManager;
  28 import org.openecomp.sdc.be.dao.api.ActionStatus;
  29 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  30 import org.openecomp.sdc.be.model.Component;
  31 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  32 import org.openecomp.sdc.be.model.PolicyDefinition;
  33 import org.openecomp.sdc.be.model.Resource;
  34 import org.openecomp.sdc.be.model.Service;
  35 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  36 import org.openecomp.sdc.common.api.ConfigurationSource;
  37 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  38 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  39
  40 import java.util.Map;
  41 import java.util.Objects;
  42 import java.util.Set;
  43
  44 import static org.junit.Assert.assertEquals;
  45 import static org.junit.Assert.assertTrue;
  46
  47 public class PolicyUtilsTest extends BeConfDependentTest{
  48
  49         private static final String PROP_NAME = "propertyName";
  50         private static final String COMP_ID = "compId";
  51         private static final String appConfigDir = "src/test/resources/config/catalog-be";
  52         private static final String EXPECTED_SERVICE_POLICY_TYPE = "a.b.c";
  53         private static final String EXPECTED_RESOURCE_POLICY_TYPE = "c.d.e";
  54         private static final String POLICY_ID_1 = "policyId1";
  55         private static final String POLICY_ID_2 = "policyId2";
  56         private static final String POLICY_NAME = "policyName";
  57
  58         @Test
  59         public void testGetNextPolicyCounter() throws Exception {
  60                 Map<String, PolicyDefinition> policies = null;
  61                 int result;
  62
  63                 // default test
  64                 result = PolicyUtils.getNextPolicyCounter(policies);
  65         }
  66
  67         @Test
  68         public void testValidatePolicyFields() throws Exception {
  69                 PolicyDefinition recievedPolicy = new PolicyDefinition();
  70                 PolicyDefinition validPolicy = new PolicyDefinition();
  71                 Map<String, PolicyDefinition> policies = null;
  72                 Either<PolicyDefinition, ActionStatus> result;
  73
  74                 // default test
  75                 result = PolicyUtils.validatePolicyFields(recievedPolicy, validPolicy, policies);
  76         }
  77
  78         @Test
  79         public void testValidatePolicyFieldsOneEmptyField() {
  80                 PolicyDefinition receivedPolicy = new PolicyDefinition();
  81                 PolicyDefinition validPolicy = new PolicyDefinition();
  82
  83                 receivedPolicy.setName(POLICY_NAME);
  84                 receivedPolicy.setUniqueId(null);
  85                 validPolicy.setUniqueId(POLICY_ID_2);
  86
  87                 Either<PolicyDefinition, ActionStatus> policyEither =
  88                                 PolicyUtils.validatePolicyFields(receivedPolicy, validPolicy, null);
  89
  90                 assertTrue(policyEither.isLeft());
  91                 assertEquals(validPolicy, policyEither.left().value());
  92         }
  93
  94         @Test
  95         public void testValidatePolicyFieldsUpdateUniqueId() {
  96                 PolicyDefinition receivedPolicy = new PolicyDefinition();
  97                 PolicyDefinition validPolicy = new PolicyDefinition();
  98
  99                 receivedPolicy.setName(POLICY_NAME);
 100                 receivedPolicy.setUniqueId(POLICY_ID_1);
 101                 validPolicy.setUniqueId(POLICY_ID_2);
 102
 103                 Either<PolicyDefinition, ActionStatus> policyEither =
 104                                 PolicyUtils.validatePolicyFields(receivedPolicy, validPolicy, null);
 105
 106                 assertTrue(policyEither.isLeft());
 107                 assertEquals(validPolicy, policyEither.left().value());
 108         }
 109
 110         @Test
 111         public void testGetExcludedPolicyTypesByComponent() throws Exception {
 112                 Component component = new Resource();
 113                 Set<String> result;
 114
 115                 // default test
 116                 result = PolicyUtils.getExcludedPolicyTypesByComponent(component);
 117                 component = new Service();
 118                 result = PolicyUtils.getExcludedPolicyTypesByComponent(component);
 119         }
 120
 121         @Test
 122         public void testGetExcludedPoliciesWithServiceComponent() {
 123                 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 124                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 125
 126                 Service service = new ServiceBuilder().setUniqueId(COMP_ID).build();
 127
 128                 Set<String> policyTypes = PolicyUtils.getExcludedPolicyTypesByComponent(service);
 129                 validateExtractedPolicies(policyTypes, EXPECTED_SERVICE_POLICY_TYPE);
 130         }
 131
 132         @Test
 133         public void testGetExcludedPoliciesWithResourceComponent() {
 134                 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 135                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 136
 137                 Resource resource = new ResourceBuilder().setUniqueId(COMP_ID).build();
 138
 139                 Set<String> policyTypes = PolicyUtils.getExcludedPolicyTypesByComponent(resource);
 140                 validateExtractedPolicies(policyTypes, EXPECTED_RESOURCE_POLICY_TYPE);
 141         }
 142
 143         @Test
 144         public void testExtractNextPolicyCounterFromUniqueId() throws Exception {
 145                 String uniqueId = "";
 146                 int result;
 147
 148                 // default test
 149                 result = Deencapsulation.invoke(PolicyUtils.class, "extractNextPolicyCounterFromUniqueId",
 150                                 new Object[] { uniqueId });
 151         }
 152
 153         @Test
 154         public void testExtractNextPolicyCounterFromName() throws Exception {
 155                 String policyName = "";
 156                 int result;
 157
 158                 // default test
 159                 result = Deencapsulation.invoke(PolicyUtils.class, "extractNextPolicyCounterFromName",
 160                                 new Object[] { policyName });
 161         }
 162
 163         @Test
 164         public void testExtractNextPolicyCounter() throws Exception {
 165                 String policyName = "";
 166                 int endIndex = 0;
 167                 int result;
 168
 169                 // default test
 170                 result = Deencapsulation.invoke(PolicyUtils.class, "extractNextPolicyCounter",
 171                                 new Object[] { policyName, endIndex });
 172         }
 173
 174         @Test
 175         public void testValidateImmutablePolicyFields() throws Exception {
 176                 PolicyDefinition receivedPolicy = new PolicyDefinition();
 177                 PolicyDefinition validPolicy = new PolicyDefinition();
 178
 179                 // default test
 180                 Deencapsulation.invoke(PolicyUtils.class, "validateImmutablePolicyFields",
 181                                 receivedPolicy, validPolicy);
 182         }
 183
 184         @Test
 185         public void testIsUpdatedField() throws Exception {
 186                 String oldField = "";
 187                 String newField = "";
 188                 boolean result;
 189
 190                 // default test
 191                 result = Deencapsulation.invoke(PolicyUtils.class, "isUpdatedField", new Object[] { oldField, newField });
 192         }
 193
 194         @Test
 195         public void testLogImmutableFieldUpdateWarning() throws Exception {
 196                 String oldValue = "";
 197                 String newValue = "";
 198                 JsonPresentationFields field = null;
 199
 200                 // default test
 201                 Deencapsulation.invoke(PolicyUtils.class, "logImmutableFieldUpdateWarning",
 202                                 new Object[] { oldValue, newValue, JsonPresentationFields.class });
 203         }
 204
 205         @Test
 206         public void testGetDeclaredPolicyDefinition() {
 207                 ComponentInstanceProperty property = new ComponentInstancePropertyBuilder().setName(PROP_NAME).build();
 208                 PolicyDefinition policy = PolicyUtils.getDeclaredPolicyDefinition(COMP_ID, property);
 209
 210                 assertTrue(Objects.nonNull(policy));
 211                 assertEquals(UniqueIdBuilder.buildPolicyUniqueId(COMP_ID, PROP_NAME), policy.getUniqueId());
 212                 assertEquals(COMP_ID, policy.getInstanceUniqueId());
 213         }
 214
 215         private void validateExtractedPolicies(Set<String> policyTypes, String expectedType) {
 216                 assertTrue(org.apache.commons.collections.CollectionUtils.isNotEmpty(policyTypes));
 217                 assertEquals(1, policyTypes.size());
 218                 assertEquals(expectedType, policyTypes.iterator().next());
 219         }
 220 }