catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import static org.junit.Assert.assertTrue;
   4 import static org.mockito.ArgumentMatchers.any;
   5 import static org.mockito.ArgumentMatchers.anySet;
   6 import static org.mockito.ArgumentMatchers.eq;
   7 import static org.mockito.Mockito.when;
   8
   9 import java.util.ArrayList;
  10 import java.util.HashMap;
  11 import java.util.HashSet;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.Set;
  15 import java.util.function.BiPredicate;
  16
  17 import org.assertj.core.util.Lists;
  18 import org.junit.Assert;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.mockito.Mockito;
  22 import org.mockito.MockitoAnnotations;
  23 import org.openecomp.sdc.be.components.validation.UserValidations;
  24 import org.openecomp.sdc.be.dao.api.ActionStatus;
  25 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  26 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  27 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  28 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  29 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  30 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  31 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  32 import org.openecomp.sdc.be.impl.ComponentsUtils;
  33 import org.openecomp.sdc.be.impl.ServletUtils;
  34 import org.openecomp.sdc.be.model.CapabilityDefinition;
  35 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  36 import org.openecomp.sdc.be.model.Component;
  37 import org.openecomp.sdc.be.model.ComponentInstance;
  38 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  39 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  40 import org.openecomp.sdc.be.model.ComponentParametersView;
  41 import org.openecomp.sdc.be.model.RelationshipImpl;
  42 import org.openecomp.sdc.be.model.RelationshipInfo;
  43 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  44 import org.openecomp.sdc.be.model.RequirementDefinition;
  45 import org.openecomp.sdc.be.model.Resource;
  46 import org.openecomp.sdc.be.model.Service;
  47 import org.openecomp.sdc.be.model.User;
  48 import org.openecomp.sdc.be.model.jsontitan.operations.ForwardingPathOperation;
  49 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.user.UserBusinessLogic;
  52 import org.openecomp.sdc.exception.ResponseFormat;
  53
  54 import fj.data.Either;
  55
  56 /**
  57  * The test suite designed for test functionality of
  58  * ComponentInstanceBusinessLogic class
  59  */
  60 public class ComponentInstanceBusinessLogicTest {
  61
  62         private final static String USER_ID = "jh0003";
  63         private final static String COMPONENT_ID = "componentId";
  64         private final static String TO_INSTANCE_ID = "toInstanceId";
  65         private final static String FROM_INSTANCE_ID = "fromInstanceId";
  66         private final static String RELATION_ID = "relationId";
  67         private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  68         private final static String CAPABILITY_UID = "capabilityUid";
  69         private final static String CAPABILITY_NAME = "capabilityName";
  70         private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  71         private final static String REQUIREMENT_UID = "requirementUid";
  72         private final static String REQUIREMENT_NAME = "requirementName";
  73         private final static String RELATIONSHIP_TYPE = "relationshipType";
  74
  75         private static ComponentsUtils componentsUtils;
  76         private static ServletUtils servletUtils;
  77         private static ResponseFormat responseFormat;
  78         private static ToscaOperationFacade toscaOperationFacade;
  79         private static UserBusinessLogic userAdmin;
  80
  81         private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
  82         private static ForwardingPathOperation forwardingPathOperation;
  83         private static User user;
  84         private static UserValidations userValidations;
  85         private static Component service;
  86         private static Component resource;
  87         private static ComponentInstance toInstance;
  88         private static ComponentInstance fromInstance;
  89         private static CapabilityDataDefinition capability;
  90         private static RequirementDataDefinition requirement;
  91         private static RequirementCapabilityRelDef relation;
  92         private static BaseBusinessLogic baseBusinessLogic;
  93
  94
  95 //      @BeforeClass
  96 //      public static void setup() {
  97 //              createMocks();
  98 //              setMocks();
  99 //              stubMethods();
 100 //              createComponents();
 101 //
 102 //      }
 103
 104         @Before
 105         public void init() {
 106                 createMocks();
 107                 setMocks();
 108                 stubMethods();
 109                 createComponents();
 110                 MockitoAnnotations.initMocks(this);
 111         }
 112
 113         @Test
 114         public void testGetRelationByIdSuccess() {
 115                 getServiceRelationByIdSuccess(service);
 116                 getServiceRelationByIdSuccess(resource);
 117         }
 118
 119         @Test
 120         public void testGetRelationByIdUserValidationFailure() {
 121                 getServiceRelationByIdUserValidationFailure(service);
 122                 getServiceRelationByIdUserValidationFailure(resource);
 123         }
 124
 125         @Test
 126         public void testGetRelationByIdComponentNotFoundFailure() {
 127                 getRelationByIdComponentNotFoundFailure(service);
 128                 getRelationByIdComponentNotFoundFailure(resource);
 129         }
 130
 131
 132         @Test
 133         public void testForwardingPathOnVersionChange() {
 134                 getforwardingPathOnVersionChange();
 135         }
 136
 137         private void getforwardingPathOnVersionChange() {
 138                 String containerComponentParam = "services";
 139                 String containerComponentID = "121-cont";
 140                 String componentInstanceID = "121-cont-1-comp";
 141                 Service component = new Service();
 142                 Map<String, ForwardingPathDataDefinition> forwardingPaths = generateForwardingPath(componentInstanceID);
 143
 144                 // Add existing componentInstance to component
 145                 List<ComponentInstance> componentInstanceList = new ArrayList<>();
 146                 ComponentInstance oldComponentInstance = new ComponentInstance();
 147                 oldComponentInstance.setName("OLD_COMP_INSTANCE");
 148                 oldComponentInstance.setUniqueId(componentInstanceID);
 149                 oldComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, "1-comp");
 150                 componentInstanceList.add(oldComponentInstance);
 151                 component.setComponentInstances(componentInstanceList);
 152                 component.setForwardingPaths(forwardingPaths);
 153
 154                 List<ComponentInstance> componentInstanceListNew = new ArrayList<>();
 155                 ComponentInstance newComponentInstance = new ComponentInstance();
 156                 String new_Comp_UID = "2-comp";
 157                 newComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, new_Comp_UID);
 158                 newComponentInstance.setUniqueId(new_Comp_UID);
 159                 componentInstanceListNew.add(newComponentInstance);
 160                 Component component2 = new Service();
 161                 component2.setComponentInstances(componentInstanceListNew);
 162
 163                 // Mock for getting component
 164                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
 165                                 .thenReturn(Either.left(component));
 166                 when(toscaOperationFacade.validateComponentExists(any(String.class))).thenReturn(Either.left(Boolean.TRUE));
 167                 // Mock for getting component for componentInstance
 168                 when(toscaOperationFacade.getToscaFullElement(eq("1-comp"))).thenReturn(Either.left(component));
 169                 when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2));
 170
 171                 Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic.forwardingPathOnVersionChange(
 172                                 containerComponentParam, containerComponentID, componentInstanceID, newComponentInstance);
 173                 Assert.assertEquals(1, resultOp.left().value().size());
 174                 Assert.assertEquals("FP-ID-1", resultOp.left().value().iterator().next());
 175
 176         }
 177
 178         @Test
 179         public void testDeleteForwardingPathsWhenComponentinstanceDeleted() {
 180
 181                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
 182                 String containerComponentID = "Service-comp";
 183                 String componentInstanceID = "NodeA1";
 184                 Service component = new Service();
 185
 186                 component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1", "1"));
 187                 component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2"));
 188                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
 189                                 .thenReturn(Either.left(component));
 190                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
 191                 when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
 192                                 .thenReturn(Either.left(new HashSet<>()));
 193                 Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic
 194                                 .deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentID, componentInstanceID,
 195                                                 containerComponentType, Either.left(new ComponentInstance()));
 196                 Assert.assertTrue(responseFormatEither.isLeft());
 197
 198         }
 199
 200         @Test
 201         public void testDeleteForwardingPathsWhenErrorInComponentinstanceDelete() {
 202
 203                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
 204                 String containerComponentID = "Service-comp";
 205                 String componentInstanceID = "NodeA1";
 206                 Service component = new Service();
 207
 208                 component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1", "1"));
 209                 component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2"));
 210                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
 211                                 .thenReturn(Either.left(component));
 212                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
 213                 when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
 214                                 .thenReturn(Either.left(new HashSet<>()));
 215                 Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic
 216                                 .deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentID, componentInstanceID,
 217                                                 containerComponentType, Either.right(new ResponseFormat()));
 218                 Assert.assertTrue(responseFormatEither.isRight());
 219
 220         }
 221
 222         private ForwardingPathDataDefinition createPath(String pathName, String fromNode, String toNode, String uniqueId) {
 223                 ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition(pathName);
 224                 forwardingPath.setProtocol("protocol");
 225                 forwardingPath.setDestinationPortNumber("port");
 226                 forwardingPath.setUniqueId(uniqueId);
 227                 ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
 228                 forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(fromNode, toNode,
 229                                 "nodeAcpType", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
 230                 forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 231
 232                 return forwardingPath;
 233         }
 234
 235         private Map<String, ForwardingPathDataDefinition> generateForwardingPath(String componentInstanceID) {
 236                 ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("fpName");
 237                 String protocol = "protocol";
 238                 forwardingPath.setProtocol(protocol);
 239                 forwardingPath.setDestinationPortNumber("DestinationPortNumber");
 240                 forwardingPath.setUniqueId("FP-ID-1");
 241                 ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
 242                 forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(componentInstanceID,
 243                                 "nodeB", "nodeA_FORWARDER_CAPABILITY", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
 244                 forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 245                 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 246                 forwardingPaths.put("1122", forwardingPath);
 247                 return forwardingPaths;
 248         }
 249
 250         @SuppressWarnings("unchecked")
 251         private void getServiceRelationByIdSuccess(Component component) {
 252                 Either<User, ActionStatus> eitherCreator = Either.left(user);
 253                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 254                 Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
 255                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
 256                                 .thenReturn(getComponentRes);
 257
 258                 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = Either.left(requirement);
 259                 when(toscaOperationFacade.getFulfilledRequirementByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID),
 260                                 eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledRequirementRes);
 261
 262                 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledCapabilityRes = Either.left(capability);
 263                 when(toscaOperationFacade.getFulfilledCapabilityByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation),
 264                                 any(BiPredicate.class))).thenReturn(getfulfilledCapabilityRes);
 265
 266                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
 267                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 268                 assertTrue(response.isLeft());
 269         }
 270
 271         private void getServiceRelationByIdUserValidationFailure(Component component) {
 272                 // Either<User, ActionStatus> eitherCreator =
 273                 // Either.right(ActionStatus.USER_NOT_FOUND);
 274                 // when(userAdmin.getUser(eq(USER_ID),
 275                 // eq(false))).thenReturn(eitherCreator);
 276                 when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false)))
 277                                 .thenReturn(Either.right(new ResponseFormat(404)));
 278                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
 279                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 280                 assertTrue(response.isRight());
 281         }
 282
 283         private void getRelationByIdComponentNotFoundFailure(Component component) {
 284                 Either<User, ActionStatus> eitherCreator = Either.left(user);
 285                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 286                 Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
 287                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
 288                                 .thenReturn(getComponentRes);
 289
 290                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
 291                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 292                 assertTrue(response.isRight());
 293         }
 294
 295         private static void createMocks() {
 296                 componentsUtils = Mockito.mock(ComponentsUtils.class);
 297                 servletUtils = Mockito.mock(ServletUtils.class);
 298                 responseFormat = Mockito.mock(ResponseFormat.class);
 299                 toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 300                 userAdmin = Mockito.mock(UserBusinessLogic.class);
 301                 user = Mockito.mock(User.class);
 302                 baseBusinessLogic = Mockito.mock(BaseBusinessLogic.class);
 303                 userValidations = Mockito.mock(UserValidations.class);
 304                 forwardingPathOperation = Mockito.mock(ForwardingPathOperation.class);
 305         }
 306
 307         private static void setMocks() {
 308                 componentInstanceBusinessLogic = new ComponentInstanceBusinessLogic();
 309                 componentInstanceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 310                 componentInstanceBusinessLogic.setUserAdmin(userAdmin);
 311                 componentInstanceBusinessLogic.setComponentsUtils(componentsUtils);
 312                 componentInstanceBusinessLogic.setUserValidations(userValidations);
 313                 componentInstanceBusinessLogic.setForwardingPathOperation(forwardingPathOperation);
 314         }
 315
 316         private static void stubMethods() {
 317                 when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
 318                 when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false)))
 319                                 .thenReturn(Either.left(user));
 320                 when(componentsUtils.getResponseFormat(eq(ActionStatus.RELATION_NOT_FOUND), eq(RELATION_ID), eq(COMPONENT_ID)))
 321                                 .thenReturn(responseFormat);
 322         }
 323
 324         private static void createComponents() {
 325                 createRelation();
 326                 createInstances();
 327                 createService();
 328                 createResource();
 329         }
 330
 331         private static void createResource() {
 332                 resource = new Resource();
 333                 resource.setUniqueId(COMPONENT_ID);
 334                 resource.setComponentInstancesRelations(Lists.newArrayList(relation));
 335                 resource.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
 336                 resource.setCapabilities(toInstance.getCapabilities());
 337                 resource.setRequirements(fromInstance.getRequirements());
 338                 resource.setComponentType(ComponentTypeEnum.RESOURCE);
 339         }
 340
 341         private static void createService() {
 342                 service = new Service();
 343                 service.setUniqueId(COMPONENT_ID);
 344                 service.setComponentInstancesRelations(Lists.newArrayList(relation));
 345                 service.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
 346                 service.setCapabilities(toInstance.getCapabilities());
 347                 service.setRequirements(fromInstance.getRequirements());
 348                 service.setComponentType(ComponentTypeEnum.SERVICE);
 349         }
 350
 351         private static void createInstances() {
 352                 toInstance = new ComponentInstance();
 353                 toInstance.setUniqueId(TO_INSTANCE_ID);
 354
 355                 fromInstance = new ComponentInstance();
 356                 fromInstance.setUniqueId(FROM_INSTANCE_ID);
 357
 358                 capability = new CapabilityDataDefinition();
 359                 capability.setOwnerId(CAPABILITY_OWNER_ID);
 360                 capability.setUniqueId(CAPABILITY_UID);
 361                 capability.setName(CAPABILITY_NAME);
 362
 363                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 364                 capabilities.put(capability.getName(), Lists.newArrayList(new CapabilityDefinition(capability)));
 365
 366                 requirement = new RequirementDataDefinition();
 367                 requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 368                 requirement.setUniqueId(REQUIREMENT_UID);
 369                 requirement.setName(REQUIREMENT_NAME);
 370                 requirement.setRelationship(RELATIONSHIP_TYPE);
 371
 372                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 373                 requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement)));
 374
 375                 toInstance.setCapabilities(capabilities);
 376                 fromInstance.setRequirements(requirements);
 377         }
 378
 379         private static void createRelation() {
 380
 381                 relation = new RequirementCapabilityRelDef();
 382                 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 383                 RelationshipInfo relationInfo = new RelationshipInfo();
 384                 relationInfo.setId(RELATION_ID);
 385                 relationship.setRelation(relationInfo);
 386
 387                 relation.setRelationships(Lists.newArrayList(relationship));
 388                 relation.setToNode(TO_INSTANCE_ID);
 389                 relation.setFromNode(FROM_INSTANCE_ID);
 390
 391                 relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 392                 relationInfo.setCapabilityUid(CAPABILITY_UID);
 393                 relationInfo.setCapability(CAPABILITY_NAME);
 394                 relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 395                 relationInfo.setRequirementUid(REQUIREMENT_UID);
 396                 relationInfo.setRequirement(REQUIREMENT_NAME);
 397                 RelationshipImpl relationshipImpl = new RelationshipImpl();
 398                 relationshipImpl.setType(RELATIONSHIP_TYPE);
 399                 relationInfo.setRelationships(relationshipImpl);
 400         }
 401
 402         private ComponentInstanceBusinessLogic createTestSubject() {
 403                         return componentInstanceBusinessLogic;
 404         }
 405
 406
 407
 408
 409
 410         @Test
 411         public void testChangeServiceProxyVersion() throws Exception {
 412                 ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 413                 String containerComponentType = "";
 414                 String containerComponentId = "";
 415                 String serviceProxyId = "";
 416                 String userId = "";
 417                 Either<ComponentInstance, ResponseFormat> result;
 418
 419                 // default test
 420                 componentInstanceBusinessLogic = createTestSubject();
 421                 result = componentInstanceBusinessLogic.changeServiceProxyVersion(containerComponentType, containerComponentId, serviceProxyId,
 422                                 userId);
 423         }
 424
 425
 426
 427
 428
 429
 430
 431         @Test
 432         public void testCreateServiceProxy() throws Exception {
 433                 ComponentInstanceBusinessLogic testSubject;
 434                 String containerComponentType = "";
 435                 String containerComponentId = "";
 436                 String userId = "";
 437                 ComponentInstance componentInstance = null;
 438                 Either<ComponentInstance, ResponseFormat> result;
 439
 440                 // default test
 441                 testSubject = createTestSubject();
 442                 result = testSubject.createServiceProxy(containerComponentType, containerComponentId, userId,
 443                                 componentInstance);
 444         }
 445
 446
 447
 448
 449         @Test
 450         public void testDeleteForwardingPathsRelatedTobeDeletedComponentInstance() throws Exception {
 451                 ComponentInstanceBusinessLogic testSubject;
 452                 String containerComponentId = "";
 453                 String componentInstanceId = "";
 454                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.RESOURCE;
 455                 Either<ComponentInstance, ResponseFormat> resultOp = null;
 456                 Either<ComponentInstance, ResponseFormat> result;
 457
 458                 // default test
 459                 testSubject = createTestSubject();
 460                 result = testSubject.deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId,
 461                                 componentInstanceId, containerComponentType, resultOp);
 462         }
 463
 464
 465         @Test
 466         public void testDeleteServiceProxy() throws Exception {
 467                 ComponentInstanceBusinessLogic testSubject;
 468                 String containerComponentType = "";
 469                 String containerComponentId = "";
 470                 String serviceProxyId = "";
 471                 String userId = "";
 472                 Either<ComponentInstance, ResponseFormat> result;
 473
 474                 // default test
 475                 testSubject = createTestSubject();
 476                 result = testSubject.deleteServiceProxy(containerComponentType, containerComponentId, serviceProxyId, userId);
 477         }
 478
 479
 480
 481
 482
 483
 484         @Test
 485         public void testGetComponentInstanceInputsByInputId() throws Exception {
 486                 ComponentInstanceBusinessLogic testSubject;
 487                 Component component = new Service();
 488                 String inputId = "";
 489                 List<ComponentInstanceInput> result;
 490
 491                 // default test
 492                 testSubject = createTestSubject();
 493                 result = testSubject.getComponentInstanceInputsByInputId(component, inputId);
 494         }
 495
 496
 497
 498         @Test
 499         public void testGetComponentInstancePropertiesByInputId() throws Exception {
 500                 ComponentInstanceBusinessLogic testSubject;
 501                 Component component = new Service();
 502                 String inputId = "";
 503                 List<ComponentInstanceProperty> result;
 504
 505                 // default test
 506                 testSubject = createTestSubject();
 507                 result = testSubject.getComponentInstancePropertiesByInputId(component, inputId);
 508         }
 509
 510
 511         @Test
 512         public void testGetRelationById() throws Exception {
 513                 ComponentInstanceBusinessLogic testSubject;
 514                 String componentId = "";
 515                 String relationId = "";
 516                 String userId = "";
 517                 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE_INSTANCE;
 518                 Either<RequirementCapabilityRelDef, ResponseFormat> result;
 519
 520                 // default test
 521                 testSubject = createTestSubject();
 522                 result = testSubject.getRelationById(componentId, relationId, userId, componentTypeEnum);
 523         }
 524
 525
 526 }
 527
 528
 529