verigraph/src/it/polito/verigraph/grpc/test/GrpcServerTest.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 package it.polito.verigraph.grpc.test;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import io.grpc.ManagedChannel;
  13 import io.grpc.inprocess.InProcessChannelBuilder;
  14 import io.grpc.inprocess.InProcessServerBuilder;
  15 import it.polito.verigraph.grpc.ConfigurationGrpc;
  16 import it.polito.verigraph.grpc.GetRequest;
  17 import it.polito.verigraph.grpc.GraphGrpc;
  18 import it.polito.verigraph.grpc.NeighbourGrpc;
  19 import it.polito.verigraph.grpc.NewGraph;
  20 import it.polito.verigraph.grpc.NewNeighbour;
  21 import it.polito.verigraph.grpc.NewNode;
  22 import it.polito.verigraph.grpc.NodeGrpc;
  23 import it.polito.verigraph.grpc.NodeGrpc.FunctionalType;
  24 import it.polito.verigraph.grpc.client.Client;
  25 import it.polito.verigraph.grpc.server.Service;
  26 import it.polito.verigraph.grpc.RequestID;
  27 import it.polito.verigraph.grpc.Status;
  28 import it.polito.verigraph.grpc.VerigraphGrpc;
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.junit.FixMethodOrder;
  33 import org.junit.runners.MethodSorters;
  34 import org.junit.runner.RunWith;
  35 import org.junit.runners.JUnit4;
  36 import java.util.HashMap;
  37 import java.util.Iterator;
  38 import java.util.Map;
  39
  40 /**
  41  * Unit tests for {@link Service}.
  42  * For testing basic gRPC unit test only.
  43  * Not intended to provide a high code coverage or to test every major usecase.
  44  */
  45 @RunWith(JUnit4.class)
  46 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  47 public class GrpcServerTest {
  48     private Service server;
  49     private ManagedChannel inProcessChannel;
  50
  51     @Before
  52     public void setUp() throws Exception {
  53         String uniqueServerName = "in-process server for " + getClass();
  54         // use directExecutor for both InProcessServerBuilder and InProcessChannelBuilder can reduce the
  55         // usage timeouts and latches in test. But we still add timeout and latches where they would be
  56         // needed if no directExecutor were used, just for demo purpose.
  57         server = new Service(InProcessServerBuilder.forName(uniqueServerName).directExecutor(),0);
  58         server.start();
  59         inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName).directExecutor().build();
  60     }
  61
  62     @After
  63     public void tearDown() throws Exception {
  64         inProcessChannel.shutdownNow();
  65         server.stop();
  66     }
  67
  68     public void deleteGraphs() {
  69         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
  70         Iterator<GraphGrpc> iter = stub.getGraphs(GetRequest.newBuilder().build());
  71         while(iter.hasNext()){
  72             stub.deleteGraph(RequestID.newBuilder().setIdGraph(iter.next().getId()).build());
  73         }
  74     }
  75
  76     @Test
  77     public void test1Graph() throws Exception {
  78         System.out.println("[DEBUG] test1Graphs starts");
  79         deleteGraphs();
  80         RequestID request = RequestID.newBuilder().setIdGraph(1).build() ;//id not present
  81         GraphGrpc ufoundedGraph = GraphGrpc.newBuilder()
  82                 //.setErrorMessage("Graph with id 1 not found").build();
  83                 .setErrorMessage("There is no Graph whose Id is '1'").build();
  84         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
  85
  86         // graph not found in the server
  87         GraphGrpc graph = stub.getGraph(request);
  88         assertEquals(ufoundedGraph, graph);
  89
  90         // getGraph in the server, but first add it
  91         GraphGrpc addedGraph = GraphGrpc.newBuilder().build();
  92         NewGraph response = stub.createGraph(addedGraph);
  93         addedGraph = response.getGraph();
  94         //request = RequestID.newBuilder().setIdGraph(1).build() ;
  95         request = RequestID.newBuilder().setIdGraph(response.getGraph().getId()).build() ;
  96         graph = stub.getGraph(request);
  97
  98         assertEquals(addedGraph.getId(), graph.getId());
  99
 100         //updateGraph
 101         GraphGrpc updatedGraph = GraphGrpc.newBuilder().setId(response.getGraph().getId()).build();
 102         response = stub.updateGraph(updatedGraph);
 103
 104         assertEquals(response.getSuccess(),true);
 105     }
 106
 107     @Test
 108     public void test2Graphs() throws Exception {
 109         System.out.println("[DEBUG] test2Graphs starts");
 110         deleteGraphs();
 111         // setup
 112         GetRequest request = GetRequest.newBuilder().build();
 113         GraphGrpc g1 = GraphGrpc.newBuilder().build();
 114         GraphGrpc g2 = GraphGrpc.newBuilder().build();
 115         GraphGrpc g3 = GraphGrpc.newBuilder().build();
 116         GraphGrpc g4 = GraphGrpc.newBuilder().build();
 117
 118         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 119
 120         NewGraph g1_new = stub.createGraph(g1);
 121         NewGraph g2_new = stub.createGraph(g2);
 122         NewGraph g3_new = stub.createGraph(g3);
 123         NewGraph g4_new = stub.createGraph(g4);
 124
 125         long g1_id = g1_new.getGraph().getId();
 126         long g2_id = g2_new.getGraph().getId();
 127         long g3_id = g3_new.getGraph().getId();
 128         long g4_id = g4_new.getGraph().getId();
 129         g1 = GraphGrpc.newBuilder(g1).setId(g1_id).build();
 130         g2 = GraphGrpc.newBuilder(g2).setId(g2_id).build();
 131         g3 = GraphGrpc.newBuilder(g3).setId(g3_id).build();
 132         g4 = GraphGrpc.newBuilder(g4).setId(g4_id).build();
 133         // run
 134         Iterator<GraphGrpc> graphs = stub.getGraphs(request);
 135
 136         while(graphs.hasNext()){
 137             graphs.next();
 138         }
 139
 140         if(graphs.hasNext()){
 141             graphs.next();
 142             assertEquals(graphs.next(), g1);
 143             assertEquals(graphs.next(), g2);
 144             assertEquals(graphs.next(), g3);
 145             assertEquals(graphs.next(), g4);
 146
 147             //deleteGraph
 148             RequestID req = RequestID.newBuilder().setIdGraph(g1.getId()).build();
 149             stub.deleteGraph(req);
 150             // run
 151             graphs = stub.getGraphs(request);
 152
 153             assertEquals(graphs.next(), g2);
 154             assertEquals(graphs.next(), g3);
 155             assertEquals(graphs.next(), g4);
 156         }
 157     }
 158
 159     @Test
 160     public void test3Node() throws Exception {
 161         System.out.println("[DEBUG] test3Graphs starts");
 162         deleteGraphs();
 163
 164         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 165         GraphGrpc g2 = GraphGrpc.newBuilder().build();
 166         NewGraph g2_new = stub.createGraph(g2);
 167         long g2_id = g2_new.getGraph().getId();
 168
 169         RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(1).build() ;//id not present
 170         // graph not found in the server
 171         NodeGrpc node = stub.getNode(request);
 172
 173         NodeGrpc unfoundedGraph = NodeGrpc.newBuilder()
 174                 //.setErrorMessage("Node with id 1 not found in graph with id 2").build();
 175                 //.setErrorMessage("There is no Graph whose Id is '2'").build();
 176                 .setErrorMessage("There is no Node whose Id is '1'").build();
 177
 178         assertEquals(unfoundedGraph, node);
 179
 180         // graph found in the server, but first add it
 181         NodeGrpc addedNode = NodeGrpc.newBuilder().setName("client").setIdGraph(g2_id)
 182                 .setFunctionalType(FunctionalType.endhost).build();
 183         NewNode response = stub.createNode(addedNode);
 184         long node_id = response.getNode().getId();
 185         //addedNode = response.getNode();
 186
 187         request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(addedNode.getId()).build() ;
 188         node = stub.getNode(request);
 189
 190         assertEquals(addedNode.getId(), node.getId());
 191         assertEquals(addedNode.getName(),"client");
 192
 193         //updateNode
 194         NodeGrpc updatedNode = NodeGrpc.newBuilder().setName("Nodo2").setIdGraph(g2_id).setId(node_id)
 195                 .setFunctionalType(FunctionalType.endhost).build();
 196
 197         response = stub.updateNode(updatedNode);
 198
 199         assertEquals(response.getSuccess(),true);
 200         assertEquals(response.getNode().getName(),"Nodo2");
 201
 202         //configureNode
 203         Map<String,String> params = new HashMap<String,String>();
 204         params.put("url", "www.facebook.com");
 205         params.put("body", "word");
 206         params.put("destination","server");
 207         params.put("protocol", "HTTP_REQUEST");
 208         ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null);
 209         ConfigurationGrpc config = ConfigurationGrpc.newBuilder(configuration).setIdGraph(g2_id)
 210                 .setIdNode(node_id).build();
 211
 212         Status status = stub.configureNode(config);
 213         assertEquals(status.getSuccess(),true);
 214     }
 215
 216     @Test
 217     public void test4Nodes() throws Exception {
 218         System.out.println("[DEBUG] test4Graphs starts");
 219         deleteGraphs();
 220
 221         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 222         GraphGrpc g2 = GraphGrpc.newBuilder().build();
 223         NewGraph g2_new = stub.createGraph(g2);
 224         long g2_id = g2_new.getGraph().getId();
 225
 226         // setup
 227         RequestID request = RequestID.newBuilder().setIdGraph(g2_id).build();
 228         NodeGrpc n1 = NodeGrpc.newBuilder(Client.createNodeGrpc("Node5", "endhost", null, null))
 229                 .setIdGraph(g2_id).build();
 230         NodeGrpc n2 =  NodeGrpc.newBuilder(Client.createNodeGrpc("Node3", "endhost", null, null))
 231                 .setIdGraph(g2_id).build();
 232         NodeGrpc n3 =  NodeGrpc.newBuilder(Client.createNodeGrpc("Node4", "endhost", null, null))
 233                 .setIdGraph(g2_id).build();
 234         NodeGrpc n4 =  NodeGrpc.newBuilder(Client.createNodeGrpc("client", "endhost", null, null))
 235                 .setIdGraph(g2_id).build();
 236
 237         NewNode nn1= stub.createNode(n1);
 238         NewNode nn2= stub.createNode(n2);
 239         NewNode nn3= stub.createNode(n3);
 240         NewNode nn4= stub.createNode(n4);
 241
 242         n1 = NodeGrpc.newBuilder(n1).setId(nn1.getNode().getId()).setIdGraph(g2_id).build();
 243         n2 = NodeGrpc.newBuilder(n2).setId(nn2.getNode().getId()).setIdGraph(g2_id).build();
 244         n3 = NodeGrpc.newBuilder(n3).setId(nn3.getNode().getId()).setIdGraph(g2_id).build();
 245         n4 = NodeGrpc.newBuilder(n4).setId(nn4.getNode().getId()).setIdGraph(g2_id).build();
 246
 247         // run
 248         Iterator<NodeGrpc> nodes = stub.getNodes(request);
 249
 250         while(nodes.hasNext()){
 251             nodes.next();
 252             //System.out.println("[DEBUG - TEST4] graph loaded: " + nodes.next());
 253         }
 254
 255         if(nodes.hasNext()){
 256             assertEquals(nodes.next(), n1);
 257             assertEquals(nodes.next(), n2);
 258             assertEquals(nodes.next(), n3);
 259             assertEquals(nodes.next(), n4);
 260         }
 261
 262         //deleteNode
 263         RequestID req = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1.getId()).build();
 264         stub.deleteNode(req);
 265         // run
 266         nodes = stub.getNodes(request);
 267
 268         while(nodes.hasNext()){
 269             nodes.next();
 270             //System.out.println("[DEBUG - TEST4] graph loaded: " + nodes.next());
 271         }
 272
 273         if(nodes.hasNext()){
 274             //assertEquals(nodes.next(), n1);
 275             assertEquals(nodes.next(), n2);
 276             assertEquals(nodes.next(), n3);
 277             assertEquals(nodes.next(), n4);
 278         }
 279     }
 280
 281     @Test
 282     public void test5Neighbours() throws Exception {
 283         System.out.println("[DEBUG] test5Graphs starts");
 284         deleteGraphs();
 285
 286         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 287
 288         GraphGrpc g2 = GraphGrpc.newBuilder().build();
 289         NewGraph g2_new = stub.createGraph(g2);
 290         long g2_id = g2_new.getGraph().getId();
 291
 292         NodeGrpc n1 = NodeGrpc.newBuilder().setName("Node1").setIdGraph(g2_id).setFunctionalType(FunctionalType.endhost).build();
 293         NewNode new_n1 = stub.createNode(n1);
 294         long n1_id = new_n1.getNode().getId();
 295
 296         NodeGrpc n2 = NodeGrpc.newBuilder().setName("client").setIdGraph(g2_id).setFunctionalType(FunctionalType.endhost).build();
 297         NewNode new_n2 = stub.createNode(n2);
 298         long n2_id = new_n2.getNode().getId();
 299
 300         RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setIdNeighbour(1).build() ;//id not present
 301         NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder()
 302                 .setErrorMessage("Neighbour with id 1 not found for node with id "+n1_id+" in graph with id "+g2_id).build();
 303
 304                 // Neighbour not found in the server
 305                 NeighbourGrpc neighbour = stub.getNeighbour(request);
 306
 307                 assertEquals(ufoundedNeighbour, neighbour);
 308
 309                 // getNeighbour, but first add it
 310                 NeighbourGrpc addedNeighbour = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setName("client").build();
 311                 NewNeighbour response = stub.createNeighbour(addedNeighbour);
 312                 addedNeighbour = response.getNeighbour();
 313                 request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
 314                         .setIdNeighbour(addedNeighbour.getId()).build();
 315                 neighbour = stub.getNeighbour(request);
 316
 317                 assertEquals(addedNeighbour.getId(), neighbour.getId());
 318
 319                 NodeGrpc updatedNode = NodeGrpc.newBuilder().setName("Node4").setIdGraph(g2_id).setId(n2_id)
 320                         .setFunctionalType(FunctionalType.endhost).build();
 321
 322                 //updateNeighbour
 323                 NewNode response_node = stub.updateNode(updatedNode);
 324                 assertEquals(response_node.getSuccess(),true);
 325
 326                 //NeighbourGrpc nu = NeighbourGrpc.newBuilder().setName("Node4")
 327                 //.setId(addedNeighbour.getId()).setIdGraph(g2_id).setIdNode(n1_id).build();
 328                 //response = stub.updateNeighbour(nu);
 329                 //System.out.println(response);
 330
 331                 request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
 332                         .setIdNeighbour(addedNeighbour.getId()).build();
 333                 neighbour = stub.getNeighbour(request);
 334                 assertEquals(neighbour.getName(),"Node4");
 335     }
 336
 337     @Test
 338     public void test6Neighbours() throws Exception {
 339         System.out.println("[DEBUG] test6Graphs starts");
 340         deleteGraphs();
 341
 342         VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 343         // setup
 344         GraphGrpc g2 = GraphGrpc.newBuilder().build();
 345         NewGraph g2_new = stub.createGraph(g2);
 346         long g2_id = g2_new.getGraph().getId();
 347
 348         NodeGrpc node1 = NodeGrpc.newBuilder().setName("Node1").setFunctionalType(FunctionalType.endhost).build();
 349         NewNode new_n1 = stub.createNode(node1);
 350         long n1_id = new_n1.getNode().getId();
 351
 352
 353
 354         NeighbourGrpc n1 = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
 355                 .setName("Node3").build();
 356         NeighbourGrpc n2 = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
 357                 .setName("client").build();
 358
 359
 360         stub.createNeighbour(n1);
 361         stub.createNeighbour(n2);
 362         n1 = NeighbourGrpc.newBuilder(n1).setId(2).setIdGraph(g2_id).setIdNode(n1_id).build();
 363         n2 = NeighbourGrpc.newBuilder(n2).setId(3).setIdGraph(g2_id).setIdNode(n1_id).build();
 364         // run
 365         RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).build();
 366         Iterator<NeighbourGrpc> neighbours = stub.getNeighbours(request);
 367
 368         while(neighbours.hasNext()){
 369             neighbours.next();
 370         }
 371
 372         if(neighbours.hasNext()){
 373             assertEquals(neighbours.next(), n1);
 374             assertEquals(neighbours.next(), n2);
 375         }
 376
 377         //deleteNeighbour
 378         RequestID req = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setIdNeighbour(n1.getId()).build();
 379         stub.deleteNeighbour(req);
 380         // run
 381         neighbours = stub.getNeighbours(request);
 382
 383         while(neighbours.hasNext()){
 384             neighbours.next();
 385         }
 386
 387         if(neighbours.hasNext()){
 388             assertEquals(neighbours.next(), n1);
 389             assertEquals(neighbours.next(), n2);
 390         }
 391     }
 392 }