nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateTemplateDefinitionTest.java

   1 /*
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent;
   9
  10 import junit.framework.TestCase;
  11 import org.junit.Assert;
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.ParameterValues;
  15 import static org.junit.Assert.*;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.nemo.user.tenantmanager.TenantManage;
  18 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.GetDefinitions;
  19 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateDefinition;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.PropertyName;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValue;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.definitions.ConnectionDefinition;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNode;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.definitions.MatchItemDefinition;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.Property;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.SubNode;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.definitions.PropertyDefinition;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.StringValue;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.definitions.ActionDefinition;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegment;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.parameter.definitions.ConditionParameterDefinition;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.AbstractIntents;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameter;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractConnection;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractFlow;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractNode;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperation;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConditionParameterName;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.ConditionParameterTargetValue;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.TemplateName;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractObjects;
  48 import java.lang.reflect.Field;
  49 import java.lang.reflect.Method;
  50 import java.util.ArrayList;
  51 import java.util.HashMap;
  52 import java.util.List;
  53 import java.util.Map;
  54 import static org.mockito.Mockito.*;
  55 /**
  56  * Created by zhangmeng on 2015/12/28.
  57  */
  58 public class UpdateTemplateDefinitionTest extends TestCase {
  59     private DataBroker dataBroker;
  60     private TenantManage tenantManage;
  61     private UpdateTemplateDefinition updateTemplateDefinition;
  62     private Class<UpdateTemplateDefinition> class1;
  63     private Field field;
  64     private Method method;
  65     @Before
  66     public void setUp() throws Exception {
  67         class1 = UpdateTemplateDefinition.class;
  68         dataBroker = mock(DataBroker.class);
  69         tenantManage = mock(TenantManage.class);
  70
  71         updateTemplateDefinition = new UpdateTemplateDefinition(dataBroker,tenantManage);
  72     }
  73
  74     @Test
  75     public void testCheckTemplateDefinition() throws Exception {
  76         field = class1.getDeclaredField("getDefinitions");
  77         field.setAccessible(true);
  78
  79         GetDefinitions getDefinitions = mock(GetDefinitions.class);
  80         UserId userId = mock(UserId.class);
  81         NodeId nodeId = mock(NodeId.class);
  82         SubNode subNode = mock(SubNode.class);
  83         EndNode endNode = mock(EndNode.class);
  84         TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
  85         TemplateName templateName = mock(TemplateName.class);
  86         ParameterName parameterName = mock(ParameterName.class);
  87         AbstractIntents abstractIntents = mock(AbstractIntents.class);
  88         TemplateParameter.ParameterValueType parameterValueType = TemplateParameter.ParameterValueType.Int;
  89         TemplateParameter templateParameter = mock(TemplateParameter.class);
  90         AbstractObjects abstractObjects = mock(AbstractObjects.class);
  91         AbstractNode node = mock(AbstractNode.class);
  92         AbstractNode node1 = mock(AbstractNode.class);
  93         NodeType nodeType = mock(NodeType.class);
  94         NodeDefinition nodeDefinition = mock(NodeDefinition.class);
  95         AbstractConnection connection = mock(AbstractConnection.class);
  96         List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
  97         List<TemplateParameter> list = new ArrayList<TemplateParameter>();
  98         List<AbstractNode> nodeList = new ArrayList<AbstractNode>();
  99         List<SubNode> subNodeList = new ArrayList<SubNode>();
 100         List<EndNode> endNodeList = new ArrayList<EndNode>();
 101         List<AbstractNode> nodeList1 = new ArrayList<AbstractNode>();
 102         List<AbstractConnection> connectionList = new ArrayList<AbstractConnection>();
 103         Map<TemplateName, TemplateDefinition> map = mock(Map.class);
 104         Map<NodeType, NodeDefinition> nodeDefinitions = mock(Map.class);
 105         Map<ConnectionType, ConnectionDefinition> connDefinitions =mock(Map.class);
 106         field.set(updateTemplateDefinition, getDefinitions);
 107 //        nodeDefinitions.put(nodeType, nodeDefinition);
 108         list.add(templateParameter);
 109         endNodeList.add(endNode);
 110         nodeList.add(node);
 111         nodeList1.add(node1);
 112         subNodeList.add(subNode);
 113         connectionList.add(connection);
 114
 115         when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
 116         when(tenantManage.getTempalteDefinition(userId))
 117                 .thenReturn(map)
 118                 .thenReturn(map)
 119                 .thenReturn(null);
 120         when(templateDefinition.getTemplateName()).thenReturn(templateName);
 121         when(templateName.getValue()).thenReturn("test");
 122         when(map.containsKey(templateDefinition.getTemplateName())).thenReturn(true);
 123         Assert.assertTrue(updateTemplateDefinition.checkTemplateDefinition(userId, templateDefinition).equals("The template " + templateDefinition.getTemplateName().getValue() + " has been defined."));
 124         verify(tenantManage, times(2)).getTempalteDefinition(userId);
 125         when(templateDefinition.getTemplateParameter()).thenReturn(list);
 126         when(templateParameter.getParameterName()).thenReturn(parameterName);
 127         when(templateParameter.getParameterValueType()).thenReturn(parameterValueType);
 128         when(templateDefinition.getAbstractIntents()).thenReturn(abstractIntents);
 129         when(abstractIntents.getAbstractObjects()).thenReturn(abstractObjects);
 130         when(abstractObjects.getAbstractNode()).thenReturn(nodeList);
 131         when(node.getNodeId()).thenReturn(nodeId);
 132         when(node.getSubNode()).thenReturn(subNodeList);
 133         when(subNode.getNodeId())
 134                 .thenReturn(mock(NodeId.class))
 135                 .thenReturn(nodeId);
 136         Assert.assertTrue(updateTemplateDefinition.checkTemplateDefinition(userId, templateDefinition).equals("The sub node is not defined."));
 137         //get into method "checkNodeTemplate" args(node,map) map(parameterName,parameterValueType)
 138         when(node.getNodeType()).thenReturn(nodeType);
 139         when(nodeDefinitions.containsKey(node.getNodeType())).thenReturn(true);
 140         when(nodeDefinitions.get(node.getNodeType())).thenReturn(nodeDefinition);
 141         when(nodeDefinition.getPropertyDefinition()).thenReturn(null);
 142         when(node.getProperty()).thenReturn(null);
 143         //return
 144
 145     }
 146
 147     @Test
 148     public void testCheckNodeTemplate() throws Exception{
 149         method = class1.getDeclaredMethod("checkNodeTemplate",new Class[]{
 150                 AbstractNode.class,
 151                 Map.class
 152         });
 153         method.setAccessible(true);
 154         field = class1.getDeclaredField("getDefinitions");
 155         field.setAccessible(true);
 156
 157         GetDefinitions getDefinitions = mock(GetDefinitions.class);
 158         AbstractNode node = mock(AbstractNode.class);
 159         NodeType nodeType = mock(NodeType.class);
 160         NodeDefinition nodeDefinition = mock(NodeDefinition.class);
 161         PropertyName propertyName = mock(PropertyName.class);
 162         Property property = mock(Property.class);
 163         StringValue stringValue = mock(StringValue.class);
 164         PropertyValues propertyValues = mock(PropertyValues.class);
 165         PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
 166         PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
 167         TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
 168         List<Property> properties = new ArrayList<Property>();
 169         List<StringValue> stringValues = new ArrayList<StringValue>();
 170         List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
 171         Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
 172         Map<NodeType, NodeDefinition> nodeDefinitions = new HashMap<NodeType, NodeDefinition>();
 173
 174         parameterValueTypeMap.put(new ParameterName("ParameterName"),valueType);
 175
 176         field.set(updateTemplateDefinition, getDefinitions);
 177         when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
 178         when(node.getNodeType()).thenReturn(nodeType);
 179         when(nodeType.getValue()).thenReturn("test");
 180         //test null
 181         Assert.assertTrue(method.invoke(updateTemplateDefinition,node,parameterValueTypeMap).equals("The node type " + node.getNodeType().getValue() + " is not defined."));
 182         verify(node,times(3)).getNodeType();
 183         //test not null
 184         nodeDefinitions.put(nodeType, nodeDefinition);
 185         propertyDefinitions.add(propertyDefinition);
 186         properties.add(property);
 187         stringValues.add(stringValue);
 188         Assert.assertTrue(nodeDefinitions.get(nodeType) == nodeDefinition);
 189         when(nodeDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
 190         when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
 191         when(propertyName.getValue()).thenReturn("test");
 192         when(node.getProperty())
 193                 .thenReturn(null)
 194                 .thenReturn(properties);
 195         Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
 196         when(property.getPropertyName())
 197                 .thenReturn(mock(PropertyName.class))
 198                 .thenReturn(propertyName);
 199         Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap).equals("The property name " + property.getPropertyName().getValue() + " is not defined."));
 200         when(propertyDefinition.getPropertyValueType())
 201                 .thenReturn(PropertyDefinition.PropertyValueType.Int)
 202                 .thenReturn(type);
 203 //        System.out.println("type" + type.getIntValue());
 204         Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
 205         when(property.getPropertyValues()).thenReturn(propertyValues);
 206         when(propertyValues.getStringValue()).thenReturn(stringValues);
 207         when(stringValue.getValue()).thenReturn(new String("ParameterName"));
 208         Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap).equals("The property " + property.getPropertyName().getValue() + " type is not right."));
 209
 210     }
 211
 212     @Test
 213     public void testCheckConnectionTemplate() throws Exception{
 214         method = class1.getDeclaredMethod("checkConnectionTemplate", new Class[]{
 215                 AbstractConnection.class,
 216                 Map.class
 217         });
 218         method.setAccessible(true);
 219         field = class1.getDeclaredField("getDefinitions");
 220         field.setAccessible(true);
 221
 222         GetDefinitions getDefinitions = mock(GetDefinitions.class);
 223         AbstractConnection connection = mock(AbstractConnection.class);
 224         ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
 225         ConnectionType connectionType = mock(ConnectionType.class);
 226         PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
 227         PropertyName propertyName = mock(PropertyName.class);
 228         PropertyValues propertyValues = mock(PropertyValues.class);
 229         StringValue stringValue = mock(StringValue.class);
 230         PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
 231         TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
 232         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property
 233                 property = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property.class);
 234         List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property>
 235                 properties = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property>();
 236         List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
 237         List<StringValue> stringValues = new ArrayList<StringValue>();
 238         Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
 239         Map<ConnectionType, ConnectionDefinition> connDefinitions = new HashMap<ConnectionType, ConnectionDefinition>();
 240
 241         field.set(updateTemplateDefinition, getDefinitions);
 242         propertyDefinitions.add(propertyDefinition);
 243         properties.add(property);
 244         stringValues.add(stringValue);
 245         parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
 246
 247         when(getDefinitions.getConnectionDefinition()).thenReturn(connDefinitions);
 248         when(connection.getConnectionType()).thenReturn(connectionType);
 249         when(connectionType.getValue()).thenReturn("test");
 250         //test null
 251         Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The connection type " + connection.getConnectionType().getValue() + " is not defined."));
 252         //test not null
 253         connDefinitions.put(connectionType, connectionDefinition);
 254         when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
 255         when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
 256         when(connection.getProperty())
 257                 .thenReturn(null)
 258                 .thenReturn(properties);
 259         Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
 260         when(property.getPropertyName())
 261                 .thenReturn(mock(PropertyName.class))
 262                 .thenReturn(propertyName);
 263         when(propertyName.getValue()).thenReturn("test");
 264         Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The property name " + property.getPropertyName().getValue() + " is not defined."));
 265         Assert.assertTrue(type.getIntValue() == 0);
 266         when(propertyDefinition.getPropertyValueType())
 267                 .thenReturn(PropertyDefinition.PropertyValueType.Int)
 268                 .thenReturn(type);
 269         Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
 270         verify(propertyDefinition).getPropertyValueType();
 271         when(property.getPropertyValues()).thenReturn(propertyValues);
 272         when(propertyValues.getStringValue()).thenReturn(stringValues);
 273         when(stringValue.getValue()).thenReturn(new String("ParameterName"));
 274         Assert.assertTrue(parameterValueTypeMap.get(new ParameterName("ParameterName")) == valueType);
 275 //        System.out.println((String) method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap));
 276 //        System.out.println("valuetype" + valueType.getIntValue());
 277         Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The property " + property.getPropertyName().getValue() + " type is not right."));
 278         verify(stringValue).getValue();
 279     }
 280
 281     @Test
 282     public void testCheckFlowTemplate() throws Exception{
 283         method = class1.getDeclaredMethod("checkFlowTemplate",new Class[]{
 284                 AbstractFlow.class,
 285                 Map.class
 286         });
 287         method.setAccessible(true);
 288         field = class1.getDeclaredField("getDefinitions");
 289         field.setAccessible(true);
 290
 291         GetDefinitions getDefinitions = mock(GetDefinitions.class);
 292         AbstractFlow flow = mock(AbstractFlow.class);
 293         MatchItem matchItem = mock(MatchItem.class);
 294         List<MatchItem> matchItemList = new ArrayList<MatchItem>();
 295         MatchItemValue matchItemValue = mock(MatchItemValue.class);
 296         MatchItemName matchItemName = mock(MatchItemName.class);
 297         MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
 298         MatchItemDefinition.MatchItemValueType type = MatchItemDefinition.MatchItemValueType.String;
 299         TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
 300         Map<MatchItemName, MatchItemDefinition> matchItemDefinitionMap = new HashMap<MatchItemName, MatchItemDefinition>();
 301         Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
 302
 303         field.set(updateTemplateDefinition, getDefinitions);
 304         parameterValueTypeMap.put(new ParameterName("ParameterName"),valueType);
 305
 306         when(getDefinitions.getMatchItemDefinition()).thenReturn(matchItemDefinitionMap);
 307         when(flow.getMatchItem()).thenReturn(matchItemList);
 308         Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
 309         matchItemList.add(matchItem);
 310         when(matchItem.getMatchItemName()).thenReturn(matchItemName);
 311         when(matchItemName.getValue()).thenReturn("test");
 312         Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap).equals("The match item " + matchItem.getMatchItemName().getValue() +" is not defined."));
 313         //test add matchItem
 314         matchItemDefinitionMap.put(matchItemName,matchItemDefinition);
 315         Assert.assertTrue(matchItemDefinitionMap.containsKey(matchItemName));
 316         when(matchItemDefinition.getMatchItemValueType())
 317                 .thenReturn(MatchItemDefinition.MatchItemValueType.Int)
 318                 .thenReturn(type);
 319         Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
 320         when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
 321         when(matchItemValue.getStringValue()).thenReturn("ParameterName");
 322         Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap).equals("The match item " + "ParameterName" +" type is not right."));
 323
 324     }
 325
 326     @Test
 327     public void testCheckOperationTemplate() throws Exception{
 328         method = class1.getDeclaredMethod("checkOperationTemplate",new Class[]{
 329                 AbstractOperation.class,
 330                 Map.class
 331         });
 332         method.setAccessible(true);
 333         field = class1.getDeclaredField("getDefinitions");
 334         field.setAccessible(true);
 335
 336         GetDefinitions getDefinitions = mock(GetDefinitions.class);
 337         Action action = mock(Action.class);
 338         ActionName actionName = mock(ActionName.class);
 339         ActionDefinition actionDefinition = mock(ActionDefinition.class);
 340         AbstractOperation operation = mock(AbstractOperation.class);
 341         ConditionSegment conditionSegment = mock(ConditionSegment.class);
 342         ParameterName parameterName = mock(ParameterName.class);
 343         ParameterValues parameterValues = mock(ParameterValues.class);
 344         ConditionParameterName conditionParameterName = mock(ConditionParameterName.class);
 345         ConditionParameterDefinition definition = mock(ConditionParameterDefinition.class);
 346         ConditionParameterDefinition conditionParameterDefinition = mock(ConditionParameterDefinition.class);
 347         ConditionParameterTargetValue conditionParameterTargetValue = mock(ConditionParameterTargetValue.class);
 348         ConditionParameterDefinition.ParameterValueType type = ConditionParameterDefinition.ParameterValueType.String;
 349         TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
 350         ActionDefinition.ParameterValueType type1 = ActionDefinition.ParameterValueType.String;
 351         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue
 352                 stringValue = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue.class);
 353         List<Action> actionList = new ArrayList<Action>();
 354         List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>
 355                 stringValues = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>();
 356         List<ConditionSegment> conditionSegmentList = new ArrayList<ConditionSegment>();
 357         Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
 358         Map<ActionName, ActionDefinition> actionDefinitionMap = new HashMap<ActionName, ActionDefinition>();
 359         Map<ParameterName, ConditionParameterDefinition> conditionParameterDefinitionMap = mock(Map.class);
 360
 361         field.set(updateTemplateDefinition, getDefinitions);
 362         conditionSegmentList.add(conditionSegment);
 363         parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
 364         conditionParameterDefinitionMap.put(parameterName, conditionParameterDefinition);
 365
 366         when(getDefinitions.getActionDefinition()).thenReturn(actionDefinitionMap);
 367         when(getDefinitions.getConditionParameterDefinition()).thenReturn(conditionParameterDefinitionMap);
 368         when(operation.getConditionSegment())
 369                 .thenReturn(null)
 370                 .thenReturn(conditionSegmentList);
 371         when(operation.getAction())
 372                 .thenReturn(null)
 373                 .thenReturn(actionList);
 374         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
 375         //test condition
 376         when(conditionSegment.getConditionParameterName())
 377                 .thenReturn(conditionParameterName);
 378         when(conditionParameterDefinitionMap.containsKey(conditionSegment.getConditionParameterName()))
 379                 .thenReturn(false)
 380                 .thenReturn(true);
 381         when(parameterName.getValue()).thenReturn("test");
 382         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The Condition " + conditionSegment.getConditionParameterName().getValue() + " is not defined."));
 383         when(conditionSegment.getConditionParameterTargetValue())
 384                 .thenReturn(null)
 385                 .thenReturn(conditionParameterTargetValue);
 386         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
 387         when(conditionParameterDefinitionMap.get(conditionSegment.getConditionParameterName())).thenReturn(definition);
 388         when(definition.getParameterValueType())
 389                 .thenReturn(ConditionParameterDefinition.ParameterValueType.Int)
 390                 .thenReturn(type);
 391         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
 392         when(conditionParameterTargetValue.getStringValue()).thenReturn("ParameterName");
 393         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The condition " + conditionSegment.getConditionParameterName().getValue() + " type is not right."));
 394
 395         //test action
 396         conditionSegmentList.clear();
 397         actionList.add(action);
 398         stringValues.add(stringValue);
 399
 400         when(action.getActionName()).thenReturn(actionName);
 401         when(actionName.getValue()).thenReturn("test");
 402         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The action " + action.getActionName().getValue() + " is not defined."));
 403         actionDefinitionMap.put(actionName, actionDefinition);
 404         when(action.getParameterValues())
 405                 .thenReturn(null)
 406                 .thenReturn(parameterValues);
 407         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
 408         when(actionDefinition.getParameterValueType()).thenReturn(type1);
 409         when(parameterValues.getStringValue()).thenReturn(stringValues);
 410         when(stringValue.getValue()).thenReturn("ParameterName");
 411         Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The action " + action.getActionName().getValue() +" type is not right."));
 412     }
 413 }