/******************************************************************************* * Copyright (c) 2017 Politecnico di Torino and others. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the Apache License, Version 2.0 * which accompanies this distribution, and is available at * http://www.apache.org/licenses/LICENSE-2.0 *******************************************************************************/ package it.polito.verigraph.grpc.test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.fail; import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.TreeSet; import org.junit.After; import org.junit.Before; import org.junit.FixMethodOrder; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.junit.runners.MethodSorters; import it.polito.verigraph.grpc.ConfigurationGrpc; import it.polito.verigraph.grpc.GraphGrpc; import it.polito.verigraph.grpc.NeighbourGrpc; import it.polito.verigraph.grpc.NewGraph; import it.polito.verigraph.grpc.NewNeighbour; import it.polito.verigraph.grpc.NewNode; import it.polito.verigraph.grpc.NodeGrpc; import it.polito.verigraph.grpc.client.Client; import it.polito.verigraph.grpc.server.Service; @RunWith(JUnit4.class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class GrpcTest { private Service server; private Client client; @Before public void setUpBeforeClass() throws Exception { client = new Client("localhost" , 50051); server = new Service(50051); server.start(); } @After public void tearDown() throws Exception { server.stop(); client.shutdown(); } // method for comparing two non-null strings private void compareString(String rs, String ts, String meaning) { assertNotNull("NULL "+meaning, ts); assertEquals("Wrong "+meaning, rs, ts); } public void deleteGraphs() { for(GraphGrpc graph : client.getGraphs()){ client.deleteGraph(graph.getId()); } } @Test public final void test1Load() throws Exception{ System.out.println("[DEBUG] test1Load starts"); deleteGraphs(); String funcType1 = "vpnaccess"; String funcType2 = "vpnexit"; // load an existing graph with 2 nodes Map map = new HashMap(); map.put("vpnexit", "Node2"); ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null); NodeGrpc node1 = Client.createNodeGrpc("Node1", funcType1, null, conf); List neighbours = new ArrayList(); NeighbourGrpc nb = Client.createNeighbourGrpc("Node1"); neighbours.add(nb); map.clear(); map.put("vpnaccess", "Node1"); conf = Client.createConfigurationGrpc(map, null, null, null); NodeGrpc node2 = Client.createNodeGrpc("Node2", funcType2, neighbours, conf); List nodes = new ArrayList(); nodes.add(node1); nodes.add(node2); GraphGrpc graph = Client.createGraphGrpc(nodes); //createGraph graph = client.createGraph(graph).getGraph(); //getGraph GraphGrpc retreivedGraph = client.getGraph(graph.getId()); assertNotNull("NULL Graph ",retreivedGraph); assertEquals(graph.getId(), retreivedGraph.getId()); // check the name of first node and the id compareString(retreivedGraph.getNodeList().get(0).getName(), graph.getNodeList().get(0).getName(), "node name"); assertEquals(retreivedGraph.getNodeList().get(0).getId(), graph.getNodeList().get(0).getId()); // check the name of second node and the id compareString(retreivedGraph.getNodeList().get(1).getName(), graph.getNodeList().get(1).getName(), "node name"); assertEquals(retreivedGraph.getNodeList().get(1).getId(), graph.getNodeList().get(1).getId()); //updateGraph GraphGrpc updatedGraph = GraphGrpc.newBuilder().build(); NewGraph response = client.updateGraph(graph.getId(),updatedGraph); assertEquals(response.getSuccess(),true); } @Test public final void test2LoadWithError() throws Exception{ System.out.println("[DEBUG] test2Load starts"); deleteGraphs(); // try to load a graph with node without functionalType NodeGrpc node = null; try{ node = Client.createNodeGrpc("Node1", null, null, null); fail( "createNodeGrpc didn't throw when I expected it to" ); } catch(Exception ex){ } List nodes = new ArrayList(); if(node != null) nodes.add(node); GraphGrpc graph = Client.createGraphGrpc(nodes); GraphGrpc g = client.createGraph(graph).getGraph(); GraphGrpc get_graph= client.getGraph(g.getId()); assertEquals(g.getErrorMessage(), get_graph.getErrorMessage()); //getGraphs List graph_list = client.getGraphs(); TreeSet pts = new TreeSet(new GraphGrpcComparator()); pts.addAll(graph_list); Iterator graphs = pts.iterator(); //assertEquals(graphs.next().getId(), g.getId()); if(graphs.hasNext()) assertEquals(graphs.next(), g); //deleteGraph boolean resp= client.deleteGraph(g.getId()); assertEquals(resp, true); List listGraphs = client.getGraphs(); assertEquals(listGraphs.size(), 0); //assertEquals(listGraphs.get(0).getId(), 1); } @Test public void test3Node() throws Exception { System.out.println("[DEBUG] test3Load starts"); deleteGraphs(); NodeGrpc ufoundedGraph = NodeGrpc.newBuilder() .setErrorMessage("There is no Graph whose Id is '1'").build(); // graph not found in the server NodeGrpc node = client.getNode(1, 1);//id not present assertEquals(ufoundedGraph, node); // graph found in the server, but first add it NodeGrpc addedNode = Client.createNodeGrpc("Node4", "firewall", null, null); GraphGrpc addedgraph = Client.createGraphGrpc(null); NewGraph response_graph = client.createGraph(addedgraph); NewNode response = client.createNode(addedNode, response_graph.getGraph().getId()); addedNode = response.getNode(); node = client.getNode(response_graph.getGraph().getId(), addedNode.getId()); assertEquals(addedNode.getId(), node.getId()); //updateNode NodeGrpc updatedNode = Client.createNodeGrpc("Node9", "endhost", null, null); response = client.updateNode(response_graph.getGraph().getId(), addedNode.getId(), updatedNode); assertEquals(response.getSuccess(),true); //configureNode //this configuration is valid only on endhost! Map params = new HashMap(); params.put("url", "www.facebook.com"); params.put("body", "word"); params.put("destination","server"); params.put("protocol", "HTTP_REQUEST"); ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null); boolean status = client.configureNode(response_graph.getGraph().getId(), addedNode.getId(), configuration); assertEquals(status,true); } @Test public void test4Nodes() throws Exception { System.out.println("[DEBUG] test4Load starts"); // setup GraphGrpc graph = Client.createGraphGrpc(null); //createGraph graph = client.createGraph(graph).getGraph(); List neighbours = new ArrayList(); NeighbourGrpc nb = Client.createNeighbourGrpc("Node6"); neighbours.add(nb); NodeGrpc n1 = Client.createNodeGrpc("Node6", "mailserver", null, null); NodeGrpc n2 = Client.createNodeGrpc("Node9", "endhost", neighbours, null); Map map = new HashMap(); map.put("mailserver", "Node6"); ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null); NodeGrpc n3 = Client.createNodeGrpc("Node10", "mailclient", null, conf); NodeGrpc n4 = Client.createNodeGrpc("Node11", "nat", null, null); NewNode nw1 = client.createNode(n1, graph.getId()); NewNode nw2 = client.createNode(n2, graph.getId()); NewNode nw3 = client.createNode(n3, graph.getId()); NewNode nw4 = client.createNode(n4, graph.getId()); assertEquals(nw1.getSuccess(),true); assertEquals(nw2.getSuccess(),true); assertEquals(nw3.getSuccess(),true); assertEquals(nw4.getSuccess(),true); n1 = NodeGrpc.newBuilder(n1).setId(nw1.getNode().getId()).build(); n2 = NodeGrpc.newBuilder(n2).setId(nw2.getNode().getId()).build(); n3 = NodeGrpc.newBuilder(n3).setId(nw3.getNode().getId()).build(); n4 = NodeGrpc.newBuilder(n4).setId(nw4.getNode().getId()).build(); // getNodes List node_list = client.getNodes(graph.getId()); TreeSet pts = new TreeSet(new NodeGrpcComparator()); pts.addAll(node_list); Iterator nodes = pts.iterator(); //sorted by name if(nodes.hasNext()){ assertEquals(nodes.next().getName(), n3.getName()); assertEquals(nodes.next().getName(), n4.getName()); assertEquals(nodes.next().getName(), n1.getName()); assertEquals(nodes.next().getName(), n2.getName()); } //deleteNode client.deleteNode(graph.getId(), n1.getId()); // run node_list = client.getNodes(graph.getId()); pts = new TreeSet(new NodeGrpcComparator()); pts.addAll(node_list); nodes = pts.iterator(); assertEquals(nodes.next().getName(), n3.getName()); assertEquals(nodes.next().getName(), n4.getName()); assertEquals(nodes.next().getName(), n2.getName()); } @Test public void test5Neighbours() throws Exception { System.out.println("[DEBUG] test5Load starts"); NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder() .setErrorMessage("There is no Graph whose Id is '1'").build();; // Neighbour not found in the server NeighbourGrpc neighbour = client.getNeighbour(1, 1, 1);//id not present assertEquals(ufoundedNeighbour, neighbour); GraphGrpc graph = Client.createGraphGrpc(null); graph = client.createGraph(graph).getGraph(); List neighbours = new ArrayList(); NeighbourGrpc nb = Client.createNeighbourGrpc("Node1"); neighbours.add(nb); NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null); NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", neighbours, null); NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null); NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null); NodeGrpc n5 = Client.createNodeGrpc("Node5", "webserver", null, null); Map map = new HashMap(); map.put("webserver", "Node5"); ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null); NodeGrpc n6 = Client.createNodeGrpc("Node6", "webclient", null, conf); NodeGrpc n7 = Client.createNodeGrpc("Node7", "cache", null, null); NodeGrpc n8 = Client.createNodeGrpc("Node8", "firewall", null, null); NodeGrpc n9 = Client.createNodeGrpc("Node9", "fieldmodifier", null, null); NodeGrpc n10 = Client.createNodeGrpc("Node10", "dpi", null, null); NewNode nw1 = client.createNode(n1, graph.getId()); NewNode nw2 = client.createNode(n2, graph.getId()); NewNode nw3 = client.createNode(n3, graph.getId()); NewNode nw4 = client.createNode(n4, graph.getId()); NewNode nw5 = client.createNode(n5, graph.getId()); NewNode nw6 = client.createNode(n6, graph.getId()); NewNode nw7 = client.createNode(n7, graph.getId()); NewNode nw8 = client.createNode(n8, graph.getId()); NewNode nw9 = client.createNode(n9, graph.getId()); NewNode nw10 = client.createNode(n10, graph.getId()); assertEquals(nw1.getSuccess(),true); assertEquals(nw2.getSuccess(),true); assertEquals(nw3.getSuccess(),true); assertEquals(nw4.getSuccess(),true); assertEquals(nw5.getSuccess(),true); assertEquals(nw6.getSuccess(),true); assertEquals(nw7.getSuccess(),true); assertEquals(nw8.getSuccess(),true); assertEquals(nw9.getSuccess(),true); assertEquals(nw10.getSuccess(),true); // getNeighbour, but first add it NeighbourGrpc addedNeighbour = Client.createNeighbourGrpc("Node9"); NewNeighbour response = client.createNeighbour(addedNeighbour, graph.getId(), nw1.getNode().getId()); addedNeighbour = response.getNeighbour(); neighbour = client.getNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour.getId()); assertEquals(addedNeighbour.getId(), neighbour.getId()); //updateNeighbour NeighbourGrpc updatedNeighbour = Client.createNeighbourGrpc("Node10"); response = client.updateNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour.getId(),updatedNeighbour); assertEquals(response.getSuccess(),true); assertEquals(response.getNeighbour().getName(),"Node10"); } @Test public void test6Neighbours() throws Exception { System.out.println("[DEBUG] test6Load starts"); // setup GraphGrpc graph = Client.createGraphGrpc(null); //createGraph graph = client.createGraph(graph).getGraph(); NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null); NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", null, null); NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null); NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null); NewNode nw1 = client.createNode(n1, graph.getId()); NewNode nw2 = client.createNode(n2, graph.getId()); NewNode nw3 = client.createNode(n3, graph.getId()); NewNode nw4 = client.createNode(n4, graph.getId()); assertEquals(nw1.getSuccess(),true); assertEquals(nw2.getSuccess(),true); assertEquals(nw3.getSuccess(),true); assertEquals(nw4.getSuccess(),true); //createNeighbour NeighbourGrpc nn1 = Client.createNeighbourGrpc("Node2"); NewNeighbour addedNeighbour1 = client.createNeighbour(nn1, graph.getId(), nw1.getNode().getId()); assertEquals(addedNeighbour1.getSuccess(),true); NeighbourGrpc nn2 = Client.createNeighbourGrpc("Node3"); NewNeighbour addedNeighbour2 = client.createNeighbour(nn2, graph.getId(), nw1.getNode().getId()); assertEquals(addedNeighbour2.getSuccess(),true); NeighbourGrpc nn3 = Client.createNeighbourGrpc("Node4"); NewNeighbour addedNeighbour3 = client.createNeighbour(nn3, graph.getId(), nw1.getNode().getId()); assertEquals(addedNeighbour3.getSuccess(),true); nn1 = NeighbourGrpc.newBuilder(nn1).setId(1).build(); nn2 = NeighbourGrpc.newBuilder(nn2).setId(2).build(); nn3 = NeighbourGrpc.newBuilder(nn3).setId(3).build(); // run List node_list = client.getNeighbours(graph.getId(), nw1.getNode().getId()); TreeSet pts = new TreeSet(new NeighbourGrpcComparator()); pts.addAll(node_list); Iterator neighbours = pts.iterator(); while(neighbours.hasNext()){ neighbours.next(); } if(neighbours.hasNext()){ assertEquals(neighbours.next(), addedNeighbour1.getNeighbour()); assertEquals(neighbours.next(), addedNeighbour2.getNeighbour()); assertEquals(neighbours.next(), addedNeighbour3.getNeighbour()); } //deleteNeighbour boolean succ = client.deleteNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour1.getNeighbour().getId()); assertEquals(succ, true); // run node_list = client.getNeighbours(graph.getId(), nw1.getNode().getId()); pts = new TreeSet(new NeighbourGrpcComparator()); pts.addAll(node_list); neighbours = pts.iterator(); while(neighbours.hasNext()){ neighbours.next(); } if(neighbours.hasNext()){ assertEquals(neighbours.next(), addedNeighbour2.getNeighbour()); assertEquals(neighbours.next(), addedNeighbour3.getNeighbour()); } } } class NodeGrpcComparator implements Comparator { public int compare(NodeGrpc n0, NodeGrpc n1) { return n0.getName().compareTo(n1.getName()); } } class NeighbourGrpcComparator implements Comparator { public int compare(NeighbourGrpc n0, NeighbourGrpc n1) { return n0.getName().compareTo(n1.getName()); } } class GraphGrpcComparator implements Comparator { public int compare(GraphGrpc n0, GraphGrpc n1) { if(n0.getId() == n1.getId()) return 0; else if (n0.getId() > n1.getId()) return 1; else return -1; } }