nemo-impl/src/test/java/org/opendaylight/nemo/user/tenantmanager/TenantManageTest.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.tenantmanager;
   9
  10 import junit.framework.TestCase;
  11 import org.junit.Assert;
  12 import org.junit.Before;
  13 import org.junit.Test;
  14
  15 import static org.junit.Assert.*;
  16 import com.google.common.base.Function;
  17 import com.google.common.base.Optional;
  18 import com.google.common.collect.Maps;
  19 import com.google.common.util.concurrent.CheckedFuture;
  20 import com.google.common.util.concurrent.FutureCallback;
  21 import com.google.common.util.concurrent.Futures;
  22 import com.google.common.util.concurrent.ListenableFuture;
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  27 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.RegisterUserInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Operations;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateDefinitions;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateInstances;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.*;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.Operation;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.OperationKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.UserRoles;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.user.roles.UserRole;
  47 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeName;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionName;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowName;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.OperationName;
  54 import java.lang.reflect.Field;
  55 import java.lang.reflect.Method;
  56 import java.util.*;
  57 import java.util.concurrent.ExecutionException;
  58 import static org.mockito.Mockito.*;
  59 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  60 import com.google.common.util.concurrent.CheckedFuture;
  61
  62 /**
  63  * Created by zhangmeng on 2015/12/31.
  64  */
  65 public class TenantManageTest extends TestCase {
  66     private DataBroker dataBroker;
  67     private TenantManage tenantManage;
  68     private Class<TenantManage> class1;
  69     private Field field_userNodeMap;
  70     private Field field_userConnectionMap;
  71     private Field field_userFlowMap;
  72     private Field field_userOperationMap;
  73     private Field field_userTemplateDefinitionMap;
  74     private Field field_userTemplateInstanceMap;
  75     private Field field_userDeleteIntent;
  76     private Field field_userNameIdMap;
  77
  78     @Before
  79     public void setUp() throws Exception {
  80         dataBroker = mock(DataBroker.class);
  81         tenantManage = new TenantManage(dataBroker);
  82         class1 = TenantManage.class;
  83
  84         field_userNodeMap = class1.getDeclaredField("userNodeMap");
  85         field_userConnectionMap = class1.getDeclaredField("userConnectionMap");
  86         field_userDeleteIntent = class1.getDeclaredField("userDeleteIntent");
  87         field_userFlowMap = class1.getDeclaredField("userFlowMap");
  88         field_userNameIdMap = class1.getDeclaredField("userNameIdMap");
  89         field_userOperationMap = class1.getDeclaredField("userOperationMap");
  90         field_userTemplateDefinitionMap = class1.getDeclaredField("userTemplateDefinitionMap");
  91         field_userTemplateInstanceMap = class1.getDeclaredField("userTemplateInstanceMap");
  92
  93         field_userTemplateInstanceMap.setAccessible(true);
  94         field_userNameIdMap.setAccessible(true);
  95         field_userDeleteIntent.setAccessible(true);
  96         field_userNodeMap.setAccessible(true);
  97         field_userConnectionMap.setAccessible(true);
  98         field_userTemplateDefinitionMap.setAccessible(true);
  99         field_userFlowMap.setAccessible(true);
 100         field_userOperationMap.setAccessible(true);
 101     }
 102
 103     @Test
 104     public void testGetUser() throws Exception {
 105         Class<TenantManage> class1 = TenantManage.class;
 106         Method method = class1.getDeclaredMethod("setUser", new Class[]{User.class});
 107         method.setAccessible(true);
 108
 109         Assert.assertTrue(tenantManage.getUser() == null);
 110         method.invoke(tenantManage, mock(User.class));
 111         Assert.assertTrue(tenantManage.getUser() != null);
 112     }
 113
 114     @Test
 115     public void testGetUserRoles() throws Exception {
 116         UserRole userRole = mock(UserRole.class);
 117         UserRoles userRoles = mock(UserRoles.class);
 118         UserRoleName userRoleName = mock(UserRoleName.class);
 119         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 120         CheckedFuture checkedFuture = mock(CheckedFuture.class);
 121         List<UserRole> userRoleList = new ArrayList<UserRole>();
 122         Optional<UserRoles> userRolesOpt = Optional.of(userRoles);
 123
 124         userRoleList.add(userRole);
 125
 126         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 127         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 128         when(checkedFuture.get()).thenReturn(userRolesOpt);
 129         when(userRoles.getUserRole()).thenReturn(userRoleList);
 130         when(userRole.getRoleName()).thenReturn(userRoleName);
 131
 132         Assert.assertTrue(tenantManage.getUserRoles().containsKey(userRoleName));
 133         verify(userRole).getRoleName();
 134
 135     }
 136
 137     @Test
 138     public void testFetchVNSpace_GetUsers_setUser() throws Exception {
 139         Assert.assertTrue(tenantManage.getUser() == null);
 140
 141         UserId userId = mock(UserId.class);
 142         Users users = mock(Users.class);
 143         User user = mock(User.class);
 144         List<User> userList = new ArrayList<User>();
 145         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 146         CheckedFuture checkedFuture = mock(CheckedFuture.class);
 147         Optional<Users> usersOpt = Optional.of(users);
 148
 149         userList.add(user);
 150
 151         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 152         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 153         when(checkedFuture.get()).thenReturn(usersOpt);
 154         when(users.getUser()).thenReturn(userList);
 155         when(user.getUserId()).thenReturn(userId);
 156
 157         Assert.assertTrue(tenantManage.getUsers().containsKey(userId));
 158         verify(user).getUserId();
 159         tenantManage.fetchVNSpace(userId);
 160         Assert.assertTrue(tenantManage.getUser() == user);
 161         verify(user,times(2)).getUserId();
 162     }
 163
 164
 165     @Test
 166     public void testAddUser() throws Exception {
 167         UserId userId = mock(UserId.class);
 168         RegisterUserInput registerUserInput = mock(RegisterUserInput.class);
 169         WriteTransaction writeTransaction = mock(WriteTransaction.class);
 170         CheckedFuture checkedFuture = mock(CheckedFuture.class);
 171
 172         when(registerUserInput.getUserId()).thenReturn(userId);
 173         when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
 174         when(writeTransaction.submit()).thenReturn(checkedFuture);
 175 //        when(checkedFuture.get()).whenReturn(Optional.of(users));
 176
 177         tenantManage.addUser(registerUserInput);
 178         verify(checkedFuture).get();
 179     }
 180
 181     @Test
 182     public void testTransactionHandling_writeDataStore() throws Exception {
 183         NodeId nodeId = mock(NodeId.class);
 184         Node node = mock(Node.class);
 185         UserId userId = mock(UserId.class);
 186         ConnectionId connectionId = mock(ConnectionId.class);
 187         Connection connection = mock(Connection.class);
 188         FlowId flowId = mock(FlowId.class);
 189         Flow flow = mock(Flow.class);
 190         OperationId operationId = mock(OperationId.class);
 191         Operation operation = mock(Operation.class);
 192         TemplateName templateName = mock(TemplateName.class);
 193         TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
 194         TemplateInstanceId templateInstanceId = mock(TemplateInstanceId.class);
 195         TemplateInstance templateInstance = mock(TemplateInstance.class);
 196         WriteTransaction writeTransaction = mock(WriteTransaction.class);
 197         CheckedFuture checkedFuture = mock(CheckedFuture.class);
 198         Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();
 199         Map<UserId, Map<NodeId, Node>> userNodeMap = mock(Map.class);
 200         Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();
 201         Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = mock(Map.class);
 202         Map<FlowId, Flow> flowMap = new HashMap<FlowId, Flow>();
 203         Map<UserId, Map<FlowId, Flow>> userFlowMap = mock(Map.class);
 204         Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();
 205         Map<String, String> deleteObject = new HashMap<String, String>();
 206         Map<UserId, Map<OperationId, Operation>> userOperationMap = mock(Map.class);
 207         Map<TemplateName, TemplateDefinition> templateDefinitionMap = new HashMap<TemplateName, TemplateDefinition>();
 208         Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = mock(Map.class);
 209         Map<TemplateInstanceId, TemplateInstance> templateInstanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();
 210         Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = mock(Map.class);
 211         Map<UserId, Map<String, String>> userDeleteIntent = mock(Map.class);
 212
 213         nodeMap.put(nodeId, node);
 214         connectionMap.put(connectionId, connection);
 215         flowMap.put(flowId, flow);
 216         operationMap.put(operationId, operation);
 217         templateDefinitionMap.put(templateName, templateDefinition);
 218         templateInstanceMap.put(templateInstanceId, templateInstance);
 219
 220         //get into method "writeDataStore" arg(userId)
 221         when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
 222         when(writeTransaction.submit()).thenReturn(checkedFuture);
 223         ////get into method "getNode" arg(userId)
 224         field_userNodeMap.set(tenantManage, userNodeMap);
 225         when(userNodeMap.isEmpty()).thenReturn(false);
 226         when(userNodeMap.get(userId)).thenReturn(nodeMap);
 227         ////get into method "getConnection" arg(userId)
 228         field_userConnectionMap.set(tenantManage, userConnectionMap);
 229         when(userConnectionMap.isEmpty()).thenReturn(false);
 230         when(userConnectionMap.get(userId)).thenReturn(connectionMap);
 231         ////get into method "getFlow" arg(userId)
 232         field_userFlowMap.set(tenantManage, userFlowMap);
 233         when(userFlowMap.isEmpty()).thenReturn(false);
 234         when(userFlowMap.get(userId)).thenReturn(flowMap);
 235         ////get into method "getOperation" arg(userId)
 236         field_userOperationMap.set(tenantManage, userOperationMap);
 237         when(userOperationMap.isEmpty()).thenReturn(false);
 238         when(userOperationMap.get(userId)).thenReturn(operationMap);
 239         ////get into method "getTempalteDefinition" arg(userId)
 240         field_userTemplateDefinitionMap.set(tenantManage, userTemplateDefinitionMap);
 241         when(userTemplateDefinitionMap.isEmpty()).thenReturn(false);
 242         when(userTemplateDefinitionMap.get(userId)).thenReturn(templateDefinitionMap);
 243         ////get into method "getTemplateInstance" arg(userId)
 244         field_userTemplateInstanceMap.set(tenantManage, userTemplateInstanceMap);
 245         when(userTemplateInstanceMap.isEmpty()).thenReturn(false);
 246         when(userTemplateInstanceMap.get(userId)).thenReturn(templateInstanceMap);
 247         tenantManage.transactionHandling(userId);
 248         verify(userNodeMap, times(3)).isEmpty();
 249         verify(userConnectionMap, times(3)).isEmpty();
 250         verify(userFlowMap, times(3)).isEmpty();
 251         verify(userOperationMap,times(3)).isEmpty();
 252         verify(userTemplateDefinitionMap, times(3)).isEmpty();
 253         verify(userTemplateInstanceMap,times(3)).isEmpty();
 254         verify(dataBroker,times(6)).newWriteOnlyTransaction();
 255
 256         //get into method "deleteDataStore" arg(userId)
 257         field_userDeleteIntent.set(tenantManage, userDeleteIntent);
 258         when(userDeleteIntent.get(userId)).thenReturn(deleteObject);
 259         deleteObject.put("11111111-1111-1111-1111-111111111111", NEMOConstants.node);
 260         tenantManage.transactionHandling(userId);
 261         verify(dataBroker, times(13)).newWriteOnlyTransaction();
 262         deleteObject.clear();
 263         deleteObject.put("11111111-1111-1111-1111-111111111111", NEMOConstants.connection);
 264         tenantManage.transactionHandling(userId);
 265         verify(dataBroker,times(20)).newWriteOnlyTransaction();
 266         deleteObject.clear();
 267         deleteObject.put("11111111-1111-1111-1111-111111111111", NEMOConstants.flow);
 268         tenantManage.transactionHandling(userId);
 269         verify(dataBroker,times(27)).newWriteOnlyTransaction();
 270         deleteObject.clear();
 271         deleteObject.put("11111111-1111-1111-1111-111111111111", NEMOConstants.operation);
 272         tenantManage.transactionHandling(userId);
 273         verify(dataBroker,times(34)).newWriteOnlyTransaction();
 274     }
 275
 276     @Test
 277     public void testSetNode_setUserNameIdMap_GetNode() throws Exception {
 278         UserId userId = mock(UserId.class);
 279         NodeId nodeId = mock(NodeId.class);
 280         Node node = mock(Node.class);
 281 //        NodeName nodeName
 282
 283         Map<UserId, Map<NodeId, Node>> userNodeMap = mock(Map.class);
 284         Map<UserId, Map<String, String>> userNameIdMap = mock(Map.class);
 285
 286         Assert.assertTrue(tenantManage.getNode(userId) == null);
 287         Assert.assertTrue(tenantManage.getUserNameIdMap(userId) == null);
 288         Assert.assertTrue(((Map) field_userNameIdMap.get(tenantManage)).isEmpty());
 289         Assert.assertTrue(((Map)field_userNodeMap.get(tenantManage)).isEmpty());
 290         when(node.getNodeName()).thenReturn(mock(NodeName.class));
 291         when(node.getNodeName().getValue()).thenReturn("name");
 292         tenantManage.setNode(userId, nodeId, node);
 293         Assert.assertTrue(tenantManage.getNode(userId) != null);
 294         Assert.assertTrue(tenantManage.getUserNameIdMap(userId) != null);
 295         Assert.assertTrue(!((Map) field_userNameIdMap.get(tenantManage)).isEmpty());
 296         Assert.assertTrue(!((Map) field_userNodeMap.get(tenantManage)).isEmpty());
 297
 298         field_userNodeMap.set(tenantManage, userNodeMap);
 299         when(userNodeMap.containsKey(userId)).thenReturn(true);
 300         when(userNodeMap.get(userId)).thenReturn(new HashMap<NodeId, Node>());
 301         field_userNameIdMap.set(tenantManage, userNameIdMap);
 302         when(userNameIdMap.containsKey(userId)).thenReturn(true);
 303         when(userNameIdMap.get(userId)).thenReturn(new HashMap<String, String>());
 304         tenantManage.setNode(userId, nodeId, node);
 305         verify(userNodeMap).get(userId);
 306         verify(userNameIdMap).get(userId);
 307
 308     }
 309
 310     @Test
 311     public void testSetConnection_GetConnection() throws Exception {
 312         UserId userId = mock(UserId.class);
 313         ConnectionId connectionId = mock(ConnectionId.class);
 314         Connection connection = mock(Connection.class);
 315
 316         Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = mock(Map.class);
 317
 318         Assert.assertTrue(tenantManage.getConnection(userId) == null);
 319         Assert.assertTrue(((Map) field_userConnectionMap.get(tenantManage)).isEmpty());
 320         when(connection.getConnectionName()).thenReturn(mock(ConnectionName.class));
 321         when(connection.getConnectionName().getValue()).thenReturn("connection");
 322         tenantManage.setConnection(userId, connectionId, connection);
 323         Assert.assertTrue(tenantManage.getConnection(userId) != null);
 324         Assert.assertTrue(!((Map) field_userConnectionMap.get(tenantManage)).isEmpty());
 325
 326         field_userConnectionMap.set(tenantManage, userConnectionMap);
 327         when(userConnectionMap.containsKey(userId)).thenReturn(true);
 328         when(userConnectionMap.get(userId)).thenReturn(new HashMap<ConnectionId, Connection>());
 329         tenantManage.setConnection(userId, connectionId, connection);
 330         verify(userConnectionMap).get(userId);
 331     }
 332
 333     @Test
 334     public void testSetFlow_GetFlow() throws Exception {
 335         UserId userId = mock(UserId.class);
 336         FlowId flowId = mock(FlowId.class);
 337         Flow flow = mock(Flow.class);
 338
 339         Map<UserId, Map<FlowId, Flow>> userFlowMap = mock(Map.class);
 340
 341         Assert.assertTrue(tenantManage.getFlow(userId) == null);
 342         Assert.assertTrue(((Map) field_userFlowMap.get(tenantManage)).isEmpty());
 343         when(flow.getFlowName()).thenReturn(mock(FlowName.class));
 344         when(flow.getFlowName().getValue()).thenReturn("name");
 345         tenantManage.setFlow(userId, flowId, flow);
 346         Assert.assertTrue(tenantManage.getFlow(userId) != null);
 347         Assert.assertTrue(!((Map) field_userFlowMap.get(tenantManage)).isEmpty());
 348
 349         field_userFlowMap.set(tenantManage, userFlowMap);
 350         when(userFlowMap.containsKey(userId)).thenReturn(true);
 351         when(userFlowMap.get(userId)).thenReturn(new HashMap<FlowId,Flow>());
 352         tenantManage.setFlow(userId, flowId, flow);
 353         verify(userFlowMap).get(userId);
 354     }
 355
 356
 357     @Test
 358     public void testSetOperation_GetOperation() throws Exception {
 359         UserId userId = mock(UserId.class);
 360         OperationId operationId = mock(OperationId.class);
 361         Operation operation = mock(Operation.class);
 362
 363         Map<UserId, Map<OperationId, Operation>> userOperationMap = mock(Map.class);
 364
 365         Assert.assertTrue(tenantManage.getOperation(userId) == null);
 366         Assert.assertTrue(((Map) field_userOperationMap.get(tenantManage)).isEmpty());
 367         when(operation.getOperationName()).thenReturn(mock(OperationName.class));
 368         when(operation.getOperationName().getValue()).thenReturn("OperationName");
 369         tenantManage.setOperation(userId, operationId, operation);
 370         Assert.assertTrue(tenantManage.getOperation(userId) != null);
 371         Assert.assertTrue(!((Map) field_userOperationMap.get(tenantManage)).isEmpty());
 372
 373         field_userOperationMap.set(tenantManage, userOperationMap);
 374         when(userOperationMap.containsKey(userId)).thenReturn(true);
 375         when(userOperationMap.get(userId)).thenReturn(new HashMap<OperationId, Operation>());
 376         tenantManage.setOperation(userId, operationId, operation);
 377         verify(userOperationMap).get(userId);
 378     }
 379
 380     @Test
 381     public void testSetTemplateDefinition_GetTempalteDefinition() throws Exception {
 382         UserId userId = mock(UserId.class);
 383         TemplateName templateName = mock(TemplateName.class);
 384         TemplateDefinition definition = mock(TemplateDefinition.class);
 385
 386         Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = mock(Map.class);
 387
 388         Assert.assertTrue(tenantManage.getTempalteDefinition(userId) == null);
 389         Assert.assertTrue(((Map) field_userTemplateDefinitionMap.get(tenantManage)).isEmpty());
 390         tenantManage.setTemplateDefinition(userId, templateName, definition);
 391         Assert.assertTrue(tenantManage.getTempalteDefinition(userId) != null);
 392         Assert.assertTrue(!((Map) field_userTemplateDefinitionMap.get(tenantManage)).isEmpty());
 393
 394         field_userTemplateDefinitionMap.set(tenantManage, userTemplateDefinitionMap);
 395         when(userTemplateDefinitionMap.containsKey(userId)).thenReturn(true);
 396         when(userTemplateDefinitionMap.get(userId)).thenReturn(new HashMap<TemplateName, TemplateDefinition>());
 397         tenantManage.setTemplateDefinition(userId, templateName, definition);
 398         verify(userTemplateDefinitionMap).get(userId);
 399     }
 400
 401     @Test
 402     public void testSetUserTemplateInstance_GetTemplateInstance() throws Exception {
 403         UserId userId = mock(UserId.class);
 404         TemplateInstanceId instanceId = mock(TemplateInstanceId.class);
 405         TemplateInstance instance = mock(TemplateInstance.class);
 406
 407         Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = mock(Map.class);
 408
 409         Assert.assertTrue(tenantManage.getTemplateInstance(userId) == null);
 410         Assert.assertTrue(((Map) field_userTemplateInstanceMap.get(tenantManage)).isEmpty());
 411         tenantManage.setUserTemplateInstance(userId, instanceId, instance);
 412         Assert.assertTrue(tenantManage.getTemplateInstance(userId) != null);
 413         Assert.assertTrue(!((Map) field_userTemplateInstanceMap.get(tenantManage)).isEmpty());
 414
 415         field_userTemplateInstanceMap.set(tenantManage, userTemplateInstanceMap);
 416         when(userTemplateInstanceMap.containsKey(userId)).thenReturn(true);
 417         when(userTemplateInstanceMap.get(userId)).thenReturn(new HashMap<TemplateInstanceId, TemplateInstance>());
 418         tenantManage.setUserTemplateInstance(userId, instanceId, instance);
 419         verify(userTemplateInstanceMap).get(userId);
 420     }
 421
 422
 423     @Test
 424     public void testSetUserDeleteIntent() throws Exception {
 425         UserId userId = mock(UserId.class);
 426         String type = "type";
 427         String objectId = "objectId";
 428
 429         Map<UserId, Map<String, String>> userDeleteIntent = mock(Map.class);
 430
 431         Assert.assertTrue(((Map) field_userDeleteIntent.get(tenantManage)).isEmpty());
 432         tenantManage.setUserDeleteIntent(userId, type, objectId);
 433         Assert.assertTrue(!((Map) field_userDeleteIntent.get(tenantManage)).isEmpty());
 434
 435         field_userDeleteIntent.set(tenantManage, userDeleteIntent);
 436         when(userDeleteIntent.containsKey(userId)).thenReturn(true);
 437         when(userDeleteIntent.get(userId)).thenReturn(new HashMap<String, String>());
 438         tenantManage.setUserDeleteIntent(userId, type, objectId);
 439         verify(userDeleteIntent).get(userId);
 440
 441     }
 442
 443     @Test
 444     public void testGetObjectId() throws Exception {
 445         UserId userId = mock(UserId.class);
 446         String name = "name";
 447
 448         Map<UserId, Map<String, String>> userNameIdMap = mock(Map.class);
 449         Map<String, String> temp = mock(Map.class);
 450
 451         Assert.assertTrue(tenantManage.getObjectId(userId,name) == null);
 452         field_userNameIdMap.set(tenantManage, userNameIdMap);
 453         when(userNameIdMap.containsKey(userId)).thenReturn(true);
 454         when(userNameIdMap.get(userId)).thenReturn(temp);
 455         when(userNameIdMap.get(userId).containsKey(name)).thenReturn(true);
 456         when(userNameIdMap.get(userId).get(name)).thenReturn("test");
 457         Assert.assertTrue(tenantManage.getObjectId(userId,name).equals("test"));
 458
 459     }
 460
 461     @Test
 462     public void testGetName() throws Exception {
 463         UserId userId = mock(UserId.class);
 464         String objectId = "objectId";
 465
 466         Map<UserId, Map<String, String>> userNameIdMap = mock(Map.class);
 467         Map<String, String> temp = new HashMap<String, String>();
 468
 469         temp.put("test", "objectId");
 470
 471         Assert.assertTrue(tenantManage.getName(userId, objectId) == null);
 472         field_userNameIdMap.set(tenantManage, userNameIdMap);
 473         when(userNameIdMap.containsKey(userId)).thenReturn(true);
 474         when(userNameIdMap.get(userId)).thenReturn(temp);
 475         Assert.assertTrue(tenantManage.getName(userId, objectId).equals("test"));
 476     }
 477
 478     @Test
 479     public void testGetNodeDataStore() throws Exception {
 480         UserId userId = mock(UserId.class);
 481
 482         Objects objects = mock(Objects.class);
 483         Operations operations = mock(Operations.class);
 484         TemplateDefinitions templateDefinitions = mock(TemplateDefinitions.class);
 485         TemplateInstances templateInstances = mock(TemplateInstances.class);
 486         Node node = mock(Node.class);
 487         Connection connection = mock(Connection.class);
 488         Flow flow = mock(Flow.class);
 489         Operation operation = mock(Operation.class);
 490         TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
 491         TemplateInstance templateInstance = mock(TemplateInstance.class);
 492         User user = mock(User.class);
 493         Users users = mock(Users.class);
 494         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 495         CheckedFuture checkedFuture = mock(CheckedFuture.class);
 496         Optional<Users> usersOpt = Optional.of(users);
 497         List<User> userList = new ArrayList<User>();
 498         List<Node> nodeList = new ArrayList<Node>();
 499         List<Connection> connectionList = new ArrayList<Connection>();
 500         List<Flow> flowList = new ArrayList<Flow>();
 501         List<Operation> operationList = new ArrayList<Operation>();
 502         List<TemplateDefinition> templateDefinitionList = new ArrayList<TemplateDefinition>();
 503         List<TemplateInstance> templateInstanceList = new ArrayList<TemplateInstance>();
 504
 505         userList.add(user);
 506         nodeList.add(node);
 507         connectionList.add(connection);
 508         flowList.add(flow);
 509         operationList.add(operation);
 510         templateDefinitionList.add(templateDefinition);
 511         templateInstanceList.add(templateInstance);
 512
 513         //get into method "fetchVNSpace" arg(userId)
 514         ////get into method "getUsers()"
 515         when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
 516         when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 517         when(checkedFuture.get()).thenReturn(usersOpt);
 518         when(users.getUser()).thenReturn(userList);//input =  users
 519         when(user.getUserId()).thenReturn(userId);
 520         /* get into method "getUser" and method "getUser" returned user */
 521         when(user.getObjects()).thenReturn(objects);
 522         when(user.getObjects().getNode()).thenReturn(nodeList);
 523         when(user.getObjects().getConnection()).thenReturn(connectionList);
 524         when(user.getObjects().getFlow()).thenReturn(flowList);
 525         when(user.getOperations()).thenReturn(operations);
 526         when(user.getOperations().getOperation()).thenReturn(operationList);
 527         when(user.getTemplateDefinitions()).thenReturn(templateDefinitions);
 528         when(user.getTemplateDefinitions().getTemplateDefinition()).thenReturn(templateDefinitionList);
 529         when(user.getTemplateInstances()).thenReturn(templateInstances);
 530         when(user.getTemplateInstances().getTemplateInstance()).thenReturn(templateInstanceList);
 531
 532         tenantManage.getNodeDataStore(userId);
 533         tenantManage.getConnectionDataStore(userId);
 534         tenantManage.getDefinitionDataStore(userId);
 535         tenantManage.getFlowDataStore(userId);
 536         tenantManage.getInstanceDataStore(userId);
 537         tenantManage.getOperationDataStore(userId);
 538         verify(objects,times(2)).getNode();
 539         verify(objects,times(2)).getConnection();
 540         verify(objects,times(2)).getFlow();
 541         verify(operations,times(2)).getOperation();
 542         verify(templateDefinitions,times(2)).getTemplateDefinition();
 543         verify(templateInstances,times(2)).getTemplateInstance();
 544
 545     }
 546
 547 }