+
+ @Test
+ public void testSetConnection_GetConnection() throws Exception {
+ UserId userId = mock(UserId.class);
+ ConnectionId connectionId = mock(ConnectionId.class);
+ Connection connection = mock(Connection.class);
+
+ Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getConnection(userId) == null);
+ Assert.assertTrue(((Map) field_userConnectionMap.get(tenantManage)).isEmpty());
+ when(connection.getConnectionName()).thenReturn(mock(ConnectionName.class));
+ when(connection.getConnectionName().getValue()).thenReturn("connection");
+ tenantManage.setConnection(userId, connectionId, connection);
+ Assert.assertTrue(tenantManage.getConnection(userId) != null);
+ Assert.assertTrue(!((Map) field_userConnectionMap.get(tenantManage)).isEmpty());
+
+ field_userConnectionMap.set(tenantManage, userConnectionMap);
+ when(userConnectionMap.containsKey(userId)).thenReturn(true);
+ when(userConnectionMap.get(userId)).thenReturn(new HashMap<ConnectionId, Connection>());
+ tenantManage.setConnection(userId, connectionId, connection);
+ verify(userConnectionMap).get(userId);
+ }
+
+ @Test
+ public void testSetFlow_GetFlow() throws Exception {
+ UserId userId = mock(UserId.class);
+ FlowId flowId = mock(FlowId.class);
+ Flow flow = mock(Flow.class);
+
+ Map<UserId, Map<FlowId, Flow>> userFlowMap = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getFlow(userId) == null);
+ Assert.assertTrue(((Map) field_userFlowMap.get(tenantManage)).isEmpty());
+ when(flow.getFlowName()).thenReturn(mock(FlowName.class));
+ when(flow.getFlowName().getValue()).thenReturn("name");
+ tenantManage.setFlow(userId, flowId, flow);
+ Assert.assertTrue(tenantManage.getFlow(userId) != null);
+ Assert.assertTrue(!((Map) field_userFlowMap.get(tenantManage)).isEmpty());
+
+ field_userFlowMap.set(tenantManage, userFlowMap);
+ when(userFlowMap.containsKey(userId)).thenReturn(true);
+ when(userFlowMap.get(userId)).thenReturn(new HashMap<FlowId,Flow>());
+ tenantManage.setFlow(userId, flowId, flow);
+ verify(userFlowMap).get(userId);
+ }
+
+
+ @Test
+ public void testSetOperation_GetOperation() throws Exception {
+ UserId userId = mock(UserId.class);
+ OperationId operationId = mock(OperationId.class);
+ Operation operation = mock(Operation.class);
+
+ Map<UserId, Map<OperationId, Operation>> userOperationMap = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getOperation(userId) == null);
+ Assert.assertTrue(((Map) field_userOperationMap.get(tenantManage)).isEmpty());
+ when(operation.getOperationName()).thenReturn(mock(OperationName.class));
+ when(operation.getOperationName().getValue()).thenReturn("OperationName");
+ tenantManage.setOperation(userId, operationId, operation);
+ Assert.assertTrue(tenantManage.getOperation(userId) != null);
+ Assert.assertTrue(!((Map) field_userOperationMap.get(tenantManage)).isEmpty());
+
+ field_userOperationMap.set(tenantManage, userOperationMap);
+ when(userOperationMap.containsKey(userId)).thenReturn(true);
+ when(userOperationMap.get(userId)).thenReturn(new HashMap<OperationId, Operation>());
+ tenantManage.setOperation(userId, operationId, operation);
+ verify(userOperationMap).get(userId);
+ }
+
+ @Test
+ public void testSetTemplateDefinition_GetTempalteDefinition() throws Exception {
+ UserId userId = mock(UserId.class);
+ TemplateName templateName = mock(TemplateName.class);
+ TemplateDefinition definition = mock(TemplateDefinition.class);
+
+ Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getTempalteDefinition(userId) == null);
+ Assert.assertTrue(((Map) field_userTemplateDefinitionMap.get(tenantManage)).isEmpty());
+ tenantManage.setTemplateDefinition(userId, templateName, definition);
+ Assert.assertTrue(tenantManage.getTempalteDefinition(userId) != null);
+ Assert.assertTrue(!((Map) field_userTemplateDefinitionMap.get(tenantManage)).isEmpty());
+
+ field_userTemplateDefinitionMap.set(tenantManage, userTemplateDefinitionMap);
+ when(userTemplateDefinitionMap.containsKey(userId)).thenReturn(true);
+ when(userTemplateDefinitionMap.get(userId)).thenReturn(new HashMap<TemplateName, TemplateDefinition>());
+ tenantManage.setTemplateDefinition(userId, templateName, definition);
+ verify(userTemplateDefinitionMap).get(userId);
+ }
+
+ @Test
+ public void testSetUserTemplateInstance_GetTemplateInstance() throws Exception {
+ UserId userId = mock(UserId.class);
+ TemplateInstanceId instanceId = mock(TemplateInstanceId.class);
+ TemplateInstance instance = mock(TemplateInstance.class);
+
+ Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getTemplateInstance(userId) == null);
+ Assert.assertTrue(((Map) field_userTemplateInstanceMap.get(tenantManage)).isEmpty());
+ tenantManage.setUserTemplateInstance(userId, instanceId, instance);
+ Assert.assertTrue(tenantManage.getTemplateInstance(userId) != null);
+ Assert.assertTrue(!((Map) field_userTemplateInstanceMap.get(tenantManage)).isEmpty());
+
+ field_userTemplateInstanceMap.set(tenantManage, userTemplateInstanceMap);
+ when(userTemplateInstanceMap.containsKey(userId)).thenReturn(true);
+ when(userTemplateInstanceMap.get(userId)).thenReturn(new HashMap<TemplateInstanceId, TemplateInstance>());
+ tenantManage.setUserTemplateInstance(userId, instanceId, instance);
+ verify(userTemplateInstanceMap).get(userId);
+ }
+
+
+ @Test
+ public void testSetUserDeleteIntent() throws Exception {
+ UserId userId = mock(UserId.class);
+ String type = "type";
+ String objectId = "objectId";
+
+ Map<UserId, Map<String, String>> userDeleteIntent = mock(Map.class);
+
+ Assert.assertTrue(((Map) field_userDeleteIntent.get(tenantManage)).isEmpty());
+ tenantManage.setUserDeleteIntent(userId, type, objectId);
+ Assert.assertTrue(!((Map) field_userDeleteIntent.get(tenantManage)).isEmpty());
+
+ field_userDeleteIntent.set(tenantManage, userDeleteIntent);
+ when(userDeleteIntent.containsKey(userId)).thenReturn(true);
+ when(userDeleteIntent.get(userId)).thenReturn(new HashMap<String, String>());
+ tenantManage.setUserDeleteIntent(userId, type, objectId);
+ verify(userDeleteIntent).get(userId);
+
+ }
+
+ @Test
+ public void testGetObjectId() throws Exception {
+ UserId userId = mock(UserId.class);
+ String name = "name";
+
+ Map<UserId, Map<String, String>> userNameIdMap = mock(Map.class);
+ Map<String, String> temp = mock(Map.class);
+
+ Assert.assertTrue(tenantManage.getObjectId(userId,name) == null);
+ field_userNameIdMap.set(tenantManage, userNameIdMap);
+ when(userNameIdMap.containsKey(userId)).thenReturn(true);
+ when(userNameIdMap.get(userId)).thenReturn(temp);
+ when(userNameIdMap.get(userId).containsKey(name)).thenReturn(true);
+ when(userNameIdMap.get(userId).get(name)).thenReturn("test");
+ Assert.assertTrue(tenantManage.getObjectId(userId,name).equals("test"));
+
+ }
+
+ @Test
+ public void testGetName() throws Exception {
+ UserId userId = mock(UserId.class);
+ String objectId = "objectId";
+
+ Map<UserId, Map<String, String>> userNameIdMap = mock(Map.class);
+ Map<String, String> temp = new HashMap<String, String>();
+
+ temp.put("test", "objectId");
+
+ Assert.assertTrue(tenantManage.getName(userId, objectId) == null);
+ field_userNameIdMap.set(tenantManage, userNameIdMap);
+ when(userNameIdMap.containsKey(userId)).thenReturn(true);
+ when(userNameIdMap.get(userId)).thenReturn(temp);
+ Assert.assertTrue(tenantManage.getName(userId, objectId).equals("test"));
+ }
+
+ @Test
+ public void testGetNodeDataStore() throws Exception {
+ UserId userId = mock(UserId.class);
+
+ Objects objects = mock(Objects.class);
+ Operations operations = mock(Operations.class);
+ TemplateDefinitions templateDefinitions = mock(TemplateDefinitions.class);
+ TemplateInstances templateInstances = mock(TemplateInstances.class);
+ Node node = mock(Node.class);
+ Connection connection = mock(Connection.class);
+ Flow flow = mock(Flow.class);
+ Operation operation = mock(Operation.class);
+ TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
+ TemplateInstance templateInstance = mock(TemplateInstance.class);
+ User user = mock(User.class);
+ Users users = mock(Users.class);
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);
+ Optional<Users> usersOpt = Optional.of(users);
+ List<User> userList = new ArrayList<User>();
+ List<Node> nodeList = new ArrayList<Node>();
+ List<Connection> connectionList = new ArrayList<Connection>();
+ List<Flow> flowList = new ArrayList<Flow>();
+ List<Operation> operationList = new ArrayList<Operation>();
+ List<TemplateDefinition> templateDefinitionList = new ArrayList<TemplateDefinition>();
+ List<TemplateInstance> templateInstanceList = new ArrayList<TemplateInstance>();
+
+ userList.add(user);
+ nodeList.add(node);
+ connectionList.add(connection);
+ flowList.add(flow);
+ operationList.add(operation);
+ templateDefinitionList.add(templateDefinition);
+ templateInstanceList.add(templateInstance);
+
+ //get into method "fetchVNSpace" arg(userId)
+ ////get into method "getUsers()"
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
+ when(checkedFuture.get()).thenReturn(usersOpt);
+ when(users.getUser()).thenReturn(userList);//input = users
+ when(user.getUserId()).thenReturn(userId);
+ /* get into method "getUser" and method "getUser" returned user */
+ when(user.getObjects()).thenReturn(objects);
+ when(user.getObjects().getNode()).thenReturn(nodeList);
+ when(user.getObjects().getConnection()).thenReturn(connectionList);
+ when(user.getObjects().getFlow()).thenReturn(flowList);
+ when(user.getOperations()).thenReturn(operations);
+ when(user.getOperations().getOperation()).thenReturn(operationList);
+ when(user.getTemplateDefinitions()).thenReturn(templateDefinitions);
+ when(user.getTemplateDefinitions().getTemplateDefinition()).thenReturn(templateDefinitionList);
+ when(user.getTemplateInstances()).thenReturn(templateInstances);
+ when(user.getTemplateInstances().getTemplateInstance()).thenReturn(templateInstanceList);
+
+ tenantManage.getNodeDataStore(userId);
+ tenantManage.getConnectionDataStore(userId);
+ tenantManage.getDefinitionDataStore(userId);
+ tenantManage.getFlowDataStore(userId);
+ tenantManage.getInstanceDataStore(userId);
+ tenantManage.getOperationDataStore(userId);
+ verify(objects,times(2)).getNode();
+ verify(objects,times(2)).getConnection();
+ verify(objects,times(2)).getFlow();
+ verify(operations,times(2)).getOperation();
+ verify(templateDefinitions,times(2)).getTemplateDefinition();
+ verify(templateInstances,times(2)).getTemplateInstance();
+
+ }
+