NAVAND-873: automatically assign routeIndex and routeOptions

CHANGELOG.md

@@ -4,6 +4,7 @@ Mapbox welcomes participation and contributions from everyone.
 
 ### main
 - Specified supported amenity types via `DirectionsCriteria#AmenityTypeCriteria`. [#1515](https://github.com/mapbox/mapbox-java/pull/1515)
+- Fixed an issue where the `OptimizationResponse#trips#routeIndex` and `OptimizationResponse#trips#routeOptions` weren't correctly assigned. [#1517](https://github.com/mapbox/mapbox-java/pull/1517)
 
 ### v6.10.0-beta.2 - November 11, 2022
 - Added `paymentMethods` parameter for `RouteOptions` and `IntersectionLanes`. [#1449](https://github.com/mapbox/mapbox-java/pull/1449)

gradle/dependencies.gradle

@@ -8,10 +8,11 @@ ext {
       gson             : '2.8.6',
       retrofit         : '2.7.2',
       okhttp3          : '4.9.0',
-      mockito          : '2.28.2',
+      mockito          : '4.2.0',
       hamcrestJunit    : '2.0.0.0',
       googleTruth      : '1.0.1',
       errorprone       : '2.3.3',
+      assertJ          : '3.23.1',
   ]
 
   pluginVersion = [
@@ -41,10 +42,11 @@ ext {
       okhttp3             : "com.squareup.okhttp3:okhttp:${version.okhttp3}",
       okhttp3Logging      : "com.squareup.okhttp3:logging-interceptor:${version.okhttp3}",
       okhttp3Mockwebserver: "com.squareup.okhttp3:mockwebserver:${version.okhttp3}",
-      mockito             : "org.mockito:mockito-core:${version.mockito}",
+      mockito             : "org.mockito:mockito-inline:${version.mockito}",
       googleTruth         : "com.google.truth:truth:${version.googleTruth}",
       hamcrestJunit       : "org.hamcrest:hamcrest-junit:${version.hamcrestJunit}",
-      errorprone          : "com.google.errorprone:error_prone_core:${version.errorprone}"
+      errorprone          : "com.google.errorprone:error_prone_core:${version.errorprone}",
+      assertJ             : "org.assertj:assertj-core:${version.assertJ}",
   ]
 
   pluginDependencies = [

services-optimization/build.gradle

@@ -15,4 +15,5 @@ dependencies {
   // Test Dependencies
   testImplementation dependenciesList.okhttp3Mockwebserver
   testImplementation project(path: ':services-core', configuration: 'testOutput')
+  testImplementation dependenciesList.assertJ
 }

services-optimization/src/main/java/com/mapbox/api/optimization/v1/MapboxOptimization.java

@@ -23,10 +23,14 @@
 import com.mapbox.core.utils.MapboxUtils;
 import com.mapbox.core.utils.TextUtils;
 import com.mapbox.geojson.Point;
+
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
 
 /**
  * The Mapbox Optimization API returns a duration-optimized trip between the input coordinates.
@@ -81,6 +85,32 @@ protected Call<OptimizationResponse> initializeCall() {
       distributions());
   }
 
+  @Override
+  public Response<OptimizationResponse> executeCall() throws IOException {
+    Response<OptimizationResponse> response = getCall().execute();
+    OptimizationResponseFactory factory = new OptimizationResponseFactory(MapboxOptimization.this);
+    return factory.generate(response);
+  }
+
+  @Override
+  public void enqueueCall(Callback<OptimizationResponse> callback) {
+    getCall().enqueue(new Callback<OptimizationResponse>() {
+      @Override
+      public void onResponse(Call<OptimizationResponse> call,
+                             Response<OptimizationResponse> response) {
+        OptimizationResponseFactory factory =
+          new OptimizationResponseFactory(MapboxOptimization.this);
+        Response<OptimizationResponse> generatedResponse = factory.generate(response);
+        callback.onResponse(call, generatedResponse);
+      }
+
+      @Override
+      public void onFailure(Call<OptimizationResponse> call, Throwable throwable) {
+        callback.onFailure(call, throwable);
+      }
+    });
+  }
+
   @NonNull
   abstract String user();
 

services-optimization/src/main/java/com/mapbox/api/optimization/v1/OptimizationResponseFactory.java

@@ -0,0 +1,78 @@
+package com.mapbox.api.optimization.v1;
+
+import com.mapbox.api.directions.v5.models.DirectionsRoute;
+import com.mapbox.api.directions.v5.models.RouteOptions;
+import com.mapbox.api.optimization.v1.models.OptimizationResponse;
+import retrofit2.Response;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class OptimizationResponseFactory {
+
+  private final MapboxOptimization mapboxOptimization;
+
+  OptimizationResponseFactory(MapboxOptimization mapboxOptimization) {
+    this.mapboxOptimization = mapboxOptimization;
+  }
+
+  Response<OptimizationResponse> generate(Response<OptimizationResponse> response) {
+    if (isNotSuccessful(response)) {
+      return response;
+    } else {
+      return Response.success(
+        response
+          .body()
+          .toBuilder()
+          .trips(generateDirectionRoutes(response))
+          .build(),
+        new okhttp3.Response.Builder()
+          .code(200)
+          .message("OK")
+          .protocol(response.raw().protocol())
+          .headers(response.headers())
+          .request(response.raw().request())
+          .build());
+    }
+  }
+
+  private boolean isNotSuccessful(Response<OptimizationResponse> response) {
+    return !response.isSuccessful()
+      || response.body() == null
+      || response.body().trips() == null
+      || response.body().trips().isEmpty();
+  }
+
+  private List<DirectionsRoute> generateDirectionRoutes(Response<OptimizationResponse> response) {
+    List<DirectionsRoute> routes = response.body().trips();
+    List<DirectionsRoute> modifiedRoutes = new ArrayList<>();
+    for (int i = 0; i < routes.size(); i++) {
+      DirectionsRoute route = routes.get(i);
+      modifiedRoutes.add(
+        route.toBuilder()
+          .routeOptions(generateRouteOptions())
+          .routeIndex(String.valueOf(i))
+          .build()
+      );
+    }
+    return modifiedRoutes;
+  }
+
+  private RouteOptions generateRouteOptions() {
+    RouteOptions.Builder builder = RouteOptions.builder()
+      .profile(mapboxOptimization.profile())
+      .coordinates(mapboxOptimization.coordinates())
+      .annotations(mapboxOptimization.annotations())
+      .bearings(mapboxOptimization.bearings())
+      .language(mapboxOptimization.language())
+      .radiuses(mapboxOptimization.radiuses())
+      .user(mapboxOptimization.user())
+      .overview(mapboxOptimization.overview())
+      .steps(mapboxOptimization.steps())
+      .baseUrl(mapboxOptimization.baseUrl());
+    if (mapboxOptimization.geometries() != null) {
+      builder.geometries(mapboxOptimization.geometries());
+    }
+    return builder.build();
+  }
+}

services-optimization/src/test/java/com/mapbox/api/optimization/v1/MapboxOptimizationTest.java

@@ -1,13 +1,9 @@
 package com.mapbox.api.optimization.v1;
 
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.*;
-import static org.junit.Assert.assertTrue;
-
+import com.mapbox.api.optimization.v1.models.OptimizationResponse;
 import com.mapbox.core.TestUtils;
-import com.mapbox.geojson.Point;
 import com.mapbox.core.exceptions.ServicesException;
-
+import com.mapbox.geojson.Point;
 import okhttp3.HttpUrl;
 import okhttp3.mockwebserver.MockResponse;
 import okhttp3.mockwebserver.MockWebServer;
@@ -17,16 +13,31 @@
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class MapboxOptimizationTest extends TestUtils {
 
   private static final String OPTIMIZATION_DISTRIBUTION = "optimized_trip_distributions.json";
   private static final String OPTIMIZATION_FIXTURE = "optimization.json";
-  private static final String OPTIMIZATION_STEPS= "optimized_trip_steps.json";
+  private static final String OPTIMIZATION_STEPS = "optimized_trip_steps.json";
 
   private MockWebServer server;
   private HttpUrl mockUrl;
@@ -120,4 +131,82 @@ public void testUserAgent() throws ServicesException, IOException {
       .build();
     assertTrue(client.executeCall().raw().request().header("User-Agent").contains("APP"));
   }
+
+  @Test
+  public void executeCall_modifiesResponse() throws IOException {
+    final Response<OptimizationResponse> modifiedResponse = mock(Response.class);
+    final MockedConstruction.MockInitializer<OptimizationResponseFactory> mockInitializer = (mock, context) ->
+      when(mock.generate(any())).thenReturn(modifiedResponse);
+    try (MockedConstruction ignored = Mockito.mockConstruction(OptimizationResponseFactory.class, mockInitializer)) {
+      MapboxOptimization client = MapboxOptimization.builder()
+        .clientAppName("APP")
+        .accessToken(ACCESS_TOKEN)
+        .coordinate(Point.fromLngLat(1.0, 1.0))
+        .coordinate(Point.fromLngLat(1.0, 1.0))
+        .baseUrl(mockUrl.url().toString())
+        .build();
+      assertEquals(modifiedResponse, client.executeCall());
+    }
+  }
+
+  @Test
+  public void enqueueCall_onSuccess_modifiesResponse() throws Exception {
+    final CountDownLatch latch = new CountDownLatch(1);
+    MapboxOptimization client = MapboxOptimization.builder()
+      .clientAppName("APP")
+      .accessToken(ACCESS_TOKEN)
+      .coordinate(Point.fromLngLat(1.0, 1.0))
+      .coordinate(Point.fromLngLat(1.0, 1.0))
+      .baseUrl(mockUrl.url().toString())
+      .build();
+    List<Response<OptimizationResponse>> actualResponses = new ArrayList<>();
+    client.enqueueCall(new Callback<OptimizationResponse>() {
+      @Override
+      public void onResponse(Call<OptimizationResponse> call, Response<OptimizationResponse> response) {
+        actualResponses.add(response);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(Call<OptimizationResponse> call, Throwable t) {
+        latch.countDown();
+      }
+    });
+    latch.await(5, TimeUnit.SECONDS);
+    assertEquals(1, actualResponses.size());
+    assertEquals("0", actualResponses.get(0).body().trips().get(0).routeIndex());
+  }
+
+  @Test
+  public void enqueueCall_onFailure() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    MapboxOptimization client = MapboxOptimization.builder()
+      .clientAppName("APP")
+      .accessToken(ACCESS_TOKEN)
+      .coordinate(Point.fromLngLat(1.0, 1.0))
+      .coordinate(Point.fromLngLat(1.0, 1.0))
+      .baseUrl(mockUrl.url().toString())
+      .build();
+    server.setDispatcher(new okhttp3.mockwebserver.Dispatcher() {
+      @Override
+      public MockResponse dispatch(RecordedRequest request) {
+        return new MockResponse().setResponseCode(500).setStatus("Error");
+      }
+    });
+    List<Throwable> actualExceptions = new ArrayList<>();
+    client.enqueueCall(new Callback<OptimizationResponse>() {
+      @Override
+      public void onResponse(Call<OptimizationResponse> call, Response<OptimizationResponse> response) {
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(Call<OptimizationResponse> call, Throwable t) {
+        actualExceptions.add(t);
+        latch.countDown();
+      }
+    });
+    latch.await(5, TimeUnit.SECONDS);
+    assertEquals(1, actualExceptions.size());
+  }
 }