gerrit.onap Code Review - sdc/sdc-workflow-designer.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.sdc.workflow.persistence.impl;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertTrue;
  21 import static org.mockito.ArgumentMatchers.isNull;
  22 import static org.mockito.Matchers.any;
  23 import static org.mockito.Matchers.eq;
  24 import static org.mockito.Mockito.doReturn;
  25 import static org.mockito.Mockito.verify;
  26
  27 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
  28 import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
  29 import com.amdocs.zusammen.datatypes.Id;
  30 import com.amdocs.zusammen.datatypes.SessionContext;
  31 import com.amdocs.zusammen.datatypes.item.ElementContext;
  32 import com.amdocs.zusammen.datatypes.item.Info;
  33 import java.util.ArrayList;
  34 import java.util.Collection;
  35 import java.util.Optional;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.junit.runner.RunWith;
  39 import org.mapstruct.ap.internal.util.Collections;
  40 import org.mockito.InjectMocks;
  41 import org.mockito.Mock;
  42 import org.mockito.Spy;
  43 import org.mockito.junit.MockitoJUnitRunner;
  44 import org.onap.sdc.common.versioning.persistence.zusammen.ZusammenSessionContextCreator;
  45 import org.onap.sdc.common.zusammen.services.ZusammenAdaptor;
  46 import org.onap.sdc.workflow.persistence.impl.types.ParameterPropertyName;
  47 import org.onap.sdc.workflow.persistence.impl.types.WorkflowElementType;
  48 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
  49 import org.onap.sdc.workflow.persistence.types.ParameterRole;
  50 import org.onap.sdc.workflow.persistence.types.ParameterType;
  51
  52 @RunWith(MockitoJUnitRunner.class)
  53 public class ParameterRepositoryTest {
  54
  55     private static final String ITEM1_ID = "item_id_1";
  56     private static final String VERSION1_ID = "version_id_1";
  57     private static final String PARAMETER1_ID = "parameter_id_1";
  58     private static final String PARAMETER2_ID = "parameter_id_2";
  59     private static final String PARAMETERS_PARENT_ID = "parameters_id";
  60     private static final SessionContext SESSION_CONTEXT = new SessionContext();
  61
  62     @Mock
  63     private ZusammenAdaptor zusammenAdaptorMock;
  64     @Mock
  65     private ZusammenSessionContextCreator contextCreatorMock;
  66     @Spy
  67     @InjectMocks
  68     private ParameterRepositoryImpl parameterRepository;
  69
  70     @Before
  71     public void setUp() {
  72         doReturn(SESSION_CONTEXT).when(contextCreatorMock).create();
  73     }
  74
  75     @Test
  76     public void shouldGetParameterById() {
  77
  78         ElementInfo element = new ElementInfo();
  79         element.setId(new Id(PARAMETER1_ID));
  80         Info info = new Info();
  81         info.setName("testInput");
  82         info.addProperty(ParameterPropertyName.TYPE.name(), ParameterType.FLOAT.name());
  83         info.addProperty(ParameterPropertyName.MANDATORY.name(), true);
  84         element.setInfo(info);
  85         doReturn(Optional.of(element)).when(zusammenAdaptorMock)
  86                                       .getElementInfo(eq(SESSION_CONTEXT), any(ElementContext.class),
  87                                               eq(new Id(PARAMETER1_ID)));
  88         ParameterEntity result = parameterRepository.get(ITEM1_ID, VERSION1_ID, PARAMETER1_ID);
  89         verify(zusammenAdaptorMock)
  90                 .getElementInfo(eq(SESSION_CONTEXT), any(ElementContext.class), eq(new Id(PARAMETER1_ID)));
  91         assertEquals("testInput", result.getName());
  92
  93     }
  94
  95
  96     @Test
  97     public void shouldUpdateParameter() {
  98         ParameterEntity parameterEntityToUpdate = new ParameterEntity();
  99         parameterEntityToUpdate.setId(PARAMETER1_ID);
 100         parameterEntityToUpdate.setName("Input1");
 101         parameterEntityToUpdate.setMandatory(true);
 102         parameterEntityToUpdate.setType(ParameterType.STRING);
 103
 104         parameterRepository.update(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, parameterEntityToUpdate);
 105         verify(zusammenAdaptorMock)
 106                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 107                         eq("Update WorkflowVersion Parameter"));
 108
 109     }
 110
 111     @Test
 112     public void shouldCreateParameterStructure() {
 113         parameterRepository.createStructure(ITEM1_ID, VERSION1_ID);
 114         verify(zusammenAdaptorMock)
 115                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 116                         eq("Create WorkflowVersion INPUTS Element"));
 117         verify(zusammenAdaptorMock)
 118                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 119                         eq("Create WorkflowVersion OUTPUTS Element"));
 120     }
 121
 122     @Test
 123     public void shouldDeleteParameter() {
 124         parameterRepository.delete(ITEM1_ID, VERSION1_ID, PARAMETER1_ID);
 125         verify(zusammenAdaptorMock)
 126                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 127                         eq("Delete Parameter with id parameter_id_1"));
 128     }
 129
 130
 131     @Test
 132     public void shouldListParametersByType() {
 133
 134         ElementInfo parameter1 = new ElementInfo();
 135         parameter1.setId(new Id(PARAMETER1_ID));
 136         Info info1 = new Info();
 137         info1.setName("input1");
 138         info1.addProperty(ParameterPropertyName.TYPE.name(), "INTEGER");
 139         info1.addProperty(ParameterPropertyName.MANDATORY.name(), true);
 140         parameter1.setInfo(info1);
 141         ElementInfo parameter2 = new ElementInfo();
 142         parameter2.setId(new Id(PARAMETER2_ID));
 143         Info info2 = new Info();
 144         info2.setName("input2");
 145         info2.addProperty(ParameterPropertyName.TYPE.name(), "STRING");
 146         info2.addProperty(ParameterPropertyName.MANDATORY.name(), false);
 147         parameter2.setInfo(info2);
 148         Collection<ElementInfo> parameters = Collections.asSet(parameter1, parameter2);
 149         doReturn(parameters).when(zusammenAdaptorMock)
 150                             .listElementsByName(eq(SESSION_CONTEXT), any(ElementContext.class), isNull(),
 151                                     eq(WorkflowElementType.INPUTS.name()));
 152         Collection<ParameterEntity> results = parameterRepository.list(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
 153
 154         verify(zusammenAdaptorMock).listElementsByName(eq(SESSION_CONTEXT), any(ElementContext.class), isNull(),
 155                 eq(WorkflowElementType.INPUTS.name()));
 156         assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER1_ID)));
 157         assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER2_ID)));
 158     }
 159
 160     @Test
 161     public void shouldDeleteAllParametersByType() {
 162         ElementInfo parameterParentElement = new ElementInfo();
 163         parameterParentElement.setId(new Id(PARAMETERS_PARENT_ID));
 164         ElementInfo parameter1 = new ElementInfo();
 165         parameter1.setId(new Id(PARAMETER1_ID));
 166         ElementInfo parameter2 = new ElementInfo();
 167         parameter2.setId(new Id(PARAMETER2_ID));
 168         parameterParentElement.setSubElements(new ArrayList<>());
 169         parameterParentElement.getSubElements().add(parameter1);
 170         parameterParentElement.getSubElements().add(parameter2);
 171
 172         Optional<ElementInfo> elementOptional = Optional.of(parameterParentElement);
 173
 174         doReturn(elementOptional).when(zusammenAdaptorMock)
 175                                  .getElementInfoByName(eq(SESSION_CONTEXT), any(ElementContext.class), isNull(),
 176                                          eq(WorkflowElementType.INPUTS.name()));
 177
 178         parameterRepository.deleteAll(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
 179         verify(zusammenAdaptorMock)
 180                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 181                         eq("Delete all INPUT"));
 182     }
 183
 184     @Test(expected = IllegalStateException.class)
 185     public void shouldFailIfParentElementDoesNotExist() {
 186         doReturn(Optional.empty()).when(zusammenAdaptorMock)
 187                                  .getElementInfoByName(eq(SESSION_CONTEXT), any(ElementContext.class), isNull(),
 188                                          eq(WorkflowElementType.INPUTS.name()));
 189         parameterRepository.deleteAll(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT);
 190     }
 191
 192     @Test
 193     public void shouldCreateParameter() {
 194         ZusammenElement zusammenParentElement = new ZusammenElement();
 195         zusammenParentElement.setElementId(new Id(PARAMETERS_PARENT_ID));
 196         ZusammenElement zusammenElement = new ZusammenElement();
 197         zusammenElement.setElementId(new Id(PARAMETER1_ID));
 198         zusammenParentElement.addSubElement(zusammenElement);
 199         doReturn(zusammenParentElement).when(zusammenAdaptorMock)
 200                                        .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class),
 201                                                any(ZusammenElement.class), eq("Create WorkflowVersion Parameter Element"));
 202         ParameterEntity parameterEntity = new ParameterEntity("test_input_parameter");
 203         parameterEntity.setType(ParameterType.INTEGER);
 204         parameterEntity.setMandatory(true);
 205
 206         ParameterEntity returnedParameter =
 207                 parameterRepository.create(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, parameterEntity);
 208         verify(zusammenAdaptorMock)
 209                 .saveElement(eq(SESSION_CONTEXT), any(ElementContext.class), any(ZusammenElement.class),
 210                         eq("Create WorkflowVersion Parameter Element"));
 211         assertEquals(PARAMETER1_ID, returnedParameter.getId());
 212     }
 213
 214 }