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