add tests for eta_model parameter

instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/CoreRerouteTest.kt

@@ -35,6 +35,7 @@ import com.mapbox.navigation.instrumentation_tests.utils.http.MockDirectionsRefr
 import com.mapbox.navigation.instrumentation_tests.utils.http.MockDirectionsRequestHandler
 import com.mapbox.navigation.instrumentation_tests.utils.idling.RouteProgressStateIdlingResource
 import com.mapbox.navigation.instrumentation_tests.utils.location.MockLocationReplayerRule
+import com.mapbox.navigation.instrumentation_tests.utils.location.stayOnPosition
 import com.mapbox.navigation.instrumentation_tests.utils.readRawFileText
 import com.mapbox.navigation.instrumentation_tests.utils.routes.MockRoute
 import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider
@@ -853,6 +854,49 @@ class CoreRerouteTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.jav
         assertEquals(routes[1], rerouteResult.navigationRoutes.first())
     }
 
+    @Test
+    fun reroute_keeps_eta_model_parameter() = sdkTest {
+        val mapboxNavigation = createMapboxNavigation()
+        val coordinates = listOf(
+            Point.fromLngLat(-77.031991, 38.894721),
+            Point.fromLngLat(-77.030923, 38.895433)
+        )
+        val offRouteLocation = mockLocationUpdatesRule.generateLocationUpdate {
+            this.latitude = coordinates[0].latitude() + 0.002
+            this.longitude = coordinates[0].longitude()
+        }
+        val handler = MockDirectionsRequestHandler(
+            DirectionsCriteria.PROFILE_DRIVING_TRAFFIC,
+            readRawFileText(context, R.raw.route_response_dc_very_short), // TODO
+            coordinates,
+            relaxedExpectedCoordinates = true
+        )
+        mockWebServerRule.requestHandlers.add(handler)
+
+        mapboxNavigation.startTripSession()
+        stayOnPosition(coordinates[0].latitude(), coordinates[0].longitude(), 0f) {
+            val routes = mapboxNavigation.requestRoutes(
+                RouteOptions.builder()
+                    .applyDefaultNavigationOptions()
+                    .applyLanguageAndVoiceUnitOptions(activity)
+                    .baseUrl(mockWebServerRule.baseUrl)
+                    .coordinatesList(coordinates)
+                    .unrecognizedProperties(mapOf("eta_model" to "enhanced"))
+                    .build()
+            ).getSuccessfulResultOrThrowException().routes
+
+            mapboxNavigation.setNavigationRoutesAndWaitForUpdate(routes)
+        }
+        stayOnPosition(offRouteLocation.latitude, offRouteLocation.longitude, 0f) {
+            mapboxNavigation.routesUpdates()
+                .filter { it.reason == RoutesExtra.ROUTES_UPDATE_REASON_REROUTE }
+                .first()
+
+            val rerouteRequest = handler.handledRequests.last()
+            assertEquals("enhanced", rerouteRequest.requestUrl?.queryParameter("eta_model"))
+        }
+    }
+
     private fun createMapboxNavigation(customRefreshInterval: Long? = null): MapboxNavigation {
         var mapboxNavigation: MapboxNavigation? = null
 

instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RequestRoutesTest.kt

@@ -0,0 +1,72 @@
+package com.mapbox.navigation.instrumentation_tests.core
+
+import android.location.Location
+import com.mapbox.navigation.base.route.RouterOrigin
+import com.mapbox.navigation.instrumentation_tests.utils.location.stayOnPosition
+import com.mapbox.navigation.instrumentation_tests.utils.routes.EvRoutesProvider
+import com.mapbox.navigation.instrumentation_tests.utils.routes.MockedEvRoutes
+import com.mapbox.navigation.instrumentation_tests.utils.tiles.OfflineRegions
+import com.mapbox.navigation.instrumentation_tests.utils.tiles.withMapboxNavigationAndOfflineTilesForRegion
+import com.mapbox.navigation.instrumentation_tests.utils.withMapboxNavigation
+import com.mapbox.navigation.instrumentation_tests.utils.withoutInternet
+import com.mapbox.navigation.testing.ui.BaseCoreNoCleanUpTest
+import com.mapbox.navigation.testing.ui.utils.coroutines.RouteRequestResult
+import com.mapbox.navigation.testing.ui.utils.coroutines.getSuccessfulResultOrThrowException
+import com.mapbox.navigation.testing.ui.utils.coroutines.requestRoutes
+import com.mapbox.navigation.testing.ui.utils.coroutines.sdkTest
+import com.mapbox.navigation.testing.ui.utils.coroutines.setNavigationRoutesAndWaitForUpdate
+import com.mapbox.navigation.testing.ui.utils.coroutines.setNavigationRoutesAsync
+import org.junit.Assert
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class RequestRoutesTest : BaseCoreNoCleanUpTest() {
+
+    override fun setupMockLocation(): Location {
+        return mockLocationUpdatesRule.generateLocationUpdate {
+            longitude = 13.361378213031003
+            latitude = 52.49813341962201
+        }
+    }
+
+    @Test
+    fun buildOfflineRouteWithUnknownParameters() = sdkTest(
+        timeout = INCREASED_TIMEOUT_BECAUSE_OF_REAL_ROUTING_TILES_USAGE
+    ) {
+        val testRoute = setupBerlinEvRoute()
+        withMapboxNavigationAndOfflineTilesForRegion(
+            OfflineRegions.Berlin,
+        ) { navigation ->
+            navigation.startTripSession()
+            stayOnPosition(
+                testRoute.origin.latitude(),
+                testRoute.origin.longitude(),
+                0.0f,
+            ) {
+                withoutInternet {
+                    val requestResult = navigation.requestRoutes(
+                        testRoute.routeOptions.toBuilder()
+                            .unrecognizedProperties(
+                                mapOf(
+                                    "unknown_key1" to "unknown_value1",
+                                    "unknown_key2" to "333",
+                                )
+                            )
+                            .build()
+                    ).getSuccessfulResultOrThrowException()
+                    assertEquals(RouterOrigin.Onboard, requestResult.routerOrigin)
+                    navigation.setNavigationRoutesAndWaitForUpdate(requestResult.routes)
+                }
+            }
+        }
+    }
+
+    private fun setupBerlinEvRoute(): MockedEvRoutes {
+        val originalTestRoute = EvRoutesProvider.getBerlinEvRoute(
+            context,
+            mockWebServerRule.baseUrl
+        )
+        mockWebServerRule.requestHandlers.add(originalTestRoute.mockWebServerHandler)
+        return originalTestRoute
+    }
+}

instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RouteAlternativesTest.kt

@@ -295,6 +295,43 @@ class RouteAlternativesTest : BaseCoreNoCleanUpTest() {
         }
     }
 
+    @Test
+    fun alternative_request_keeps_eta_model_parameter() = sdkTest {
+        setupMockRequestHandlers()
+        withMapboxNavigation(
+            historyRecorderRule = mapboxHistoryTestRule
+        ) { mapboxNavigation ->
+            val routes = mapboxNavigation.requestNavigationRoutes(
+                startCoordinates,
+                unrecognized = mapOf("eta_model" to "enhanced")
+            )
+            mockWebServerRule.requestHandlers.clear()
+            val alternativesHandler = MockDirectionsRequestHandler(
+                "driving-traffic",
+                readRawFileText(context, R.raw.route_response_alternative_during_navigation),
+                startCoordinates,
+                relaxedExpectedCoordinates = true
+            )
+            mockWebServerRule.requestHandlers.add(alternativesHandler)
+            mapboxNavigation.startTripSession()
+            mapboxNavigation.flowLocationMatcherResult().first()
+            mapboxNavigation.setNavigationRoutesAsync(routes)
+            mockLocationReplayerRule.playRoute(routes.first().directionsRoute)
+
+            mapboxNavigation.alternativesUpdates()
+                .filterIsInstance<NavigationRouteAlternativesResult.OnRouteAlternatives>()
+                .filter {
+                    it.alternatives.isNotEmpty() && it.alternatives.none {
+                        it.id.startsWith("1SSd29ZxmjD7ELLqDJHRPPDP5W4wdh633IbGo41pJrL6wpJRmzNaMA==")
+                    }
+                }
+                .first()
+
+            val alternativesRequest = alternativesHandler.handledRequests.last()
+            assertEquals("enhanced", alternativesRequest.requestUrl?.queryParameter("eta_model"))
+        }
+    }
+
     private fun createExternalAlternatives(): List<NavigationRoute> {
         return NavigationRoute.create(
             readRawFileText(context, R.raw.route_response_alternative_continue),
@@ -328,12 +365,14 @@ class RouteAlternativesTest : BaseCoreNoCleanUpTest() {
     }
 
     private suspend fun MapboxNavigation.requestNavigationRoutes(
-        coordinates: List<Point>
+        coordinates: List<Point>,
+        unrecognized: Map<String, String>? = null
     ): List<NavigationRoute> {
         val routeOptions = RouteOptions.builder()
             .applyDefaultNavigationOptions()
             .alternatives(true)
             .coordinatesList(coordinates)
+            .unrecognizedProperties(unrecognized)
             .baseUrl(mockWebServerRule.baseUrl) // Comment out to test a real server
             .build()
         return requestRoutes(routeOptions)