react-native-background-geolocation 5.3.0 → 5.4.0

package/RNBackgroundGeolocation.podspec

@@ -26,7 +26,7 @@ Pod::Spec.new do |s|
   s.source_files        = 'ios/RNBackgroundGeolocation/*.{h,m,mm}'
   s.preserve_paths      = 'docs', 'CHANGELOG.md', 'LICENSE', 'package.json', 'RNBackgroundGeolocation.ios.js'
 
-  tslm_version = ENV['TSLOCATIONMANAGER_VERSION'] || '~> 4.3.0'
+  tslm_version = ENV['TSLOCATIONMANAGER_VERSION'] || '~> 4.4.0'
   s.dependency 'TSLocationManager', tslm_version
 
   s.libraries           = 'sqlite3', 'z', 'stdc++'

package/android/build.gradle

@@ -9,7 +9,7 @@ def DEFAULT_TARGET_SDK_VERSION                      = 35
 
 // Plugin dependencies
 def DEFAULT_PLAY_SERVICES_LOCATION_VERSION          = "21.3.0"
-def DEFAULT_TSLOCATIONMANAGER_VERSION               = "4.3.+"
+def DEFAULT_TSLOCATIONMANAGER_VERSION               = "4.4.+"
 def DEFAULT_OK_HTTP_VERSION                         = "4.12.0"
 def DEFAULT_ANDROID_PERMISSIONS_VERSION             = "2.1.6"
 def DEFAULT_EVENTBUS_VERSION                        = "3.3.1"
@@ -83,6 +83,11 @@ android {
             java.srcDir("$buildDir/generated/source/codegen/java")
         }
     }
+    testOptions {
+        unitTests {
+            includeAndroidResources = true
+        }
+    }
 }
 
 repositories{
@@ -103,6 +108,10 @@ dependencies {
         api "com.transistorsoft:tslocationmanager-gms20:$tslocationmanagerVersion"
     }
         
-    implementation "com.google.android.gms:play-services-location:$playServicesLocationVersion"    
+    implementation "com.google.android.gms:play-services-location:$playServicesLocationVersion"
     implementation 'org.greenrobot:eventbus:3.3.1'
+
+    // Bridge-translation unit tests (JVM/Robolectric) — not shipped to consumers.
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.robolectric:robolectric:4.14.1"
 }

package/android/src/main/java/com/transistorsoft/rnbackgroundgeolocation/RNBackgroundGeolocationModule.java

@@ -521,7 +521,7 @@ public class RNBackgroundGeolocationModule
                 response.resolve(uuid);
             }
             @Override public void onFailure(String error) {
-                response.reject(error);
+                response.reject("insert_location_error", error);
             }
         });
     }

package/android/src/test/java/com/transistorsoft/rnbackgroundgeolocation/RNBackgroundGeolocationModuleTest.java

@@ -0,0 +1,70 @@
+package com.transistorsoft.rnbackgroundgeolocation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+
+import org.json.JSONObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/**
+ * Bridge-translation tests for the React Native Android module — the JS→native marshaling seam.
+ *
+ * These run on the JVM (Robolectric only for a real {@code org.json} implementation) with no device
+ * and no SDK: they exercise the exact {@code ReadableMap → org.json.JSONObject} conversion the real
+ * {@code insertLocation} path hands to the native SDK. This is the layer where the bridge-audit
+ * findings live (a numeric timestamp must stay a number; nested {@code coords}/{@code extras} must
+ * survive), and it is un-catchable by either a JS-only Jest test (mocked native) or a native SDK
+ * test (no bridge).
+ *
+ * The complementary half — the native {@code onSuccess(uuid) → promise.resolve(uuid)} settlement —
+ * is trivial glue that needs a live React runtime (RN 0.81's {@code ReactApplicationContext} is
+ * abstract and the module constructor initialises the SDK), so it belongs to the on-device E2E
+ * layer rather than a JVM unit test.
+ */
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class RNBackgroundGeolocationModuleTest {
+
+    /** A bridge-shaped insertLocation params map: {coords:{lat,lng}, timestamp, extras:{...}}. */
+    private JavaOnlyMap makeInsertParams(double timestampMillis) {
+        JavaOnlyMap coords = new JavaOnlyMap();
+        coords.putDouble("latitude", 45.5152);
+        coords.putDouble("longitude", -73.6104);
+
+        JavaOnlyMap extras = new JavaOnlyMap();
+        extras.putString("source", "import");
+
+        JavaOnlyMap params = new JavaOnlyMap();
+        params.putMap("coords", coords);
+        params.putDouble("timestamp", timestampMillis);
+        params.putMap("extras", extras);
+        return params;
+    }
+
+    @Test
+    public void mapToJson_preservesNestedCoordsAndExtras() throws Exception {
+        JSONObject json = RNBackgroundGeolocationModule.mapToJson(makeInsertParams(1_705_314_600_000d));
+
+        assertTrue("coords must survive as a nested object", json.has("coords"));
+        assertEquals(45.5152, json.getJSONObject("coords").getDouble("latitude"), 0.0);
+        assertEquals(-73.6104, json.getJSONObject("coords").getDouble("longitude"), 0.0);
+        assertEquals("import", json.getJSONObject("extras").getString("source"));
+    }
+
+    @Test
+    public void mapToJson_keepsNumericTimestampAsNumber_notString() throws Exception {
+        // Audit finding: a numeric epoch timestamp must reach the SDK as a NUMBER, so the SDK's
+        // epoch branch (TSLocation.normalizeTimestamp `raw instanceof Number`) fires — never a String.
+        JSONObject json = RNBackgroundGeolocationModule.mapToJson(makeInsertParams(1_705_314_600_000d));
+
+        Object ts = json.get("timestamp");
+        assertTrue("timestamp must be a JSON number, not a String (got " + ts.getClass().getSimpleName() + ")",
+                ts instanceof Number);
+        assertEquals(1_705_314_600_000L, ((Number) ts).longValue());
+    }
+}

package/mocks/react-native.js

@@ -9,38 +9,41 @@ class NativeEventEmitter {
   removeAllListeners() { listeners.clear(); }
 }
 
+// The native module is a TurboModule: every data method returns a Promise (not the pre-migration
+// callback convention). NativeModule.js returns these calls directly, so the mocks must resolve a
+// Promise. `log`/`playSound` are fire-and-forget (void).
 const RNBackgroundGeolocation = {
   // Minimal surface your JS calls in tests:
-  ready: (cfg, ok) => ok?.({ enabled: false }),
-  configure: (cfg, ok) => ok?.({}),
-  setConfig: (cfg, ok) => ok?.({}),
-  reset: (cfg, ok) => ok?.({ enabled: false }),
-  getState: (ok) => ok?.({ enabled: false }),
-  beginBackgroundTask: (ok) => ok?.(1),
-  finish: (id, ok) => ok?.(id),
-  addGeofence: (_cfg, ok) => ok?.(),
-  addGeofences: (_list, ok) => ok?.(),
-  removeGeofence: (_id, ok) => ok?.(),
-  removeGeofences: (ok) => ok?.(),
-  getGeofences: (ok) => ok?.([]),
-  getGeofence: (_id, ok) => ok?.(null),
-  geofenceExists: (_id, cb) => cb(false),
-  changePace: (_b, ok) => ok?.(),
-  getLog: (ok) => ok?.(''),
-  destroyLog: (ok) => ok?.(),
-  emailLog: (_email, ok) => ok?.(),
-  getOdometer: (ok) => ok?.(0),
-  setOdometer: (_v, ok) => ok?.({}),
-  getLocations: (ok) => ok?.([]),
-  getCount: (ok) => ok?.(0),
-  destroyLocations: (ok) => ok?.(),
-  insertLocation: (_p, ok) => ok?.({}),
-  sync: (ok) => ok?.({ success: true }),
-  getProviderState: (ok) => ok?.({ enabled: true }),
-  requestPermission: (ok) => ok?.(1),
-  requestTemporaryFullAccuracy: (_p, ok) => ok?.(1),
+  ready: () => Promise.resolve({ enabled: false }),
+  configure: () => Promise.resolve({}),
+  setConfig: () => Promise.resolve({}),
+  reset: () => Promise.resolve({ enabled: false }),
+  getState: () => Promise.resolve({ enabled: false }),
+  beginBackgroundTask: () => Promise.resolve(1),
+  finish: (id) => Promise.resolve(id),
+  addGeofence: () => Promise.resolve(),
+  addGeofences: () => Promise.resolve(),
+  removeGeofence: () => Promise.resolve(),
+  removeGeofences: () => Promise.resolve(),
+  getGeofences: () => Promise.resolve([]),
+  getGeofence: () => Promise.resolve(null),
+  geofenceExists: () => Promise.resolve(false),
+  changePace: () => Promise.resolve(),
+  getLog: () => Promise.resolve(''),
+  destroyLog: () => Promise.resolve(),
+  emailLog: () => Promise.resolve(),
+  getOdometer: () => Promise.resolve(0),
+  setOdometer: () => Promise.resolve({}),
+  getLocations: () => Promise.resolve([]),
+  getCount: () => Promise.resolve(0),
+  destroyLocations: () => Promise.resolve(),
+  insertLocation: () => Promise.resolve('00000000-0000-0000-0000-000000000000'),
+  sync: () => Promise.resolve({ success: true }),
+  getProviderState: () => Promise.resolve({ enabled: true }),
+  requestPermission: () => Promise.resolve(1),
+  requestTemporaryFullAccuracy: () => Promise.resolve(1),
   log: () => {},
-  getDeviceInfo: (ok) => ok?.({ model: 'mock' }),
+  getDeviceInfo: () => Promise.resolve({ model: 'mock' }),
   playSound: () => {},
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
 
   "name": "react-native-background-geolocation",  
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "The most sophisticated cross-platform background location-tracking & geofencing module with battery-conscious motion-detection intelligence",
   "scripts": {
     "build": "yarn run build:expo",
@@ -41,7 +41,7 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.26.0",
-    "@transistorsoft/background-geolocation-types": "^5.2.0",
+    "@transistorsoft/background-geolocation-types": "^5.2.2",
     "tslib": "^2.6.3"
   },
   "author": "Chris Scott <chris@transistorsoft.com>",

package/tests/insert-location.test.js

@@ -0,0 +1,51 @@
+// JS-side marshaling test for insertLocation: does the JavaScript API layer forward the caller's
+// location to the native bridge boundary *unchanged*, and pass the returned uuid back — with no
+// real SDK and no device? The native module is a jest spy standing in for the bridge; we assert on
+// what it receives (the args that crossed JS -> native) and what the caller ultimately gets back.
+//
+// This is the JS half of the two-halves bridge-marshaling strategy. The native half (ReadableMap ->
+// JSONObject) is covered by the Android Robolectric test `RNBackgroundGeolocationModuleTest`.
+
+const { NativeModules } = require('react-native'); // mapped to mocks/react-native.js via jest config
+const BG = require('../src/index.js').default;
+
+const native = NativeModules.RNBackgroundGeolocation;
+
+describe('insertLocation — JS -> native bridge marshaling', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('forwards the location to the native module unchanged and resolves its uuid', async () => {
+    const insert = jest.spyOn(native, 'insertLocation').mockResolvedValue('uuid-abc');
+
+    const location = {
+      coords: { latitude: 45.5152, longitude: -73.6104 },
+      timestamp: 1705314600000, // numeric epoch
+      extras: { source: 'import' },
+    };
+
+    const uuid = await BG.insertLocation(location);
+
+    // The exact object reaches the native boundary — no mangling by index.js / NativeModule.
+    expect(insert).toHaveBeenCalledTimes(1);
+    expect(insert).toHaveBeenCalledWith(location);
+
+    // Type/shape preserved across the JS layers: numeric timestamp stays a number, coords/extras nested.
+    const [passed] = insert.mock.calls[0];
+    expect(typeof passed.timestamp).toBe('number');
+    expect(passed.coords).toEqual({ latitude: 45.5152, longitude: -73.6104 });
+    expect(passed.extras).toEqual({ source: 'import' });
+
+    // The uuid string flows back out through NativeModule + index.js.
+    expect(uuid).toBe('uuid-abc');
+  });
+
+  test('propagates a native rejection to the caller', async () => {
+    jest.spyOn(native, 'insertLocation').mockRejectedValue(new Error('insert_location_error'));
+
+    await expect(
+      BG.insertLocation({ coords: { latitude: 0, longitude: 0 }, timestamp: 0 })
+    ).rejects.toThrow('insert_location_error');
+  });
+});