catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/group/ComponentGroupMergeCommandTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.components.merge.group;
  22
  23 import fj.data.Either;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.ArgumentCaptor;
  28 import org.mockito.Captor;
  29 import org.mockito.Mock;
  30 import org.mockito.Mockito;
  31 import org.mockito.junit.MockitoJUnitRunner;
  32 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  33 import org.openecomp.sdc.be.components.utils.ComponentInstanceBuilder;
  34 import org.openecomp.sdc.be.components.utils.GroupDefinitionBuilder;
  35 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  36 import org.openecomp.sdc.be.dao.api.ActionStatus;
  37 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
  38 import org.openecomp.sdc.be.impl.ComponentsUtils;
  39 import org.openecomp.sdc.be.model.ComponentInstance;
  40 import org.openecomp.sdc.be.model.GroupDefinition;
  41 import org.openecomp.sdc.be.model.Resource;
  42 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.GroupsOperation;
  43
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.stream.Stream;
  47
  48 import static java.util.Arrays.asList;
  49 import static java.util.Collections.emptyList;
  50 import static java.util.Collections.emptyMap;
  51 import static java.util.Collections.singletonList;
  52 import static java.util.stream.Collectors.toMap;
  53 import static org.assertj.core.api.Assertions.assertThat;
  54 import static org.mockito.ArgumentMatchers.eq;
  55 import static org.mockito.Mockito.verifyZeroInteractions;
  56 import static org.mockito.Mockito.when;
  57
  58 @RunWith(MockitoJUnitRunner.class)
  59 public class ComponentGroupMergeCommandTest {
  60
  61     private static final Resource DONT_CARE = new Resource();
  62     private ComponentGroupMergeCommand testInstance;
  63     @Mock
  64     private GroupsOperation groupsOperation;
  65
  66     @Captor
  67     private ArgumentCaptor<List<GroupDefinition>> groupsToAddCaptor;
  68
  69     @Before
  70     public void setUp() throws Exception {
  71         testInstance = new ComponentGroupMergeCommand(groupsOperation, new ComponentsUtils(Mockito.mock(AuditingManager.class)));
  72     }
  73
  74     @Test
  75     public void whenPrevComponentHasNoGroups_returnOk() {
  76         ActionStatus actionStatus = testInstance.mergeComponents(new Resource(), DONT_CARE);
  77         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
  78
  79         Resource prevResource = new Resource();
  80         prevResource.setGroups(emptyList());
  81
  82         actionStatus = testInstance.mergeComponents(prevResource, DONT_CARE);
  83         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
  84         verifyZeroInteractions(groupsOperation);
  85     }
  86
  87     @Test
  88     public void whenAllPrevGroupsCreatedFromCsar_returnOk() {
  89         GroupDefinition group1 = createCsarGroup("group1");
  90         GroupDefinition group2 = createCsarGroup("group2");
  91         Resource prevResource = createResourceWithGroups(group1, group2);
  92         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, DONT_CARE);
  93         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
  94         verifyZeroInteractions(groupsOperation);
  95     }
  96
  97     @Test
  98     public void whenAllPrevGroupsAlreadyExistInNewComponent_returnOk() {
  99         GroupDefinition group1 = createCsarGroup("group1");
 100         GroupDefinition group2 = createUserDefinedGroup("group2");
 101         GroupDefinition group3 = createUserDefinedGroup("group3");
 102         Resource prevResource = createResourceWithGroups(group1, group2, group3);
 103         Resource currResource = createResourceWithGroups(group1, group2, group3);
 104         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource);
 105         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
 106         verifyZeroInteractions(groupsOperation);
 107     }
 108
 109     @Test
 110     public void addAllPrevUserDefinedGroupsToComponent() {
 111         GroupDefinition group1 = createCsarGroup("group1");
 112         GroupDefinition group2 = createUserDefinedGroup("group2");
 113         GroupDefinition group3 = createUserDefinedGroup("group3");
 114         Resource prevResource = createResourceWithGroups(group1, group2, group3);
 115         Resource currResource = createResourceWithGroups(group1, group2);
 116         when(groupsOperation.addGroups(eq(currResource), groupsToAddCaptor.capture())).thenReturn(Either.left(null));
 117         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource);
 118         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
 119         assertThat(groupsToAddCaptor.getValue())
 120                 .containsExactlyInAnyOrder(group3);
 121         assertThat(currResource.getGroups())
 122                 .containsExactlyInAnyOrder(group1, group2, group3);
 123     }
 124
 125     @Test
 126     public void whenPrevUserDefinedGroupHasNoMembers_itShouldHaveNoMembersInNewComponent() {
 127         GroupDefinition group1 = createUserDefinedGroup("group1");
 128         Resource prevResource = createResourceWithGroups(group1);
 129         Resource currResource = new Resource();
 130         when(groupsOperation.addGroups(eq(currResource), groupsToAddCaptor.capture())).thenReturn(Either.left(null));
 131         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource);
 132         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
 133         List<GroupDefinition> groupsAdded = groupsToAddCaptor.getValue();
 134         assertThat(groupsAdded)
 135                 .extracting("members")
 136                 .containsNull();
 137     }
 138
 139     @Test
 140     public void whenPrevUserDefinedGroupHasInstanceMembersThatNotExistInNewComponent_removeMembersFromGroup() {
 141         GroupDefinition group1 = createUserDefinedGroup("group1", "inst1Id", "inst2Id", "inst3Id");
 142         GroupDefinition group2 = createUserDefinedGroup("group2", "inst1Id");
 143
 144         ComponentInstance inst1 = createInstance("inst1", "inst1Id");
 145         ComponentInstance inst2 = createInstance("inst2", "inst2Id");
 146         ComponentInstance inst3 = createInstance("inst3", "inst3Id");
 147
 148         Resource prevResource = createResourceWithGroupsAndInstances(asList(group1, group2), asList(inst1, inst2, inst3));
 149         Resource currResource = createResourceWithInstances(inst3);
 150
 151         when(groupsOperation.addGroups(eq(currResource), groupsToAddCaptor.capture())).thenReturn(Either.left(null));
 152         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource);
 153
 154         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
 155         List<GroupDefinition> groupsAdded = groupsToAddCaptor.getValue();
 156         Map<String, String> group1ExpectedMembers = cmptInstancesToGroups(inst3);
 157         Map<String, String> group2ExpectedMembers = emptyMap();
 158         assertThat(groupsAdded)
 159                 .extracting("members")
 160                 .containsExactlyInAnyOrder(group1ExpectedMembers, group2ExpectedMembers);
 161     }
 162
 163     @Test
 164     public void groupsMembersShouldBeUpdatedAccordingToNewInstancesIds() {
 165         String prevInstance1Id = "inst1Id";
 166         String prevInstance2Id = "inst2Id";
 167
 168         String currInstance1Id = "newInst1Id";
 169         String currInstance2Id = "newInst2Id";
 170
 171         GroupDefinition group1 = createUserDefinedGroup("group1", prevInstance1Id, prevInstance2Id);
 172         ComponentInstance prevInst1 = createInstance("inst1", prevInstance1Id);
 173         ComponentInstance prevInst2 = createInstance("inst2", prevInstance2Id);
 174         Resource prevResource = createResourceWithGroupsAndInstances(singletonList(group1), asList(prevInst1, prevInst2));
 175
 176         ComponentInstance currInst1 = createInstance("inst1", currInstance1Id);
 177         ComponentInstance currInst2 = createInstance("inst2", currInstance2Id);
 178         Resource currResource = createResourceWithInstances(currInst1, currInst2);
 179
 180         when(groupsOperation.addGroups(eq(currResource), groupsToAddCaptor.capture())).thenReturn(Either.left(null));
 181         ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource);
 182         assertThat(actionStatus).isEqualTo(ActionStatus.OK);
 183         List<GroupDefinition> groupsAdded = groupsToAddCaptor.getValue();
 184         assertThat(groupsAdded)
 185                 .extracting("members")
 186                 .containsExactly(cmptInstancesToGroups(currInst1, currInst2));
 187     }
 188
 189     private ComponentInstance createInstance(String name, String instId) {
 190         return new ComponentInstanceBuilder()
 191                     .setName(name)
 192                     .setUniqueId(instId)
 193                     .build();
 194     }
 195
 196     private GroupDefinition createCsarGroup(String id) {
 197         return createGroup(id, CreatedFrom.CSAR);
 198     }
 199
 200     private GroupDefinition createUserDefinedGroup(String id, String ... members) {
 201         return createGroup(id, CreatedFrom.UI, members);
 202     }
 203
 204     private GroupDefinition createGroup(String id, CreatedFrom createdFrom, String ... members) {
 205         GroupDefinitionBuilder groupDefinitionBuilder = GroupDefinitionBuilder.create()
 206                 .setUniqueId(id)
 207                 .setCreatedFrom(createdFrom)
 208                 .setName("name" + id)
 209                 .setInvariantName("invName" + id);
 210         Stream.of(members).forEach(groupDefinitionBuilder::addMember);
 211         return groupDefinitionBuilder.build();
 212     }
 213
 214     private Resource createResourceWithGroups(GroupDefinition ... groups) {
 215         return createResourceWithGroupsAndInstances(asList(groups), null);
 216     }
 217
 218     private Resource createResourceWithInstances(ComponentInstance ... instances) {
 219         return createResourceWithGroupsAndInstances(null, asList(instances));
 220     }
 221
 222     private Resource createResourceWithGroupsAndInstances(List<GroupDefinition> groups, List<ComponentInstance> instances) {
 223         ResourceBuilder resourceBuilder = new ResourceBuilder();
 224         if (groups != null) {
 225             groups.forEach(resourceBuilder::addGroup);
 226         }
 227         if (instances != null) {
 228             instances.forEach(resourceBuilder::addComponentInstance);
 229         }
 230         return resourceBuilder.build();
 231     }
 232
 233     private Map<String, String> cmptInstancesToGroups(ComponentInstance ... instances) {
 234         return Stream.of(instances).collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
 235     }
 236
 237 }