Merge pull request #6 from AITestingOrg/integration-test-refactor

Integration test refactor

Author: erinyoo

Dockerfile

@@ -1,6 +1,6 @@
 FROM anapsix/alpine-java:8
 MAINTAINER Justin Phillips "[email protected]"
 VOLUME /tmp
-ADD build/libs/microservices--backing-service--edge-service-0.0.1.jar app.jar
+ADD build/libs/edge-service-0.0.1.jar app.jar
 RUN bash -c 'touch /app.jar'
 ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

docker-compose.yml

@@ -31,9 +31,9 @@ services:
 #    ports:
 #      - 8888:8888
 
-  mysql-server:
+  mysqlserver:
     image: mysql:5.7
-    container_name: mysql-server
+    container_name: mysqlserver
     volumes:
       - mysql-data:/var/lib/mysql:rw
     restart: always
@@ -46,14 +46,14 @@ services:
       MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
       MYSQL_DATABASE: 'user_service'
 
-  microservice--user-service:
+  userservice:
     image: aista/user-service
     depends_on:
       - discovery-service
-      - mysql-server
-    container_name: microservice--user-service
+      - mysqlserver
+    container_name: userservice
     ports:
-      - '8091:8091'
+      - '8080'
 
   mongo:
     image: 'mongo:3.4.1'

src/test/java/aist/edge/edgeservice/EdgeServiceIntegrationTests.java

@@ -3,17 +3,21 @@
 import static org.assertj.core.api.Java6Assertions.assertThat;
 
 import com.palantir.docker.compose.DockerComposeRule;
+import com.palantir.docker.compose.connection.DockerPort;
 import com.palantir.docker.compose.connection.waiting.HealthChecks;
 
 import java.util.*;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.web.client.TestRestTemplate;
 import org.springframework.http.*;
@@ -23,27 +27,73 @@
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = EdgeServiceApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
 public class EdgeServiceIntegrationTests {
+    protected static final Logger LOG = LoggerFactory.getLogger(EdgeServiceIntegrationTests.class);
 
+    private static String tripCommandURL;
+    private static String tripQueryURL;
+    private static String gmapsAdapterURL;
+    private static String calculationServiceURL;
+    private static String userServiceURL;
+
+    //Wait for all services to have ports open
     @ClassRule
     public static DockerComposeRule docker = DockerComposeRule.builder().pullOnStartup(true)
             .file("src/test/resources/docker-compose.yml")
-            .waitingForService("microservice--user-service", HealthChecks.toHaveAllPortsOpen())
-            .waitingForService("microservice--user-service", HealthChecks.toRespondOverHttp(8091,
-                (port) -> port.inFormat("http://localhost:8091")))
-            .waitingForService("trip-management-cmd", HealthChecks.toHaveAllPortsOpen())
-            .waitingForService("trip-management-cmd", HealthChecks.toRespondOverHttp(8080,
-                (port) -> port.inFormat("http://localhost:8092")))
-            .waitingForService("trip-management-query", HealthChecks.toHaveAllPortsOpen())
-            .waitingForService("trip-management-query", HealthChecks.toRespondOverHttp(8080,
-                (port) -> port.inFormat("http://localhost:8093")))
+            .waitingForService("userservice", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("mongo", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("rabbitmq", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("tripmanagementcmd", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("tripmanagementquery", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("gmapsadapter", HealthChecks.toHaveAllPortsOpen())
+            .waitingForService("calculationservice", HealthChecks.toHaveAllPortsOpen())
             .waitingForService("discovery-service", HealthChecks.toHaveAllPortsOpen())
             .waitingForService("discovery-service", HealthChecks.toRespondOverHttp(8761,
                 (port) -> port.inFormat("http://localhost:8761")))
             .build();
 
+    //Get IP addresses and ports to run tests on
+    @BeforeClass
+    public static void initialize() {
+        LOG.info("Initializing ports from Docker");
+        DockerPort tripManagementCommand = docker.containers().container("tripmanagementcmd")
+                .port(8080);
+        tripCommandURL = String.format("http://%s:%s", tripManagementCommand.getIp(),
+                tripManagementCommand.getExternalPort());
+        LOG.info("Trip Command url found: " + tripCommandURL);
+
+        DockerPort tripManagementQuery = docker.containers().container("tripmanagementquery")
+                .port(8080);
+        tripQueryURL = String.format("http://%s:%s", tripManagementQuery.getIp(),
+                tripManagementQuery.getExternalPort());
+        LOG.info("Trip Query url found: " + tripQueryURL);
+
+        DockerPort gmapsAdapter = docker.containers().container("gmapsadapter")
+                .port(8080);
+        gmapsAdapterURL = String.format("http://%s:%s", gmapsAdapter.getIp(),
+                gmapsAdapter.getExternalPort());
+        LOG.info("Gmaps Adapter url found: " + gmapsAdapterURL);
+
+        DockerPort calculationService = docker.containers().container("calculationservice")
+                .port(8080);
+        calculationServiceURL = String.format("http://%s:%s", calculationService.getIp(),
+                calculationService.getExternalPort());
+        LOG.info("Calculation Service url found: " + calculationServiceURL);
+
+        DockerPort userService = docker.containers().container("userservice")
+                .port(8080);
+        userServiceURL = String.format("http://%s:%s", userService.getIp(),
+                userService.getExternalPort());
+        while (!docker.containers().container("userservice").portIsListeningOnHttp(8080,
+            (port) -> port.inFormat(userServiceURL)).succeeded()) {
+            LOG.info("Waiting for user service to respond over HTTP");
+        }
+        LOG.info("User Service url found: " + userServiceURL);
+    }
+
     private TestRestTemplate restTemplate = new TestRestTemplate();
 
     private String token;
+    private String tripId;
 
     @Before
     public void setUp() throws JSONException {
@@ -63,40 +113,67 @@ public void setUp() throws JSONException {
         HttpEntity<String> request = new HttpEntity<>(body, headers);
 
         //when:
-        ResponseEntity<String> response = restTemplate.postForEntity("http://localhost:8091/auth/oauth/token", request, String.class, parameters);
+        ResponseEntity<String> response = restTemplate.postForEntity(userServiceURL + "/auth/oauth/token",
+                request, String.class, parameters);
 
         //then:
         assertThat(response.getStatusCodeValue()).isEqualTo(200);
         JSONObject json = new JSONObject(response.getBody());
         token = json.getString("access_token");
     }
 
+
     @Test
     public void tripCommandPOSTRequestSuccess() {
         //given:
         HttpHeaders headers = new HttpHeaders();
         headers.add("Authorization", "Bearer " + token);
         headers.add("Content-Type", "application/json");
 
-        String body = "{ \"originAddress\": \"Somewhere of the origin\", \"destinationAddress\": "
-                + "\"Somewhere destination\", \"userId\": \"123e4567-e89b-12d3-a456-426655440000\" }";
+        String body = "{ \"originAddress\": \"Weston, FL\", \"destinationAddress\": "
+                + "\"Miami, FL\", \"userId\": \"123e4567-e89b-12d3-a456-426655440000\" }";
         HttpEntity<String> request = new HttpEntity<>(body, headers);
 
         //when:
-        ResponseEntity<String> response = restTemplate.postForEntity("http://localhost:8092/api/trip", request, String.class);
+        ResponseEntity<String> response = restTemplate.postForEntity(tripCommandURL + "/api/v1/trip", request,
+                String.class);
+
+        //then:
+        assertThat(response.getStatusCodeValue()).isEqualTo(201);
+    }
+
+    @Test
+    public void tripQueryGETSpecificTripRequestSuccess() throws JSONException {
+        //given:
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("Authorization", "Bearer " + token);
+        headers.add("Content-Type", "application/json");
+
+        String body = "{ \"originAddress\": \"Weston, FL\", \"destinationAddress\": "
+                + "\"Miami, FL\", \"userId\": \"123e4567-e89b-12d3-a456-426655440000\" }";
+        HttpEntity<String> request = new HttpEntity<>(body, headers);
+        ResponseEntity<String> postResponse = restTemplate.postForEntity(tripCommandURL + "/api/v1/trip", request, String.class);
+        assertThat(postResponse.getStatusCodeValue()).isEqualTo(201);
+
+        JSONObject json = new JSONObject(postResponse.getBody());
+        tripId = json.getString("id");
+
+        //when:
+        ResponseEntity<String> response = restTemplate.getForEntity(tripQueryURL + "/api/v1/trip/" + tripId, String.class);
 
         //then:
         assertThat(response.getStatusCodeValue()).isEqualTo(200);
     }
 
     @Test
-    public void tripQueryGETRequestSuccess() {
+    public void tripQueryGETAllTripsRequestSuccess() {
         //given:
         HttpHeaders headers = new HttpHeaders();
         headers.add("Authorization", "Bearer " + token);
+        headers.add("Content-Type", "application/json");
 
         //when:
-        ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:8093/api/trips", String.class);
+        ResponseEntity<String> response = restTemplate.getForEntity(tripQueryURL + "/api/v1/trips", String.class);
 
         //then:
         assertThat(response.getStatusCodeValue()).isEqualTo(200);

src/test/resources/docker-compose.yml

@@ -6,7 +6,6 @@ services:
     image: springcloud/eureka
     ports:
       - "8761:8761"
-    container_name: eureka-server
 
 #  hystrix-dashboard:
 #    image: kbastani/hystrix-dashboard
@@ -24,9 +23,9 @@ services:
 #    ports:
 #      - 8888:8888
 
-  mysql-server:
+  mysqlserver:
     image: mysql:5.7
-    container_name: mysql-server
+    container_name: mysqlserver
     volumes:
       - mysql-data:/var/lib/mysql:rw
     restart: always
@@ -39,14 +38,14 @@ services:
       MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
       MYSQL_DATABASE: 'user_service'
 
-  microservice--user-service:
+  userservice:
     image: aista/user-service
+    container_name: userservice
     depends_on:
       - discovery-service
-      - mysql-server
-    container_name: microservice--user-service
+      - mysqlserver
     ports:
-      - '8091:8091'
+      - '8080'
 
   mongo:
     image: 'mongo:3.4.1'
@@ -63,32 +62,48 @@ services:
       - "5672:5672"
       - "15672:15672"
 
-  trip-management-cmd:
+  tripmanagementcmd:
     image: aista/trip-management-cmd
-    container_name: trip-management-cmd
     environment:
       - RABBIT_HOST=rabbitmq
       - MONGO_HOST=mongo
     ports:
-      - '8092:8080'
+      - '8080'
     depends_on:
       - discovery-service
       - rabbitmq
       - mongo
 
-  trip-management-query:
+  tripmanagementquery:
     image: aista/trip-management-query
-    container_name: trip-management-query
     environment:
       - RABBIT_HOST=rabbitmq
       - MONGO_HOST=mongo
     ports:
-      - '8093:8080'
+      - '8080'
     depends_on:
       - rabbitmq
       - mongo
       - discovery-service
 
+  gmapsadapter:
+    image: aista/gmaps-adapter
+    environment:
+      - EUREKA_SERVER=discovery-service
+    ports:
+      - '8080'
+    depends_on:
+      - discovery-service
+
+  calculationservice:
+    image: aista/calculation-service
+    environment:
+      - EUREKA_SERVER=discovery-service
+    ports:
+      - '8080'
+    depends_on:
+      - discovery-service
+
 volumes:
   mongo:
   mysql-data: