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

   1 package org.openecomp.sdc.be.components.utils;
   2
   3 import org.openecomp.sdc.be.dao.utils.MapUtil;
   4 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
   5 import org.openecomp.sdc.be.model.*;
   6
   7 import java.util.ArrayList;
   8 import java.util.HashMap;
   9 import java.util.List;
  10
  11 public abstract class ComponentBuilder<T extends Component, B extends ComponentBuilder<T, B>> {
  12
  13     private T component;
  14
  15     protected abstract T component();
  16
  17     protected abstract ComponentBuilder<T, B> self();
  18
  19     public ComponentBuilder() {
  20         this.component = component();
  21     }
  22
  23     public ComponentBuilder(T component) {
  24         this.component = component;
  25     }
  26
  27     public ComponentBuilder<T, B> setUniqueId(String id) {
  28         component.setUniqueId(id);
  29         return self();
  30     }
  31
  32     public ComponentBuilder<T, B> setLifeCycleState(LifecycleStateEnum lifeCycleState) {
  33         component.setLifecycleState(lifeCycleState);
  34         return self();
  35     }
  36
  37     public ComponentBuilder<T, B> setLastUpdaterUserId(String lastUpdater) {
  38         component.setLastUpdaterUserId(lastUpdater);
  39         return self();
  40     }
  41
  42     public ComponentBuilder<T, B> setInvariantUUid(String invariantUUid) {
  43         component.setInvariantUUID(invariantUUid);
  44         return self();
  45     }
  46
  47     public ComponentBuilder<T, B> setName(String name) {
  48         component.setName(name);
  49         return self();
  50     }
  51
  52     public ComponentBuilder<T, B> setComponentType(ComponentTypeEnum type) {
  53         component.setComponentType(type);
  54         return self();
  55     }
  56
  57     public ComponentBuilder<T, B> setSystemName(String systemName) {
  58         component.setSystemName(systemName);
  59         return self();
  60     }
  61
  62     public ComponentBuilder<T, B> addComponentInstance(String instanceName) {
  63         ComponentInstance instance = new ComponentInstanceBuilder()
  64                 .setUniqueId(instanceName)
  65                 .setName(instanceName)
  66                 .build();
  67         return addComponentInstance(instance);
  68     }
  69
  70     public ComponentBuilder<T, B> addComponentInstance(String instanceName, String uniqueId) {
  71         ComponentInstance instance = new ComponentInstanceBuilder()
  72                 .setUniqueId(uniqueId)
  73                 .setName(instanceName)
  74                 .build();
  75         return addComponentInstance(instance);
  76     }
  77
  78     public ComponentBuilder<T, B> addComponentInstance(ComponentInstance componentInstance) {
  79         initInstances();
  80         component.getComponentInstances().add(componentInstance);
  81         return self();
  82     }
  83
  84     private void initInstances() {
  85         if (component.getComponentInstances() == null) {
  86             component.setComponentInstances(new ArrayList<>());
  87         }
  88     }
  89
  90     public ComponentBuilder<T, B> addInput(InputDefinition input) {
  91         if (component.getInputs() == null) {
  92             component.setInputs(new ArrayList<>());
  93         }
  94         component.getInputs().add(input);
  95         return self();
  96     }
  97
  98     public ComponentBuilder<T, B> addInput(String inputName) {
  99         InputDefinition inputDefinition = new InputDefinition();
 100         inputDefinition.setName(inputName);
 101         inputDefinition.setUniqueId(inputName);
 102         this.addInput(inputDefinition);
 103         return self();
 104     }
 105
 106     public ComponentBuilder<T, B> addInstanceProperty(String instanceId, ComponentInstanceProperty prop) {
 107         if (component.getComponentInstancesProperties() == null) {
 108             component.setComponentInstancesProperties(new HashMap<>());
 109         }
 110         component.getComponentInstancesProperties().computeIfAbsent(instanceId, key -> new ArrayList<>()).add(prop);
 111         return self();
 112     }
 113
 114     public ComponentBuilder<T, B> addInstanceProperty(String instanceId, String propName) {
 115         ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
 116         componentInstanceProperty.setName(propName);
 117         componentInstanceProperty.setUniqueId(propName);
 118         this.addInstanceProperty(instanceId, componentInstanceProperty);
 119         return self();
 120     }
 121
 122     public ComponentBuilder<T, B> addInstanceInput(String instanceId, ComponentInstanceInput prop) {
 123         if (component.getComponentInstancesInputs() == null) {
 124             component.setComponentInstancesInputs(new HashMap<>());
 125         }
 126         component.getComponentInstancesInputs().computeIfAbsent(instanceId, key -> new ArrayList<>()).add(prop);
 127         return self();
 128     }
 129
 130     public ComponentBuilder<T, B> addInstanceInput(String instanceId, String propName) {
 131         ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
 132         componentInstanceInput.setName(propName);
 133         componentInstanceInput.setUniqueId(propName);
 134         this.addInstanceInput(instanceId, componentInstanceInput);
 135         return self();
 136     }
 137
 138     public ComponentBuilder<T, B> addRelationship(RequirementCapabilityRelDef requirementCapabilityRelDef) {
 139         if (component.getComponentInstancesRelations() == null) {
 140             component.setComponentInstancesRelations(new ArrayList<>());
 141         }
 142         component.getComponentInstancesRelations().add(requirementCapabilityRelDef);
 143         return self();
 144     }
 145
 146     public ComponentBuilder<T, B> addPolicy(PolicyDefinition policyDefinition) {
 147         if (component.getPolicies() == null) {
 148             component.setPolicies(new HashMap<>());
 149         }
 150         component.getPolicies().put(policyDefinition.getUniqueId(), policyDefinition);
 151         return self();
 152     }
 153
 154     public ComponentBuilder<T, B> addPolicyProperty(String policyId, String propName){
 155         PolicyDefinition policyWithProp = PolicyDefinitionBuilder.create()
 156                 .addProperty(propName)
 157                 .setUniqueId(policyId)
 158                 .build();
 159         return addPolicy(policyWithProp);
 160     }
 161
 162     public ComponentBuilder<T, B> addGroup(GroupDefinition groupDefinition){
 163         initGroups();
 164         component.getGroups().add(groupDefinition);
 165         return self();
 166     }
 167
 168     public ComponentBuilder<T, B> addGroupProperty(String groupId, String propName){
 169         GroupDefinition groupWithProp = GroupDefinitionBuilder.create()
 170                 .addProperty(propName)
 171                 .setUniqueId(groupId)
 172                 .build();
 173         return addGroup(groupWithProp);
 174     }
 175
 176     private void initGroups() {
 177         if(component.getGroups() == null){
 178             component.setGroups(new ArrayList<>());
 179         }
 180     }
 181
 182     public ComponentBuilder<T, B> setPolicies(List<PolicyDefinition> policies) {
 183         component.setPolicies(MapUtil.toMap(policies, PolicyDefinition::getUniqueId));
 184         return self();
 185     }
 186
 187     public ComponentBuilder<T, B> setGroups(List<GroupDefinition> groups) {
 188         component.setGroups(groups);
 189         return self();
 190     }
 191
 192     public T build() {
 193         return component;
 194     }
 195 }