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.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Map.Entry;
  33
  34 import fj.data.Either;
  35 import org.apache.commons.collections4.MapUtils;
  36 import org.apache.commons.lang3.tuple.ImmutablePair;
  37 import org.junit.Before;
  38 import org.junit.BeforeClass;
  39 import org.junit.Test;
  40 import org.junit.runner.RunWith;
  41 import org.mockito.InjectMocks;
  42 import org.mockito.Mock;
  43 import org.mockito.Mockito;
  44 import org.mockito.MockitoAnnotations;
  45 import org.mockito.Spy;
  46 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  47 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  48 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  49 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  51 import org.openecomp.sdc.be.model.ModelTestBase;
  52 import org.openecomp.sdc.be.model.PropertyConstraint;
  53 import org.openecomp.sdc.be.model.PropertyDefinition;
  54 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  55 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  56 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  57 import org.openecomp.sdc.be.model.tosca.ToscaType;
  58 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
  59 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  60 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  61 import org.openecomp.sdc.be.resources.data.RelationshipTypeData;
  62 import org.springframework.test.context.ContextConfiguration;
  63 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  64
  65 @RunWith(SpringJUnit4ClassRunner.class)
  66 @ContextConfiguration("classpath:application-context-test.xml")
  67 public class RelationshipTypeOperationTest extends ModelTestBase {
  68
  69     private static final String PROP = "prop";
  70
  71     @Mock
  72     TitanGenericDao titanGenericDao;
  73
  74     @Mock
  75     PropertyOperation propertyOperation;
  76
  77     @Mock
  78     DerivedFromOperation derivedFromOperation;
  79
  80     @InjectMocks
  81     @Spy
  82     private RelationshipTypeOperation relationshipTypeOperation;
  83
  84     private RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
  85
  86     {
  87         relationshipTypeDefinition.setDescription("desc1");
  88         relationshipTypeDefinition.setType("tosca.relationships.Container1");
  89         relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
  90         relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
  91         relationshipTypeDefinition.setUniqueId("tosca.relationships.Container1");
  92     }
  93
  94     @BeforeClass
  95     public static void setupBeforeClass() {
  96         ModelTestBase.init();
  97     }
  98
  99     @Before
 100     public void setUp() throws Exception {
 101         MockitoAnnotations.initMocks(this);
 102
 103         Mockito.doReturn(TitanOperationStatus.OK).when(titanGenericDao).commit();
 104         Mockito.doReturn(TitanOperationStatus.OK).when(titanGenericDao).rollback();
 105     }
 106
 107     @Test
 108     public void getRelationshipTypeByNameNotCreated() {
 109         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CREATED))
 110                 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 111
 112         Either<RelationshipTypeDefinition, TitanOperationStatus> either =
 113                 relationshipTypeOperation.getRelationshipTypeByName("name");
 114         assertTrue(either.isRight());
 115     }
 116
 117     @Test
 118     public void testDummy() {
 119         assertNotNull(relationshipTypeOperation);
 120     }
 121
 122     @Test
 123     public void testAddRelationshipTypeValidationFailStatusNullInTransactionFalse() {
 124         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED))
 125                 .when(propertyOperation)
 126                 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 127
 128
 129         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
 130                 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
 131
 132         assertTrue(addRelationshipType.isRight());
 133     }
 134
 135     @Test
 136     public void testAddRelationshipTypeValidationFailStatusPropertiesReturnedInTransactionFalse() {
 137         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 138                 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 139         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_FOUND)).when(propertyOperation)
 140                 .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
 141
 142         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
 143                 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
 144
 145         assertTrue(addRelationshipType.isRight());
 146     }
 147
 148     @Test
 149     public void testGetAllRelationshipTypesNotFound() {
 150         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_FOUND)).when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null,
 151                 RelationshipTypeData.class);
 152         Either<Map<String, RelationshipTypeDefinition>, TitanOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes();
 153
 154         assertTrue(either.isLeft() && MapUtils.isEmpty(either.left().value()));
 155     }
 156
 157     @Test
 158     public void testGetAllRelationshipTypesNotConnnected() {
 159         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED)).when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null,
 160                 RelationshipTypeData.class);
 161         Either<Map<String, RelationshipTypeDefinition>, TitanOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes();
 162
 163         assertTrue(either.isRight() && TitanOperationStatus.NOT_CONNECTED == either.right().value());
 164     }
 165
 166     @Test
 167     public void testGetAllRelationshipTypesSuccess() {
 168         List<RelationshipTypeData> relationshipTypeDataList = new ArrayList<>();
 169
 170         RelationshipTypeData relationshipTypeData1 = new RelationshipTypeData();
 171         RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
 172         relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root1");
 173         relationshipInstDataDefinition1.setType("tosca.relationships.Root1");
 174         relationshipTypeData1.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
 175
 176         relationshipTypeDataList.add(relationshipTypeData1);
 177
 178         Mockito.doReturn(Either.left(relationshipTypeDataList))
 179                 .when(titanGenericDao).getByCriteria(NodeTypeEnum.RelationshipType, null,
 180                 RelationshipTypeData.class);
 181
 182         Mockito.doReturn(Either.left(relationshipTypeData1)).when(titanGenericDao)
 183                 .getNode(Mockito.anyString(), Mockito.anyString(), Mockito.eq(RelationshipTypeData.class));
 184
 185         Mockito.doReturn(Either.left(createPropertyData("prop1"))).when(propertyOperation)
 186                 .findPropertiesOfNode(NodeTypeEnum.RelationshipType, "tosca.relationships.Root1");
 187
 188         RelationshipInstDataDefinition derivedFromRelationshipTypeDefinition = new RelationshipInstDataDefinition();
 189         derivedFromRelationshipTypeDefinition.setUniqueId("tosca.relationships.Root1");
 190         derivedFromRelationshipTypeDefinition.setType("tosca.relationships.Parent");
 191
 192         Mockito.doReturn(Either.left(new RelationshipTypeData(derivedFromRelationshipTypeDefinition)))
 193                 .when(derivedFromOperation)
 194                 .getDerivedFromChild("tosca.relationships.Root1", NodeTypeEnum.RelationshipType, RelationshipTypeData.class);
 195
 196         Either<Map<String, RelationshipTypeDefinition>, TitanOperationStatus> either =
 197                                             relationshipTypeOperation.getAllRelationshipTypes();
 198
 199         assertTrue(either.isLeft());
 200         RelationshipTypeDefinition relationshipTypeDefinition = either.left().value().get("tosca.relationships.Root1");
 201         assertEquals("tosca.relationships.Parent", relationshipTypeDefinition.getDerivedFrom());
 202     }
 203
 204     public RelationshipTypeDefinition createRelationship(String relationshipTypeName) {
 205
 206         RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
 207         relationshipTypeDefinition.setDescription("desc1");
 208         relationshipTypeDefinition.setType(relationshipTypeName);
 209
 210         Map<String, PropertyDefinition> properties = new HashMap<>();
 211
 212         String propName1 = "disk_size";
 213         String propName2 = "num_cpus";
 214
 215         PropertyDefinition property1 = buildProperty1();
 216
 217         properties.put(propName1, property1);
 218
 219         PropertyDefinition property2 = buildProperty2();
 220
 221         properties.put(propName2, property2);
 222
 223         relationshipTypeDefinition.setProperties(properties);
 224
 225         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType1 =
 226                 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
 227
 228         RelationshipTypeDefinition relationshipTypeDefinitionCreated = addRelationshipType1.left().value();
 229         Either<RelationshipTypeDefinition, StorageOperationStatus> relationshipType =
 230                 relationshipTypeOperation.getRelationshipType(relationshipTypeDefinitionCreated.getUniqueId(), true);
 231         assertTrue("check relationship type fetched", relationshipType.isLeft());
 232         RelationshipTypeDefinition fetchedCTD = relationshipType.left().value();
 233
 234         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 235
 236         compareProperties(fetchedProps, properties);
 237
 238         return fetchedCTD;
 239
 240     }
 241
 242     private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 243
 244         assertTrue("check properties are full or empty",
 245                 ((first == null && second == null) || (first != null && second != null)));
 246         if (first != null) {
 247             assertEquals("check properties size", first.size(), second.size());
 248
 249             for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 250
 251                 String propName = entry.getKey();
 252                 PropertyDefinition secondPD = second.get(propName);
 253                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 254
 255                 PropertyDefinition firstPD = entry.getValue();
 256
 257                 comparePropertyDefinition(firstPD, secondPD);
 258             }
 259
 260         }
 261
 262     }
 263
 264     private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 265
 266         assertTrue("check objects are full or empty",
 267                 ((first == null && second == null) || (first != null && second != null)));
 268         if (first != null) {
 269             assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 270             assertTrue("check property default value", compareValue((String) first.getDefaultValue(),
 271                     (String) second.getDefaultValue()));
 272             assertTrue("check property type", compareValue(first.getType(), second.getType()));
 273             compareList(first.getConstraints(), second.getConstraints());
 274         }
 275
 276     }
 277
 278     private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 279
 280         assertTrue("check lists are full or empty",
 281                 ((first == null && second == null) || (first != null && second != null)));
 282         if (first != null) {
 283             assertEquals("check list size", first.size(), second.size());
 284         }
 285     }
 286
 287     private PropertyDefinition buildProperty2() {
 288         PropertyDefinition property2 = new PropertyDefinition();
 289         property2.setDefaultValue("2");
 290         property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 291         property2.setType(ToscaType.INTEGER.name().toLowerCase());
 292         List<PropertyConstraint> constraints3 = new ArrayList<>();
 293         List<String> range = new ArrayList<>();
 294         range.add("4");
 295         range.add("1");
 296         InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 297         constraints3.add(propertyConstraint3);
 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("Size of the local disk, in Gigabytes (GB), "
 306                 + "available to applications running on the Compute node.");
 307         property1.setType(ToscaType.INTEGER.name().toLowerCase());
 308         List<PropertyConstraint> constraints = new ArrayList<>();
 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 boolean compareValue(String first, String second) {
 320
 321         if (first == null && second == null) {
 322             return true;
 323         }
 324         if (first != null) {
 325             return first.equals(second);
 326         } else {
 327             return false;
 328         }
 329     }
 330
 331     public void setOperations(RelationshipTypeOperation relationshipTypeOperation) {
 332         this.relationshipTypeOperation = relationshipTypeOperation;
 333     }
 334
 335     @Test
 336     public void testAddRelationshipType() {
 337
 338         RelationshipTypeData relationshipTypeData = new RelationshipTypeData();
 339         RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
 340         relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root");
 341         relationshipInstDataDefinition1.setType("tosca.relationships.Root");
 342         relationshipTypeData.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
 343
 344         RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition(relationshipTypeData);
 345         relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
 346         relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
 347
 348         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 349                 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 350
 351         Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation)
 352                 .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
 353
 354         Mockito.doReturn(Either.left(relationshipTypeData)).when(titanGenericDao)
 355                 .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 356
 357         Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation)
 358                 .addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
 359
 360         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 361                 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 362
 363         Mockito.doReturn(Either.left(new GraphRelation()))
 364                 .when(derivedFromOperation)
 365                 .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 366
 367         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 368                 .when(relationshipTypeOperation).getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 369
 370         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 371                 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
 372
 373         assertTrue(either.isLeft());
 374     }
 375
 376     @Test
 377     public void testGetRelationshipTypeNotConnected() {
 378         Mockito.doReturn(Either.right(TitanOperationStatus.NOT_CONNECTED))
 379                 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 380
 381         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 382                 relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 383
 384         assertTrue(either.isRight());
 385     }
 386
 387     @Test
 388     public void testGetRelationshipTypeSuccess() {
 389         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 390                 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 391
 392         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 393                 relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 394
 395         assertTrue(either.isLeft());
 396     }
 397
 398     @Test
 399     public void testUpdateRelationshipType() {
 400         RelationshipTypeDefinition newRelationshipTypeDefinition = new RelationshipTypeDefinition();
 401         newRelationshipTypeDefinition.setUniqueId("tosca.relationships.Container2");
 402         newRelationshipTypeDefinition.setDescription("desc2");
 403         newRelationshipTypeDefinition.setType("tosca.relationships.Container2");
 404         newRelationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
 405         newRelationshipTypeDefinition.setProperties(createPropertyData("prop1"));
 406
 407         Mockito.doReturn(Either.left(new RelationshipTypeData(newRelationshipTypeDefinition))).when(titanGenericDao)
 408                 .updateNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 409
 410         Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
 411                 .when(propertyOperation).deletePropertiesAssociatedToNode(Mockito.any(), Mockito.anyString());
 412
 413         Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
 414                 .when(propertyOperation).addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
 415
 416         Mockito.doReturn(Either.left(newRelationshipTypeDefinition)).when(relationshipTypeOperation)
 417                 .getRelationshipTypeByUid(Mockito.anyString());
 418
 419         Mockito.doReturn(StorageOperationStatus.OK).when(derivedFromOperation)
 420                 .removeDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 421
 422         Mockito.doReturn(Either.left(new GraphRelation()))
 423                 .when(derivedFromOperation)
 424                 .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 425
 426         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 427                 relationshipTypeOperation.updateRelationshipType(relationshipTypeDefinition,
 428                         newRelationshipTypeDefinition, false);
 429
 430         assertTrue(either.isLeft());
 431     }
 432
 433     @Test
 434     public void testGetRelationshipTypeByUid() {
 435         RelationshipTypeData relationshipTypeData = new RelationshipTypeData(relationshipTypeDefinition);
 436
 437         Mockito.doReturn(Either.left(relationshipTypeData)).when(titanGenericDao)
 438                 .getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 439
 440         Mockito.doReturn(Either.left(relationshipTypeDefinition.getProperties()))
 441                 .when(propertyOperation).findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 442
 443         RelationshipTypeDefinition childRelationshipTypeDefinition = new RelationshipTypeDefinition();
 444         childRelationshipTypeDefinition.setType("tosca.relationships.ContainerChild");
 445
 446         Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(childRelationshipTypeDefinition), null))).when(titanGenericDao)
 447                 .getChild(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(),
 448                         Mockito.eq(RelationshipTypeData.class));
 449
 450         Either<RelationshipTypeDefinition, TitanOperationStatus> either =
 451                 relationshipTypeOperation.getRelationshipTypeByUid("tosca.relationships.Container1");
 452
 453         assertTrue(either.isLeft()
 454                 && "tosca.relationships.ContainerChild".equals(either.left().value().getDerivedFrom()));
 455     }
 456
 457     private Map<String, PropertyDefinition> createPropertyData(String value) {
 458         PropertyDefinition propertyDefinition = new PropertyDefinition();
 459         propertyDefinition.setDefaultValue(value);
 460         propertyDefinition.setDescription(PROP + "_" + value);
 461         propertyDefinition.setType(ToscaType.INTEGER.name().toLowerCase());
 462         List<PropertyConstraint> constraints = new ArrayList<>();
 463         List<String> range = new ArrayList<>();
 464         range.add("1");
 465         range.add("4");
 466         InRangeConstraint propertyConstraint = new InRangeConstraint(range);
 467         constraints.add(propertyConstraint);
 468         propertyDefinition.setConstraints(constraints);
 469         Map<String, PropertyDefinition> propertiesMap = new HashMap<>();
 470         propertiesMap.put(PROP, propertyDefinition);
 471         return propertiesMap;
 472     }
 473
 474 }