catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/CapabilitiesValidationTest.java

   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.openecomp.sdc.be.components.validation;
  18
  19
  20 import fj.data.Either;
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.mockito.Mockito;
  25 import org.mockito.MockitoAnnotations;
  26 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  27 import org.openecomp.sdc.be.model.CapabilityDefinition;
  28 import org.openecomp.sdc.be.model.Component;
  29 import org.openecomp.sdc.be.model.Resource;
  30 import org.openecomp.sdc.exception.ResponseFormat;
  31
  32 import java.util.ArrayList;
  33 import java.util.Collections;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37
  38 import static org.mockito.ArgumentMatchers.any;
  39 import static org.mockito.Mockito.when;
  40
  41 public class CapabilitiesValidationTest  {
  42     private ResponseFormatManager responseFormatManagerMock;
  43     private final Component component = createComponent();
  44     private final CapabilitiesValidationUtilTest capabilitiesValidationUtilTest = new CapabilitiesValidationUtilTest();
  45     @Before
  46     public void init() {
  47         MockitoAnnotations.openMocks(this);
  48         responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
  49         when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  50         when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  51         when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  52     }
  53
  54     @Test
  55     public void shouldPassCapabilitiesValidationForHappyScenario() {
  56         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
  57         capabilityDefinitions.add(createCapability("capName", "capDesc", "capType", "source1",
  58                 "0", "10"));
  59         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
  60                 .validateCapabilities(capabilityDefinitions, component, false);
  61         Assert.assertTrue(validateCapabilitiesResponseEither.isLeft());
  62     }
  63
  64     @Test
  65     public void shouldFailWhenCapabilityNameAlreadyExist() {
  66         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
  67         capabilityDefinitions.add(createCapability("capNameC", "capDesc", "capType", "source1",
  68                 "0", "10"));
  69         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
  70                 .validateCapabilities(capabilityDefinitions, component, false);
  71         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
  72     }
  73
  74     @Test
  75     public void shouldFailWhenCapabilityNameEmpty() {
  76         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
  77         capabilityDefinitions.add(createCapability("", "capDesc", "capType", "source1",
  78                 "0", "10"));
  79         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
  80                 .validateCapabilities(capabilityDefinitions, component, false);
  81         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
  82     }
  83
  84     @Test
  85     public void shouldFailWhenCapabilityTypeEmpty() {
  86         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
  87         capabilityDefinitions.add(createCapability("capName1", "capDesc", "", "source1",
  88                 "0", "10"));
  89         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
  90                 .validateCapabilities(capabilityDefinitions, component, false);
  91         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
  92     }
  93
  94     @Test
  95     public void shouldFailWhenCapabilityMaxOccurrencesLessThanMinOccurrences() {
  96         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
  97         capabilityDefinitions.add(createCapability("capName1", "capDesc", "capType", "source1",
  98                 "111", "3"));
  99         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 100                 .validateCapabilities(capabilityDefinitions, component, false);
 101         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 102     }
 103
 104     @Test
 105     public void shouldPassWhenCapabilityMaxOccurrencesIsUnbounded() {
 106         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 107         capabilityDefinitions.add(createCapability("capName1", "capDesc", "capType", "source1",
 108                 "111", "UNBOUNDED"));
 109         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 110                 .validateCapabilities(capabilityDefinitions, component, false);
 111         Assert.assertTrue(validateCapabilitiesResponseEither.isLeft());
 112     }
 113
 114     @Test
 115     public void shouldFailWhenCapabilityMinOccurrencesIsNegative() {
 116         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 117         capabilityDefinitions.add(createCapability("capName1", "capDesc", "capType", "source1",
 118                 "-1", "3"));
 119         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 120                 .validateCapabilities(capabilityDefinitions, component, false);
 121         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 122     }
 123
 124     @Test
 125     public void shouldThrowExceptionWhenMin_MaxOccurrencesIsNotInteger() {
 126         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 127         capabilityDefinitions.add(createCapability("capName1", "capDesc", "capType", "source1",
 128                 "occur", "3"));
 129         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 130                 .validateCapabilities(capabilityDefinitions, component, false);
 131         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 132     }
 133
 134     @Test
 135     public void shouldFailWhenCapabilityNotFoundForUpdate() {
 136         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 137         CapabilityDefinition capabilityToUpdate = createCapability("capName1", "capDesc", "capType", "source1",
 138                 "1", "3");
 139         capabilityToUpdate.setUniqueId("uniqueId2");
 140
 141         capabilityDefinitions.add(capabilityToUpdate);
 142         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 143                 .validateCapabilities(capabilityDefinitions, component, true);
 144         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 145     }
 146
 147     @Test
 148     public void shouldFailWhenCapabilityMapIsEmptyInComponentForUpdate() {
 149         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 150         CapabilityDefinition capabilityToUpdate = createCapability("capName1", "capDesc", "capType", "source1",
 151                 "1", "3");
 152         capabilityToUpdate.setUniqueId("uniqueId2");
 153         capabilityDefinitions.add(capabilityToUpdate);
 154         Component resource = new Resource();
 155         List<CapabilityDefinition> componentCap = new ArrayList<>();
 156         Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 157         capabilityMap.put("capTypeC", componentCap);
 158
 159         resource.setCapabilities(capabilityMap);
 160         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 161                 .validateCapabilities(capabilityDefinitions, resource, true);
 162         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 163     }
 164
 165     @Test
 166     public void shouldFailWhenCapabilityMapIsNullInComponentForUpdate() {
 167         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 168         CapabilityDefinition capabilityToUpdate = createCapability("capName1", "capDesc", "capType", "source1",
 169                 "1", "3");
 170         capabilityToUpdate.setUniqueId("uniqueId2");
 171
 172         capabilityDefinitions.add(capabilityToUpdate);
 173         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 174                 .validateCapabilities(capabilityDefinitions, new Resource(), true);
 175         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 176     }
 177
 178     @Test
 179     public void shouldFailWhenCapabilityNameContainsSpecialSymbolExceptDot() {
 180         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 181         capabilityDefinitions.add(createCapability("cap@name", "capDesc", "capType", "source1",
 182                 "0", "10"));
 183         Either<Boolean, ResponseFormat> validateCapabilitiesResponseEither = capabilitiesValidationUtilTest
 184                 .validateCapabilities(capabilityDefinitions, component, false);
 185         Assert.assertTrue(validateCapabilitiesResponseEither.isRight());
 186     }
 187
 188     private CapabilityDefinition createCapability(String name, String description, String type,
 189                                                   String validSourceTypes, String minOccurrences,
 190                                                   String maxOccurrences) {
 191         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 192         capabilityDefinition.setName(name);
 193         capabilityDefinition.setDescription(description);
 194         capabilityDefinition.setType(type);
 195         capabilityDefinition.setValidSourceTypes(Collections.singletonList(validSourceTypes));
 196         capabilityDefinition.setMaxOccurrences(maxOccurrences);
 197         capabilityDefinition.setMinOccurrences(minOccurrences);
 198         capabilityDefinition.setUniqueId("uniqueId");
 199
 200         return capabilityDefinition;
 201     }
 202
 203     private Resource createComponent() {
 204         Resource resource = new Resource();
 205         resource.setName("Resource1");
 206         resource.addCategory("Network Layer 2-3", "Router");
 207         resource.setDescription("My short description");
 208         List<String> tgs = new ArrayList<>();
 209         tgs.add("test");
 210         tgs.add(resource.getName());
 211         resource.setTags(tgs);
 212
 213         List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
 214         capabilityDefinitions.add(createCapability("capNameC", "capDesc", "capType", "source1",
 215                 "0", "10"));
 216         Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 217         capabilityMap.put("capTypeC", capabilityDefinitions);
 218         resource.setCapabilities(capabilityMap);
 219
 220         return resource;
 221     }
 222
 223     private class CapabilitiesValidationUtilTest extends CapabilitiesValidation {
 224
 225         protected ResponseFormatManager getResponseFormatManager() {
 226             return responseFormatManagerMock;
 227         }
 228     }
 229 }