verigraph/src/main/java/it/polito/grpc/test/GrpcTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2017 Politecnico di Torino and others.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Apache License, Version 2.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *******************************************************************************/
   9
  10 package it.polito.grpc.test;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.fail;
  15
  16 import java.util.ArrayList;
  17 import java.util.HashMap;
  18 import java.util.Iterator;
  19 import java.util.List;
  20 import java.util.Map;
  21
  22 import org.junit.After;
  23 import org.junit.Before;
  24 import org.junit.FixMethodOrder;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.junit.runners.JUnit4;
  28 import org.junit.runners.MethodSorters;
  29
  30 import io.grpc.verigraph.ConfigurationGrpc;
  31 import io.grpc.verigraph.GraphGrpc;
  32 import io.grpc.verigraph.NeighbourGrpc;
  33 import io.grpc.verigraph.NewGraph;
  34 import io.grpc.verigraph.NewNeighbour;
  35 import io.grpc.verigraph.NewNode;
  36 import io.grpc.verigraph.NodeGrpc;
  37 import it.polito.grpc.Client;
  38 import it.polito.grpc.Service;
  39
  40 @RunWith(JUnit4.class)
  41 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  42 public class GrpcTest {
  43         private Service server;
  44         private Client client;
  45
  46         @Before
  47         public void setUpBeforeClass() throws Exception {
  48                 client = new Client("localhost" , 50051);
  49                 server = new Service(50051);
  50                 server.start();
  51         }
  52
  53         @After
  54         public void tearDown() throws Exception {
  55                 server.stop();
  56                 client.shutdown();
  57         }
  58
  59         // method for comparing two non-null strings
  60         private void compareString(String rs, String ts, String meaning) {
  61                 assertNotNull("NULL "+meaning, ts);
  62                 assertEquals("Wrong "+meaning, rs, ts);
  63         }
  64
  65         @Test
  66         public final void test1Load() throws Exception{
  67                 String funcType1 = "vpnaccess";
  68                 String funcType2 = "vpnexit";
  69
  70                 // load an existing graph with 2 nodes
  71                 Map<String,String> map = new HashMap<String,String>();
  72                 map.put("vpnexit", "Node2");
  73                 ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
  74                 NodeGrpc node1 = Client.createNodeGrpc("Node1", funcType1, null, conf);
  75                 List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
  76                 NeighbourGrpc nb = Client.createNeighbourGrpc("Node1");
  77                 neighbours.add(nb);
  78                 map.clear();
  79                 map.put("vpnaccess", "Node1");
  80                 conf = Client.createConfigurationGrpc(map, null, null, null);
  81                 NodeGrpc node2 = Client.createNodeGrpc("Node2", funcType2, neighbours, conf);
  82                 List<NodeGrpc> nodes = new ArrayList<NodeGrpc>();
  83                 nodes.add(node1);
  84                 nodes.add(node2);
  85                 GraphGrpc graph = Client.createGraphGrpc(nodes);
  86                 //createGraph
  87                 graph = client.createGraph(graph).getGraph();
  88
  89                 //getGraph
  90                 GraphGrpc retreivedGraph = client.getGraph(graph.getId());
  91
  92                 assertNotNull("NULL Graph ",retreivedGraph);
  93                 assertEquals(graph.getId(), retreivedGraph.getId());
  94
  95                 // check the name of first node and the id
  96                 compareString(retreivedGraph.getNodeList().get(0).getName(), graph.getNodeList().get(0).getName(), "node name");
  97                 assertEquals(retreivedGraph.getNodeList().get(0).getId(), graph.getNodeList().get(0).getId());
  98
  99                 // check the name of second node and the id
 100                 compareString(retreivedGraph.getNodeList().get(1).getName(), graph.getNodeList().get(1).getName(), "node name");
 101                 assertEquals(retreivedGraph.getNodeList().get(1).getId(), graph.getNodeList().get(1).getId());
 102
 103                 //updateGraph
 104                 GraphGrpc updatedGraph = GraphGrpc.newBuilder().build();
 105                 NewGraph response = client.updateGraph(graph.getId(),updatedGraph);
 106
 107                 assertEquals(response.getSuccess(),true);
 108         }
 109
 110         @Test
 111         public final void test2LoadWithError() throws Exception{
 112                 // try to load a graph with node without functionalType
 113                 NodeGrpc node = null;
 114                 try{
 115                         node = Client.createNodeGrpc("Node1", null, null, null);
 116                         fail( "createNodeGrpc didn't throw when I expected it to" );
 117                 }
 118                 catch(Exception ex){
 119                 }
 120                 List<NodeGrpc> nodes = new ArrayList<NodeGrpc>();
 121                 if(node != null)
 122                         nodes.add(node);
 123
 124                 GraphGrpc graph = Client.createGraphGrpc(nodes);
 125                 graph = client.createGraph(graph).getGraph();
 126
 127                 assertEquals(graph.getId(), 2);
 128
 129                 //getGraphs
 130                 Iterator<GraphGrpc> graphs = client.getGraphs().iterator();
 131
 132                 assertEquals(graphs.next().getId(), 1);
 133                 assertEquals(graphs.next(), graph);
 134
 135                 //deleteGraph
 136                 boolean resp= client.deleteGraph(graph.getId());
 137                 assertEquals(resp, true);
 138
 139                 List<GraphGrpc> listGraphs = client.getGraphs();
 140
 141                 assertEquals(listGraphs.size(), 1);
 142                 assertEquals(listGraphs.get(0).getId(), 1);
 143         }
 144
 145         @Test
 146         public void test3Node() throws Exception {
 147                 NodeGrpc ufoundedGraph = NodeGrpc.newBuilder()
 148                                 .setErrorMessage("Node with id 1 not found in graph with id 1").build();
 149
 150                 // graph not found in the server
 151                 NodeGrpc node = client.getNode(1, 1);//id not present
 152
 153                 assertEquals(ufoundedGraph, node);
 154
 155                 // graph found in the server, but first add it
 156                 NodeGrpc addedNode = Client.createNodeGrpc("Node4", "firewall", null, null);
 157                 NewNode response = client.createNode(addedNode, 1);
 158                 addedNode = response.getNode();
 159                 node = client.getNode(1, 1);
 160
 161                 assertEquals(addedNode.getId(), node.getId());
 162
 163                 //updateNode
 164                 NodeGrpc updatedNode = Client.createNodeGrpc("Node9", "endhost", null, null);
 165                 response = client.updateNode(1, addedNode.getId(), updatedNode);
 166
 167                 assertEquals(response.getSuccess(),true);
 168
 169                 //configureNode
 170                 //this configuration is valid only on endhost!
 171                 Map<String,String> params = new HashMap<String,String>();
 172                 params.put("url", "www.facebook.com");
 173                 params.put("body", "word");
 174                 params.put("destination","server");
 175                 params.put("protocol", "HTTP_REQUEST");
 176                 ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null);
 177
 178                 boolean status = client.configureNode(1, 1, configuration);
 179
 180                 assertEquals(status,true);
 181         }
 182
 183         @Test
 184         public void test4Nodes() throws Exception {
 185                 // setup
 186                 GraphGrpc graph = Client.createGraphGrpc(null);
 187                 //createGraph
 188                 graph = client.createGraph(graph).getGraph();
 189
 190                 List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
 191                 NeighbourGrpc nb = Client.createNeighbourGrpc("Node6");
 192                 neighbours.add(nb);
 193                 NodeGrpc n1 = Client.createNodeGrpc("Node6", "mailserver", null, null);
 194                 NodeGrpc n2 = Client.createNodeGrpc("Node9", "endhost", neighbours, null);
 195                 Map<String,String> map = new HashMap<String,String>();
 196                 map.put("mailserver", "Node6");
 197                 ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
 198                 NodeGrpc n3 = Client.createNodeGrpc("Node10", "mailclient", null, conf);
 199                 NodeGrpc n4 = Client.createNodeGrpc("Node11", "nat", null, null);
 200
 201                 NewNode nw1 = client.createNode(n1, graph.getId());
 202                 NewNode nw2 = client.createNode(n2, graph.getId());
 203                 NewNode nw3 = client.createNode(n3, graph.getId());
 204                 NewNode nw4 = client.createNode(n4, graph.getId());
 205                 assertEquals(nw1.getSuccess(),true);
 206                 assertEquals(nw2.getSuccess(),true);
 207                 assertEquals(nw3.getSuccess(),true);
 208                 assertEquals(nw4.getSuccess(),true);
 209                 n1 = NodeGrpc.newBuilder(n1).setId(nw1.getNode().getId()).build();
 210                 n2 = NodeGrpc.newBuilder(n2).setId(nw2.getNode().getId()).build();
 211                 n3 = NodeGrpc.newBuilder(n3).setId(nw3.getNode().getId()).build();
 212                 n4 = NodeGrpc.newBuilder(n4).setId(nw4.getNode().getId()).build();
 213
 214                 // getNodes
 215                 Iterator<NodeGrpc> nodes = client.getNodes(graph.getId()).iterator();
 216
 217                 assertEquals(nodes.next().getName(), n1.getName());
 218                 assertEquals(nodes.next().getName(), n2.getName());
 219                 assertEquals(nodes.next().getName(), n3.getName());
 220                 assertEquals(nodes.next().getName(), n4.getName());
 221
 222                 //deleteNode
 223                 client.deleteNode(graph.getId(), 1);
 224                 // run
 225                 nodes = client.getNodes(graph.getId()).iterator();
 226
 227                 assertEquals(nodes.next().getName(), n2.getName());
 228                 assertEquals(nodes.next().getName(), n3.getName());
 229                 assertEquals(nodes.next().getName(), n4.getName());
 230         }
 231
 232         @Test
 233         public void test5Neighbours() throws Exception {
 234                 NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder()
 235                                 .setErrorMessage("Neighbour with id 1 not found for node with id 1 in graph with id 1").build();;
 236
 237                 // Neighbour not found in the server
 238                 NeighbourGrpc neighbour = client.getNeighbour(1, 1, 1);//id not present
 239
 240                 assertEquals(ufoundedNeighbour, neighbour);
 241
 242                 GraphGrpc graph = Client.createGraphGrpc(null);
 243                 graph = client.createGraph(graph).getGraph();
 244
 245                 List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
 246                 NeighbourGrpc nb = Client.createNeighbourGrpc("Node1");
 247                 neighbours.add(nb);
 248                 NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null);
 249                 NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", neighbours, null);
 250                 NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null);
 251                 NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null);
 252                 NodeGrpc n5 = Client.createNodeGrpc("Node5", "webserver", null, null);
 253                 Map<String,String> map = new HashMap<String,String>();
 254                 map.put("webserver", "Node5");
 255                 ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
 256                 NodeGrpc n6 = Client.createNodeGrpc("Node6", "webclient", null, conf);
 257                 NodeGrpc n7 = Client.createNodeGrpc("Node7", "cache", null, null);
 258                 NodeGrpc n8 = Client.createNodeGrpc("Node8", "firewall", null, null);
 259                 NodeGrpc n9 = Client.createNodeGrpc("Node9", "fieldmodifier", null, null);
 260                 NodeGrpc n10 = Client.createNodeGrpc("Node10", "dpi", null, null);
 261                 NewNode nw1 = client.createNode(n1, graph.getId());
 262                 NewNode nw2 = client.createNode(n2, graph.getId());
 263                 NewNode nw3 = client.createNode(n3, graph.getId());
 264                 NewNode nw4 = client.createNode(n4, graph.getId());
 265                 NewNode nw5 = client.createNode(n5, graph.getId());
 266                 NewNode nw6 = client.createNode(n6, graph.getId());
 267                 NewNode nw7 = client.createNode(n7, graph.getId());
 268                 NewNode nw8 = client.createNode(n8, graph.getId());
 269                 NewNode nw9 = client.createNode(n9, graph.getId());
 270                 NewNode nw10 = client.createNode(n10, graph.getId());
 271                 assertEquals(nw1.getSuccess(),true);
 272                 assertEquals(nw2.getSuccess(),true);
 273                 assertEquals(nw3.getSuccess(),true);
 274                 assertEquals(nw4.getSuccess(),true);
 275                 assertEquals(nw5.getSuccess(),true);
 276                 assertEquals(nw6.getSuccess(),true);
 277                 assertEquals(nw7.getSuccess(),true);
 278                 assertEquals(nw8.getSuccess(),true);
 279                 assertEquals(nw9.getSuccess(),true);
 280                 assertEquals(nw10.getSuccess(),true);
 281
 282                 // getNeighbour, but first add it
 283                 NeighbourGrpc addedNeighbour = Client.createNeighbourGrpc("Node9");
 284                 NewNeighbour response = client.createNeighbour(addedNeighbour, graph.getId(), nw1.getNode().getId());
 285                 addedNeighbour = response.getNeighbour();
 286                 neighbour = client.getNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour.getId());
 287
 288                 assertEquals(addedNeighbour.getId(), neighbour.getId());
 289
 290                 //updateNeighbour
 291                 NeighbourGrpc updatedNeighbour = Client.createNeighbourGrpc("Node10");
 292
 293                 response = client.updateNeighbour(graph.getId(), 1, addedNeighbour.getId(),updatedNeighbour);
 294
 295                 assertEquals(response.getSuccess(),true);
 296                 assertEquals(response.getNeighbour().getName(),"Node10");
 297         }
 298
 299         @Test
 300         public void test6Neighbours() throws Exception {
 301                 // setup
 302                 GraphGrpc graph = Client.createGraphGrpc(null);
 303                 //createGraph
 304                 graph = client.createGraph(graph).getGraph();
 305
 306                 NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null);
 307                 NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", null, null);
 308                 NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null);
 309                 NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null);
 310                 NewNode nw1 = client.createNode(n1, graph.getId());
 311                 NewNode nw2 = client.createNode(n2, graph.getId());
 312                 NewNode nw3 = client.createNode(n3, graph.getId());
 313                 NewNode nw4 = client.createNode(n4, graph.getId());
 314                 assertEquals(nw1.getSuccess(),true);
 315                 assertEquals(nw2.getSuccess(),true);
 316                 assertEquals(nw3.getSuccess(),true);
 317                 assertEquals(nw4.getSuccess(),true);
 318
 319                 //createNeighbour
 320                 NeighbourGrpc nn1 = Client.createNeighbourGrpc("Node2");
 321                 NewNeighbour addedNeighbour1 = client.createNeighbour(nn1, graph.getId(), nw1.getNode().getId());
 322                 assertEquals(addedNeighbour1.getSuccess(),true);
 323                 NeighbourGrpc nn2 = Client.createNeighbourGrpc("Node3");
 324                 NewNeighbour addedNeighbour2 = client.createNeighbour(nn2, graph.getId(), nw1.getNode().getId());
 325                 assertEquals(addedNeighbour2.getSuccess(),true);
 326                 NeighbourGrpc nn3 = Client.createNeighbourGrpc("Node4");
 327                 NewNeighbour addedNeighbour3 = client.createNeighbour(nn3, graph.getId(), nw1.getNode().getId());
 328                 assertEquals(addedNeighbour3.getSuccess(),true);
 329
 330                 nn1 = NeighbourGrpc.newBuilder(nn1).setId(1).build();
 331                 nn2 = NeighbourGrpc.newBuilder(nn2).setId(2).build();
 332                 nn3 = NeighbourGrpc.newBuilder(nn3).setId(3).build();
 333                 // run
 334                 Iterator<NeighbourGrpc> neighbours = client.getNeighbours(graph.getId(), nw1.getNode().getId()).iterator();
 335
 336                 assertEquals(neighbours.next(), nn1);
 337                 assertEquals(neighbours.next(), nn2);
 338                 assertEquals(neighbours.next(), nn3);
 339
 340                 //deleteNeighbour
 341                 boolean succ = client.deleteNeighbour(graph.getId(), nw1.getNode().getId(), 1);
 342                 assertEquals(succ, true);
 343                 // run
 344                 neighbours = client.getNeighbours(graph.getId(), nw1.getNode().getId()).iterator();
 345
 346                 assertEquals(neighbours.next(), nn2);
 347                 assertEquals(neighbours.next(), nn3);
 348         }
 349 }