preact-homeassistant 0.1.0

package/src/__tests__/testHelpers.tsx

@@ -0,0 +1,73 @@
+import { type RenderOptions, render } from '@testing-library/preact';
+import type { ComponentChildren } from 'preact';
+import { vi } from 'vitest';
+import { HAProvider } from '../HAContext';
+import type { HomeAssistant } from '../types';
+
+export type MockSubscribeFn = (entityId: string, callback: (entity: any) => void) => () => void;
+
+export function makeHass(
+  states: Record<string, any> = {},
+  overrides: Partial<HomeAssistant> = {},
+): HomeAssistant {
+  return {
+    states,
+    config: {} as any,
+    services: {} as any,
+    connection: {
+      sendMessagePromise: vi.fn(),
+    } as any,
+    callService: vi.fn(),
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock subscribeToEntity that stores callbacks for manual triggering.
+ */
+export function createMockSubscribe() {
+  const listeners = new Map<string, Set<(entity: any) => void>>();
+
+  const subscribe: MockSubscribeFn = (entityId, callback) => {
+    if (!listeners.has(entityId)) {
+      listeners.set(entityId, new Set());
+    }
+    listeners.get(entityId)!.add(callback);
+
+    return () => {
+      listeners.get(entityId)?.delete(callback);
+    };
+  };
+
+  const notify = (entityId: string, entity: any) => {
+    listeners.get(entityId)?.forEach((cb) => cb(entity));
+  };
+
+  return { subscribe, notify, listeners };
+}
+
+interface RenderWithHAOptions extends Omit<RenderOptions, 'wrapper'> {
+  hass?: HomeAssistant;
+  subscribeFn?: MockSubscribeFn;
+}
+
+export function renderWithHA(ui: ComponentChildren, options: RenderWithHAOptions = {}) {
+  const {
+    hass = makeHass(),
+    subscribeFn = createMockSubscribe().subscribe,
+    ...renderOptions
+  } = options;
+
+  function Wrapper({ children }: { children: ComponentChildren }) {
+    return (
+      <HAProvider hass={hass} subscribeToEntity={subscribeFn}>
+        {children}
+      </HAProvider>
+    );
+  }
+
+  return {
+    ...render(ui as any, { wrapper: Wrapper as any, ...renderOptions }),
+    hass,
+  };
+}

package/src/__tests__/useCachedFetch.test.tsx

@@ -0,0 +1,147 @@
+import { act, screen, waitFor } from '@testing-library/preact';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useCachedFetch } from '../HAContext';
+import type { FetchStatus } from '../types';
+import { createMockSubscribe, makeHass, renderWithHA } from './testHelpers';
+
+let lastStatus: FetchStatus;
+
+function FetchDisplay({
+  cacheKey,
+  fetcher,
+  deps,
+}: {
+  cacheKey: string;
+  fetcher: () => Promise<any>;
+  deps: unknown[];
+}) {
+  const { data, status, error } = useCachedFetch(cacheKey, fetcher, deps);
+  lastStatus = status;
+  return (
+    <div>
+      <span data-testid="data">{JSON.stringify(data) ?? 'undefined'}</span>
+      <span data-testid="status">{status}</span>
+      <span data-testid="error">{error?.message ?? 'none'}</span>
+    </div>
+  );
+}
+
+describe('useCachedFetch', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('transitions from loading to ready on successful fetch', async () => {
+    const fetcher = vi.fn().mockResolvedValue({ temp: 72 });
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<FetchDisplay cacheKey="test" fetcher={fetcher} deps={[]} />, {
+      subscribeFn: subscribe,
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    expect(screen.getByTestId('data').textContent).toBe('{"temp":72}');
+  });
+
+  it('shows cached data while refreshing', async () => {
+    // Pre-populate cache
+    const entry = {
+      data: { temp: 68 },
+      timestamp: Date.now(),
+    };
+    localStorage.setItem('preact-ha:test', JSON.stringify(entry));
+
+    let resolve: (v: any) => void;
+    const fetcher = vi.fn().mockImplementation(
+      () =>
+        new Promise((r) => {
+          resolve = r;
+        }),
+    );
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<FetchDisplay cacheKey="test" fetcher={fetcher} deps={[]} />, {
+      subscribeFn: subscribe,
+    });
+
+    // Should show cached data
+    expect(screen.getByTestId('data').textContent).toBe('{"temp":68}');
+
+    // Resolve the fetch
+    await act(async () => {
+      resolve!({ temp: 75 });
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    expect(screen.getByTestId('data').textContent).toBe('{"temp":75}');
+  });
+
+  it('reports errors from failed fetches', async () => {
+    const fetcher = vi.fn().mockRejectedValue(new Error('Network error'));
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<FetchDisplay cacheKey="test" fetcher={fetcher} deps={[]} />, {
+      subscribeFn: subscribe,
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('error').textContent).toBe('Network error');
+    });
+  });
+
+  it('saves fetched data to cache', async () => {
+    const fetcher = vi.fn().mockResolvedValue({ temp: 72 });
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<FetchDisplay cacheKey="cache-write-test" fetcher={fetcher} deps={[]} />, {
+      subscribeFn: subscribe,
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    const cached = localStorage.getItem('preact-ha:cache-write-test');
+    expect(cached).toBeTruthy();
+    expect(JSON.parse(cached!).data).toEqual({ temp: 72 });
+  });
+
+  it('ignores stale fetch results', async () => {
+    const resolvers: Array<(v: any) => void> = [];
+    const fetcher = vi.fn().mockImplementation(
+      () =>
+        new Promise((r) => {
+          resolvers.push(r);
+        }),
+    );
+    const { subscribe } = createMockSubscribe();
+
+    const { rerender } = renderWithHA(
+      <FetchDisplay cacheKey="test" fetcher={fetcher} deps={['a']} />,
+      { subscribeFn: subscribe },
+    );
+
+    // Trigger a second fetch by changing deps
+    rerender(<FetchDisplay cacheKey="test" fetcher={fetcher} deps={['b']} />);
+
+    // Resolve the first (stale) fetch
+    await act(async () => {
+      resolvers[0]?.({ temp: 'stale' });
+    });
+
+    // Resolve the second (current) fetch
+    await act(async () => {
+      resolvers[1]?.({ temp: 'fresh' });
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('data').textContent).toBe('{"temp":"fresh"}');
+    });
+  });
+});

package/src/__tests__/useEntity.test.tsx

@@ -0,0 +1,140 @@
+import { act, screen } from '@testing-library/preact';
+import { useRef } from 'preact/hooks';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useEntity } from '../HAContext';
+import { createMockSubscribe, makeHass, renderWithHA } from './testHelpers';
+
+function EntityDisplay({ entityId }: { entityId: string }) {
+  const entity = useEntity(entityId);
+  const renderCount = useRef(0);
+  renderCount.current++;
+  return (
+    <div>
+      <span data-testid="state">{entity?.state ?? 'undefined'}</span>
+      <span data-testid="id">{entity?.entity_id ?? 'none'}</span>
+      <span data-testid="renders">{renderCount.current}</span>
+    </div>
+  );
+}
+
+describe('useEntity', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('returns the initial entity state from hass', () => {
+    const hass = makeHass({
+      'sensor.temp': { entity_id: 'sensor.temp', state: '72' },
+    });
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass,
+      subscribeFn: subscribe,
+    });
+
+    expect(screen.getByTestId('state').textContent).toBe('72');
+  });
+
+  it('returns undefined for missing entities', () => {
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.missing" />, {
+      hass: makeHass({}),
+      subscribeFn: subscribe,
+    });
+
+    expect(screen.getByTestId('state').textContent).toBe('undefined');
+  });
+
+  it('updates when subscribeToEntity fires', async () => {
+    const { subscribe, notify } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass: makeHass({}),
+      subscribeFn: subscribe,
+    });
+
+    expect(screen.getByTestId('state').textContent).toBe('undefined');
+
+    await act(() => {
+      notify('sensor.temp', { entity_id: 'sensor.temp', state: '75' });
+    });
+
+    expect(screen.getByTestId('state').textContent).toBe('75');
+  });
+
+  it('caches entity to localStorage on update', async () => {
+    const { subscribe, notify } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass: makeHass({}),
+      subscribeFn: subscribe,
+    });
+
+    await act(() => {
+      notify('sensor.temp', { entity_id: 'sensor.temp', state: '75' });
+    });
+
+    const cached = localStorage.getItem('preact-ha:entity:sensor.temp');
+    expect(cached).toBeTruthy();
+    const parsed = JSON.parse(cached!);
+    expect(parsed.data.state).toBe('75');
+  });
+
+  it('loads from cache when hass has no state', () => {
+    // Pre-populate cache
+    const entry = {
+      data: { entity_id: 'sensor.temp', state: '68' },
+      timestamp: Date.now(),
+    };
+    localStorage.setItem('preact-ha:entity:sensor.temp', JSON.stringify(entry));
+
+    const { subscribe } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass: makeHass({}),
+      subscribeFn: subscribe,
+    });
+
+    expect(screen.getByTestId('state').textContent).toBe('68');
+  });
+
+  it('does not re-render when a different entity changes', async () => {
+    const { subscribe, notify } = createMockSubscribe();
+
+    renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass: makeHass({
+        'sensor.temp': { entity_id: 'sensor.temp', state: '72' },
+      }),
+      subscribeFn: subscribe,
+    });
+
+    const rendersAfterMount = Number(screen.getByTestId('renders').textContent);
+
+    // Notify a completely different entity
+    await act(() => {
+      notify('sensor.humidity', { entity_id: 'sensor.humidity', state: '45' });
+    });
+
+    // Render count should not have increased
+    expect(Number(screen.getByTestId('renders').textContent)).toBe(rendersAfterMount);
+    // Original state unchanged
+    expect(screen.getByTestId('state').textContent).toBe('72');
+  });
+
+  it('unsubscribes on unmount', () => {
+    const { subscribe, listeners } = createMockSubscribe();
+
+    const { unmount } = renderWithHA(<EntityDisplay entityId="sensor.temp" />, {
+      hass: makeHass({}),
+      subscribeFn: subscribe,
+    });
+
+    expect(listeners.get('sensor.temp')?.size).toBe(1);
+
+    unmount();
+
+    expect(listeners.get('sensor.temp')?.size ?? 0).toBe(0);
+  });
+});

package/src/__tests__/useMultiCalendarEvents.test.tsx

@@ -0,0 +1,217 @@
+import { act, screen, waitFor } from '@testing-library/preact';
+import { render } from '@testing-library/preact';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useMultiCalendarEvents } from '../HAContext';
+import { HAProvider } from '../HAContext';
+import type { FetchStatus } from '../types';
+import type { CalendarEventWithSource } from '../types';
+import { createMockSubscribe, makeHass } from './testHelpers';
+
+function CalendarDisplay({
+  entityIds,
+  start,
+  end,
+}: {
+  entityIds: `calendar.${string}`[];
+  start: Date;
+  end: Date;
+}) {
+  const { events, status, error } = useMultiCalendarEvents(entityIds, {
+    start,
+    end,
+  });
+  return (
+    <div>
+      <span data-testid="count">{events?.length ?? 'loading'}</span>
+      <span data-testid="status">{status}</span>
+      <span data-testid="error">{error?.message ?? 'none'}</span>
+      <span data-testid="events">
+        {events?.map((e: CalendarEventWithSource) => `${e.calendarId}:${e.summary}`).join(',') ??
+          ''}
+      </span>
+    </div>
+  );
+}
+
+describe('useMultiCalendarEvents', () => {
+  const start = new Date('2025-01-01');
+  const end = new Date('2025-01-31');
+
+  beforeEach(() => {
+    localStorage.clear();
+    vi.restoreAllMocks();
+  });
+
+  it('fetches events from multiple calendars', async () => {
+    const sendMessagePromise = vi
+      .fn()
+      .mockResolvedValueOnce({
+        response: {
+          'calendar.family': {
+            events: [{ start: '2025-01-05', end: '2025-01-05', summary: 'Birthday' }],
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        response: {
+          'calendar.work': {
+            events: [{ start: '2025-01-10', end: '2025-01-10', summary: 'Meeting' }],
+          },
+        },
+      });
+
+    const hass = makeHass(
+      {},
+      {
+        connection: { sendMessagePromise } as any,
+      },
+    );
+    const { subscribe } = createMockSubscribe();
+
+    render(
+      <HAProvider hass={hass} subscribeToEntity={subscribe}>
+        <CalendarDisplay entityIds={['calendar.family', 'calendar.work']} start={start} end={end} />
+      </HAProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    expect(screen.getByTestId('count').textContent).toBe('2');
+    expect(screen.getByTestId('events').textContent).toContain('calendar.family:Birthday');
+    expect(screen.getByTestId('events').textContent).toContain('calendar.work:Meeting');
+  });
+
+  it('attaches calendarId to each event', async () => {
+    const sendMessagePromise = vi.fn().mockResolvedValue({
+      response: {
+        'calendar.family': {
+          events: [{ start: '2025-01-05', end: '2025-01-05', summary: 'Event' }],
+        },
+      },
+    });
+
+    const hass = makeHass(
+      {},
+      {
+        connection: { sendMessagePromise } as any,
+      },
+    );
+    const { subscribe } = createMockSubscribe();
+
+    render(
+      <HAProvider hass={hass} subscribeToEntity={subscribe}>
+        <CalendarDisplay entityIds={['calendar.family']} start={start} end={end} />
+      </HAProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('events').textContent).toBe('calendar.family:Event');
+    });
+  });
+
+  it('handles fetch failure for one calendar gracefully', async () => {
+    const sendMessagePromise = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('Calendar offline'))
+      .mockResolvedValueOnce({
+        response: {
+          'calendar.work': {
+            events: [{ start: '2025-01-10', end: '2025-01-10', summary: 'Meeting' }],
+          },
+        },
+      });
+
+    // Suppress the expected console.error
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const hass = makeHass(
+      {},
+      {
+        connection: { sendMessagePromise } as any,
+      },
+    );
+    const { subscribe } = createMockSubscribe();
+
+    render(
+      <HAProvider hass={hass} subscribeToEntity={subscribe}>
+        <CalendarDisplay entityIds={['calendar.family', 'calendar.work']} start={start} end={end} />
+      </HAProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    // Should still get events from the working calendar
+    expect(screen.getByTestId('count').textContent).toBe('1');
+    expect(screen.getByTestId('events').textContent).toBe('calendar.work:Meeting');
+  });
+
+  it('returns empty array for empty entityIds', async () => {
+    const { subscribe } = createMockSubscribe();
+
+    render(
+      <HAProvider hass={makeHass()} subscribeToEntity={subscribe}>
+        <CalendarDisplay entityIds={[]} start={start} end={end} />
+      </HAProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('status').textContent).toBe('ready');
+    });
+
+    expect(screen.getByTestId('count').textContent).toBe('0');
+  });
+
+  it('refetches when entity changes (debounced)', async () => {
+    vi.useFakeTimers();
+
+    const sendMessagePromise = vi.fn().mockResolvedValue({
+      response: {
+        'calendar.family': {
+          events: [{ start: '2025-01-05', end: '2025-01-05', summary: 'Event' }],
+        },
+      },
+    });
+
+    const hass = makeHass(
+      {},
+      {
+        connection: { sendMessagePromise } as any,
+      },
+    );
+    const { subscribe, notify } = createMockSubscribe();
+
+    render(
+      <HAProvider hass={hass} subscribeToEntity={subscribe}>
+        <CalendarDisplay entityIds={['calendar.family']} start={start} end={end} />
+      </HAProvider>,
+    );
+
+    // Wait for initial fetch
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(100);
+    });
+
+    const initialCallCount = sendMessagePromise.mock.calls.length;
+
+    // Simulate entity change
+    act(() => {
+      notify('calendar.family', { state: 'on' });
+    });
+
+    // Not called yet (debounced)
+    expect(sendMessagePromise.mock.calls.length).toBe(initialCallCount);
+
+    // Advance past debounce
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(600);
+    });
+
+    expect(sendMessagePromise.mock.calls.length).toBeGreaterThan(initialCallCount);
+
+    vi.useRealTimers();
+  });
+});