nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/GetDefinitionsTest.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 org.junit.Assert;
  11 import org.junit.Before;
  12 import org.junit.Test;
  13 import com.google.common.base.Optional;
  14 import com.google.common.util.concurrent.FutureCallback;
  15 import com.google.common.util.concurrent.Futures;
  16 import com.google.common.util.concurrent.ListenableFuture;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostName;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHost;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.ConnectionDefinitions;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.MatchItemDefinitions;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.NodeDefinitions;
  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.match.item.definitions.MatchItemDefinition;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.ActionDefinitions;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.ConditionParameterDefinitions;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.definitions.ActionDefinition;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.parameter.definitions.ConditionParameterDefinition;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 import java.util.HashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.ArrayList;
  40 import java.util.HashMap;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.LinkedList;
  47 import org.junit.Assert;
  48 import org.junit.Before;
  49 import org.junit.Test;
  50 import java.util.*;
  51 import java.util.List;
  52
  53 import static org.mockito.Matchers.any;
  54 import static org.mockito.Mockito.mock;
  55 import static org.mockito.Mockito.times;
  56 import static org.mockito.Mockito.verify;
  57 import static org.mockito.Mockito.when;
  58 import com.google.common.util.concurrent.CheckedFuture;
  59
  60 import java.lang.reflect.Field;
  61 import java.lang.reflect.Method;
  62 import java.util.ArrayList;
  63 import java.util.List;
  64 import java.lang.reflect.Field;
  65 import java.lang.reflect.Method;
  66 import java.util.HashMap;
  67 import java.util.List;
  68 import java.util.Map;
  69 import java.util.concurrent.ExecutionException;
  70 import java.util.concurrent.TimeUnit;
  71 import java.util.concurrent.TimeoutException;
  72 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  73
  74
  75 import static org.junit.Assert.*;
  76 import static org.junit.Assert.*;
  77
  78 /**
  79  * Created by ldzd11 on 2015/12/22.
  80  */
  81 public class GetDefinitionsTest {
  82
  83     private GetDefinitions getDefinitions;
  84     private DataBroker dataBroker;
  85     private NodeDefinition nodeDefinition;
  86     private List<NodeDefinition> nodeDefinitionList;
  87     private Map<NodeType,NodeDefinition> map;
  88     private NodeType nodeType;
  89     @Before
  90     public void setUp() throws Exception {
  91         dataBroker = mock(DataBroker.class);
  92         nodeDefinition = mock(NodeDefinition.class);
  93         nodeDefinitionList = new ArrayList<NodeDefinition>(1);
  94         nodeDefinitionList.add(nodeDefinition);
  95         nodeType = mock(NodeType.class);
  96         map = new HashMap<NodeType, NodeDefinition>();
  97         map.put(nodeType, nodeDefinition);
  98
  99         getDefinitions = new GetDefinitions(dataBroker);
 100     }
 101
 102     @Test
 103     public void testGetNodeDefinition() throws Exception {
 104         //fetchNodeDefinitions
 105
 106         Class<GetDefinitions> class_1 = GetDefinitions.class;
 107         Field field = class_1.getDeclaredField("nodeDefinitionList");
 108         field.setAccessible(true);
 109
 110         field.set(getDefinitions,nodeDefinitionList);
 111
 112         CheckedFuture nodedefinitionFuture = mock(CheckedFuture.class);
 113         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 114         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 115         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodedefinitionFuture);
 116
 117         when(nodeDefinition.getNodeType()).thenReturn(nodeType);
 118         Assert.assertEquals(getDefinitions.getNodeDefinition(),map);
 119
 120     }
 121
 122     @Test
 123     public void testGetMatchItemDefinition() throws Exception {
 124         Map<MatchItemName, MatchItemDefinition> map1 = new HashMap<MatchItemName, MatchItemDefinition>();
 125         MatchItemName matchItemName = mock(MatchItemName.class);
 126         MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
 127         map1.put(matchItemName, matchItemDefinition);
 128
 129         List<MatchItemDefinition> matchItemDefinitionList = new ArrayList<MatchItemDefinition>();
 130         matchItemDefinitionList.add(matchItemDefinition);
 131
 132         Class<GetDefinitions> class_1 = GetDefinitions.class;
 133         Field field = class_1.getDeclaredField("matchItemDefinitionList");
 134         field.setAccessible(true);
 135
 136         field.set(getDefinitions, matchItemDefinitionList);
 137
 138
 139         CheckedFuture matchitemdefinitionFuture = mock(CheckedFuture.class);
 140         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 141         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 142         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(matchitemdefinitionFuture);
 143         when(matchItemDefinition.getMatchItemName()).thenReturn(matchItemName);
 144         Assert.assertEquals(getDefinitions.getMatchItemDefinition(), map1);
 145
 146
 147
 148
 149     }
 150
 151     @Test
 152     public void testGetConnectionDefinition() throws Exception {
 153
 154         Map<ConnectionType, ConnectionDefinition> map1 = new HashMap<ConnectionType, ConnectionDefinition>();
 155         ConnectionType connectionType = mock(ConnectionType.class);
 156         ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
 157         map1.put(connectionType,connectionDefinition);
 158         List<ConnectionDefinition> connectionDefinitionList = new ArrayList<ConnectionDefinition>();
 159         connectionDefinitionList.add(connectionDefinition);
 160
 161         Class<GetDefinitions> class_1 = GetDefinitions.class;
 162         Field field = class_1.getDeclaredField("connectionDefinitionsList");
 163         field.setAccessible(true);
 164
 165         field.set(getDefinitions, connectionDefinitionList);
 166
 167         CheckedFuture connectiondefinitionFuture = mock(CheckedFuture.class);
 168         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 169         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 170         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(connectiondefinitionFuture);
 171         when(connectionDefinition.getConnectionType()).thenReturn(connectionType);
 172         Assert.assertEquals(getDefinitions.getConnectionDefinition(), map1);
 173
 174
 175     }
 176
 177     @Test
 178     public void testGetActionDefinition() throws Exception {
 179         Map<ActionName,ActionDefinition> map1 = new HashMap<ActionName, ActionDefinition>();
 180         ActionName actionName = mock(ActionName.class);
 181         ActionDefinition actionDefinition = mock(ActionDefinition.class);
 182         map1.put(actionName,actionDefinition);
 183         List<ActionDefinition> actionDefinitionList = new ArrayList<ActionDefinition>();
 184         actionDefinitionList.add(actionDefinition);
 185
 186         Class<GetDefinitions> class_1 = GetDefinitions.class;
 187         Field field = class_1.getDeclaredField("actionDefinitionList");
 188         field.setAccessible(true);
 189
 190         field.set(getDefinitions, actionDefinitionList);
 191
 192
 193         CheckedFuture actiondefinitionFuture = mock(CheckedFuture.class);
 194         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 195         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 196         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(actiondefinitionFuture);
 197
 198         when(actionDefinition.getActionName()).thenReturn(actionName);
 199         Assert.assertEquals(getDefinitions.getActionDefinition(), map1);
 200
 201
 202     }
 203
 204     @Test
 205     public void testGetConditionParameterDefinition() throws Exception {
 206         Map<ParameterName, ConditionParameterDefinition> map1 = new HashMap<ParameterName, ConditionParameterDefinition>();
 207         ParameterName parameterName = mock(ParameterName.class);
 208         ConditionParameterDefinition conditionParameterDefinition = mock(ConditionParameterDefinition.class);
 209         map1.put(parameterName,conditionParameterDefinition);
 210
 211         List<ConditionParameterDefinition> conditionParameterDefinitionList = new ArrayList<ConditionParameterDefinition>();
 212         conditionParameterDefinitionList.add(conditionParameterDefinition);
 213
 214         Class<GetDefinitions> class_1 = GetDefinitions.class;
 215         Field field = class_1.getDeclaredField("conditionParameterDefinitionList");
 216         field.setAccessible(true);
 217
 218         field.set(getDefinitions, conditionParameterDefinitionList);
 219
 220
 221         CheckedFuture conditionparadefinitionFuture = mock(CheckedFuture.class);
 222         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 223         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 224         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(conditionparadefinitionFuture);
 225         when(conditionParameterDefinition.getParameterName()).thenReturn(parameterName);
 226
 227         Assert.assertEquals(getDefinitions.getConditionParameterDefinition(), map1);
 228
 229
 230     }
 231
 232     @Test
 233     public void testGetPhysicalHost() throws Exception {
 234         Map<PhysicalHostName, PhysicalHost> map1 = new HashMap<PhysicalHostName, PhysicalHost>();
 235         PhysicalHostName physicalHostName = mock(PhysicalHostName.class);
 236         PhysicalHost physicalHost = mock(PhysicalHost.class);
 237         map1.put(physicalHostName,physicalHost);
 238
 239         List<PhysicalHost> physicalHostList = new ArrayList<PhysicalHost>();
 240         physicalHostList.add(physicalHost);
 241
 242         Class<GetDefinitions> class_1 = GetDefinitions.class;
 243         Field field = class_1.getDeclaredField("physicalHostList");
 244         field.setAccessible(true);
 245
 246         field.set(getDefinitions, physicalHostList);
 247         CheckedFuture physicalHostsFuture = mock(CheckedFuture.class);
 248         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 249         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 250         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(physicalHostsFuture);
 251         when(physicalHost.getHostName()).thenReturn(physicalHostName);
 252
 253         Assert.assertEquals(getDefinitions.getPhysicalHost(), map1);
 254     }
 255 }