catalog-be/src/test/java/org/openecomp/sdc/be/tosca/GroupExportParserImplTest.java

   1 package org.openecomp.sdc.be.tosca;
   2
   3 import fj.data.Either;
   4 import org.apache.commons.lang3.tuple.Pair;
   5 import org.junit.Before;
   6 import org.junit.Test;
   7 import org.junit.runner.RunWith;
   8 import org.mockito.Mock;
   9 import org.mockito.junit.MockitoJUnitRunner;
  10 import org.openecomp.sdc.be.components.impl.exceptions.SdcResourceNotFoundException;
  11 import org.openecomp.sdc.be.components.utils.GroupDefinitionBuilder;
  12 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  13 import org.openecomp.sdc.be.model.*;
  14 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  15 import org.openecomp.sdc.be.tosca.model.ToscaGroupTemplate;
  16 import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.stream.Stream;
  23
  24 import static java.util.Collections.singletonList;
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
  27 import static org.mockito.Mockito.when;
  28
  29 @RunWith(MockitoJUnitRunner.class)
  30 public class GroupExportParserImplTest {
  31
  32         private static final String GROUP_DEFINITION_NAME = "groupDefinitionName";
  33         private static final String GROUP_DEFINITION_INVARIANT_UUID = "groupDefinitionInvariantUUID";
  34         private static final String GROUP_DEFINITION_GROUP_UUID = "groupDefinitionGroupUUID";
  35         private static final String GROUP_DEFINITION_VERSION = "groupDefinitionVersion";
  36         private static final String GROUP_DEFINITION_TYPE = "groupDefinitionType";
  37
  38         private static final String CAPABILITIE_NAME = "capabilitieName";
  39         private static final String COMPONENT_INSTANCE_PROPERTY_NAME = "componentInstancePropertyName";
  40         private static final String COMPONENT_INSTANCE_PROPERTY_VALUE = "componentInstancePropertyValue";
  41
  42
  43         private GroupExportParser groupExportParser;
  44
  45         @Mock
  46         private ApplicationDataTypeCache dataTypeCache;
  47
  48         @Mock
  49         private Component component;
  50
  51         @Before
  52         public void setUp() throws Exception {
  53                 initGroupExportParser();
  54         }
  55
  56         private void initGroupExportParser() {
  57                 when(dataTypeCache.getAll()).thenReturn(Either.left(null));
  58                 groupExportParser = new GroupExportParserImpl(dataTypeCache);
  59         }
  60
  61         @Test
  62         public void failToGetAllDataTypes() {
  63                 when(dataTypeCache.getAll()).thenReturn(Either.right(null));
  64                 assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> groupExportParser = new GroupExportParserImpl(dataTypeCache));
  65         }
  66
  67         @Test
  68         public void noGroupsInComponent() {
  69                 when(component.getGroups()).thenReturn(null);
  70                 Map<String, ToscaGroupTemplate> groups = groupExportParser.getGroups(component);
  71                 assertThat(groups).isNull();
  72         }
  73
  74         @Test
  75         public void oneGroupInComponent() {
  76                 when(component.getGroups()).thenReturn(genOneGroup());
  77                 Map<String, ToscaGroupTemplate> groups = groupExportParser.getGroups(component);
  78                 assertThat(groups).isNotNull();
  79                 assertThat(groups.size()).isOne();
  80                 ToscaGroupTemplate toscaGroupTemplate = groups.get(GROUP_DEFINITION_NAME);
  81                 Map<String, ToscaTemplateCapability> capabilities = toscaGroupTemplate.getCapabilities();
  82                 ToscaTemplateCapability toscaTemplateCapability = capabilities.get(CAPABILITIE_NAME);
  83                 Map<String, Object> properties = toscaTemplateCapability.getProperties();
  84                 assertThat(properties).containsEntry(COMPONENT_INSTANCE_PROPERTY_NAME, COMPONENT_INSTANCE_PROPERTY_VALUE);
  85
  86         }
  87
  88         @Test
  89         public void whenExportingGroupMembers_takeNamesFromTheMembersAndNotFromTheGroupMembersMap() {
  90                 GroupDefinition group1 = getGroup("group1", "type1", Pair.of("instance1Name", "inst1"));
  91                 GroupDefinition group2 = getGroup("group2", "type2", Pair.of("instance2Name", "inst2"));
  92                 Resource resource = new ResourceBuilder()
  93                                 .addComponentInstance("inst1")
  94                                 .addComponentInstance("inst2")
  95                                 .addGroup(group1)
  96                                 .addGroup(group2)
  97                                 .build();
  98                 Map<String, ToscaGroupTemplate> groups = groupExportParser.getGroups(resource);
  99                 assertThat(groups.values())
 100                                 .extracting("members")
 101                                 .containsExactlyInAnyOrder(singletonList("inst1"), singletonList("inst2"));
 102         }
 103
 104         @SafeVarargs
 105         private final GroupDefinition getGroup(String name, String type, Pair<String, String>... members) {
 106                 GroupDefinitionBuilder groupBuilder = GroupDefinitionBuilder.create()
 107                                 .setName(name)
 108                                 .setType(type);
 109                 Stream.of(members).forEach(member -> groupBuilder.addMember(member.getKey(), member.getValue()));
 110                 return groupBuilder.build();
 111         }
 112
 113         private List<GroupDefinition> genOneGroup() {
 114                 List<GroupDefinition> group = new ArrayList<>();
 115                 GroupDefinitionBuilder groupBuilder = GroupDefinitionBuilder.create()
 116                                 .setName(GROUP_DEFINITION_NAME)
 117                                 .setInvariantUUID(GROUP_DEFINITION_INVARIANT_UUID)
 118                                 .setGroupUUID(GROUP_DEFINITION_GROUP_UUID)
 119                                 .setVersion(GROUP_DEFINITION_VERSION)
 120                                 .setType(GROUP_DEFINITION_TYPE);
 121
 122                 GroupDefinition groupDefinition = groupBuilder.build();
 123
 124                 Map<String, List<CapabilityDefinition>> capabilities = genCapabilities();
 125                 groupDefinition.setCapabilities(capabilities);
 126
 127                 group.add(groupDefinition);
 128                 return group;
 129         }
 130
 131         private Map<String, List<CapabilityDefinition>> genCapabilities() {
 132
 133                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 134                 List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 135                 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 136
 137                 List<ComponentInstanceProperty> capabilityProperties = new ArrayList<>();
 138                 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
 139                 componentInstanceProperty.setName(COMPONENT_INSTANCE_PROPERTY_NAME);
 140                 componentInstanceProperty.setValue(COMPONENT_INSTANCE_PROPERTY_VALUE);
 141
 142                 capabilityProperties.add(componentInstanceProperty);
 143                 capabilityDefinition.setProperties(capabilityProperties);
 144                 capabilityDefinition.setName(CAPABILITIE_NAME);
 145
 146                 capabilityDefinitions.add(capabilityDefinition);
 147                 capabilities.put("JustSoneName", capabilityDefinitions);
 148                 return capabilities;
 149         }
 150
 151 }