Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

10.2 KB
Raw Blame
/**
 * @vitest-environment jsdom
 */

import { ThrownResultError } from '@core/util/result';
import { createSignal, type JSX } from 'solid-js';
import { render } from 'solid-js/web';
import { afterEach, describe, expect, it, vi } from 'vitest';

vi.mock('./AccessErrorViews/Gone', () => ({
  default: () => <div>Gone</div>,
}));
vi.mock('./AccessErrorViews/NotFound', () => ({
  default: () => <div>Not found</div>,
}));
vi.mock('./AccessErrorViews/Unauthorized', () => ({
  default: () => <div>Unauthorized</div>,
}));
vi.mock('./LoadingBlock', () => ({
  LoadingBlock: () => <div>Loading</div>,
}));

// A real signal so components reacting to connectivity changes re-run.
const network = vi.hoisted(() => ({
  set: (_status: 'unknown' | 'online' | 'offline') => {},
}));
vi.mock('@core/mobile/native-network-status', async () => {
  const { createSignal } = await import('solid-js');
  const [status, setStatus] = createSignal<'unknown' | 'online' | 'offline'>(
    'unknown'
  );
  network.set = setStatus;
  return { nativeNetworkStatus: status };
});

import {
  type EntityLoadErrorCode,
  EntityLoadGate,
  type EntityLoadResult,
  toEntityLoadError,
} from './EntityLoadGate';

let dispose: (() => void) | undefined;

function renderGate<Data>(
  result: EntityLoadResult<Data>,
  loadingFallback?: JSX.Element
): HTMLElement {
  const container = document.createElement('div');
  document.body.appendChild(container);
  const disposeRender = render(
    () => (
      <EntityLoadGate result={result} loadingFallback={loadingFallback}>
        <div>Loaded</div>
      </EntityLoadGate>
    ),
    container
  );
  dispose = () => {
    disposeRender();
    container.remove();
  };
  return container;
}

afterEach(() => {
  dispose?.();
  dispose = undefined;
  network.set('unknown');
  vi.useRealTimers();
});

describe('EntityLoadGate', () => {
  it('uses the conversation placeholder while pending without masking access failures', () => {
    const [pending, setPending] = createSignal(true);
    const [error, setError] = createSignal<EntityLoadErrorCode>();
    const container = renderGate(
      {
        data: () => undefined,
        error,
        isPending: pending,
      },
      <div>Conversation placeholder</div>
    );
    expect(container.textContent).toBe('Conversation placeholder');
    setPending(false);
    setError('FORBIDDEN');
    expect(container.textContent).toBe('Unauthorized');
  });

  it('renders its child after data loads', () => {
    const container = renderGate({
      data: () => 'channel data',
      error: () => undefined,
      isPending: () => false,
    });

    expect(container.textContent).toBe('Loaded');
  });

  it.each([
    { label: 'zero', data: 0 },
    { label: 'false', data: false },
    { label: 'an empty string', data: '' },
  ])('renders its child when data is $label', ({ data }) => {
    const container = renderGate({
      data: () => data,
      error: () => undefined,
      isPending: () => false,
    });

    expect(container.textContent).toBe('Loaded');
  });

  it('does not mount its child while data is pending', () => {
    let childMounted = false;
    const Child = () => {
      childMounted = true;
      return <div>Loaded</div>;
    };
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => undefined,
            isPending: () => true,
          }}
        >
          <Child />
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    expect(childMounted).toBe(false);
    expect(container.textContent).toBe('Loading');
  });

  it('renders loading while data is pending', () => {
    const container = renderGate({
      data: () => undefined,
      error: () => undefined,
      isPending: () => true,
    });

    expect(container.textContent).toBe('Loading');
  });

  it.each<readonly [EntityLoadErrorCode, string]>([
    ['UNAUTHORIZED', 'Unauthorized'],
    ['FORBIDDEN', 'Unauthorized'],
    ['NOT_FOUND', 'Not found'],
    ['GONE', 'Gone'],
  ])('renders the gated view for %s', (code, expected) => {
    const container = renderGate({
      data: () => undefined,
      error: () => code,
      isPending: () => false,
    });

    expect(container.textContent).toBe(expected);
  });

  it('renders the retryable load-error state for other failures', () => {
    const container = renderGate({
      data: () => undefined,
      error: () => 'LOAD_FAILED',
      isPending: () => false,
    });

    expect(container.textContent).toContain('Unable to load this view');
    expect(container.textContent).toContain(
      'Check your internet connection and try again.'
    );
  });

  it('renders loaded content over a LOAD_FAILED error', () => {
    const container = renderGate({
      data: () => 'cached entity',
      error: () => 'LOAD_FAILED',
      isPending: () => false,
    });

    expect(container.textContent).toBe('Loaded');
  });

  it('renders the structural error view even over loaded content', () => {
    const container = renderGate({
      data: () => 'cached entity',
      error: () => 'UNAUTHORIZED',
      isPending: () => false,
    });

    expect(container.textContent).toBe('Unauthorized');
  });

  it('renders the retryable load-error state when offline with nothing to show', () => {
    network.set('offline');
    const container = renderGate({
      data: () => undefined,
      error: () => undefined,
      isPending: () => true,
    });

    expect(container.textContent).toContain('Unable to load this view');
  });

  it('renders loaded content while offline', () => {
    network.set('offline');
    const container = renderGate({
      data: () => 'cached entity',
      error: () => undefined,
      isPending: () => false,
    });

    expect(container.textContent).toBe('Loaded');
  });

  it('hides the Retry action while the device is offline', () => {
    network.set('offline');
    const onRetry = vi.fn();
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => 'LOAD_FAILED',
            isPending: () => false,
          }}
          onRetry={onRetry}
        >
          <div>Loaded</div>
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    expect(container.textContent).toContain('Unable to load this view');
    expect(container.querySelector('button')).toBeNull();

    network.set('online');
    expect(container.querySelector('button')?.textContent).toContain('Retry');
  });

  it('auto-retries shortly after connectivity returns', () => {
    vi.useFakeTimers();
    network.set('offline');
    const onRetry = vi.fn();
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => 'LOAD_FAILED',
            isPending: () => false,
          }}
          onRetry={onRetry}
        >
          <div>Loaded</div>
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    network.set('online');
    expect(onRetry).not.toHaveBeenCalled();
    vi.advanceTimersByTime(2_000);
    expect(onRetry).toHaveBeenCalledOnce();
  });

  it('does not auto-retry when mounted while already online', () => {
    vi.useFakeTimers();
    network.set('online');
    const onRetry = vi.fn();
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => 'LOAD_FAILED',
            isPending: () => false,
          }}
          onRetry={onRetry}
        >
          <div>Loaded</div>
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    vi.advanceTimersByTime(10_000);
    expect(onRetry).not.toHaveBeenCalled();
  });

  it('cancels the pending auto-retry when connectivity drops again', () => {
    vi.useFakeTimers();
    network.set('offline');
    const onRetry = vi.fn();
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => 'LOAD_FAILED',
            isPending: () => false,
          }}
          onRetry={onRetry}
        >
          <div>Loaded</div>
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    network.set('online');
    vi.advanceTimersByTime(1_000);
    network.set('offline');
    vi.advanceTimersByTime(10_000);
    expect(onRetry).not.toHaveBeenCalled();
  });

  it('invokes onRetry from the load-error state', () => {
    const onRetry = vi.fn();
    const container = document.createElement('div');
    document.body.appendChild(container);
    const disposeRender = render(
      () => (
        <EntityLoadGate
          result={{
            data: () => undefined,
            error: () => 'LOAD_FAILED',
            isPending: () => false,
          }}
          onRetry={onRetry}
        >
          <div>Loaded</div>
        </EntityLoadGate>
      ),
      container
    );
    dispose = () => {
      disposeRender();
      container.remove();
    };

    const retryButton = container.querySelector('button');
    expect(retryButton?.textContent).toContain('Retry');
    retryButton?.click();
    expect(onRetry).toHaveBeenCalledOnce();
  });

  it('normalizes query errors into gate errors', () => {
    expect(
      toEntityLoadError(
        new ThrownResultError([
          { code: 'NOT_FOUND', message: 'entity load failed' },
        ])
      )
    ).toBe('NOT_FOUND');
    expect(toEntityLoadError(new Error('network unavailable'))).toBe(
      'LOAD_FAILED'
    );
  });
});