Skip to content

Colota - Android GPS Location tracker

Add tests for useTimeout, useAutoSave, useLocationTracking, and LocationServicePermission

Max Dietrich464f2cddb93e
diff --git a/src/hooks/__tests__/useAutoSave.test.ts b/src/hooks/__tests__/useAutoSave.test.ts
new file mode 100644
index 00000000..9ad3b478
--- /dev/null
+++ b/src/hooks/__tests__/useAutoSave.test.ts
@@ -0,0 +1,249 @@
+import { renderHook, act } from "@testing-library/react-native"
+import { useAutoSave } from "../useAutoSave"
+import { AUTOSAVE_DEBOUNCE_MS, SAVE_SUCCESS_DISPLAY_MS } from "../../constants"
+
+beforeEach(() => {
+ jest.useFakeTimers()
+ jest.spyOn(console, "error").mockImplementation()
+})
+
+afterEach(() => {
+ jest.useRealTimers()
+ jest.restoreAllMocks()
+})
+
+describe("useAutoSave", () => {
+ describe("initial state", () => {
+ it("starts with saving=false and saveSuccess=false", () => {
+ const { result } = renderHook(() => useAutoSave())
+
+ expect(result.current.saving).toBe(false)
+ expect(result.current.saveSuccess).toBe(false)
+ })
+ })
+
+ describe("debouncedSaveAndRestart", () => {
+ it("does not call saveFn immediately", () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ expect(saveFn).not.toHaveBeenCalled()
+ })
+
+ it("calls saveFn after debounce delay", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(saveFn).toHaveBeenCalledTimes(1)
+ })
+
+ it("cancels previous debounce when called again", async () => {
+ const saveFn1 = jest.fn().mockResolvedValue(undefined)
+ const saveFn2 = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn1, restartFn)
+ })
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn2, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(saveFn1).not.toHaveBeenCalled()
+ expect(saveFn2).toHaveBeenCalledTimes(1)
+ })
+
+ it("sets saving=true during save, then schedules restart", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ // After save completes, restart is debounced
+ expect(saveFn).toHaveBeenCalled()
+ expect(restartFn).not.toHaveBeenCalled()
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(restartFn).toHaveBeenCalledTimes(1)
+ })
+
+ it("sets saveSuccess=true after restart completes, then clears it", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ // Trigger save
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ // Trigger restart
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(result.current.saveSuccess).toBe(true)
+
+ // Success display clears
+ await act(async () => {
+ jest.advanceTimersByTime(SAVE_SUCCESS_DISPLAY_MS)
+ })
+
+ expect(result.current.saveSuccess).toBe(false)
+ })
+
+ it("handles save failure gracefully", async () => {
+ const saveFn = jest.fn().mockRejectedValue(new Error("save failed"))
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(result.current.saving).toBe(false)
+ expect(restartFn).not.toHaveBeenCalled()
+ })
+
+ it("handles restart failure gracefully", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockRejectedValue(new Error("restart failed"))
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.debouncedSaveAndRestart(saveFn, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(result.current.saving).toBe(false)
+ expect(result.current.saveSuccess).toBe(false)
+ })
+ })
+
+ describe("immediateSaveAndRestart", () => {
+ it("calls saveFn immediately", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ await act(async () => {
+ result.current.immediateSaveAndRestart(saveFn, restartFn)
+ })
+
+ expect(saveFn).toHaveBeenCalledTimes(1)
+ })
+
+ it("sets saving=true immediately", () => {
+ const saveFn = jest.fn().mockReturnValue(new Promise(() => {})) // never resolves
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ act(() => {
+ result.current.immediateSaveAndRestart(saveFn, restartFn)
+ })
+
+ expect(result.current.saving).toBe(true)
+ })
+
+ it("cancels any pending debounced save", async () => {
+ const debouncedSave = jest.fn().mockResolvedValue(undefined)
+ const immediateSave = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ // Start a debounced save
+ act(() => {
+ result.current.debouncedSaveAndRestart(debouncedSave, restartFn)
+ })
+
+ // Immediately save (should cancel debounced)
+ await act(async () => {
+ result.current.immediateSaveAndRestart(immediateSave, restartFn)
+ })
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(debouncedSave).not.toHaveBeenCalled()
+ expect(immediateSave).toHaveBeenCalledTimes(1)
+ })
+
+ it("schedules debounced restart after save", async () => {
+ const saveFn = jest.fn().mockResolvedValue(undefined)
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ await act(async () => {
+ result.current.immediateSaveAndRestart(saveFn, restartFn)
+ })
+
+ // Restart not called yet (debounced)
+ expect(restartFn).not.toHaveBeenCalled()
+
+ await act(async () => {
+ jest.advanceTimersByTime(AUTOSAVE_DEBOUNCE_MS)
+ })
+
+ expect(restartFn).toHaveBeenCalledTimes(1)
+ })
+
+ it("handles save failure gracefully", async () => {
+ const saveFn = jest.fn().mockRejectedValue(new Error("save failed"))
+ const restartFn = jest.fn().mockResolvedValue(undefined)
+ const { result } = renderHook(() => useAutoSave())
+
+ await act(async () => {
+ result.current.immediateSaveAndRestart(saveFn, restartFn)
+ })
+
+ expect(result.current.saving).toBe(false)
+ expect(restartFn).not.toHaveBeenCalled()
+ })
+ })
+})
diff --git a/src/hooks/__tests__/useLocationTracking.test.ts b/src/hooks/__tests__/useLocationTracking.test.ts
new file mode 100644
index 00000000..fd04cba6
--- /dev/null
+++ b/src/hooks/__tests__/useLocationTracking.test.ts
@@ -0,0 +1,269 @@
+import { renderHook, act } from "@testing-library/react-native"
+import { Alert } from "react-native"
+import { DEFAULT_SETTINGS } from "../../types/global"
+
+// Mock NativeLocationService
+const mockStart = jest.fn().mockResolvedValue(undefined)
+const mockStop = jest.fn()
+const mockGetMostRecentLocation = jest.fn().mockResolvedValue(null)
+
+jest.mock("../../services/NativeLocationService", () => ({
+ start: (...args: any[]) => mockStart(...args),
+ stop: (...args: any[]) => mockStop(...args),
+ getMostRecentLocation: (...args: any[]) => mockGetMostRecentLocation(...args)
+}))
+
+// Mock permissions
+const mockEnsurePermissions = jest.fn().mockResolvedValue(true)
+jest.mock("../../services/LocationServicePermission", () => ({
+ ensurePermissions: (...args: any[]) => mockEnsurePermissions(...args)
+}))
+
+// Mock NativeEventEmitter as a class
+const mockRemove = jest.fn()
+const mockAddListener = jest.fn().mockReturnValue({ remove: mockRemove })
+
+jest.mock("react-native/Libraries/EventEmitter/NativeEventEmitter", () => {
+ return {
+ __esModule: true,
+ default: function () {
+ return { addListener: (...args: any[]) => mockAddListener(...args) }
+ }
+ }
+})
+
+import { useLocationTracking } from "../useLocationTracking"
+
+beforeEach(() => {
+ jest.clearAllMocks()
+ jest.spyOn(Alert, "alert").mockImplementation()
+ jest.spyOn(console, "log").mockImplementation()
+ jest.spyOn(console, "error").mockImplementation()
+})
+
+afterEach(() => {
+ jest.restoreAllMocks()
+})
+
+describe("useLocationTracking", () => {
+ describe("initial state", () => {
+ it("returns default state", () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ expect(result.current.coords).toBeNull()
+ expect(result.current.tracking).toBe(false)
+ expect(result.current.settings).toBe(DEFAULT_SETTINGS)
+ })
+ })
+
+ describe("startTracking", () => {
+ it("requests permissions and starts native service", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(mockEnsurePermissions).toHaveBeenCalled()
+ expect(mockStart).toHaveBeenCalledWith(DEFAULT_SETTINGS)
+ expect(result.current.tracking).toBe(true)
+ })
+
+ it("does not start if already tracking", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(mockStart).toHaveBeenCalledTimes(1)
+ })
+
+ it("shows alert and does not start if permissions denied", async () => {
+ mockEnsurePermissions.mockResolvedValueOnce(false)
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(Alert.alert).toHaveBeenCalledWith("Permission Required", expect.any(String))
+ expect(mockStart).not.toHaveBeenCalled()
+ expect(result.current.tracking).toBe(false)
+ })
+
+ it("reverts tracking state if native start fails", async () => {
+ mockStart.mockRejectedValueOnce(new Error("native error"))
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(result.current.tracking).toBe(false)
+ expect(Alert.alert).toHaveBeenCalledWith("Error", expect.any(String))
+ })
+ })
+
+ describe("stopTracking", () => {
+ it("stops native service and clears state", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ act(() => {
+ result.current.stopTracking()
+ })
+
+ expect(mockStop).toHaveBeenCalled()
+ expect(result.current.tracking).toBe(false)
+ expect(result.current.coords).toBeNull()
+ })
+
+ it("does nothing if not tracking", () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ act(() => {
+ result.current.stopTracking()
+ })
+
+ expect(mockStop).not.toHaveBeenCalled()
+ })
+ })
+
+ describe("restartTracking", () => {
+ it("stops the service and clears coords during restart", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(result.current.tracking).toBe(true)
+
+ await act(async () => {
+ await result.current.restartTracking({ ...DEFAULT_SETTINGS, interval: 30 })
+ })
+
+ expect(mockStop).toHaveBeenCalled()
+ })
+
+ it("queues restart if already restarting", async () => {
+ const logSpy = jest.spyOn(console, "log").mockImplementation()
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ // Start two restarts simultaneously
+ act(() => {
+ result.current.restartTracking()
+ result.current.restartTracking() // should queue
+ })
+
+ const queuedCalls = logSpy.mock.calls.filter((c: any[]) => typeof c[0] === "string" && c[0].includes("queuing"))
+ expect(queuedCalls.length).toBeGreaterThan(0)
+ })
+ })
+
+ describe("reconnect", () => {
+ it("sets tracking to true without requesting permissions or starting service", () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ act(() => {
+ result.current.reconnect()
+ })
+
+ expect(result.current.tracking).toBe(true)
+ expect(mockEnsurePermissions).not.toHaveBeenCalled()
+ expect(mockStart).not.toHaveBeenCalled()
+ })
+
+ it("does nothing if already tracking", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ act(() => {
+ result.current.reconnect()
+ })
+
+ expect(result.current.tracking).toBe(true)
+ })
+ })
+
+ describe("native event listener", () => {
+ it("attaches listener when tracking starts", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ expect(mockAddListener).toHaveBeenCalledWith("onLocationUpdate", expect.any(Function))
+ })
+
+ it("updates coords when location event fires", async () => {
+ let eventCallback: (event: any) => void
+ mockAddListener.mockImplementation((_event: string, cb: (event: any) => void) => {
+ eventCallback = cb
+ return { remove: mockRemove }
+ })
+
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ act(() => {
+ eventCallback!({
+ latitude: 48.123,
+ longitude: 11.456,
+ accuracy: 5,
+ altitude: 500,
+ speed: 1.2,
+ bearing: 90,
+ timestamp: 1700000000,
+ battery: 85,
+ batteryStatus: 2
+ })
+ })
+
+ expect(result.current.coords).toEqual({
+ latitude: 48.123,
+ longitude: 11.456,
+ accuracy: 5,
+ altitude: 500,
+ speed: 1.2,
+ bearing: 90,
+ timestamp: 1700000000,
+ battery: 85,
+ battery_status: 2
+ })
+ })
+
+ it("removes listener when tracking stops", async () => {
+ const { result } = renderHook(() => useLocationTracking(DEFAULT_SETTINGS))
+
+ await act(async () => {
+ await result.current.startTracking(DEFAULT_SETTINGS)
+ })
+
+ act(() => {
+ result.current.stopTracking()
+ })
+
+ expect(mockRemove).toHaveBeenCalled()
+ })
+ })
+})
diff --git a/src/hooks/__tests__/useTimeout.test.ts b/src/hooks/__tests__/useTimeout.test.ts
new file mode 100644
index 00000000..8b32dbaf
--- /dev/null
+++ b/src/hooks/__tests__/useTimeout.test.ts
@@ -0,0 +1,96 @@
+import { renderHook, act } from "@testing-library/react-native"
+import { useTimeout } from "../useTimeout"
+
+beforeEach(() => {
+ jest.useFakeTimers()
+})
+
+afterEach(() => {
+ jest.useRealTimers()
+})
+
+describe("useTimeout", () => {
+ it("executes callback after delay", () => {
+ const callback = jest.fn()
+ const { result } = renderHook(() => useTimeout())
+
+ act(() => {
+ result.current.set(callback, 1000)
+ })
+
+ expect(callback).not.toHaveBeenCalled()
+
+ act(() => {
+ jest.advanceTimersByTime(1000)
+ })
+
+ expect(callback).toHaveBeenCalledTimes(1)
+ })
+
+ it("cancels previous timeout when set is called again", () => {
+ const callback1 = jest.fn()
+ const callback2 = jest.fn()
+ const { result } = renderHook(() => useTimeout())
+
+ act(() => {
+ result.current.set(callback1, 1000)
+ })
+
+ act(() => {
+ result.current.set(callback2, 1000)
+ })
+
+ act(() => {
+ jest.advanceTimersByTime(1000)
+ })
+
+ expect(callback1).not.toHaveBeenCalled()
+ expect(callback2).toHaveBeenCalledTimes(1)
+ })
+
+ it("clear cancels pending timeout", () => {
+ const callback = jest.fn()
+ const { result } = renderHook(() => useTimeout())
+
+ act(() => {
+ result.current.set(callback, 1000)
+ })
+
+ act(() => {
+ result.current.clear()
+ })
+
+ act(() => {
+ jest.advanceTimersByTime(1000)
+ })
+
+ expect(callback).not.toHaveBeenCalled()
+ })
+
+ it("cleans up on unmount", () => {
+ const callback = jest.fn()
+ const { result, unmount } = renderHook(() => useTimeout())
+
+ act(() => {
+ result.current.set(callback, 1000)
+ })
+
+ unmount()
+
+ act(() => {
+ jest.advanceTimersByTime(1000)
+ })
+
+ expect(callback).not.toHaveBeenCalled()
+ })
+
+ it("clear is safe to call with no pending timeout", () => {
+ const { result } = renderHook(() => useTimeout())
+
+ expect(() => {
+ act(() => {
+ result.current.clear()
+ })
+ }).not.toThrow()
+ })
+})
diff --git a/src/services/__tests__/LocationServicePermission.test.ts b/src/services/__tests__/LocationServicePermission.test.ts
new file mode 100644
index 00000000..d0f9993c
--- /dev/null
+++ b/src/services/__tests__/LocationServicePermission.test.ts
@@ -0,0 +1,225 @@
+import { Platform, PermissionsAndroid, Alert } from "react-native"
+import { ensurePermissions, checkPermissions } from "../LocationServicePermission"
+
+// Mock NativeLocationService
+jest.mock("../NativeLocationService", () => ({
+ isIgnoringBatteryOptimizations: jest.fn().mockResolvedValue(true),
+ requestIgnoreBatteryOptimizations: jest.fn().mockResolvedValue(undefined)
+}))
+
+import NativeLocationService from "../NativeLocationService"
+
+const mockIsIgnoring = NativeLocationService.isIgnoringBatteryOptimizations as jest.Mock
+const mockRequestIgnore = NativeLocationService.requestIgnoreBatteryOptimizations as jest.Mock
+
+let alertSpy: jest.SpyInstance
+let requestSpy: jest.SpyInstance
+let checkSpy: jest.SpyInstance
+
+function setPlatform(os: string, version: number) {
+ Object.defineProperty(Platform, "OS", { get: () => os, configurable: true })
+ Object.defineProperty(Platform, "Version", { get: () => version, configurable: true })
+}
+
+const originalOS = Platform.OS
+const originalVersion = Platform.Version
+
+beforeEach(() => {
+ jest.clearAllMocks()
+ jest.spyOn(console, "error").mockImplementation()
+ requestSpy = jest.spyOn(PermissionsAndroid, "request").mockResolvedValue(PermissionsAndroid.RESULTS.GRANTED)
+ checkSpy = jest.spyOn(PermissionsAndroid, "check").mockResolvedValue(true)
+ alertSpy = jest.spyOn(Alert, "alert").mockImplementation()
+})
+
+afterEach(() => {
+ jest.restoreAllMocks()
+ setPlatform(originalOS, originalVersion as number)
+})
+
+describe("ensurePermissions", () => {
+ it("returns true immediately on non-Android platforms", async () => {
+ setPlatform("ios", 0)
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(true)
+ expect(requestSpy).not.toHaveBeenCalled()
+ })
+
+ it("requests fine location permission", async () => {
+ setPlatform("android", 28)
+
+ await ensurePermissions()
+
+ expect(requestSpy).toHaveBeenCalledWith(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION, expect.any(Object))
+ })
+
+ it("returns false if fine location denied", async () => {
+ setPlatform("android", 28)
+ requestSpy.mockResolvedValueOnce(PermissionsAndroid.RESULTS.DENIED)
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(false)
+ expect(alertSpy).toHaveBeenCalledWith("Permission Required", expect.any(String), expect.any(Array))
+ })
+
+ it("requests background location on Android 10+", async () => {
+ setPlatform("android", 29)
+
+ await ensurePermissions()
+
+ expect(requestSpy).toHaveBeenCalledWith(
+ PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION,
+ expect.any(Object)
+ )
+ })
+
+ it("skips background location on Android < 10", async () => {
+ setPlatform("android", 28)
+
+ await ensurePermissions()
+
+ const permissions = requestSpy.mock.calls.map((c: any[]) => c[0])
+ expect(permissions).not.toContain(PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION)
+ })
+
+ it("requests notification permission on Android 13+", async () => {
+ setPlatform("android", 33)
+
+ await ensurePermissions()
+
+ expect(requestSpy).toHaveBeenCalledWith(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS, expect.any(Object))
+ })
+
+ it("skips notification permission on Android < 13", async () => {
+ setPlatform("android", 29)
+
+ await ensurePermissions()
+
+ const permissions = requestSpy.mock.calls.map((c: any[]) => c[0])
+ expect(permissions).not.toContain(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS)
+ })
+
+ it("returns false if background location denied", async () => {
+ setPlatform("android", 29)
+ requestSpy
+ .mockResolvedValueOnce(PermissionsAndroid.RESULTS.GRANTED) // fine location
+ .mockResolvedValueOnce(PermissionsAndroid.RESULTS.DENIED) // background
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(false)
+ })
+
+ it("returns false if notification permission denied", async () => {
+ setPlatform("android", 33)
+ requestSpy
+ .mockResolvedValueOnce(PermissionsAndroid.RESULTS.GRANTED) // fine location
+ .mockResolvedValueOnce(PermissionsAndroid.RESULTS.GRANTED) // background
+ .mockResolvedValueOnce(PermissionsAndroid.RESULTS.DENIED) // notification
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(false)
+ })
+
+ it("requests battery optimization exemption", async () => {
+ setPlatform("android", 33)
+ mockIsIgnoring.mockResolvedValueOnce(false)
+
+ await ensurePermissions()
+
+ expect(mockRequestIgnore).toHaveBeenCalled()
+ })
+
+ it("skips battery request if already exempted", async () => {
+ setPlatform("android", 28)
+ mockIsIgnoring.mockResolvedValueOnce(true)
+
+ await ensurePermissions()
+
+ expect(mockRequestIgnore).not.toHaveBeenCalled()
+ })
+
+ it("still returns true if battery optimization request fails", async () => {
+ setPlatform("android", 28)
+ mockIsIgnoring.mockRejectedValueOnce(new Error("battery check failed"))
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(true)
+ })
+
+ it("returns false and shows alert on unexpected error", async () => {
+ setPlatform("android", 28)
+ requestSpy.mockRejectedValueOnce(new Error("unexpected"))
+
+ const result = await ensurePermissions()
+
+ expect(result).toBe(false)
+ expect(alertSpy).toHaveBeenCalledWith("Permission Error", expect.any(String), expect.any(Array))
+ })
+})
+
+describe("checkPermissions", () => {
+ it("returns all true on non-Android platforms", async () => {
+ setPlatform("ios", 0)
+
+ const result = await checkPermissions()
+
+ expect(result).toEqual({
+ location: true,
+ background: true,
+ notifications: true,
+ batteryOptimized: true
+ })
+ })
+
+ it("checks all permissions in parallel on Android", async () => {
+ setPlatform("android", 33)
+
+ checkSpy.mockImplementation((permission: string) => {
+ if (permission === PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS) {
+ return Promise.resolve(false)
+ }
+ return Promise.resolve(true)
+ })
+ mockIsIgnoring.mockResolvedValueOnce(true)
+
+ const result = await checkPermissions()
+
+ expect(result.location).toBe(true)
+ expect(result.background).toBe(true)
+ expect(result.notifications).toBe(false)
+ expect(result.batteryOptimized).toBe(true)
+ })
+
+ it("returns true for background on Android < 10", async () => {
+ setPlatform("android", 28)
+ mockIsIgnoring.mockResolvedValueOnce(true)
+
+ const result = await checkPermissions()
+
+ expect(result.background).toBe(true)
+ })
+
+ it("returns true for notifications on Android < 13", async () => {
+ setPlatform("android", 29)
+ mockIsIgnoring.mockResolvedValueOnce(true)
+
+ const result = await checkPermissions()
+
+ expect(result.notifications).toBe(true)
+ })
+
+ it("returns false for battery if check throws", async () => {
+ setPlatform("android", 28)
+ mockIsIgnoring.mockRejectedValueOnce(new Error("failed"))
+
+ const result = await checkPermissions()
+
+ expect(result.batteryOptimized).toBe(false)
+ })
+})