verigraph/src/main/java/it/polito/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
  10 package it.polito.grpc.test;
  11
  12 import static org.junit.Assert.assertEquals;
  13
  14 import io.grpc.ManagedChannel;
  15 import io.grpc.inprocess.InProcessChannelBuilder;
  16 import io.grpc.inprocess.InProcessServerBuilder;
  17 import io.grpc.verigraph.ConfigurationGrpc;
  18 import io.grpc.verigraph.GetRequest;
  19 import io.grpc.verigraph.GraphGrpc;
  20 import io.grpc.verigraph.NeighbourGrpc;
  21 import io.grpc.verigraph.NewGraph;
  22 import io.grpc.verigraph.NewNeighbour;
  23 import io.grpc.verigraph.NewNode;
  24 import io.grpc.verigraph.NodeGrpc;
  25 import io.grpc.verigraph.NodeGrpc.FunctionalType;
  26 import io.grpc.verigraph.RequestID;
  27 import io.grpc.verigraph.Status;
  28 import io.grpc.verigraph.VerigraphGrpc;
  29 import it.polito.grpc.Client;
  30 import it.polito.grpc.Service;
  31
  32 import org.junit.After;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.junit.FixMethodOrder;
  36 import org.junit.runners.MethodSorters;
  37 import org.junit.runner.RunWith;
  38 import org.junit.runners.JUnit4;
  39
  40 import java.util.HashMap;
  41 import java.util.Iterator;
  42 import java.util.Map;
  43
  44 /**
  45  * Unit tests for {@link Service}.
  46  * For testing basic gRPC unit test only.
  47  * Not intended to provide a high code coverage or to test every major usecase.
  48  */
  49 @RunWith(JUnit4.class)
  50 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  51 public class GrpcServerTest {
  52         private Service server;
  53         private ManagedChannel inProcessChannel;
  54
  55         @Before
  56         public void setUp() throws Exception {
  57                 String uniqueServerName = "in-process server for " + getClass();
  58                 // use directExecutor for both InProcessServerBuilder and InProcessChannelBuilder can reduce the
  59                 // usage timeouts and latches in test. But we still add timeout and latches where they would be
  60                 // needed if no directExecutor were used, just for demo purpose.
  61                 server = new Service(InProcessServerBuilder.forName(uniqueServerName).directExecutor(),0);
  62                 server.start();
  63                 inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName).directExecutor().build();
  64         }
  65
  66         @After
  67         public void tearDown() throws Exception {
  68                 inProcessChannel.shutdownNow();
  69                 server.stop();
  70         }
  71
  72         @Test
  73         public void test1Graph() throws Exception {
  74                 RequestID request = RequestID.newBuilder().setIdGraph(1).build() ;//id not present
  75                 GraphGrpc ufoundedGraph = GraphGrpc.newBuilder()
  76                                 .setErrorMessage("Graph with id 1 not found").build();
  77                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
  78
  79                 // graph not found in the server
  80                 GraphGrpc graph = stub.getGraph(request);
  81
  82                 assertEquals(ufoundedGraph, graph);
  83
  84                 // getGraph in the server, but first add it
  85                 GraphGrpc addedGraph = GraphGrpc.newBuilder().build();
  86                 NewGraph response = stub.createGraph(addedGraph);
  87                 addedGraph = response.getGraph();
  88                 request = RequestID.newBuilder().setIdGraph(1).build() ;
  89                 graph = stub.getGraph(request);
  90
  91                 assertEquals(addedGraph.getId(), graph.getId());
  92
  93                 //updateGraph
  94                 GraphGrpc updatedGraph = GraphGrpc.newBuilder().setId(response.getGraph().getId()).build();
  95                 response = stub.updateGraph(updatedGraph);
  96
  97                 assertEquals(response.getSuccess(),true);
  98         }
  99
 100         @Test
 101         public void test2Graphs() throws Exception {
 102                 // setup
 103                 GetRequest request = GetRequest.newBuilder().build();
 104                 GraphGrpc g1 = GraphGrpc.newBuilder().build();
 105                 GraphGrpc g2 = GraphGrpc.newBuilder().build();
 106                 GraphGrpc g3 = GraphGrpc.newBuilder().build();
 107                 GraphGrpc g4 = GraphGrpc.newBuilder().build();
 108
 109                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 110
 111                 stub.createGraph(g1);
 112                 stub.createGraph(g2);
 113                 stub.createGraph(g3);
 114                 stub.createGraph(g4);
 115                 g1 = GraphGrpc.newBuilder(g1).setId(1).build();
 116                 g2 = GraphGrpc.newBuilder(g2).setId(2).build();
 117                 g3 = GraphGrpc.newBuilder(g3).setId(3).build();
 118                 g4 = GraphGrpc.newBuilder(g4).setId(4).build();
 119                 // run
 120                 Iterator<GraphGrpc> graphs = stub.getGraphs(request);
 121
 122                 assertEquals(graphs.next(), g1);
 123                 assertEquals(graphs.next(), g2);
 124                 assertEquals(graphs.next(), g3);
 125                 assertEquals(graphs.next(), g4);
 126
 127                 //deleteGraph
 128                 RequestID req = RequestID.newBuilder().setIdGraph(g1.getId()).build();
 129                 stub.deleteGraph(req);
 130                 // run
 131                 graphs = stub.getGraphs(request);
 132
 133                 assertEquals(graphs.next(), g2);
 134                 assertEquals(graphs.next(), g3);
 135                 assertEquals(graphs.next(), g4);
 136         }
 137
 138         @Test
 139         public void test3Node() throws Exception {
 140                 RequestID request = RequestID.newBuilder().setIdGraph(2).setIdNode(1).build() ;//id not present
 141                 NodeGrpc ufoundedGraph = NodeGrpc.newBuilder()
 142                                         .setErrorMessage("Node with id 1 not found in graph with id 2").build();
 143                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 144
 145                 // graph not found in the server
 146                 NodeGrpc node = stub.getNode(request);
 147
 148                 assertEquals(ufoundedGraph, node);
 149
 150                 // graph found in the server, but first add it
 151                 NodeGrpc addedNode = NodeGrpc.newBuilder().setName("client").setIdGraph(2)
 152                                 .setFunctionalType(FunctionalType.endhost).build();
 153                 NewNode response = stub.createNode(addedNode);
 154                 addedNode = response.getNode();
 155                 request = RequestID.newBuilder().setIdGraph(2).setIdNode(1).build() ;
 156                 node = stub.getNode(request);
 157
 158                 assertEquals(addedNode.getId(), node.getId());
 159                 assertEquals(addedNode.getName(),"client");
 160
 161                 //updateNode
 162                 NodeGrpc updatedNode = NodeGrpc.newBuilder().setName("Nodo2").setIdGraph(2).setId(1)
 163                                 .setFunctionalType(FunctionalType.endhost).build();
 164                 response = stub.updateNode(updatedNode);
 165
 166                 assertEquals(response.getSuccess(),true);
 167                 assertEquals(response.getNode().getName(),"Nodo2");
 168
 169                 //configureNode
 170                 Map<String,String> params = new HashMap<String,String>();
 171                 params.put("url", "www.facebook.com");
 172                 params.put("body", "word");
 173                 params.put("destination","server");
 174                 params.put("protocol", "HTTP_REQUEST");
 175                 ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null);
 176                 ConfigurationGrpc config = ConfigurationGrpc.newBuilder(configuration).setIdGraph(2)
 177                                                         .setIdNode(1).build();
 178
 179                 Status status = stub.configureNode(config);
 180
 181                 assertEquals(status.getSuccess(),true);
 182         }
 183
 184         @Test
 185         public void test4Nodes() throws Exception {
 186                 // setup
 187                 RequestID request = RequestID.newBuilder().setIdGraph(2).build();
 188                 NodeGrpc n1 = NodeGrpc.newBuilder(Client.createNodeGrpc("Node5", "endhost", null, null))
 189                                 .setIdGraph(2).build();
 190                 NodeGrpc n2 =  NodeGrpc.newBuilder(Client.createNodeGrpc("Node3", "endhost", null, null))
 191                                 .setIdGraph(2).build();
 192                 NodeGrpc n3 =  NodeGrpc.newBuilder(Client.createNodeGrpc("Node4", "endhost", null, null))
 193                                 .setIdGraph(2).build();
 194                 NodeGrpc n4 =  NodeGrpc.newBuilder(Client.createNodeGrpc("client", "endhost", null, null))
 195                                 .setIdGraph(2).build();
 196
 197                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 198
 199                 stub.createNode(n1);
 200                 stub.createNode(n2);
 201                 stub.createNode(n3);
 202                 stub.createNode(n4);
 203                 n1 = NodeGrpc.newBuilder(n1).setId(2).setIdGraph(0).build();
 204                 n2 = NodeGrpc.newBuilder(n2).setId(3).setIdGraph(0).build();
 205                 n3 = NodeGrpc.newBuilder(n3).setId(4).setIdGraph(0).build();
 206                 n4 = NodeGrpc.newBuilder(n4).setId(5).setIdGraph(0).build();
 207                 // run
 208                 Iterator<NodeGrpc> nodes = stub.getNodes(request);
 209
 210                 nodes.next();
 211                 assertEquals(nodes.next(), n1);
 212                 assertEquals(nodes.next(), n2);
 213                 assertEquals(nodes.next(), n3);
 214                 assertEquals(nodes.next(), n4);
 215
 216                 //deleteNode
 217                 RequestID req = RequestID.newBuilder().setIdGraph(2).setIdNode(1).build();
 218                 stub.deleteNode(req);
 219                 // run
 220                 nodes = stub.getNodes(request);
 221
 222                 assertEquals(nodes.next(), n1);
 223                 assertEquals(nodes.next(), n2);
 224                 assertEquals(nodes.next(), n3);
 225                 assertEquals(nodes.next(), n4);
 226         }
 227
 228         @Test
 229         public void test5Neighbours() throws Exception {
 230                 RequestID request = RequestID.newBuilder().setIdGraph(2).setIdNode(2).setIdNeighbour(1).build() ;//id not present
 231                 NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder()
 232                                                 .setErrorMessage("Neighbour with id 1 not found for node with id 2 in graph with id 2").build();;
 233                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 234
 235                 // Neighbour not found in the server
 236                 NeighbourGrpc neighbour = stub.getNeighbour(request);
 237
 238                 assertEquals(ufoundedNeighbour, neighbour);
 239
 240                 // getNeighbour, but first add it
 241                 NeighbourGrpc addedNeighbour = NeighbourGrpc.newBuilder().setIdGraph(2).setIdNode(2)
 242                                                                                 .setName("client").build();
 243                 NewNeighbour response = stub.createNeighbour(addedNeighbour);
 244                 addedNeighbour = response.getNeighbour();
 245                 request = RequestID.newBuilder().setIdGraph(2).setIdNode(2)
 246                                                 .setIdNeighbour(addedNeighbour.getId()).build();
 247                 neighbour = stub.getNeighbour(request);
 248
 249                 assertEquals(addedNeighbour.getId(), neighbour.getId());
 250
 251                 //updateNeighbour
 252                 NeighbourGrpc updatedNeighbour = Client.createNeighbourGrpc("Node4");
 253                 NeighbourGrpc nu = NeighbourGrpc.newBuilder(updatedNeighbour)
 254                                 .setId(response.getNeighbour().getId()).setIdGraph(2).setIdNode(2).build();
 255                 response = stub.updateNeighbour(nu);
 256
 257                 assertEquals(response.getSuccess(),true);
 258                 assertEquals(response.getNeighbour().getName(),"Node4");
 259         }
 260
 261         @Test
 262         public void test6Neighbours() throws Exception {
 263                 // setup
 264                 RequestID request = RequestID.newBuilder().setIdGraph(2).setIdNode(2).build();
 265                 NeighbourGrpc n1 = NeighbourGrpc.newBuilder().setIdGraph(2).setIdNode(2)
 266                                                         .setName("Node3").build();
 267                 NeighbourGrpc n2 = NeighbourGrpc.newBuilder().setIdGraph(2).setIdNode(2)
 268                                                         .setName("client").build();
 269
 270                 VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
 271
 272                 stub.createNeighbour(n1);
 273                 stub.createNeighbour(n2);
 274                 n1 = NeighbourGrpc.newBuilder(n1).setId(2).setIdGraph(0).setIdNode(0).build();
 275                 n2 = NeighbourGrpc.newBuilder(n2).setId(3).setIdGraph(0).setIdNode(0).build();
 276                 // run
 277                 Iterator<NeighbourGrpc> neighbours = stub.getNeighbours(request);
 278
 279                 neighbours.next();
 280                 assertEquals(neighbours.next(), n1);
 281                 assertEquals(neighbours.next(), n2);
 282
 283                 //deleteNeighbour
 284                 RequestID req = RequestID.newBuilder().setIdGraph(2).setIdNode(2).setIdNeighbour(1).build();
 285                 stub.deleteNeighbour(req);
 286                 // run
 287                 neighbours = stub.getNeighbours(request);
 288
 289                 assertEquals(neighbours.next(), n1);
 290                 assertEquals(neighbours.next(), n2);
 291         }
 292 }