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
 122                                 .addCapabilityType(capabilityTypeDefinition, true);
 123                 assertEquals("check capability type added", true, addCapabilityType1.isLeft());
 124
 125                 CapabilityTypeDefinition capabilityTypeAdded = addCapabilityType1.left().value();
 126                 compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
 127
 128                 Either<CapabilityTypeDefinition, TitanOperationStatus> capabilityTypeByUid = capabilityTypeOperation
 129                                 .getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId());
 130                 compareBetweenCreatedToSent(capabilityTypeByUid.left().value(), capabilityTypeDefinition);
 131
 132                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType2 = capabilityTypeOperation
 133                                 .addCapabilityType(capabilityTypeDefinition, true);
 134                 assertEquals("check capability type failed", true, addCapabilityType2.isRight());
 135                 assertEquals("check returned error", StorageOperationStatus.SCHEMA_VIOLATION,
 136                                 addCapabilityType2.right().value());
 137
 138         }
 139
 140         @Test
 141         public void testAddDerviedCapabilityType() {
 142
 143                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 144                 capabilityTypeDefinition.setDescription("desc1");
 145                 capabilityTypeDefinition.setType("tosca.capabilities.Container2");
 146                 capabilityTypeDefinition.setDerivedFrom("derivedFrom");
 147
 148                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
 149                                 .addCapabilityType(capabilityTypeDefinition, true);
 150                 // assertEquals("check capability type parent not exist",
 151                 // StorageOperationStatus.INVALID_ID,
 152                 // addCapabilityType1.right().value());
 153                 // TODO: esofer change to INVALID_ID
 154                 assertEquals("check capability type parent not exist", StorageOperationStatus.INVALID_ID,
 155                                 addCapabilityType1.right().value());
 156         }
 157
 158         public CapabilityTypeDefinition createCapability(String capabilityTypeName) {
 159
 160                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 161                 capabilityTypeDefinition.setDescription("desc1");
 162                 capabilityTypeDefinition.setType(capabilityTypeName);
 163
 164                 Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
 165
 166                 String propName1 = "disk_size";
 167                 String propName2 = "num_cpus";
 168
 169                 PropertyDefinition property1 = buildProperty1();
 170
 171                 properties.put(propName1, property1);
 172
 173                 PropertyDefinition property2 = buildProperty2();
 174
 175                 properties.put(propName2, property2);
 176
 177                 capabilityTypeDefinition.setProperties(properties);
 178
 179                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
 180                                 .addCapabilityType(capabilityTypeDefinition, true);
 181
 182                 CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 183                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
 184                                 .getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId(), true);
 185                 assertEquals("check capability type fetched", true, capabilityType.isLeft());
 186                 CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 187
 188                 Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 189
 190                 compareProperties(fetchedProps, properties);
 191
 192                 return fetchedCTD;
 193
 194         }
 195
 196         @Test
 197         public void testAddCapabilityTypeWithProperties() {
 198
 199                 CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 200                 capabilityTypeDefinition.setDescription("desc1");
 201                 capabilityTypeDefinition.setType("tosca.capabilities.Container3");
 202
 203                 Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
 204
 205                 String propName1 = "disk_size";
 206                 String propName2 = "num_cpus";
 207
 208                 PropertyDefinition property1 = buildProperty1();
 209
 210                 properties.put(propName1, property1);
 211
 212                 PropertyDefinition property2 = buildProperty2();
 213
 214                 properties.put(propName2, property2);
 215
 216                 capabilityTypeDefinition.setProperties(properties);
 217
 218                 Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation
 219                                 .addCapabilityType(capabilityTypeDefinition, true);
 220
 221                 CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 222                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
 223                                 .getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId());
 224                 assertEquals("check capability type fetched", true, capabilityType.isLeft());
 225                 CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 226
 227                 Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 228
 229                 compareProperties(fetchedProps, properties);
 230         }
 231
 232         private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 233
 234                 assertTrue("check properties are full or empty",
 235                                 ((first == null && second == null) || (first != null && second != null)));
 236                 if (first != null) {
 237                         assertEquals("check properties size", first.size(), second.size());
 238
 239                         for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 240
 241                                 String propName = entry.getKey();
 242                                 PropertyDefinition secondPD = second.get(propName);
 243                                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 244
 245                                 PropertyDefinition firstPD = entry.getValue();
 246
 247                                 comparePropertyDefinition(firstPD, secondPD);
 248                         }
 249
 250                 }
 251
 252         }
 253
 254         @Test
 255         public void testGetCapabilityTypeNotFound() {
 256
 257                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation
 258                                 .getCapabilityType("not_exists");
 259                 assertEquals("check not found is returned", StorageOperationStatus.NOT_FOUND, capabilityType.right().value());
 260
 261         }
 262
 263         private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 264
 265                 assertTrue("check objects are full or empty",
 266                                 ((first == null && second == null) || (first != null && second != null)));
 267                 if (first != null) {
 268                         assertTrue("check property default value", compareValue(first.getDefaultValue(), second.getDefaultValue()));
 269                         assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 270                         assertTrue("check property type", compareValue(first.getType(), second.getType()));
 271                         compareList(first.getConstraints(), second.getConstraints());
 272                 }
 273
 274         }
 275
 276         private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 277
 278                 assertTrue("check lists are full or empty",
 279                                 ((first == null && second == null) || (first != null && second != null)));
 280                 if (first != null) {
 281                         assertEquals("check list size", first.size(), second.size());
 282                 }
 283         }
 284
 285         private PropertyDefinition buildProperty2() {
 286                 PropertyDefinition property2 = new PropertyDefinition();
 287                 property2.setDefaultValue("2");
 288                 property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 289                 property2.setType(ToscaType.INTEGER.name().toLowerCase());
 290                 List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
 291                 List<String> range = new ArrayList<String>();
 292                 range.add("1");
 293                 range.add("4");
 294
 295                 InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 296                 constraints3.add(propertyConstraint3);
 297                 // property2.setConstraints(constraints3);
 298                 property2.setConstraints(constraints3);
 299                 return property2;
 300         }
 301
 302         private PropertyDefinition buildProperty1() {
 303                 PropertyDefinition property1 = new PropertyDefinition();
 304                 property1.setDefaultValue("10");
 305                 property1.setDescription(
 306                                 "Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
 307                 property1.setType(ToscaType.INTEGER.name().toLowerCase());
 308                 List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
 309                 GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 310                 constraints.add(propertyConstraint1);
 311
 312                 LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 313                 constraints.add(propertyConstraint2);
 314
 315                 property1.setConstraints(constraints);
 316                 return property1;
 317         }
 318
 319         private void compareBetweenCreatedToSent(CapabilityTypeDefinition x, CapabilityTypeDefinition y) {
 320
 321                 assertTrue(compareValue(x.getDerivedFrom(), y.getDerivedFrom()));
 322                 assertTrue(compareValue(x.getType(), y.getType()));
 323                 assertTrue(compareValue(x.getDescription(), y.getDescription()));
 324
 325         }
 326
 327         public boolean compareValue(String first, String second) {
 328
 329                 if (first == null && second == null) {
 330                         return true;
 331                 }
 332                 if (first != null) {
 333                         return first.equals(second);
 334                 } else {
 335                         return false;
 336                 }
 337         }
 338
 339         public void setOperations(TitanGenericDao titanDao, CapabilityTypeOperation capabilityTypeOperation) {
 340                 this.titanDao = titanDao;
 341                 this.capabilityTypeOperation = capabilityTypeOperation;
 342
 343         }
 344
 345 }