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