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