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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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)+ })+})