@symbiote-native/sensors 0.1.0

package/src/angular/services/light-sensor.service/light-sensor.service.test.ts

@@ -0,0 +1,118 @@
+// Co-located Angular-driven test (ADR 0025) for LightSensorService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { ILightSensorMeasurement } from '../../../core';
+import { LightSensorService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  LightSensor: {
+    addListener: (listener: (measurement: ILightSensorMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: ILightSensorMeasurement = { illuminance: 42, timestamp: 123 };
+
+let capturedResult: Signal<ILightSensorMeasurement | null> | undefined;
+let capturedListener: ((measurement: ILightSensorMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-light-sensor-host',
+  standalone: true,
+  template: '',
+})
+class LightSensorHost {
+  readonly measurement = inject(LightSensorService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-light-sensor-interval-host',
+  standalone: true,
+  template: '',
+})
+class LightSensorIntervalHost {
+  readonly measurement = inject(LightSensorService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('LightSensorService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, LightSensorHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, LightSensorHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, LightSensorHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, LightSensorIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, LightSensorHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/magnetometer-uncalibrated.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { MagnetometerUncalibrated, type IMagnetometerUncalibratedMeasurement } from '../../../core';
+
+// Angular twin of React's `useMagnetometerUncalibrated` hook and Vue's
+// `useMagnetometerUncalibrated` composable. Angular has no per-instance hook — state and
+// lifecycle live in DI instead, so `connect()` stands in for the hook's role: call it ONCE
+// (typically from a component's field initializer, inside an injection context).
+//
+//   readonly measurement = inject(MagnetometerUncalibratedService).connect();
+//   // template: {{ measurement()?.x }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class MagnetometerUncalibratedService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IMagnetometerUncalibratedMeasurement | null> {
+    const measurement = signal<IMagnetometerUncalibratedMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          MagnetometerUncalibrated.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = MagnetometerUncalibrated.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/magnetometer-uncalibrated.service/magnetometer-uncalibrated.service.test.ts

@@ -0,0 +1,123 @@
+// Co-located Angular-driven test (ADR 0025) for MagnetometerUncalibratedService. Mounts a real
+// host component through @symbiote-native/angular so `connect()` runs the same way an app would
+// call it — inside the component's own injection context — and drives the returned signal
+// through a full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only
+// fires correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IMagnetometerUncalibratedMeasurement } from '../../../core';
+import { MagnetometerUncalibratedService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  MagnetometerUncalibrated: {
+    addListener: (listener: (measurement: IMagnetometerUncalibratedMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IMagnetometerUncalibratedMeasurement = {
+  x: 0.1,
+  y: 0.2,
+  z: 0.3,
+  timestamp: 123,
+};
+
+let capturedResult: Signal<IMagnetometerUncalibratedMeasurement | null> | undefined;
+let capturedListener: ((measurement: IMagnetometerUncalibratedMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-magnetometer-uncalibrated-host',
+  standalone: true,
+  template: '',
+})
+class MagnetometerUncalibratedHost {
+  readonly measurement = inject(MagnetometerUncalibratedService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-magnetometer-uncalibrated-interval-host',
+  standalone: true,
+  template: '',
+})
+class MagnetometerUncalibratedIntervalHost {
+  readonly measurement = inject(MagnetometerUncalibratedService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('MagnetometerUncalibratedService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, MagnetometerUncalibratedHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, MagnetometerUncalibratedHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, MagnetometerUncalibratedHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, MagnetometerUncalibratedIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, MagnetometerUncalibratedHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/magnetometer.service/index.ts

@@ -0,0 +1,39 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { Magnetometer, type IMagnetometerMeasurement } from '../../../core';
+
+// Angular twin of React's `useMagnetometer` hook and Vue's `useMagnetometer` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly measurement = inject(MagnetometerService).connect();
+//   // template: {{ measurement()?.x }}
+//
+// Unlike HideAnimationService.connect(), there is no per-render config to re-sync — the
+// subscription doesn't depend on anything the caller's own signals could change between
+// renders — so a single effect() that subscribes once and cleans up once is enough; no
+// `updateConfig`-style effect that re-runs on every read is needed here.
+@Injectable({ providedIn: 'root' })
+export class MagnetometerService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's
+  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors HideAnimationService.
+  private readonly injector = inject(Injector);
+
+  connect(updateIntervalMs?: number): Signal<IMagnetometerMeasurement | null> {
+    const measurement = signal<IMagnetometerMeasurement | null>(null);
+
+    effect(
+      onCleanup => {
+        if (updateIntervalMs !== undefined) {
+          Magnetometer.setUpdateInterval(updateIntervalMs);
+        }
+        const subscription = Magnetometer.addListener(next => measurement.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return measurement.asReadonly();
+  }
+}

package/src/angular/services/magnetometer.service/magnetometer.service.test.ts

@@ -0,0 +1,118 @@
+// Co-located Angular-driven test (ADR 0025) for MagnetometerService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires
+// correctly when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IMagnetometerMeasurement } from '../../../core';
+import { MagnetometerService } from './index';
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const setUpdateIntervalMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  Magnetometer: {
+    addListener: (listener: (measurement: IMagnetometerMeasurement) => void) =>
+      addListenerMock(listener),
+    setUpdateInterval: (intervalMs: number) => setUpdateIntervalMock(intervalMs),
+  },
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const MEASUREMENT: IMagnetometerMeasurement = { x: 0.1, y: 0.2, z: 0.3, timestamp: 123 };
+
+let capturedResult: Signal<IMagnetometerMeasurement | null> | undefined;
+let capturedListener: ((measurement: IMagnetometerMeasurement) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-magnetometer-host',
+  standalone: true,
+  template: '',
+})
+class MagnetometerHost {
+  readonly measurement = inject(MagnetometerService).connect();
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+@Component({
+  selector: 'symbiote-magnetometer-interval-host',
+  standalone: true,
+  template: '',
+})
+class MagnetometerIntervalHost {
+  readonly measurement = inject(MagnetometerService).connect(500);
+
+  constructor() {
+    capturedResult = this.measurement;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('MagnetometerService.connect', () => {
+  it('reports null before any measurement event fires', async () => {
+    mount(ROOT_TAG, MagnetometerHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a measurement', async () => {
+    mount(ROOT_TAG, MagnetometerHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener(MEASUREMENT);
+
+    expect(capturedResult?.()).toEqual(MEASUREMENT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, MagnetometerHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+
+  it('calls setUpdateInterval with the given interval when one is passed', async () => {
+    mount(ROOT_TAG, MagnetometerIntervalHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).toHaveBeenCalledWith(500);
+  });
+
+  it('does not call setUpdateInterval when no interval is passed', async () => {
+    mount(ROOT_TAG, MagnetometerHost);
+    await tick();
+
+    expect(setUpdateIntervalMock).not.toHaveBeenCalled();
+  });
+});

package/src/angular/services/pedometer.service/index.ts

@@ -0,0 +1,34 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { watchStepCount, type IPedometerResult } from '../../../core';
+
+// Angular twin of React's `usePedometer` hook and Vue's `usePedometer` composable. Angular has
+// no per-instance hook — state and lifecycle live in DI instead, so `connect()` stands in for
+// the hook's role: call it ONCE (typically from a component's field initializer, inside an
+// injection context).
+//
+//   readonly result = inject(PedometerService).connect();
+//   // template: {{ result()?.steps }}
+//
+// Unlike AccelerometerService.connect(), there is no updateIntervalMs to apply — Pedometer has
+// no setUpdateInterval — so a single effect() that subscribes once and cleans up once is enough.
+@Injectable({ providedIn: 'root' })
+export class PedometerService {
+  // Captured in the constructor (itself always run inside an injection context by Angular's own
+  // DI) so `connect()` can create an `effect()` even when called from plain field-initializer
+  // code that is not, on its own, an active injection context — mirrors AccelerometerService.
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<IPedometerResult | null> {
+    const result = signal<IPedometerResult | null>(null);
+
+    effect(
+      onCleanup => {
+        const subscription = watchStepCount(next => result.set(next));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return result.asReadonly();
+  }
+}

package/src/angular/services/pedometer.service/pedometer.service.test.ts

@@ -0,0 +1,86 @@
+// Co-located Angular-driven test (ADR 0025) for PedometerService. Mounts a real host component
+// through @symbiote-native/angular so `connect()` runs the same way an app would call it —
+// inside the component's own injection context — and drives the returned signal through a full
+// mount/unmount lifecycle, because `effect()`'s injector-scoped cleanup only fires correctly
+// when torn down through a real Angular injection context.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IPedometerResult } from '../../../core';
+import { PedometerService } from './index';
+
+const watchStepCountMock = vi.fn();
+const removeMock = vi.fn();
+
+vi.mock('../../../core', () => ({
+  watchStepCount: (listener: (result: IPedometerResult) => void) => watchStepCountMock(listener),
+}));
+
+const ROOT_TAG = 942;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+const RESULT: IPedometerResult = { steps: 789 };
+
+let capturedResult: Signal<IPedometerResult | null> | undefined;
+let capturedListener: ((result: IPedometerResult) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-pedometer-host',
+  standalone: true,
+  template: '',
+})
+class PedometerHost {
+  readonly result = inject(PedometerService).connect();
+
+  constructor() {
+    capturedResult = this.result;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  watchStepCountMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('PedometerService.connect', () => {
+  it('reports null before any step count event fires', async () => {
+    mount(ROOT_TAG, PedometerHost);
+    await tick();
+
+    expect(capturedResult?.()).toBeNull();
+  });
+
+  it('updates the signal when the registered listener fires with a result', async () => {
+    mount(ROOT_TAG, PedometerHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('watchStepCount callback was not captured');
+    capturedListener(RESULT);
+
+    expect(capturedResult?.()).toEqual(RESULT);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, PedometerHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+});

package/src/core/accelerometer.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_ACCELEROMETER = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExponentAccelerometer native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-accelerometer', () => ({
+  exponentAccelerometer: FAKE_NATIVE_ACCELEROMETER,
+}));
+
+// device-sensor.ts (imported transitively through ./accelerometer) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { Accelerometer } = await import('./accelerometer');
+
+afterEach(() => {
+  Accelerometer.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('Accelerometer', () => {
+  it('sets the update interval', () => {
+    Accelerometer.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_ACCELEROMETER.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_ACCELEROMETER.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared accelerometerDidUpdate event name', () => {
+    const listener = vi.fn();
+    Accelerometer.addListener(listener);
+
+    expect(FAKE_NATIVE_ACCELEROMETER.addListener).toHaveBeenCalledWith(
+      'accelerometerDidUpdate',
+      listener,
+    );
+  });
+});

package/src/core/accelerometer.ts

@@ -0,0 +1,19 @@
+import { DeviceSensor } from './device-sensor';
+import { exponentAccelerometer } from './native/exponent-accelerometer';
+
+// Values are g-force (a `g` = 9.81 m/s^2) reported along each axis; timestamp is in seconds.
+export type IAccelerometerMeasurement = {
+  x: number;
+  y: number;
+  z: number;
+  timestamp: number;
+};
+
+export class AccelerometerSensor extends DeviceSensor<IAccelerometerMeasurement> {}
+
+const ACCELEROMETER_DID_UPDATE_EVENT_NAME = 'accelerometerDidUpdate';
+
+export const Accelerometer = new AccelerometerSensor(
+  exponentAccelerometer,
+  ACCELEROMETER_DID_UPDATE_EVENT_NAME,
+);

package/src/core/barometer.test.ts

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_BAROMETER = {
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+  listenerCount: vi.fn(() => 0),
+  removeAllListeners: vi.fn(),
+  setUpdateInterval: vi.fn(),
+};
+
+// The real ExpoBarometer native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of `expo-modules-core`'s runtime resolution.
+vi.mock('./native/exponent-barometer', () => ({
+  exponentBarometer: FAKE_NATIVE_BAROMETER,
+}));
+
+// device-sensor.ts (imported transitively through ./barometer) pulls Platform/PermissionStatus
+// from expo-modules-core, whose real entry drags in the Flow-typed 'react-native' source that
+// Vitest's Oxc transform can't parse — same fake as device-sensor.test.ts.
+vi.mock('expo-modules-core', () => ({
+  Platform: { OS: 'ios' },
+  PermissionStatus: { GRANTED: 'granted', UNDETERMINED: 'undetermined', DENIED: 'denied' },
+}));
+
+const { Barometer } = await import('./barometer');
+
+afterEach(() => {
+  Barometer.removeAllListeners();
+  vi.clearAllMocks();
+});
+
+describe('Barometer', () => {
+  it('sets the update interval', () => {
+    Barometer.setUpdateInterval(1234);
+
+    expect(FAKE_NATIVE_BAROMETER.setUpdateInterval).toHaveBeenCalledTimes(1);
+    expect(FAKE_NATIVE_BAROMETER.setUpdateInterval).toHaveBeenCalledWith(1234);
+  });
+
+  it('subscribes through the shared barometerDidUpdate event name', () => {
+    const listener = vi.fn();
+    Barometer.addListener(listener);
+
+    expect(FAKE_NATIVE_BAROMETER.addListener).toHaveBeenCalledWith('barometerDidUpdate', listener);
+  });
+});