react-native-brouter 0.0.1

package/android/src/test/java/com/jhotadhari/reactnative/brouter/BRouterClientTest.java

@@ -0,0 +1,247 @@
+package com.jhotadhari.reactnative.brouter;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.IBinder;
+
+import btools.routingapp.IBRouterService;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+
+/**
+ * Unit tests for {@link BRouterClient} lifecycle.
+ *
+ * <p>These tests mock {@link BRouterServiceConnection#connect} so they
+ * don't need a real Android environment.
+ */
+public class BRouterClientTest {
+
+	private Context mockContext;
+
+	@Before
+	public void setUp() {
+		mockContext = mock(Context.class);
+		when(mockContext.getApplicationContext()).thenReturn(mockContext);
+	}
+
+	// ── Construction ───────────────────────────────────────────────
+
+	@Test
+	public void constructorStoresContextAndTimeout() {
+		BRouterClient client = new BRouterClient(mockContext, 2000);
+
+		assertFalse(client.isConnected());
+		// Timeout stored internally — verified implicitly by connect()
+		// behavior in tests below.
+	}
+
+	// ── connect() ──────────────────────────────────────────────────
+
+	@Test
+	public void connectReturnsNullWhenServiceUnavailable() {
+		// BRouterServiceConnection.connect returns null when BRouter
+		// app is not installed — simulate that.
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(null);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			IBRouterService service = client.connect();
+
+			assertNull(service);
+			assertFalse(client.isConnected());
+		}
+	}
+
+	@Test
+	public void connectReturnsServiceWhenAvailable() {
+		BRouterServiceConnection mockConn = mock(BRouterServiceConnection.class);
+		IBRouterService mockService = mock(IBRouterService.class);
+		IBinder mockBinder = mock(IBinder.class);
+
+		when(mockConn.getBRouterService()).thenReturn(mockService);
+		when(mockService.asBinder()).thenReturn(mockBinder);
+		when(mockBinder.isBinderAlive()).thenReturn(true);
+
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(mockConn);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			IBRouterService service = client.connect();
+
+			assertNotNull(service);
+			assertEquals(mockService, service);
+			assertTrue(client.isConnected());
+		}
+	}
+
+	// ── getService() ───────────────────────────────────────────────
+
+	@Test
+	public void getServiceReconnectsWhenBinderDead() {
+		BRouterServiceConnection mockConn1 = mock(BRouterServiceConnection.class);
+		BRouterServiceConnection mockConn2 = mock(BRouterServiceConnection.class);
+		IBRouterService mockService1 = mock(IBRouterService.class);
+		IBRouterService mockService2 = mock(IBRouterService.class);
+		IBinder mockBinder1 = mock(IBinder.class);
+		IBinder mockBinder2 = mock(IBinder.class);
+
+		when(mockConn1.getBRouterService()).thenReturn(mockService1);
+		when(mockService1.asBinder()).thenReturn(mockBinder1);
+		when(mockBinder1.isBinderAlive()).thenReturn(true);
+
+		when(mockConn2.getBRouterService()).thenReturn(mockService2);
+		when(mockService2.asBinder()).thenReturn(mockBinder2);
+		when(mockBinder2.isBinderAlive()).thenReturn(true);
+
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			// First connect succeeds
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(mockConn1);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			IBRouterService svc = client.getService();
+			assertEquals(mockService1, svc);
+
+			// Now simulate binder death
+			when(mockBinder1.isBinderAlive()).thenReturn(false);
+
+			// Second connect call should get a new connection
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(mockConn2);
+
+			svc = client.getService();
+			assertEquals(mockService2, svc);
+		}
+	}
+
+	// ── getRoute() ─────────────────────────────────────────────────
+
+	@Test
+	public void getRouteCallsServiceGetTrackFromParams() throws Exception {
+		BRouterServiceConnection mockConn = mock(BRouterServiceConnection.class);
+		IBRouterService mockService = mock(IBRouterService.class);
+		IBinder mockBinder = mock(IBinder.class);
+
+		when(mockConn.getBRouterService()).thenReturn(mockService);
+		when(mockService.asBinder()).thenReturn(mockBinder);
+		when(mockBinder.isBinderAlive()).thenReturn(true);
+		when(mockService.getTrackFromParams(any(Bundle.class)))
+			.thenReturn("<gpx>track</gpx>");
+
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(mockConn);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			Bundle params = new Bundle();
+			params.putString("lonlats", "10,20|30,40");
+
+			String result = client.getRoute(params);
+
+			assertEquals("<gpx>track</gpx>", result);
+			verify(mockService).getTrackFromParams(params);
+		}
+	}
+
+	@Test
+	public void getRouteThrowsWhenServiceUnavailable() throws Exception {
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(null);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			try {
+				client.getRoute(new Bundle());
+				fail("Expected IllegalStateException");
+			} catch (IllegalStateException e) {
+				assertEquals(BRouterError.SERVICE_NOT_INSTALLED, e.getMessage());
+			}
+		}
+	}
+
+	@Test
+	public void getLastErrorReturnsCodeAfterFailedConnect() {
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(null);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			IBRouterService service = client.connect();
+
+			assertNull(service);
+			assertEquals(BRouterError.SERVICE_NOT_INSTALLED, client.getLastError());
+		}
+	}
+
+	@Test
+	public void getConnectTimeoutMsReturnsStoredValue() {
+		BRouterClient client = new BRouterClient(mockContext, 2000);
+		assertEquals(2000, client.getConnectTimeoutMs());
+	}
+
+	// ── disconnect() ───────────────────────────────────────────────
+
+	@Test
+	public void disconnectClearsConnection() {
+		BRouterServiceConnection mockConn = mock(BRouterServiceConnection.class);
+		IBRouterService mockService = mock(IBRouterService.class);
+		IBinder mockBinder = mock(IBinder.class);
+
+		when(mockConn.getBRouterService()).thenReturn(mockService);
+		when(mockService.asBinder()).thenReturn(mockBinder);
+		when(mockBinder.isBinderAlive()).thenReturn(true);
+
+		try (MockedStatic<BRouterServiceConnection> mockedStatic =
+				mockStatic(BRouterServiceConnection.class)) {
+
+			mockedStatic.when(() ->
+				BRouterServiceConnection.connect(any(Context.class))
+			).thenReturn(mockConn);
+
+			BRouterClient client = new BRouterClient(mockContext, 500);
+			client.connect();
+			assertTrue(client.isConnected());
+
+			client.disconnect();
+			assertFalse(client.isConnected());
+
+			// Verify unbind was called
+			verify(mockConn).disconnect(any(Context.class));
+		}
+	}
+
+	@Test
+	public void disconnectIsIdempotent() {
+		BRouterClient client = new BRouterClient(mockContext, 500);
+		// Should not throw
+		client.disconnect();
+		client.disconnect();
+		assertFalse(client.isConnected());
+	}
+}

package/android/src/test/java/com/jhotadhari/reactnative/brouter/BRouterErrorTest.java

@@ -0,0 +1,48 @@
+package com.jhotadhari.reactnative.brouter;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+/**
+ * Unit tests for {@link BRouterError}.
+ */
+public class BRouterErrorTest {
+
+	@Test
+	public void constantsAreDistinct() {
+		assertEquals("SERVICE_NOT_INSTALLED", BRouterError.SERVICE_NOT_INSTALLED);
+		assertEquals("SERVICE_UNAVAILABLE", BRouterError.SERVICE_UNAVAILABLE);
+		assertEquals("CONNECTION_TIMEOUT", BRouterError.CONNECTION_TIMEOUT);
+		assertEquals("ROUTING_TIMEOUT", BRouterError.ROUTING_TIMEOUT);
+		assertEquals("INVALID_PARAMS", BRouterError.INVALID_PARAMS);
+		assertEquals("ROUTING_FAILED", BRouterError.ROUTING_FAILED);
+		assertEquals("UNKNOWN", BRouterError.UNKNOWN);
+
+		// Sanity: all codes are different
+		String[] codes = {
+			BRouterError.SERVICE_NOT_INSTALLED,
+			BRouterError.SERVICE_UNAVAILABLE,
+			BRouterError.CONNECTION_TIMEOUT,
+			BRouterError.ROUTING_TIMEOUT,
+			BRouterError.INVALID_PARAMS,
+			BRouterError.ROUTING_FAILED,
+			BRouterError.UNKNOWN,
+		};
+		for (int i = 0; i < codes.length; i++) {
+			for (int j = i + 1; j < codes.length; j++) {
+				assertNotEquals(
+					"Error codes should be distinct: " + codes[i],
+					codes[i],
+					codes[j]
+				);
+			}
+		}
+	}
+
+	@Test
+	public void constructorIsPrivate() {
+		// Verify the utility class exists and is usable
+		assertNotNull(BRouterError.INVALID_PARAMS);
+	}
+}

package/android/src/test/java/com/jhotadhari/reactnative/brouter/BRouterModuleTest.java

@@ -0,0 +1,137 @@
+package com.jhotadhari.reactnative.brouter;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import android.os.Bundle;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class BRouterModuleTest {
+
+	private ReactApplicationContext mockReactContext;
+	private BRouterClient mockClient;
+
+	@Before
+	public void setUp() {
+		mockReactContext = mock( ReactApplicationContext.class );
+		when( mockReactContext.getApplicationContext() ).thenReturn( mockReactContext );
+		mockClient = mock( BRouterClient.class );
+	}
+
+	private BRouterModule createSpy() {
+		BRouterModule module = new BRouterModule( mockReactContext );
+		BRouterModule spy = spy( module );
+		doReturn( mockClient ).when( spy ).getClient( any( ReadableMap.class ) );
+		return spy;
+	}
+
+	private ReadableMap validParams() {
+		ReadableArray arr = mock( ReadableArray.class );
+		when( arr.size() ).thenReturn( 2 );
+		when( arr.getDouble( 0 ) ).thenReturn( 10.0 );
+		when( arr.getDouble( 1 ) ).thenReturn( 30.0 );
+
+		ReadableArray lats = mock( ReadableArray.class );
+		when( lats.size() ).thenReturn( 2 );
+		when( lats.getDouble( 0 ) ).thenReturn( 20.0 );
+		when( lats.getDouble( 1 ) ).thenReturn( 40.0 );
+
+		ReadableMap params = mock( ReadableMap.class );
+		when( params.hasKey( "lonlats" ) ).thenReturn( true );
+		when( params.getString( "lonlats" ) ).thenReturn( "10,20|30,40" );
+		when( params.hasKey( "lats" ) ).thenReturn( true );
+		when( params.getArray( "lats" ) ).thenReturn( lats );
+		when( params.hasKey( "lons" ) ).thenReturn( true );
+		when( params.getArray( "lons" ) ).thenReturn( arr );
+
+		return params;
+	}
+
+	@Test
+	public void rejectsWhenLonlatsMissing() {
+		BRouterModule spy = createSpy();
+		ReadableMap params = mock( ReadableMap.class );
+		Promise mp = mock( Promise.class );
+		spy.getRoute( params, mp );
+		verify( mp ).reject( BRouterError.INVALID_PARAMS, "At least 2 waypoints are required" );
+	}
+
+	@Test
+	public void rejectsWhenServiceUnavailable() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) )
+			.thenThrow( new IllegalStateException( BRouterError.SERVICE_UNAVAILABLE ) );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).reject( eq( BRouterError.SERVICE_UNAVAILABLE ), anyString() );
+	}
+
+	@Test
+	public void rejectsWhenServiceNotInstalled() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) )
+			.thenThrow( new IllegalStateException( BRouterError.SERVICE_NOT_INSTALLED ) );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).reject( eq( BRouterError.SERVICE_NOT_INSTALLED ), anyString() );
+	}
+
+	@Test
+	public void rejectsWhenConnectionTimeout() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) )
+			.thenThrow( new IllegalStateException( BRouterError.CONNECTION_TIMEOUT ) );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).reject( eq( BRouterError.CONNECTION_TIMEOUT ), anyString() );
+	}
+
+	@Test
+	public void resolvesWithTrackOnSuccess() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) ).thenReturn( "<gpx>track</gpx>" );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).resolve( "<gpx>track</gpx>" );
+	}
+
+	@Test
+	public void rejectsWhenRouteReturnsNull() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) ).thenReturn( null );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).reject( eq( BRouterError.ROUTING_FAILED ), anyString() );
+	}
+
+	@Test
+	public void rejectsOnUnexpectedException() throws Exception {
+		when( mockClient.getRoute( any( Bundle.class ) ) )
+			.thenThrow( new RuntimeException( "Boom" ) );
+		BRouterModule spy = createSpy();
+		Promise mp = mock( Promise.class );
+		spy.getRoute( validParams(), mp );
+		verify( mp ).reject( eq( BRouterError.UNKNOWN ), anyString() );
+	}
+
+	@Test
+	public void invalidateDisconnectsClient() {
+		// Use a subclass that injects the mock client directly into the field
+		BRouterModule module = new BRouterModule( mockReactContext ) {
+			{
+				// Set via the package-private field (same package in test)
+				this.client = mockClient;
+			}
+		};
+
+		module.invalidate();
+		verify( mockClient ).disconnect();
+	}
+}

package/android/src/test/java/com/jhotadhari/reactnative/brouter/ParamMapperTest.java

@@ -0,0 +1,279 @@
+package com.jhotadhari.reactnative.brouter;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import android.os.Bundle;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+/**
+ * Unit tests for {@link ParamMapper}.
+ */
+public class ParamMapperTest {
+
+	@Test
+	public void mapsLonlats() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("lonlats")).thenReturn(true);
+		when(params.getString("lonlats")).thenReturn("10,20|30,40");
+
+		Bundle b = mock(Bundle.class);
+
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("lonlats", "10,20|30,40");
+	}
+
+	@Test
+	public void mapsLatsArray() {
+		ReadableArray lats = mock(ReadableArray.class);
+		when(lats.size()).thenReturn(2);
+		when(lats.getDouble(0)).thenReturn(20.0);
+		when(lats.getDouble(1)).thenReturn(40.0);
+
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("lats")).thenReturn(true);
+		when(params.getArray("lats")).thenReturn(lats);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		ArgumentCaptor<double[]> captor = ArgumentCaptor.forClass(double[].class);
+		verify(b).putDoubleArray(eq("lats"), captor.capture());
+		assertEquals(20.0, captor.getValue()[0], 0.001);
+		assertEquals(40.0, captor.getValue()[1], 0.001);
+	}
+
+	@Test
+	public void mapsStraightIndices() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("straight")).thenReturn(true);
+		when(params.getString("straight")).thenReturn("1,3");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("straight", "1,3");
+	}
+
+	@Test
+	public void mapsProfile() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("profile")).thenReturn(true);
+		when(params.getString("profile")).thenReturn("trekking");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("profile", "trekking");
+	}
+
+	@Test
+	public void mapsVehicleToV() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("v")).thenReturn(true);
+		when(params.getString("v")).thenReturn("bicycle");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("v", "bicycle");
+	}
+
+	@Test
+	public void mapsFast() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("fast")).thenReturn(true);
+		when(params.getInt("fast")).thenReturn(1);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putInt("fast", 1);
+	}
+
+	@Test
+	public void mapsTrackFormat() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("trackFormat")).thenReturn(true);
+		when(params.getString("trackFormat")).thenReturn("json");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("trackFormat", "json");
+	}
+
+	@Test
+	public void mapsAlternativeidx() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("alternativeidx")).thenReturn(true);
+		when(params.getInt("alternativeidx")).thenReturn(2);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putInt("alternativeidx", 2);
+	}
+
+	@Test
+	public void mapsExportWaypoints() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("exportWaypoints")).thenReturn(true);
+		when(params.getInt("exportWaypoints")).thenReturn(1);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putInt("exportWaypoints", 1);
+	}
+
+	@Test
+	public void mapsTurnInstructionFormat() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("turnInstructionFormat")).thenReturn(true);
+		when(params.getString("turnInstructionFormat")).thenReturn("osmand");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("turnInstructionFormat", "osmand");
+	}
+
+	@Test
+	public void mapsTimode() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("timode")).thenReturn(true);
+		when(params.getInt("timode")).thenReturn(3);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putInt("timode", 3);
+	}
+
+	@Test
+	public void mapsHeading() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("heading")).thenReturn(true);
+		when(params.getDouble("heading")).thenReturn(90.5);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putDouble("heading", 90.5);
+	}
+
+	@Test
+	public void mapsEngineMode() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("engineMode")).thenReturn(true);
+		when(params.getInt("engineMode")).thenReturn(2);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putInt("engineMode", 2);
+	}
+
+	@Test
+	public void mapsMaxRunningTime() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("maxRunningTime")).thenReturn(true);
+		when(params.getInt("maxRunningTime")).thenReturn(120);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("maxRunningTime", "120");
+	}
+
+	@Test
+	public void mapsPathToFileResult() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("pathToFileResult")).thenReturn(true);
+		when(params.getString("pathToFileResult")).thenReturn("/sdcard/route.gpx");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("pathToFileResult", "/sdcard/route.gpx");
+	}
+
+	@Test
+	public void mapsAcceptCompressedResult() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("acceptCompressedResult")).thenReturn(true);
+		when(params.getBoolean("acceptCompressedResult")).thenReturn(true);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putBoolean("acceptCompressedResult", true);
+	}
+
+	@Test
+	public void mapsExtraParams() {
+		ReadableMap extra = mock(ReadableMap.class);
+		ReadableMapKeySetIterator mockIterator = mock(ReadableMapKeySetIterator.class);
+		when(mockIterator.hasNextKey()).thenReturn(true, false);
+		when(mockIterator.nextKey()).thenReturn("key1");
+		when(extra.keySetIterator()).thenReturn(mockIterator);
+		when(extra.getType("key1")).thenReturn(ReadableType.String);
+		when(extra.getString("key1")).thenReturn("value1");
+
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("extraParams")).thenReturn(true);
+		when(params.getMap("extraParams")).thenReturn(extra);
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		ArgumentCaptor<Bundle> captor = ArgumentCaptor.forClass(Bundle.class);
+		verify(b).putBundle(eq("extraParams"), captor.capture());
+		assertNotNull(captor.getValue());
+	}
+
+	@Test
+	public void mapsNogos() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("nogos")).thenReturn(true);
+		when(params.getString("nogos")).thenReturn("15,25,500|35,45,1000,2");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("nogos", "15,25,500|35,45,1000,2");
+	}
+
+	@Test
+	public void mapsPolylines() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("polylines")).thenReturn(true);
+		when(params.getString("polylines")).thenReturn("15,25,16,26");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("polylines", "15,25,16,26");
+	}
+
+	@Test
+	public void mapsPois() {
+		ReadableMap params = mock(ReadableMap.class);
+		when(params.hasKey("pois")).thenReturn(true);
+		when(params.getString("pois")).thenReturn("15,25,Cafe");
+
+		Bundle b = mock(Bundle.class);
+		ParamMapper.toBundle(params, b);
+
+		verify(b).putString("pois", "15,25,Cafe");
+	}
+}