import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+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.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.object.rev151010.ConnectionDefinitions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.MatchItemDefinitions;
}
+
+ @Test
+ public void testGetPhysicalHost() throws Exception {
+ Map<PhysicalHostName, PhysicalHost> map1 = new HashMap<PhysicalHostName, PhysicalHost>();
+ PhysicalHostName physicalHostName = mock(PhysicalHostName.class);
+ PhysicalHost physicalHost = mock(PhysicalHost.class);
+ map1.put(physicalHostName,physicalHost);
+
+ List<PhysicalHost> physicalHostList = new ArrayList<PhysicalHost>();
+ physicalHostList.add(physicalHost);
+
+ Class<GetDefinitions> class_1 = GetDefinitions.class;
+ Field field = class_1.getDeclaredField("physicalHostList");
+ field.setAccessible(true);
+
+ field.set(getDefinitions, physicalHostList);
+ CheckedFuture physicalHostsFuture = mock(CheckedFuture.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(physicalHostsFuture);
+ when(physicalHost.getHostName()).thenReturn(physicalHostName);
+
+ Assert.assertEquals(getDefinitions.getPhysicalHost(), map1);
+ }
}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.structurestyle.updateintent;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;
+import com.google.common.base.Optional;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionId;
+
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Connection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.ConnectionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.ConnectionKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.ConnectionDefinitions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.definitions.ConnectionDefinition;
+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.Property;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.definitions.PropertyDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.PropertyName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import java.util.LinkedList;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import java.util.*;
+import java.util.List;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+
+import com.google.common.util.concurrent.CheckedFuture;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.doNothing;
+
+/**
+ * Created by ldzd11 on 2015/12/21.
+ */
+public class UpdateConnectionTest {
+
+ UpdateConnection updateConnection;
+
+ private DataBroker dataBroker;
+ private TenantManage tenantManage;
+ private List<Property> propertyList;
+ private PropertyName propertyName;
+ private PropertyName propertyName2;
+ private Property property;
+ private Connection connection;
+ private Connection connection2;
+ private NodeId nodeId;
+ private NodeId nodeId2;
+
+
+ private List<Connection> connectionList;
+ private ConnectionType connectionType;
+ private ConnectionType connectionType2;
+ private ConnectionName connectionName;
+ private ConnectionName connectionName2;
+ private User user;
+ private UserId userId;
+ private ConnectionId connectionId;
+ private Objects objects;
+ private EndNode endNode;
+ private List<EndNode> endNodeList;
+ private EndNode endNode2;
+ private List<EndNode> endNodeList2;
+ private Node node;
+ private Node node2;
+
+
+
+ private PropertyDefinition propertyDefinition;
+ private List<PropertyDefinition> propertyDefinitionList;
+ @Before
+ public void setUp() throws Exception {
+ dataBroker = mock(DataBroker.class);
+ tenantManage = mock(TenantManage.class);
+
+ property = mock(Property.class);
+ propertyList = new ArrayList<Property>(1);
+ propertyList.add(property);
+
+ propertyName = mock(PropertyName.class);
+ propertyName2 = mock(PropertyName.class);
+
+ connectionName = mock(ConnectionName.class);
+ connectionName2 = mock(ConnectionName.class);
+
+ propertyDefinition = mock(PropertyDefinition.class);
+ propertyDefinitionList = new ArrayList<PropertyDefinition>(1);
+ propertyDefinitionList.add(propertyDefinition);
+
+ connectionType = mock(ConnectionType.class);
+ connectionType2 = mock(ConnectionType.class);
+ connection = mock(Connection.class);
+ connection2 = mock(Connection.class);
+ connectionList = new ArrayList<Connection>(1);
+ connectionList.add(connection);
+ objects = mock(Objects.class);
+
+ user = mock(User.class);
+ userId = mock(UserId.class);
+ nodeId = mock(NodeId.class);
+ nodeId2 = mock(NodeId.class);
+
+ endNode = mock(EndNode.class);
+ endNodeList = new ArrayList<EndNode>();
+ endNodeList.add(endNode);
+ endNode2 = mock(EndNode.class);
+ endNodeList2 = new ArrayList<EndNode>();
+ endNodeList2.add(endNode2);
+ node = mock(Node.class);
+ node2 = mock(Node.class);
+
+
+ connectionId = mock(ConnectionId.class);
+ updateConnection = new UpdateConnection(dataBroker,tenantManage);
+
+ }
+
+ @Test
+ public void testConnectionHandling() throws Exception {
+
+ CheckedFuture connectiondefinitionFuture = mock(CheckedFuture.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(connectiondefinitionFuture);
+
+ List<ConnectionDefinition> connectionDefinitionList = new ArrayList<ConnectionDefinition>();
+ List<ConnectionDefinition> connectionDefinitionListnull = new ArrayList<ConnectionDefinition>();
+ ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
+ connectionDefinitionList.add(connectionDefinition);
+ when(connectionDefinition.getConnectionType()).thenReturn(connectionType);
+
+
+ Class<UpdateConnection> class1 = UpdateConnection.class;
+ Class<GetDefinitions> class2 = GetDefinitions.class;
+ Field field = class1.getDeclaredField("getDefinitions");
+ field.setAccessible(true);
+ Field field1 = class2.getDeclaredField("connectionDefinitionsList");
+ field1.setAccessible(true);
+
+ field1.set(field.get(updateConnection), connectionDefinitionList);
+ when(connection.getConnectionType()).thenReturn(connectionType);
+ when(connection.getProperty()).thenReturn(null);
+ when(connectionDefinition.getPropertyDefinition()).thenReturn(null);
+
+ when(tenantManage.getConnection(userId)).thenReturn(null);
+ when(tenantManage.getConnectionDataStore(userId)).thenReturn(null);
+ when(connection.getEndNode()).thenReturn(endNodeList);
+ Map<NodeId, Node> map2 = new HashMap<NodeId, Node>();
+ map2.put(nodeId, node2);
+ when(tenantManage.getNode(userId)).thenReturn(map2);
+ when(endNode.getNodeId()).thenReturn(nodeId);
+ when(tenantManage.getNodeDataStore(userId)).thenReturn(map2);
+ when(connection.getConnectionId()).thenReturn(connectionId);
+ doNothing().when(tenantManage).setConnection(any(UserId.class),any(ConnectionId.class),any(Connection.class));
+ Assert.assertEquals(updateConnection.ConnectionHandling(userId,connection),null);
+
+
+
+ /* when(tenantManage.getUser()).thenReturn(null);
+ when(connection.getEndNode()).thenReturn(null);
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ ConnectionId connectionId = mock(ConnectionId.class);
+ when(connection.getConnectionId()).thenReturn(connectionId);
+
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> f;
+ f=mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(f);
+ Assert.assertEquals(updateConnection.ConnectionHandling(userId,connection),null);
+ */
+
+
+
+
+
+
+
+
+ }
+
+ @Test
+ public void testcheckInstance() throws Exception {
+ Class<UpdateConnection> class1 = UpdateConnection.class;
+ Method method = class1.getDeclaredMethod("checkInstance", new Class[]{UserId.class, Connection.class});
+ method.setAccessible(true);
+
+ Map<ConnectionId, Connection> map1 = new HashMap<ConnectionId, Connection>();
+ map1.put(connectionId, connection2);
+
+ when(tenantManage.getConnection(userId)).thenReturn(map1);
+ when(connection.getConnectionId()).thenReturn(connectionId);
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection name should not be changed.");
+
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName2);
+ when(connection2.getConnectionType()).thenReturn(connectionType2);
+ when(connection.getConnectionType()).thenReturn(connectionType);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection type should not be changed.");
+
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName2);
+ when(connection2.getConnectionType()).thenReturn(connectionType2);
+ when(connection.getConnectionType()).thenReturn(connectionType2);
+ when(connection2.getEndNode()).thenReturn(endNodeList2);
+ when(connection.getEndNode()).thenReturn(endNodeList);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection end node should not be changed.");
+
+ when(tenantManage.getConnection(userId)).thenReturn(null);
+ when(tenantManage.getConnectionDataStore(userId)).thenReturn(map1);
+ when(connection.getConnectionId()).thenReturn(connectionId);
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection name should not be changed.");
+
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName2);
+ when(connection2.getConnectionType()).thenReturn(connectionType2);
+ when(connection.getConnectionType()).thenReturn(connectionType);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection type should not be changed.");
+
+ when(connection2.getConnectionName()).thenReturn(connectionName2);
+ when(connection.getConnectionName()).thenReturn(connectionName2);
+ when(connection2.getConnectionType()).thenReturn(connectionType2);
+ when(connection.getConnectionType()).thenReturn(connectionType2);
+ when(connection2.getEndNode()).thenReturn(endNodeList2);
+ when(connection.getEndNode()).thenReturn(endNodeList);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The connection end node should not be changed.");
+
+ when(tenantManage.getConnection(userId)).thenReturn(null);
+ when(tenantManage.getConnectionDataStore(userId)).thenReturn(null);
+ when(connection.getEndNode()).thenReturn(endNodeList);
+
+ Map<NodeId, Node> map2 = new HashMap<NodeId, Node>();
+ map2.put(nodeId, node2);
+ when(tenantManage.getNode(userId)).thenReturn(map2);
+ when(endNode.getNodeId()).thenReturn(nodeId);
+ when(tenantManage.getNodeDataStore(userId)).thenReturn(map2);
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), null);
+
+ when(tenantManage.getConnection(userId)).thenReturn(null);
+ when(tenantManage.getConnectionDataStore(userId)).thenReturn(null);
+ when(connection.getEndNode()).thenReturn(endNodeList);
+ when(tenantManage.getNode(userId)).thenReturn(null);
+ when(tenantManage.getNodeDataStore(userId)).thenReturn(null);
+ when(endNode.getNodeId()).thenReturn(nodeId);
+ when(endNode.getNodeId().getValue()).thenReturn(new String("nodeId"));
+ Assert.assertEquals(method.invoke(updateConnection, userId, connection), "The endnode "+ endNode.getNodeId().getValue() +" is not exist;");
+ }
+
+ @Test
+ public void testcheckDefinition() throws Exception {
+ Class<UpdateConnection> class3 = UpdateConnection.class;
+ Method method = class3.getDeclaredMethod("checkDefinition",new Class[]{Connection.class});
+ method.setAccessible(true);
+
+ CheckedFuture connectiondefinitionFuture = mock(CheckedFuture.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(connectiondefinitionFuture);
+
+ List<ConnectionDefinition> connectionDefinitionList = new ArrayList<ConnectionDefinition>();
+ List<ConnectionDefinition> connectionDefinitionListnull = new ArrayList<ConnectionDefinition>();
+ ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
+ connectionDefinitionList.add(connectionDefinition);
+ when(connectionDefinition.getConnectionType()).thenReturn(connectionType);
+
+
+ Class<UpdateConnection> class1 = UpdateConnection.class;
+ Class<GetDefinitions> class2 = GetDefinitions.class;
+ Field field = class1.getDeclaredField("getDefinitions");
+ field.setAccessible(true);
+ Field field1 = class2.getDeclaredField("connectionDefinitionsList");
+ field1.setAccessible(true);
+
+
+ // when(connection.getConnectionType()).thenReturn(connectionType);
+ // when(connection.getProperty()).thenReturn(propertyList);
+ // when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitionList);
+ // Assert.assertEquals(method.invoke(updateConnection, connection), "There are no properties for this type of connection.");
+
+ field1.set(field.get(updateConnection), connectionDefinitionList);
+ when(connection.getConnectionType()).thenReturn(connectionType);
+ when(connection.getProperty()).thenReturn(propertyList);
+ when(connectionDefinition.getPropertyDefinition()).thenReturn(null);
+ // when(connection.getConnectionType()).thenReturn(connectionType2);
+ Assert.assertEquals(method.invoke(updateConnection, connection), "There are no properties for this type of connection.");
+
+ field1.set(field.get(updateConnection), connectionDefinitionList);
+ when(connection.getConnectionType()).thenReturn(connectionType);
+ when(connection.getProperty()).thenReturn(propertyList);
+ when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitionList);
+ when(property.getPropertyName()).thenReturn(propertyName);
+ when(propertyDefinition.getPropertyName()).thenReturn(propertyName2);
+ when(property.getPropertyName().toString()).thenReturn(new String("propertyname"));
+ Assert.assertEquals(method.invoke(updateConnection, connection), "This type of propertypropertyname has not been defined.");
+
+ when(connection.getConnectionType()).thenReturn(connectionType2);
+ Assert.assertEquals(method.invoke(updateConnection, connection),"This type of connection has not been defined.");
+
+ field1.set(field.get(updateConnection), connectionDefinitionListnull);
+ Assert.assertEquals(method.invoke(updateConnection, connection), "This type of connection has not been defined.");
+
+ }
+
+ @Test
+ public void testcheckProperty() throws Exception {
+ Class<UpdateConnection> class1 = UpdateConnection.class;
+ Method method = class1.getDeclaredMethod("checkProperty",new Class[]{List.class,List.class});
+ method.setAccessible(true);
+ when(property.getPropertyName()).thenReturn(propertyName);
+ when(propertyDefinition.getPropertyName()).thenReturn(propertyName2);
+ when(property.getPropertyName().toString()).thenReturn(new String("propertyname"));
+ Assert.assertEquals(method.invoke(updateConnection, propertyList, propertyDefinitionList), "This type of propertypropertyname has not been defined.");
+
+
+
+
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.structurestyle.updateintent;
+
+
+
+import static org.mockito.Mockito.doNothing;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;
+import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.MatchItemName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.FlowBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.FlowKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.MatchItemDefinitions;
+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.match.item.definitions.MatchItemDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowName;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.LinkedList;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import java.util.*;
+import java.util.List;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.CheckedFuture;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by ldzd11 on 2015/12/22.
+ */
+public class UpdateFlowTest {
+
+ private UpdateFlow updateFlow;
+ private DataBroker dataBroker;
+ private TenantManage tenantManage;
+ private MatchItemName matchItemName;
+ private MatchItemName matchItemName2;
+ private MatchItem matchItem;
+ private List<MatchItem> matchItemList;
+ private List<MatchItem> matchItemListnull;
+ private User user;
+ private UserId userId;
+ private Objects objects;
+ private List<Flow> flowList;
+ private FlowId flowId;
+ private FlowName flowName;
+ private FlowName flowName2;
+
+
+
+ private MatchItemValue matchItemValue;
+ private Flow flow;
+ private Flow flow2;
+
+ @Before
+ public void setUp() throws Exception {
+ dataBroker = mock(DataBroker.class);
+ tenantManage = mock(TenantManage.class);
+ matchItemName = mock(MatchItemName.class);
+ matchItemName2= mock(MatchItemName.class);
+ matchItem = mock(MatchItem.class);
+ matchItemList = new ArrayList<MatchItem>(1);
+ matchItemListnull = new ArrayList<MatchItem>();
+ userId = mock(UserId.class);
+ user = mock(User.class);
+ matchItemList.add(matchItem);
+ flow = mock(Flow.class);
+ flow2 = mock(Flow.class);
+ flowId = mock(FlowId.class);
+ flowName = mock(FlowName.class);
+ flowName2 = mock(FlowName.class);
+
+ matchItemValue = mock(MatchItemValue.class);
+ objects = mock(Objects.class);
+ flowList = new ArrayList<Flow>(1);
+ flowList.add(flow2);
+
+ updateFlow = new UpdateFlow(dataBroker,tenantManage);
+
+ }
+
+
+
+
+ @Test
+ public void testFlowHandling() throws Exception {
+
+ //into checkdefinition for error = null
+ CheckedFuture matchitemdefinitionFuture = mock(CheckedFuture.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(matchitemdefinitionFuture);
+
+ List<MatchItemDefinition> matchItemDefinitions = new ArrayList<MatchItemDefinition>();
+ MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
+ matchItemDefinitions.add(matchItemDefinition);
+ when(matchItemDefinition.getMatchItemName()).thenReturn(matchItemName);
+
+ Class<UpdateFlow> class1 = UpdateFlow.class;
+ Class<GetDefinitions> class2 = GetDefinitions.class;
+ Field field = class1.getDeclaredField("getDefinitions");
+ field.setAccessible(true);
+ Field field1 = class2.getDeclaredField("matchItemDefinitionList");
+ field1.setAccessible(true);
+
+ field1.set(field.get(updateFlow), matchItemDefinitions);
+ when(flow.getMatchItem()).thenReturn(null);
+ //into checkinstance for error = null
+ when(tenantManage.getFlow(userId)).thenReturn(null);
+ when(tenantManage.getFlowDataStore(userId)).thenReturn(null);
+ doNothing().when(tenantManage).setFlow(any(UserId.class),any(FlowId.class),any(Flow.class));
+
+
+ Assert.assertEquals(updateFlow.FlowHandling(userId, flow), null);
+
+
+
+
+ }
+
+ @Test
+ public void testcheckInstance() throws Exception {
+ Class<UpdateFlow> class1 = UpdateFlow.class;
+ Method method = class1.getDeclaredMethod("checkInstance",new Class[]{UserId.class, Flow.class});
+ method.setAccessible(true);
+ Map<FlowId,Flow> map1 = new HashMap<FlowId, Flow>();
+ map1.put(flowId,flow2);
+ when(tenantManage.getFlow(userId)).thenReturn(map1);
+ when(flow.getFlowId()).thenReturn(flowId);
+ when(flow2.getFlowName()).thenReturn(flowName2);
+ when(flow.getFlowName()).thenReturn(flowName);
+ Assert.assertEquals(method.invoke(updateFlow, userId, flow), "The flow name should not be changed.");
+
+ when(tenantManage.getFlow(userId)).thenReturn(null);
+ when(tenantManage.getFlowDataStore(userId)).thenReturn(map1);
+ when(flow.getFlowId()).thenReturn(flowId);
+ when(flow2.getFlowName()).thenReturn(flowName2);
+ when(flow.getFlowName()).thenReturn(flowName);
+ Assert.assertEquals(method.invoke(updateFlow, userId, flow), "The flow name should not be changed.");
+
+ when(tenantManage.getFlow(userId)).thenReturn(null);
+ when(tenantManage.getFlowDataStore(userId)).thenReturn(null);
+ Assert.assertEquals(method.invoke(updateFlow, userId, flow), null);
+ }
+
+ @Test
+ public void testcheckDefinition() throws Exception {
+ Class<UpdateFlow> class3 = UpdateFlow.class;
+ Method method = class3.getDeclaredMethod("checkDefinition",new Class[]{Flow.class});
+ method.setAccessible(true);
+
+ CheckedFuture matchitemdefinitionFuture = mock(CheckedFuture.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(matchitemdefinitionFuture);
+
+
+ List<MatchItemDefinition> matchItemDefinitions = new ArrayList<MatchItemDefinition>();
+ List<MatchItemDefinition> matchItemDefinitionsnull = new ArrayList<MatchItemDefinition>();
+ MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
+ matchItemDefinitions.add(matchItemDefinition);
+ when(matchItemDefinition.getMatchItemName()).thenReturn(matchItemName);
+
+
+ Class<UpdateFlow> class1 = UpdateFlow.class;
+ Class<GetDefinitions> class2 = GetDefinitions.class;
+ Field field = class1.getDeclaredField("getDefinitions");
+ field.setAccessible(true);
+ Field field1 = class2.getDeclaredField("matchItemDefinitionList");
+ field1.setAccessible(true);
+
+ //the else
+ field1.set(field.get(updateFlow), matchItemDefinitions);
+ when(flow.getMatchItem()).thenReturn(matchItemList);
+ when(matchItem.getMatchItemName()).thenReturn(matchItemName2);
+ Assert.assertEquals(method.invoke(updateFlow, flow), "The match item has not been defined.");
+
+ //the upper
+ field1.set(field.get(updateFlow), matchItemDefinitionsnull);
+ Assert.assertEquals(method.invoke(updateFlow, flow), "The match item has not been defined.");
+
+ //the if errorInfo == null into checkPredefine
+ field1.set(field.get(updateFlow), matchItemDefinitions);
+ when(flow.getMatchItem()).thenReturn(matchItemListnull);
+ //into checkPredefine
+ Assert.assertEquals(method.invoke(updateFlow, flow), null);
+
+
+
+
+ }
+
+ @Test
+ public void testcheckPredefine() throws Exception {
+ Class<UpdateFlow> class1 = UpdateFlow.class;
+ Method method = class1.getDeclaredMethod("checkPredefine",new Class[]{List.class});
+ method.setAccessible(true);
+
+ when(matchItem.getMatchItemName()).thenReturn(matchItemName);
+ when(matchItem.getMatchItemName().getValue()).thenReturn(new String("src-ip"));
+ when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
+
+ //stringValues.contains("/")
+ when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110/"));
+ //into checkIpPrefix(stringvalues) legalValue=false
+ Assert.assertEquals(method.invoke(updateFlow, matchItemList),"The " + NEMOConstants.ip_address + " is not legal.");
+
+ when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110\\."));
+ //into checkip address
+ Assert.assertEquals(method.invoke(updateFlow, matchItemList),"The " + NEMOConstants.ip_address + " is not legal.");
+
+
+ when(matchItem.getMatchItemName().getValue()).thenReturn(new String("src-mac"));
+ when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
+ when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110:"));
+ //into valuecheck.checkMac
+ Assert.assertEquals(method.invoke(updateFlow, matchItemList), "The " + NEMOConstants.mac_address + " is not legal.");
+
+
+
+
+
+
+
+
+
+
+
+ }
+}
\ No newline at end of file
import org.junit.Test;
import java.util.*;
import java.util.List;
+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.instances.TemplateInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateInstances;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateDefinitions;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
private List<Operation> operationList;
private Results results;
private StructureStyleNemoUpdateInput structureStyleNemoUpdateInput;
+ private TemplateDefinition templateDefinition;
+ private List<TemplateDefinition> templateDefinitionList;
+ private TemplateInstance templateInstance;
+ private List<TemplateInstance> templateInstanceList;
+ private TemplateDefinitions templateDefinitions;
+ private TemplateInstances templateInstances;
+
@Before
public void setUp() throws Exception {
flowList = new ArrayList<Flow>(1);
flowList.add(flow);
+ templateDefinition = mock(TemplateDefinition.class);
+ templateDefinitionList = new ArrayList<TemplateDefinition>();
+ templateDefinitionList.add(templateDefinition);
+ templateDefinitions = mock(TemplateDefinitions.class);
+
+ templateInstance = mock(TemplateInstance.class);
+ templateInstanceList = new ArrayList<TemplateInstance>();
+ templateInstanceList.add(templateInstance);
+ templateInstances = mock(TemplateInstances.class);
+
updateIntent = new UpdateIntent(dataBroker,tenantManage);
field_1.setAccessible(true);
UpdateNode updateNode_1 = mock(UpdateNode.class);
- field_1.set(updateIntent,updateNode_1);
+ field_1.set(updateIntent, updateNode_1);
when(updateNode_1.NodeHandling(userId,node)).thenReturn(new String("node success"));
Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "node success");
when(updateResult.ResultHandling(userId, results)).thenReturn(new String("result success"));
Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "result success");
+ //getTemplateDefinitions
+ when(structureStyleNemoUpdateInput.getObjects()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getOperations()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getResults()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getTemplateDefinitions()).thenReturn(templateDefinitions);
+ when(structureStyleNemoUpdateInput.getTemplateDefinitions().getTemplateDefinition()).thenReturn(templateDefinitionList);
+
+ Field field_6 = class_1.getDeclaredField("updateTemplateDefinition");
+ field_6.setAccessible(true);
+ UpdateTemplateDefinition updateTemplateDefinition = mock(UpdateTemplateDefinition.class);
+ field_6.set(updateIntent, updateTemplateDefinition);
+ when(updateTemplateDefinition.checkTemplateDefinition(userId, templateDefinition)).thenReturn(new String("templateDefinition success"));
+ Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "templateDefinition success");
+
+
+ //getTemplateInstances
+ when(structureStyleNemoUpdateInput.getObjects()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getOperations()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getResults()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getTemplateDefinitions()).thenReturn(null);
+ when(structureStyleNemoUpdateInput.getTemplateInstances()).thenReturn(templateInstances);
+ when(structureStyleNemoUpdateInput.getTemplateInstances().getTemplateInstance()).thenReturn(templateInstanceList);
+
+ Field field_7 = class_1.getDeclaredField("updateTemplateInstance");
+ field_7.setAccessible(true);
+ UpdateTemplateInstance updateTemplateInstance = mock(UpdateTemplateInstance.class);
+ field_7.set(updateIntent, updateTemplateInstance);
+ when(updateTemplateInstance.checkTemplateInstance(userId, templateInstance)).thenReturn(new String("templateInstance success"));
+ Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput),"templateInstance success");
+
--- /dev/null
+/*\r
+ * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent;\r
+\r
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateNode;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;\r
+\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import com.google.common.base.Optional;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import com.google.common.util.concurrent.FutureCallback;\r
+import com.google.common.util.concurrent.Futures;\r
+import com.google.common.util.concurrent.ListenableFuture;\r
+import com.google.common.util.concurrent.SettableFuture;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.SubNode;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Node;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.NodeBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.NodeKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.NodeDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.Property;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.definitions.PropertyDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.StringValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.PropertyName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.NodeKey;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
+import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateTemplateInstanceLang;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Node;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.Property;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.definitions.PropertyDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.StringValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameter;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameterBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.TemplateParameterKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.template.parameter.ParameterValuesBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.instance.grouping.template.parameter.parameter.values.*;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance;\r
+\r
+\r
+import java.util.LinkedList;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.lang.reflect.Field;\r
+import java.lang.reflect.Method;\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.util.concurrent.ExecutionException;\r
+import java.util.concurrent.TimeUnit;\r
+import java.util.concurrent.TimeoutException;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserRoleName;\r
+import java.util.LinkedList;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import java.util.*;\r
+import java.util.List;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.times;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import static org.mockito.Mockito.doNothing;\r
+\r
+/**\r
+ * Created by ldzd11 on 2015/12/18.\r
+ */\r
+public class UpdateNodeTest {\r
+\r
+ private UpdateNode updateNode;\r
+ private Node node;\r
+ private Node node2;\r
+ private NodeName nodeName;\r
+ private NodeName nodeName2;\r
+ private List<Node> nodeList;\r
+ private DataBroker dataBroker;\r
+ private TenantManage tenantManage;\r
+ private Property property;\r
+ private List<Property> propertyList;\r
+ private PropertyName propertyName;\r
+ private PropertyName propertyName2;\r
+ private StringValue stringValue;\r
+ private List<StringValue> stringValues;\r
+ private org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.RangeValue rangeValue;\r
+ private PropertyValues propertyValues;\r
+ private ValueCheck valueCheck;\r
+ private PropertyDefinition propertyDefinition;\r
+ private NodeType nodeType;\r
+ private NodeType nodeType2;\r
+ private List<PropertyDefinition> propertyDefinitions;\r
+ private UserId userId;\r
+ private WriteTransaction writeTransaction;\r
+ private User user;\r
+ private NodeId nodeId;\r
+ private NodeKey nodeKey;\r
+ private Objects objects;\r
+ private SubNode subNode;\r
+ private UserRoleName userRoleName;\r
+ private org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.IntValue intValue;\r
+ private List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.IntValue> intValueList;\r
+ private List<SubNode> subNodeList;\r
+ @org.junit.Before\r
+ public void setUp() throws Exception {\r
+ dataBroker = mock(DataBroker.class);\r
+ tenantManage = mock(TenantManage.class);\r
+ propertyValues = mock(PropertyValues.class);\r
+ valueCheck = mock(ValueCheck.class);\r
+ nodeId = mock(NodeId.class);\r
+ nodeName = mock(NodeName.class);\r
+ nodeName2 = mock(NodeName.class);\r
+\r
+ propertyName = mock(PropertyName.class);\r
+ propertyName2 = mock(PropertyName.class);\r
+\r
+ property = mock(Property.class);\r
+ propertyList = new ArrayList<Property>(1);\r
+ propertyList.add(property);\r
+\r
+ stringValue = mock(StringValue.class);\r
+ stringValues = new ArrayList<StringValue>(1);\r
+ stringValues.add(stringValue);\r
+ nodeType = mock(NodeType.class);\r
+\r
+ propertyDefinition= mock(PropertyDefinition.class);\r
+ propertyDefinitions = new ArrayList<PropertyDefinition>(1);\r
+ propertyDefinitions.add(propertyDefinition);\r
+\r
+ node = mock(Node.class);\r
+ node2 = mock(Node.class);\r
+ userId = mock(UserId.class);\r
+ user = mock(User.class);\r
+ objects = mock(Objects.class);\r
+ nodeKey = mock(NodeKey.class);\r
+\r
+ nodeList = new ArrayList<Node>(1);\r
+ nodeList.add(node2);\r
+ writeTransaction = mock(WriteTransaction.class);\r
+\r
+ subNode = mock(SubNode.class);\r
+ subNodeList = new ArrayList<SubNode>();\r
+ subNodeList.add(subNode);\r
+\r
+ intValue = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.IntValue.class);\r
+ intValueList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.IntValue>();\r
+ intValueList.add(intValue);\r
+\r
+ rangeValue = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.RangeValue.class);\r
+\r
+\r
+\r
+ updateNode = new UpdateNode(dataBroker,tenantManage);\r
+ nodeType2 = mock(NodeType.class);\r
+ userRoleName = mock(UserRoleName.class);\r
+\r
+\r
+\r
+ }\r
+\r
+ @org.junit.Test\r
+ public void testNodeHandling() throws Exception {\r
+\r
+ Class<UpdateNode> class1 = UpdateNode.class;\r
+ TemplateName templateName = new TemplateName("aaa");\r
+ TemplateDefinition templateDefinition = mock(TemplateDefinition.class);\r
+ Map<TemplateName, TemplateDefinition> map1 = new HashMap<TemplateName, TemplateDefinition>();\r
+ map1.put(templateName, templateDefinition);\r
+ // userTemplateDefinitionMap.put(userId, map1);\r
+ //field1.set(field.get(updateNode), userTemplateDefinitionMap);\r
+\r
+ when(tenantManage.getTempalteDefinition(userId)).thenReturn(map1);\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ when(node.getNodeType().getValue()).thenReturn(new String("aaa"));\r
+\r
+ when(tenantManage.getDefinitionDataStore(userId)).thenReturn(map1)\r
+; when(node.getNodeType()).thenReturn(nodeType);\r
+ when(node.getNodeType().getValue()).thenReturn(new String("aaa"));\r
+\r
+ ///////////////////////////////////////////////////////////////\r
+ when(tenantManage.getTempalteDefinition(userId)).thenReturn(null);\r
+ when(tenantManage.getDefinitionDataStore(userId)).thenReturn(null);\r
+ Map<UserId, User> map2 = new HashMap<UserId,User>();\r
+ UserId userId1 = mock(UserId.class);\r
+ User user1 = mock(User.class);\r
+ map2.put(userId1, user1);\r
+ when(tenantManage.getUsers()).thenReturn(map2);\r
+ when(user1.getUserRole()).thenReturn(userRoleName);\r
+ when(user1.getUserRole().getValue()).thenReturn(NEMOConstants.admin);\r
+ when(user1.getUserId()).thenReturn(userId1);\r
+ when(tenantManage.getDefinitionDataStore(user1.getUserId())).thenReturn(map1);\r
+ when(tenantManage.getDefinitionDataStore(user1.getUserId())).thenReturn(map1);\r
+ /////////////////////////////////////////////////////////////////////////////////\r
+\r
+\r
+ //first nodeModel = true 79 if\r
+ when(node.getSubNode()).thenReturn(subNodeList);\r
+ Assert.assertEquals(updateNode.NodeHandling(userId, node), "Subnodes should not be included in template instance.");\r
+ //else 83\r
+ when(node.getSubNode()).thenReturn(null);\r
+ when(node.getNodeId()).thenReturn(nodeId);\r
+ when(node.getNodeId().getValue()).thenReturn(new String("00001111-0000-0000-0000-000011112222"));\r
+ when(node.getNodeName()).thenReturn(nodeName);\r
+ when(node.getNodeName().getValue()).thenReturn(new String("nodename"));\r
+ when(node.getProperty()).thenReturn(propertyList);\r
+ when(property.getPropertyName()).thenReturn(propertyName);\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("propertyname"));\r
+ when(property.getPropertyValues()).thenReturn(propertyValues);\r
+ //intValue\r
+ when(property.getPropertyValues().getIntValue()).thenReturn(intValueList);\r
+ long a = 1;\r
+ long b = 2;\r
+ when(intValue.getOrder()).thenReturn(a);\r
+ when(intValue.getValue()).thenReturn(a);\r
+ //stringValue\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(stringValue.getOrder()).thenReturn(a);\r
+ when(stringValue.getValue()).thenReturn(new String("stringvalue"));\r
+ //RangeValue\r
+ when(property.getPropertyValues().getRangeValue()).thenReturn(rangeValue);\r
+ when(property.getPropertyValues().getRangeValue().getMin()).thenReturn(a);\r
+ when(property.getPropertyValues().getRangeValue().getMax()).thenReturn(b);\r
+\r
+ UpdateTemplateInstance updateTemplateInstance = mock(UpdateTemplateInstance.class);\r
+ Field field1 = class1.getDeclaredField("updateTemplateInstance");\r
+ field1.setAccessible(true);\r
+ field1.set(updateNode, updateTemplateInstance);\r
+ when(updateTemplateInstance.checkTemplateInstance(any(UserId.class), any(TemplateInstance.class))).thenReturn(new String("success"));\r
+ Assert.assertEquals(updateNode.NodeHandling(userId, node), "success");\r
+\r
+\r
+ when(tenantManage.getTempalteDefinition(userId)).thenReturn(null);\r
+ when(tenantManage.getDefinitionDataStore(userId)).thenReturn(null);\r
+ Map<UserId, User> mapnull = new HashMap<UserId, User>();\r
+ when(tenantManage.getUsers()).thenReturn(mapnull);\r
+\r
+ //into checkDefinition\r
+ CheckedFuture connectiondefinitionFuture = mock(CheckedFuture.class);\r
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);\r
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);\r
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(connectiondefinitionFuture);\r
+\r
+ //Class<UpdateNode> class1 = UpdateNode.class;\r
+ Class<GetDefinitions> class2 = GetDefinitions.class;\r
+ Field field = class1.getDeclaredField("getDefinitions");\r
+ field.setAccessible(true);\r
+ Field field2 = class2.getDeclaredField("nodeDefinitionList");\r
+ field2.setAccessible(true);\r
+\r
+\r
+ List<NodeDefinition> nodeDefinitionList = new ArrayList<NodeDefinition>();\r
+ NodeDefinition nodeDefinition = mock(NodeDefinition.class);\r
+ when(nodeDefinition.getNodeType()).thenReturn(nodeType);\r
+ nodeDefinitionList.add(nodeDefinition);\r
+\r
+ field2.set(field.get(updateNode), nodeDefinitionList);\r
+ // System.out.print("2");\r
+ // Assert.assertTrue((List<NodeDefinition>) field1.get(field.get(updateNode)) == nodeDefinitionList);\r
+\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ when(node.getProperty()).thenReturn(null);\r
+ when(nodeDefinition.getPropertyDefinition()).thenReturn(null);\r
+\r
+ //into checkinstance\r
+ when(tenantManage.getNode(userId)).thenReturn(null);\r
+ when(tenantManage.getNodeDataStore(userId)).thenReturn(null);\r
+ //into else tenantManage.setNode\r
+ when(node.getNodeId()).thenReturn(nodeId);\r
+ doNothing().when(tenantManage).setNode(any(UserId.class), any(NodeId.class), any(Node.class));\r
+ Assert.assertEquals(updateNode.NodeHandling(userId, node), null);\r
+ }\r
+ @Test\r
+ public void testcheckInstance() throws Exception {\r
+ Class<UpdateNode> class1 = UpdateNode.class;\r
+ Method method = class1.getDeclaredMethod("checkInstance", new Class[]{UserId.class, Node.class});\r
+ method.setAccessible(true);\r
+\r
+ Class<TenantManage> class2 = TenantManage.class;\r
+ Field field = class1.getDeclaredField("tenantManage");\r
+ field.setAccessible(true);\r
+ Field field1 = class2.getDeclaredField("userNodeMap");\r
+ field1.setAccessible(true);\r
+\r
+ Map<UserId, Map<NodeId, Node>> userNodeMap = new HashMap<UserId, Map<NodeId, Node>>();\r
+ Map<UserId, Map<NodeId, Node>> userNodeMap2 = new HashMap<UserId, Map<NodeId, Node>>();\r
+\r
+ Map<NodeId, Node> map1 = new HashMap<NodeId, Node>();\r
+ map1.put(nodeId, node2);\r
+ userNodeMap.put(userId, map1);\r
+ field1.set(field.get(updateNode), userNodeMap);\r
+\r
+ when(tenantManage.getNode(userId)).thenReturn(map1);\r
+ when(node.getNodeId()).thenReturn(nodeId);\r
+ when(node2.getNodeName()).thenReturn(nodeName);\r
+ when(node.getNodeName()).thenReturn(nodeName2);\r
+ Assert.assertEquals(method.invoke(updateNode, userId, node), "The node name should not be changed.");\r
+\r
+ when(node2.getNodeName()).thenReturn(nodeName);\r
+ when(node.getNodeName()).thenReturn(nodeName);\r
+ when(node2.getNodeType()).thenReturn(nodeType2);\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ Assert.assertEquals(method.invoke(updateNode, userId, node), "The node type should not be changed.");\r
+\r
+ field1.set(field.get(updateNode), userNodeMap2);\r
+ Field field2 = class2.getDeclaredField("user");\r
+ field2.setAccessible(true);\r
+ field2.set(field.get(updateNode), user);\r
+ when(user.getObjects()).thenReturn(objects);\r
+ when(user.getObjects().getNode()).thenReturn(nodeList);\r
+ when(node2.getNodeId()).thenReturn(nodeId);//map.put(nodeId,node2)\r
+ //when(tenantManage.getNodeDataStore(userId)).thenReturn(map1);\r
+ when(node.getNodeId()).thenReturn(nodeId);\r
+ when(node2.getNodeName()).thenReturn(nodeName2);\r
+ when(node.getNodeName()).thenReturn(nodeName);\r
+ Assert.assertEquals(method.invoke(updateNode, userId, node), "The node name should not be changed.");\r
+\r
+ when(node2.getNodeName()).thenReturn(nodeName);\r
+ when(node.getNodeName()).thenReturn(nodeName);\r
+ when(node2.getNodeType()).thenReturn(nodeType2);\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ Assert.assertEquals(method.invoke(updateNode, userId, node), "The node type should not be changed.");\r
+\r
+ }\r
+\r
+@Test\r
+ public void testcheckDefinition() throws Exception {\r
+\r
+ Class<UpdateNode> class3 = UpdateNode.class;\r
+ Method method = class3.getDeclaredMethod("checkDefinition", new Class[]{Node.class});\r
+ method.setAccessible(true);\r
+\r
+ CheckedFuture nodedefinitionFuture = mock(CheckedFuture.class);\r
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);\r
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);\r
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodedefinitionFuture);\r
+\r
+ List<NodeDefinition> nodeDefinitionList = new ArrayList<NodeDefinition>();\r
+ List<NodeDefinition> nodeDefinitionListnull = new ArrayList<NodeDefinition>();\r
+ NodeDefinition nodeDefinition = mock(NodeDefinition.class);\r
+ nodeDefinitionList.add(nodeDefinition);\r
+ when(nodeDefinition.getNodeType()).thenReturn(nodeType);\r
+\r
+ Class<UpdateNode> class1 = UpdateNode.class;\r
+ Class<GetDefinitions> class2 = GetDefinitions.class;\r
+ Field field = class1.getDeclaredField("getDefinitions");\r
+ field.setAccessible(true);\r
+ Field field1 = class2.getDeclaredField("nodeDefinitionList");\r
+ field1.setAccessible(true);\r
+\r
+\r
+ System.out.println(field1.get(field.get(updateNode)));\r
+ field1.set(field.get(updateNode), nodeDefinitionList);\r
+ System.out.println(field1.get(field.get(updateNode)));\r
+ Assert.assertTrue((List<NodeDefinition>) field1.get(field.get(updateNode)) == nodeDefinitionList);\r
+\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ when(node.getProperty()).thenReturn(propertyList);\r
+ when(nodeDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);\r
+\r
+ when(property.getPropertyName()).thenReturn(propertyName);\r
+ when(propertyDefinition.getPropertyName()).thenReturn(propertyName2);\r
+\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("propertyname"));\r
+ Assert.assertEquals(method.invoke(updateNode, node), "The property propertyname has not been defined.");\r
+\r
+ field1.set(field.get(updateNode), nodeDefinitionList);\r
+ when(node.getNodeType()).thenReturn(nodeType);\r
+ List<Property> propertyListnull = new ArrayList<Property>();\r
+ List<PropertyDefinition> propertyDefinitionListnull = new ArrayList<PropertyDefinition>();\r
+\r
+ when(node.getProperty()).thenReturn(propertyListnull);\r
+ when(nodeDefinition.getPropertyDefinition()).thenReturn(propertyDefinitionListnull);\r
+ Assert.assertEquals(method.invoke(updateNode, node), null);\r
+\r
+ field1.set(field.get(updateNode), nodeDefinitionListnull);\r
+ Assert.assertEquals(method.invoke(updateNode, node), "This type of Node has not been defined.");\r
+\r
+ field1.set(field.get(updateNode), nodeDefinitionList);\r
+ when(node.getNodeType()).thenReturn(nodeType2);\r
+ Assert.assertEquals(method.invoke(updateNode, node), "This type of Node has not been defined.");\r
+\r
+\r
+/*\r
+ (String)method.invoke(updateNode,node)*/\r
+ }\r
+\r
+ @Test\r
+ public void testcheckProperty() throws Exception {\r
+ Class<UpdateNode> class1 = UpdateNode.class;\r
+ Method method = class1.getDeclaredMethod("checkProperty", new Class[]{List.class, List.class});\r
+ method.setAccessible(true);\r
+ when(property.getPropertyName()).thenReturn(propertyName);\r
+ when(propertyDefinition.getPropertyName()).thenReturn(propertyName2);\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("propertyname"));\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList,propertyDefinitions), "The property propertyname has not been defined.");\r
+\r
+ }\r
+\r
+\r
+ @Test\r
+ public void testcheckPredefine() throws Exception {\r
+ Class<UpdateNode> class1 = UpdateNode.class;\r
+ Method method = class1.getDeclaredMethod("checkPredefine", new Class[]{List.class});\r
+ method.setAccessible(true);\r
+\r
+ when(property.getPropertyName()).thenReturn(propertyName);\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("mac-address"));\r
+ when(property.getPropertyValues()).thenReturn(propertyValues);\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(stringValue.getValue()).thenReturn(new String("test"));\r
+ when(valueCheck.checkMac(stringValue.getValue())).thenReturn(false);\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList), "The mac-address is not legal.");\r
+\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("ip-address"));\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(stringValue.getValue()).thenReturn(new String("/"));\r
+ when(valueCheck.checkIpPrefix(stringValue.getValue())).thenReturn(false);\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList), "The ip-address is not legal.");\r
+\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("gateway-ip"));\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(valueCheck.checkIpAddress(stringValue.getValue())).thenReturn(false);\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList), "The gateway-ip is not legal.");\r
+\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("ac-info-network"));\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(stringValue.getValue()).thenReturn(new String("layer4"));\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList), "The ac-info-network is not legal.");\r
+\r
+ when(property.getPropertyName().getValue()).thenReturn(new String("operating-mode"));\r
+ when(property.getPropertyValues().getStringValue()).thenReturn(stringValues);\r
+ when(stringValue.getValue()).thenReturn(new String("layer4"));\r
+ Assert.assertEquals(method.invoke(updateNode, propertyList), "The operating-mode is not legal.");\r
+\r
+ }\r
+}
\ No newline at end of file
Code Review / nemo.git / commitdiff