From 27c483217e85eab6d2be89837bec7b594514c35f Mon Sep 17 00:00:00 2001 From: ldzd11 <1875840145@qq.com> Date: Sat, 26 Dec 2015 17:25:50 +0800 Subject: [PATCH 1/1] Added two test files Change-Id: Ia5c73891a0fd9be8929599d751c7eb7e72479623 Signed-off-by: ldzd11 <1875840145@qq.com> --- .../UpdateTemplateDefinitionLangTest.java | 354 ++++++++++++++++++ .../UpdateTemplateInstanceLangTest.java | 94 +++++ 2 files changed, 448 insertions(+) create mode 100644 nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLangTest.java create mode 100644 nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateInstanceLangTest.java diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLangTest.java new file mode 100644 index 0000000..31d9884 --- /dev/null +++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLangTest.java @@ -0,0 +1,354 @@ +/* + * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.nemo.user.tenantmanager.TenantManage; +import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants; +import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.GetDefinitions; +import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHost; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValueBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValuesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.ParameterValuesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegment; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.ConditionParameterTargetValueBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.AbstractIntentsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameter; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractObjectsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractOperationsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId; +import java.lang.reflect.Field; +import java.util.*; +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/12/29. + */ +public class UpdateTemplateDefinitionLangTest extends TestCase { + private DataBroker dataBroker; + private TenantManage tenantManage; + private UpdateTemplateDefinitionLang updateTemplateDefinitionLang; + private Class class1; + private Field field_definition; + private Field field_abstractNodes ; + private Field field_abstractConnections; + private Field field_abstractFlows; + private Field field_abstractOperations; + private Field field; + + @Before + public void setUp() throws Exception { + class1 = UpdateTemplateDefinitionLang.class; + field_definition = class1.getDeclaredField("definition"); + field_abstractNodes = class1.getDeclaredField("abstractNodes"); + field_abstractConnections = class1.getDeclaredField("abstractConnections"); + field_abstractFlows = class1.getDeclaredField("abstractFlows"); + field_abstractOperations = class1.getDeclaredField("abstractOperations"); + field = class1.getDeclaredField("getDefinitions"); + field_definition.setAccessible(true); + field_abstractNodes.setAccessible(true); + field_abstractConnections.setAccessible(true); + field_abstractFlows.setAccessible(true); + field_abstractOperations.setAccessible(true); + field.setAccessible(true); + + dataBroker = mock(DataBroker.class); + tenantManage = mock(TenantManage.class); + + updateTemplateDefinitionLang = new UpdateTemplateDefinitionLang(dataBroker,tenantManage); + } + + @Test + public void testTemplateDefinitionLang() throws Exception { + + UserId userId = mock(UserId.class); + NodeName nodeName = mock(NodeName.class); + AbstractNode abstractNode = mock(AbstractNode.class); + ConnectionName connectionName = mock(ConnectionName.class); + AbstractConnection abstractConnection = mock(AbstractConnection.class); + FlowName flowName = mock(FlowName.class); + AbstractFlow abstractFlow = mock(AbstractFlow.class); + OperationName operationName = mock(OperationName.class); + AbstractOperation abstractOperation = mock(AbstractOperation.class); + UpdateTemplateDefinition updateTemplateDefinition = mock(UpdateTemplateDefinition.class); + String templateName = new String("test"); + String value = new String("string"); + LinkedHashMap parameters = new LinkedHashMap(); + Map abstractNodes = new HashMap(); + Map abstractConnections = new HashMap(); + Map abstractFlows = new HashMap(); + Map abstractOperations = new HashMap(); + + parameters.put(value, NEMOConstants.string); + abstractConnections.put(connectionName,abstractConnection); + abstractNodes.put(nodeName, abstractNode); + abstractFlows.put(flowName,abstractFlow); + abstractOperations.put(operationName,abstractOperation); + field_definition.set(updateTemplateDefinitionLang, updateTemplateDefinition); + + when(updateTemplateDefinition.checkTemplateDefinition(any(UserId.class),any(TemplateDefinition.class))) + .thenReturn("1") + .thenReturn("2") + .thenReturn("3"); + Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("1")); + parameters.clear(); + parameters.put(value, NEMOConstants.integer); + field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes); + field_abstractConnections.set(updateTemplateDefinitionLang, abstractConnections); + field_abstractFlows.set(updateTemplateDefinitionLang,abstractFlows); + field_abstractOperations.set(updateTemplateDefinitionLang,abstractOperations); + Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("2")); + parameters.clear(); + parameters.put(value, NEMOConstants.range); + Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("3")); + verify(updateTemplateDefinition,times(3)).checkTemplateDefinition(any(UserId.class),any(TemplateDefinition.class)); + } + + @Test + public void testCreateAbstractNode() throws Exception { + String name = new String("name"); + String type = NEMOConstants.host; + List subnodes = new ArrayList(); + LinkedHashMap> propertyList = new LinkedHashMap>(); + GetDefinitions getDefinitions = mock(GetDefinitions.class); + String nodeName1 = new String("nodeName"); + String propertyName = new String("propertyName"); + String ValueName = new String("valuename"); + String Value = NEMOConstants.string; + NodeName nodeName = new NodeName(nodeName1); + AbstractNode abstractNode = mock(AbstractNode.class); + PhysicalHostId physicalHostId = mock(PhysicalHostId.class); + PhysicalHost physicalHost = mock(PhysicalHost.class); + LinkedHashMap values = new LinkedHashMap(); + Map physicalHostMap = mock(Map.class); + Map abstractNodes = new HashMap(); + + field.set(updateTemplateDefinitionLang, getDefinitions); + subnodes.add(nodeName1); + + when(getDefinitions.getPhysicalHost()).thenReturn(physicalHostMap); + when(physicalHostMap.containsKey(any(PhysicalHostName.class))) + .thenReturn(false) + .thenReturn(true); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList).equals("The host " + name + " is not exist in physical network.")); + when(physicalHostMap.get(any(PhysicalHostName.class))).thenReturn(physicalHost); + when(physicalHost.getHostId()).thenReturn(physicalHostId); + when(physicalHostId.getValue()).thenReturn("00001111-0000-0000-0000-000011112222"); + //test nodes empty + field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList).equals("There are no nodes.")); + //nodes not empty propertyList empty + abstractNodes.put(nodeName, abstractNode); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null); + //propertyList not empty + propertyList.put(propertyName,values); + values.put(ValueName,Value); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null); + values.clear(); + values.put("11", NEMOConstants.integer); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null); + values.clear(); + values.put("1,1", NEMOConstants.range); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null); + type = NEMOConstants.SubNodes; + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null); + + } + + @Test + public void testCreateAbstractConnection() throws Exception { + String name = new String("name"); + String type = NEMOConstants.host; + String endNode = new String("endNode"); + String propertyName = new String("propertyName"); + String ValueName = new String("valuename"); + String Value = NEMOConstants.string; + List endnodes = new ArrayList(); + NodeName nodeName = mock(NodeName.class); + NodeId nodeId = mock(NodeId.class); + AbstractNode abstractNode = mock(AbstractNode.class); + LinkedHashMap values = new LinkedHashMap(); + LinkedHashMap> propertyList = new LinkedHashMap>(); + Map abstractNodes = new HashMap(); + + abstractNodes.put(nodeName, abstractNode); + endnodes.add(endNode); + + //test abstractNodes empty + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList).equals("There are nodes exist.")); + //abstractNodes not empty + field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList).equals("The endnode " + endNode + " is not exit.")); + abstractNodes.clear(); + abstractNodes.put(new NodeName(endNode), abstractNode); + when(abstractNode.getNodeId()).thenReturn(nodeId); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null); + //test propertyList not null + propertyList.put(propertyName, values); + // string + values.put(ValueName,Value); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null); + values.clear(); + values.put("11", NEMOConstants.integer); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null); + values.clear(); + values.put("1,1", NEMOConstants.range); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null); + + } + + @Test + public void testCreateAbstractFlow() throws Exception { + String name = new String("name"); + String value = new String("value"); + String Value = NEMOConstants.string; + String matchName = new String("matchName"); + LinkedHashMap values = new LinkedHashMap(); + LinkedHashMap> matches = new LinkedHashMap>(); + LinkedHashMap> propertyList = new LinkedHashMap>(); + + matches.put(matchName,values); + + //string + values.put(value,Value); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null); + values.clear(); + values.put("11", NEMOConstants.integer); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null); + values.clear(); + values.put("1,1", NEMOConstants.range); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null); + + } + + @Test + public void testCreateAbstractOperation() throws Exception { + String name = new String("name"); + String target = new String("target"); + String priority = new String("1"); + LinkedHashMap> conditions = new LinkedHashMap>(); + LinkedHashMap>actions = new LinkedHashMap>(); + + String conditionName = new String("!,name,=="); + String value = new String("value"); + String actionName = new String("actionName"); + AbstractNode abstractNode = mock(AbstractNode.class); + AbstractFlow abstractFlow = mock(AbstractFlow.class); + AbstractConnection abstractConnection = mock(AbstractConnection.class); + LinkedHashMap parameters = new LinkedHashMap(); + LinkedHashMap targetValue = new LinkedHashMap(); + Map abstractNodes = mock(Map.class); + Map abstractConnections = mock(Map.class); + Map abstractFlows = mock(Map.class); + + field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes); + field_abstractConnections.set(updateTemplateDefinitionLang, abstractConnections); + field_abstractFlows.set(updateTemplateDefinitionLang, abstractFlows); + + when(abstractNodes.containsKey(any(NodeName.class))).thenReturn(true); + when(abstractNodes.get(new NodeName(target))).thenReturn(abstractNode); + when(abstractNode.getNodeId()).thenReturn(mock(NodeId.class)); + when(abstractConnections.containsKey(any(ConnectionName.class))).thenReturn(true); + when(abstractConnections.get(new ConnectionName(target))).thenReturn(abstractConnection); + when(abstractConnection.getConnectionId()).thenReturn(mock(ConnectionId.class)); + when(abstractFlows.containsKey(any(FlowName.class))).thenReturn(true); + when(abstractFlows.get(new FlowName(target))).thenReturn(abstractFlow); + when(abstractFlow.getFlowId()).thenReturn(mock(FlowId.class)); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + //test conditions not empty + targetValue.put(value,NEMOConstants.string); //string + conditions.put(conditionName, targetValue);// not equal +// System.out.println(",1,2".split(NEMOConstants.comma)[1] == null); +// System.out.println("split" + conditionName.split(NEMOConstants.comma)[0] + "+" + conditionName.split(NEMOConstants.comma)[2]); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("11", NEMOConstants.integer); // int + conditions.put("&&,name,!=", targetValue);// and notEqual + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put("||,name,>", targetValue);// and greater_than + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put(",name,<", targetValue);// null less_than + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put(",name,>=", targetValue);// null not_less_than + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put(",name,<=", targetValue);// null not_greater_than + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put(",name,*", targetValue);// null between + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + targetValue.clear(); + conditions.clear(); + targetValue.put("1,1", NEMOConstants.range); // range + conditions.put(",name,==", targetValue);// null equal + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + + //test actions not empty + parameters.put("string", NEMOConstants.string); + actions.put(actionName, parameters); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + actions.clear(); + parameters.clear(); + parameters.put("11", NEMOConstants.integer); + actions.put(actionName, parameters); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null); + actions.clear(); + parameters.clear(); + parameters.put("1,1", NEMOConstants.range); + actions.put(actionName,parameters); + Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions).equals("The action values are not consistent.")); + + + } +} \ No newline at end of file diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateInstanceLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateInstanceLangTest.java new file mode 100644 index 0000000..7477350 --- /dev/null +++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateInstanceLangTest.java @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang; + +import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.nemo.user.tenantmanager.TenantManage; +import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants; +import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateTemplateInstanceLang; +import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateInstance; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameter; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameterBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameterKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.template.parameter.ParameterValuesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.template.parameter.parameter.values.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.Field; +import java.util.*; +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; +/** + * Created by zhangmeng on 2015/12/29. + */ +public class UpdateTemplateInstanceLangTest extends TestCase { + private DataBroker dataBroker; + private TenantManage tenantManage; + private UpdateTemplateInstanceLang updateTemplateInstanceLang; + @Before + public void setUp() throws Exception { + dataBroker = mock(DataBroker.class); + tenantManage = mock(TenantManage.class); + + updateTemplateInstanceLang = new UpdateTemplateInstanceLang(dataBroker,tenantManage); + } + + @Test + public void testTemplateInstanceLang() throws Exception { + Class class1 = UpdateTemplateInstanceLang.class; + Field field = class1.getDeclaredField("updateTemplateInstance"); + field.setAccessible(true); + + UserId userId = mock(UserId.class); + String nodeName = new String("nodename"); + String nodeType = new String("nodetype"); + LinkedHashMap> propertyList = new LinkedHashMap>(); + LinkedHashMap values = new LinkedHashMap(); + Map map = mock(Map.class); + UpdateTemplateInstance updateTemplateInstance = mock(UpdateTemplateInstance.class); + String parameterName = new String("parameterName"); + + propertyList.put(parameterName, values); + values.put("string", NEMOConstants.string); + field.set(updateTemplateInstanceLang, updateTemplateInstance); + + when(tenantManage.getTemplateInstance(userId)) + .thenReturn(map) + .thenReturn(map) + .thenReturn(null); + when(tenantManage.getObjectId(userId, nodeName)).thenReturn("11111111-1111-1111-1111-111111111111"); + when(map.containsKey(any(TemplateInstanceId.class))) + .thenReturn(true) + .thenReturn(false); + Assert.assertTrue(updateTemplateInstanceLang.templateInstanceLang(userId, nodeName, nodeType, propertyList).equals("The instance " + nodeName + " has exist.")); + verify(tenantManage,times(2)).getTemplateInstance(userId); + Assert.assertTrue(propertyList.get(parameterName) == values); + when(updateTemplateInstance.checkTemplateInstance(any(UserId.class), any(TemplateInstance.class))) + .thenReturn(null) + .thenReturn("int") + .thenReturn("range"); + doNothing().when(tenantManage).setUserTemplateInstance(any(UserId.class), any(TemplateInstanceId.class), any(TemplateInstance.class)); + Assert.assertTrue(updateTemplateInstanceLang.templateInstanceLang(userId, nodeName, nodeType, propertyList) == null); + values.clear(); + values.put("11", NEMOConstants.integer); + Assert.assertTrue(updateTemplateInstanceLang.templateInstanceLang(userId, nodeName, nodeType, propertyList).equals("int")); + values.clear(); + values.put("1,1", NEMOConstants.range); + Assert.assertTrue(updateTemplateInstanceLang.templateInstanceLang(userId, nodeName, nodeType, propertyList).equals("range")); + verify(updateTemplateInstance,times(3)).checkTemplateInstance(any(UserId.class), any(TemplateInstance.class)); + } +} \ No newline at end of file -- 2.36.6