1 files changed, 220 insertions, 0 deletions
diff --git a/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java b/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java
new file mode 100644
index 0000000..79deaff
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java
@@ -0,0 +1,220 @@
+/*******************************************************************************
+ * 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 java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.junit.After;
+import org.junit.Assert;
+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 com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.client.VerifyClientException;
+import it.polito.verigraph.grpc.client.Client;
+import it.polito.verigraph.grpc.server.Service;
+
+/**
+ * Unit tests for gRPC project.
+ * For testing concurrency on server side.
+ */
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MultiThreadTest {
+    private Service server;
+    private Client client;
+
+    @Before
+    public void setUp() throws Exception {
+        client = new Client("localhost" , 50051);
+        server = new Service(50051);
+
+        server.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        server.stop();
+        client.shutdown();
+    }
+
+    private void testUpdateGraphStatus(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+        GraphGrpc retrieveGraphResponse =client.getGraph(1);
+
+        UpdateGraph task = new UpdateGraph(client, 1, retrieveGraphResponse);
+
+        List<MultiThreadTest.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+        List<Future<NewGraph>> futures = executorService.invokeAll(tasks);
+        List<Boolean> resultList = new ArrayList<Boolean>(futures.size());
+
+        // Check for exceptions
+        for (Future<NewGraph> future : futures) {
+            // Throws an exception if an exception was thrown by the task.
+            resultList.add(future.get().getSuccess());
+        }
+        // Validate the dimensions
+        Assert.assertEquals(threadCount, futures.size());
+
+        List<Boolean> expectedList = new ArrayList<Boolean>(threadCount);
+        for (int i = 1; i <= threadCount; i++) {
+            expectedList.add(true);
+        }
+        // Validate expected results
+        Assert.assertEquals(expectedList, resultList);
+    }
+
+    private void testUpdateGraph(final int threadCount) throws Exception {
+        GraphGrpc retrieveGraph = client.getGraph(2L);
+
+        NodeGrpc nodeToEdit = Client.createNodeGrpc("client",
+                "endpoint",
+                null,
+                Client.createConfigurationGrpc(null, null, "client", ""));
+
+        GraphGrpc graphToUpdate = GraphGrpc.newBuilder(retrieveGraph).addNode(nodeToEdit).build();
+
+        String graphAsString = graphToUpdate.toString();
+
+        UpdateGraph task = new UpdateGraph(client, 2, graphToUpdate);
+
+        List<MultiThreadTest.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+        List<Future<NewGraph>> futures = executorService.invokeAll(tasks);
+        List<String> resultList = new ArrayList<String>(futures.size());
+
+        // Check for exceptions
+        for (Future<NewGraph> future : futures) {
+            // Throws an exception if an exception was thrown by the task.
+            GraphGrpc graphReceived = future.get().getGraph();
+            NodeGrpc node = NodeGrpc.newBuilder(graphReceived.getNode(0)).setId(0).build();
+            GraphGrpc graph = GraphGrpc.newBuilder(graphReceived).setNode(0, node).build();
+            resultList.add(graph.toString());
+        }
+        // Validate dimensions
+        Assert.assertEquals(threadCount, futures.size());
+
+        List<String> expectedList = new ArrayList<String>(threadCount);
+        for (int i = 1; i <= threadCount; i++) {
+            expectedList.add(graphAsString);
+        }
+        // Validate expected results
+        Assert.assertEquals(expectedList, resultList);
+    }
+
+    private void testCreateGraphStatus(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException {
+
+        GraphGrpc graph = GraphGrpc.newBuilder().build();
+
+        CreateGraph task = new CreateGraph(client, graph);
+
+        List<MultiThreadTest.CreateGraph> tasks = Collections.nCopies(threadCount, task);
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+        List<Future<Boolean>> futures = executorService.invokeAll(tasks);
+        List<Boolean> resultList = new ArrayList<Boolean>(futures.size());
+
+        // Check for exceptions
+        for (Future<Boolean> future : futures) {
+            // Throws an exception if an exception was thrown by the task.
+            resultList.add(future.get());
+        }
+        // Validate the IDs
+        Assert.assertEquals(threadCount, futures.size());
+
+        List<Boolean> expectedList = new ArrayList<Boolean>(threadCount);
+        for (int i = 1; i <= threadCount; i++) {
+            expectedList.add(true);
+        }
+        // Validate expected results
+        Assert.assertEquals(expectedList, resultList);
+    }
+
+    private int randInt(int min, int max){
+        Random rand = new Random();
+        int randomNum = rand.nextInt((max - min) + 1) + min;
+        return randomNum;
+    }
+
+    @Test
+    public void updateGraphStatusCheck() throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+        testUpdateGraphStatus(64);
+    }
+
+    @Test
+    public void updateGraphResponseCheck() throws Exception {
+        testUpdateGraph(16);
+    }
+
+    @Test
+    public void createGraphStatusCheck() throws JsonParseException, JsonMappingException, InterruptedException, ExecutionException, IOException {
+        testCreateGraphStatus(8);
+    }
+
+    class UpdateGraph implements Callable<NewGraph> {
+
+        private Client verifyClient;
+
+        private int graphId;
+
+        private GraphGrpc graph;
+
+        public UpdateGraph(Client verifyClient, int graphId, GraphGrpc graph) {
+            this.graphId = graphId;
+            this.graph = graph;
+            this.verifyClient = verifyClient;
+        }
+
+        @Override
+        public NewGraph call() throws Exception {
+            Thread.sleep(randInt(0,2000));
+            return this.verifyClient.updateGraph(this.graphId, this.graph);
+        }
+    }
+
+    class CreateGraph implements Callable<Boolean> {
+
+        private Client verifyClient;
+
+        private GraphGrpc graph;
+
+        public CreateGraph(Client verifyClient, GraphGrpc graph) {
+            this.graph = graph;
+            this.verifyClient = verifyClient;
+        }
+
+        @Override
+        public Boolean call() throws Exception {
+            Thread.sleep(randInt(0,2000));
+            return this.verifyClient.createGraph(this.graph).getSuccess();
+        }
+
+    }
+
+}