catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/RequirementValidationTest.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 import fj.data.Either;
  20 import org.junit.Assert;
  21 import org.junit.Before;
  22 import org.junit.Test;
  23 import org.mockito.Mockito;
  24 import org.mockito.MockitoAnnotations;
  25 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  26 import org.openecomp.sdc.be.model.Component;
  27 import org.openecomp.sdc.be.model.RequirementDefinition;
  28 import org.openecomp.sdc.be.model.Resource;
  29 import org.openecomp.sdc.exception.ResponseFormat;
  30
  31 import java.util.ArrayList;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35
  36 import static org.mockito.ArgumentMatchers.any;
  37 import static org.mockito.Mockito.when;
  38
  39 public class RequirementValidationTest {
  40     private ResponseFormatManager responseFormatManagerMock;
  41     private final Component component = createComponent();
  42     private final RequirementValidationUtilTest requirementValidationUtilTest = new RequirementValidationUtilTest();
  43     @Before
  44     public void init() {
  45         MockitoAnnotations.openMocks(this);
  46         responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
  47         when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  48         when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  49         when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  50     }
  51
  52     @Test
  53     public void shouldPassRequirementsValidationForHappyScenario() {
  54         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
  55         requirementsDefinitions.add(createRequirement("reqName", "capType", "node", "source1",
  56                 "0", "10"));
  57         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
  58                 .validateRequirements(requirementsDefinitions, component, false);
  59         Assert.assertTrue(validateRequirementsResponseEither.isLeft());
  60     }
  61
  62     @Test
  63     public void shouldFailWhenRequirementNameAlreadyExist() {
  64         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
  65         requirementsDefinitions.add(createRequirement("ReqNameC", "capType", "node", "source1",
  66                 "0", "10"));
  67         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
  68                 .validateRequirements(requirementsDefinitions, component, false);
  69         Assert.assertTrue(validateRequirementsResponseEither.isRight());
  70     }
  71
  72     @Test
  73     public void shouldFailWhenRequirementNameEmpty() {
  74         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
  75         requirementsDefinitions.add(createRequirement("", "capType", "node", "source1",
  76                 "0", "10"));
  77         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
  78                 .validateRequirements(requirementsDefinitions, component, false);
  79         Assert.assertTrue(validateRequirementsResponseEither.isRight());
  80     }
  81
  82     @Test
  83     public void shouldFailWhenRequirementCapabilityEmpty() {
  84         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
  85         requirementsDefinitions.add(createRequirement("reqName1", "", "node", "source1",
  86                 "0", "10"));
  87         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
  88                 .validateRequirements(requirementsDefinitions, component, false);
  89         Assert.assertTrue(validateRequirementsResponseEither.isRight());
  90     }
  91
  92     @Test
  93     public void shouldFailWhenRequirementMaxOccurrencesLessThanMinOccurrences() {
  94         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
  95         requirementsDefinitions.add(createRequirement("reqName1", "capType", "node", "source1",
  96                 "111", "3"));
  97         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
  98                 .validateRequirements(requirementsDefinitions, component, false);
  99         Assert.assertTrue(validateRequirementsResponseEither.isRight());
 100     }
 101
 102     @Test
 103     public void shouldFailWhenRequirementNotFoundForUpdate() {
 104         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
 105         RequirementDefinition requirementsToUpdate = createRequirement("reqName1", "capType", "node", "source1",
 106                 "1", "3");
 107         requirementsToUpdate.setUniqueId("uniqueId2");
 108
 109         requirementsDefinitions.add(requirementsToUpdate);
 110         Either<Boolean, ResponseFormat> validateRequirementsResponseEither = requirementValidationUtilTest
 111                 .validateRequirements(requirementsDefinitions, component, true);
 112         Assert.assertTrue(validateRequirementsResponseEither.isRight());
 113     }
 114
 115     private RequirementDefinition createRequirement(String name, String capability, String node,
 116                                                     String relationship, String minOccurrences,
 117                                                     String maxOccurrences) {
 118         RequirementDefinition requirementDefinition = new RequirementDefinition();
 119         requirementDefinition.setName(name);
 120         requirementDefinition.setCapability(capability);
 121         requirementDefinition.setNode(node);
 122         requirementDefinition.setRelationship(relationship);
 123         requirementDefinition.setMaxOccurrences(maxOccurrences);
 124         requirementDefinition.setMinOccurrences(minOccurrences);
 125         requirementDefinition.setUniqueId("uniqueId");
 126
 127         return requirementDefinition;
 128     }
 129
 130     private Resource createComponent() {
 131         Resource resource = new Resource();
 132         resource.setName("Resource1");
 133         resource.addCategory("Network Layer 2-3", "Router");
 134         resource.setDescription("My short description");
 135         List<String> tgs = new ArrayList<>();
 136         tgs.add("test");
 137         tgs.add(resource.getName());
 138         resource.setTags(tgs);
 139
 140         List<RequirementDefinition> requirementsDefinitions = new ArrayList<>();
 141         requirementsDefinitions.add(createRequirement("ReqNameC", "reqDesc", "capType", "source1",
 142                 "0", "10"));
 143         Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
 144         requirementsMap.put("capTypeC", requirementsDefinitions);
 145         resource.setRequirements(requirementsMap);
 146
 147         return resource;
 148     }
 149
 150     private class RequirementValidationUtilTest extends RequirementValidation {
 151
 152         protected ResponseFormatManager getResponseFormatManager() {
 153             return responseFormatManagerMock;
 154         }
 155     }
 156 }