catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java

   1 package org.openecomp.sdc.be.components.utils;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5 import java.util.Map;
   6 import java.util.Optional;
   7
   8 import org.junit.Assert;
   9 import org.junit.Before;
  10 import org.junit.Test;
  11 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  12 import org.openecomp.sdc.be.model.InterfaceDefinition;
  13 import org.openecomp.sdc.be.model.Operation;
  14 import org.openecomp.sdc.be.model.Resource;
  15 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  16
  17 public class InterfaceOperationUtilsTest {
  18
  19     private static final String TEST_RESOURCE_NAME = "TestResource";
  20     private static final String operationId = "operationId";
  21     private static final String operationName = "createOperation";
  22     private static final String interfaceId = "interfaceId";
  23     private static final String operationId1 = "operationId1";
  24     private static final String interfaceId1 = "interfaceId1";
  25     private static Resource resource;
  26
  27     @Before
  28     public void setup() {
  29         resource =
  30                 new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setName(TEST_RESOURCE_NAME).build();
  31         resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId,
  32                 operationName));
  33     }
  34
  35     @Test
  36     public void testGetInterfaceDefinitionFromComponentByInterfaceTypeSuccess() {
  37         Assert.assertTrue(
  38                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId)
  39                         .isPresent());
  40     }
  41
  42     @Test
  43     public void testGetInterfaceDefinitionFromComponentByInterfaceTypeFailure() {
  44         Assert.assertFalse(
  45                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, TEST_RESOURCE_NAME)
  46                         .isPresent());
  47     }
  48
  49     @Test
  50     public void testGetInterfaceDefinitionFromComponentByInterfaceTypeNoInterface() {
  51         resource.getInterfaces().clear();
  52         Assert.assertFalse(
  53                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId)
  54                         .isPresent());
  55     }
  56
  57     @Test
  58     public void testGetInterfaceDefinitionFromComponentByInterfaceIdSuccess() {
  59         Assert.assertTrue(
  60                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId)
  61                         .isPresent());
  62     }
  63
  64     @Test
  65     public void testGetInterfaceDefinitionFromComponentByInterfaceIdFailure() {
  66         Assert.assertFalse(
  67                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, TEST_RESOURCE_NAME)
  68                         .isPresent());
  69     }
  70
  71     @Test
  72     public void testGetInterfaceDefinitionFromComponentByInterfaceIdNoInterface() {
  73         resource.getInterfaces().clear();
  74         Assert.assertFalse(
  75                 InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId)
  76                         .isPresent());
  77     }
  78
  79     @Test
  80     public void testGetOperationFromInterfaceDefinitionSuccess() {
  81         Assert.assertTrue(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
  82                 InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), operationId).isPresent());
  83     }
  84
  85     @Test
  86     public void testGetOperationFromInterfaceDefinitionFailure() {
  87         Assert.assertFalse(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
  88                 InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), TEST_RESOURCE_NAME)
  89                                    .isPresent());
  90     }
  91
  92     @Test
  93     public void testGetOperationFromInterfaceDefinitionNoOperationMap() {
  94         InterfaceDefinition interfaceDefinition =
  95                 InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName);
  96         interfaceDefinition.getOperations().clear();
  97         Optional<Map.Entry<String, Operation>> operationEntry =
  98                 InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, TEST_RESOURCE_NAME);
  99         Assert.assertFalse(operationEntry.isPresent());
 100     }
 101
 102     @Test
 103     public void testGetInterfaceDefinitionFromOperationIdSuccess() {
 104         List<InterfaceDefinition> interfaces = new ArrayList<>();
 105         interfaces.add(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName));
 106         interfaces.add(InterfaceOperationTestUtils.createMockInterface(interfaceId1, operationId1, operationName));
 107         Assert.assertTrue(InterfaceOperationUtils.getInterfaceDefinitionFromOperationId(interfaces, operationId)
 108                                   .isPresent());
 109     }
 110
 111     @Test
 112     public void testGetInterfaceDefinitionFromOperationIdFailure() {
 113         List<InterfaceDefinition> interfaces = new ArrayList<>();
 114         interfaces.add(InterfaceOperationTestUtils.createMockInterface(interfaceId1, operationId1, operationName));
 115         Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromOperationId(interfaces, operationId)
 116                                   .isPresent());
 117     }
 118
 119     @Test
 120     public void testGetInterfaceDefinitionFromOperationIdFailureInterfacesEmpty() {
 121         List<InterfaceDefinition> interfaces = new ArrayList<>();
 122         Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromOperationId(interfaces, operationId)
 123                                    .isPresent());
 124     }
 125
 126 }