gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T 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.be.model.operations.impl;
  22
  23 import fj.data.Either;
  24 import org.junit.BeforeClass;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  28 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  29 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  30 import org.openecomp.sdc.be.model.ModelTestBase;
  31 import org.openecomp.sdc.be.model.PropertyConstraint;
  32 import org.openecomp.sdc.be.model.PropertyDefinition;
  33 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  34 import org.openecomp.sdc.be.model.tosca.ToscaType;
  35 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
  36 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  37 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  38 import org.springframework.test.context.ContextConfiguration;
  39 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  40
  41 import javax.annotation.Resource;
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.Map.Entry;
  47
  48 import static org.junit.Assert.assertEquals;
  49 import static org.junit.Assert.assertNotNull;
  50 import static org.junit.Assert.assertTrue;
  51
  52 @RunWith(SpringJUnit4ClassRunner.class)
  53 @ContextConfiguration("classpath:application-context-test.xml")
  54 public class CapabilityTypeOperationTest extends ModelTestBase {
  55
  56         @Resource(name = "titan-generic-dao")
  57         private TitanGenericDao titanDao;
  58
  59         @Resource(name = "capability-type-operation")
  60         private CapabilityTypeOperation capabilityTypeOperation;
  61
  62         @BeforeClass
  63         public static void setupBeforeClass() {
  64                 ModelTestBase.init();
  65
  66         }
  67
  68         @Test
  69         public void testDummy() {
  70
  71                 assertTrue(capabilityTypeOperation != null);
  72
  73         }
  74
  75         @Test
  76         public void testAddCapabilityType() {
  77
  78                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
  79                 capabilityTypeDefinition.setDescription("desc1");
  80                 capabilityTypeDefinition.setType("tosca.capabilities.Container1");
  81
  82                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
  83                 assertEquals("check capability type added", true, addCapabilityType1.isLeft());
  84
  85                 CapabilityTypeDefinition capabilityTypeAdded = addCapabilityType1.left().value();
  86                 compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
  87
  88                 Either<CapabilityTypeDefinition, TitanOperationStatus> capabilityTypeByUid = capabilityTypeOperation.getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId());
  89                 compareBetweenCreatedToSent(capabilityTypeByUid.left().value(), capabilityTypeDefinition);
  90
  91                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType2 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
  92                 assertEquals("check capability type failed", true, addCapabilityType2.isRight());
  93                 assertEquals("check returned error", StorageOperationStatus.SCHEMA_VIOLATION, addCapabilityType2.right().value());
  94
  95         }
  96
  97         @Test
  98         public void testAddDerviedCapabilityType() {
  99
 100                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 101                 capabilityTypeDefinition.setDescription("desc1");
 102                 capabilityTypeDefinition.setType("tosca.capabilities.Container2");
 103                 capabilityTypeDefinition.setDerivedFrom("derivedFrom");
 104
 105                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 106                 assertEquals("check capability type parent not exist", StorageOperationStatus.INVALID_ID, addCapabilityType1.right().value());
 107         }
 108
 109         public CapabilityTypeDefinition createCapability(String capabilityTypeName) {
 110
 111                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 112                 capabilityTypeDefinition.setDescription("desc1");
 113                 capabilityTypeDefinition.setType(capabilityTypeName);
 114
 115                 Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
 116
 117                 String propName1 = "disk_size";
 118                 String propName2 = "num_cpus";
 119
 120                 PropertyDefinition property1 = buildProperty1();
 121
 122                 properties.put(propName1, property1);
 123
 124                 PropertyDefinition property2 = buildProperty2();
 125
 126                 properties.put(propName2, property2);
 127
 128                 capabilityTypeDefinition.setProperties(properties);
 129
 130                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 131
 132                 CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 133                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId(), true);
 134                 assertEquals("check capability type fetched", true, capabilityType.isLeft());
 135                 CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 136
 137                 Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 138
 139                 compareProperties(fetchedProps, properties);
 140
 141                 return fetchedCTD;
 142
 143         }
 144
 145         @Test
 146         public void testAddCapabilityTypeWithProperties() {
 147
 148                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 149                 capabilityTypeDefinition.setDescription("desc1");
 150                 capabilityTypeDefinition.setType("tosca.capabilities.Container3");
 151
 152                 Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
 153
 154                 String propName1 = "disk_size";
 155                 String propName2 = "num_cpus";
 156
 157                 PropertyDefinition property1 = buildProperty1();
 158
 159                 properties.put(propName1, property1);
 160
 161                 PropertyDefinition property2 = buildProperty2();
 162
 163                 properties.put(propName2, property2);
 164
 165                 capabilityTypeDefinition.setProperties(properties);
 166
 167                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 168
 169                 CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 170                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId());
 171                 assertEquals("check capability type fetched", true, capabilityType.isLeft());
 172                 CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 173
 174                 Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 175
 176                 compareProperties(fetchedProps, properties);
 177         }
 178
 179         private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 180
 181                 assertTrue("check properties are full or empty", ((first == null && second == null) || (first != null && second != null)));
 182                 if (first != null) {
 183                         assertEquals("check properties size", first.size(), second.size());
 184
 185                         for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 186
 187                                 String propName = entry.getKey();
 188                                 PropertyDefinition secondPD = second.get(propName);
 189                                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 190
 191                                 PropertyDefinition firstPD = entry.getValue();
 192
 193                                 comparePropertyDefinition(firstPD, secondPD);
 194                         }
 195
 196                 }
 197
 198         }
 199
 200         @Test
 201         public void testGetCapabilityTypeNotFound() {
 202
 203                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType("not_exists");
 204                 assertEquals("check not found is returned", StorageOperationStatus.NOT_FOUND, capabilityType.right().value());
 205
 206         }
 207
 208         private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 209
 210                 assertTrue("check objects are full or empty", ((first == null && second == null) || (first != null && second != null)));
 211                 if (first != null) {
 212                         assertTrue("check property default value", compareValue(first.getDefaultValue(), second.getDefaultValue()));
 213                         assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 214                         assertTrue("check property type", compareValue(first.getType(), second.getType()));
 215                         compareList(first.getConstraints(), second.getConstraints());
 216                 }
 217
 218         }
 219
 220         private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 221
 222                 assertTrue("check lists are full or empty", ((first == null && second == null) || (first != null && second != null)));
 223                 if (first != null) {
 224                         assertEquals("check list size", first.size(), second.size());
 225                 }
 226         }
 227
 228         private PropertyDefinition buildProperty2() {
 229                 PropertyDefinition property2 = new PropertyDefinition();
 230                 property2.setDefaultValue("2");
 231                 property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 232                 property2.setType(ToscaType.INTEGER.name().toLowerCase());
 233                 List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
 234                 List<String> range = new ArrayList<String>();
 235                 range.add("1");
 236                 range.add("4");
 237
 238                 InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 239                 constraints3.add(propertyConstraint3);
 240                 // property2.setConstraints(constraints3);
 241                 property2.setConstraints(constraints3);
 242                 return property2;
 243         }
 244
 245         private PropertyDefinition buildProperty1() {
 246                 PropertyDefinition property1 = new PropertyDefinition();
 247                 property1.setDefaultValue("10");
 248                 property1.setDescription("Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
 249                 property1.setType(ToscaType.INTEGER.name().toLowerCase());
 250                 List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
 251                 GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 252                 constraints.add(propertyConstraint1);
 253
 254                 LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 255                 constraints.add(propertyConstraint2);
 256
 257                 property1.setConstraints(constraints);
 258                 return property1;
 259         }
 260
 261         private void compareBetweenCreatedToSent(CapabilityTypeDefinition x, CapabilityTypeDefinition y) {
 262
 263                 assertTrue(compareValue(x.getDerivedFrom(), y.getDerivedFrom()));
 264                 assertTrue(compareValue(x.getType(), y.getType()));
 265                 assertTrue(compareValue(x.getDescription(), y.getDescription()));
 266
 267         }
 268
 269         public boolean compareValue(String first, String second) {
 270
 271                 if (first == null && second == null) {
 272                         return true;
 273                 }
 274                 if (first != null) {
 275                         return first.equals(second);
 276                 } else {
 277                         return false;
 278                 }
 279         }
 280 }