gerrit.onap Code Review - sdc.git/blob

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