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.

5.0 KB
Raw Blame
import { Model } from '@core/component/AI/constant';
import { storeChatStateImmediate } from '@core/component/AI/util/storage';
import { cleanup, render } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { ChatProviderIcon } from './ChatProviderIcon';

vi.hoisted(() => {
  const storage = new Map<string, string>();
  Object.defineProperty(globalThis, 'localStorage', {
    configurable: true,
    value: {
      getItem: (key: string) => storage.get(key) ?? null,
      setItem: (key: string, value: string) => storage.set(key, value),
      removeItem: (key: string) => storage.delete(key),
    },
  });
});
vi.mock('@core/component/EntityIcon', () => ({
  EntityIcon: (props: { targetType: string }) => (
    <svg data-entity-type={props.targetType} />
  ),
}));
afterEach(cleanup);

describe('soup chat provider selection', () => {
  it('reacts to soup model updates without a query provider', () => {
    const [model, setModel] = createSignal<string>();
    const { container } = render(() => (
      <ChatProviderIcon id="soup-updates" model={model()} />
    ));
    expect(container.querySelector('[data-entity-type="chat"]')).not.toBeNull();
    setModel(Model.gpt56);
    expect(
      container.querySelector('[data-ai-provider="openai"]')
    ).not.toBeNull();
    setModel(Model.sonnet55);
    expect(
      container.querySelector('[data-ai-provider="anthropic"]')
    ).not.toBeNull();
    expect(container.querySelector('[data-entity-type="chat"]')).toBeNull();
  });

  it('uses a saved selection without a saved soup model', async () => {
    storeChatStateImmediate('draft-only', { model: Model.sonnet55 });
    const { container } = render(() => <ChatProviderIcon id="draft-only" />);
    expect(
      container.querySelector('[data-ai-provider="anthropic"]')
    ).not.toBeNull();
  });

  it.each(['openai/gpt-5.5', 'gpt-5.5', 'gpt-4o'])(
    'keeps the OpenAI logo for historical server model %s',
    (model) => {
      const { container } = render(() => (
        <ChatProviderIcon id={`unsupported-model-${model}`} model={model} />
      ));
      expect(
        container.querySelector('[data-ai-provider="openai"] svg')
      ).not.toBeNull();
      expect(
        container.querySelector('[data-ai-provider="anthropic"]')
      ).toBeNull();
    }
  );

  it('preserves a historical stored provider when server metadata is missing or still has the default', () => {
    storeChatStateImmediate('historical-draft', {
      model: 'openai/gpt-5.5' as Model,
    });
    const [model, setModel] = createSignal<string>();
    const { container } = render(() => (
      <ChatProviderIcon id="historical-draft" model={model()} />
    ));
    expect(
      container.querySelector('[data-ai-provider="openai"] svg')
    ).not.toBeNull();
    setModel(Model.sonnet55);
    expect(
      container.querySelector('[data-ai-provider="openai"] svg')
    ).not.toBeNull();
  });

  it('keeps supported OpenAI and Anthropic chats distinct', async () => {
    const { container } = render(() => (
      <>
        <ChatProviderIcon id="openai-chat" model={Model.gpt56} />
        <ChatProviderIcon id="anthropic-chat" model={Model.opus55} />
      </>
    ));
    expect(
      Array.from(container.querySelectorAll('[data-ai-provider]'), (el) =>
        el.getAttribute('data-ai-provider')
      )
    ).toEqual(['openai', 'anthropic']);
  });

  it.each([undefined, 'retired-model' as Model])(
    'uses the soup model when a draft has no valid model (%s)',
    async (model) => {
      const id = `draft-with-${model}`;
      storeChatStateImmediate(id, { input: 'draft', model });
      const { container } = render(() => (
        <ChatProviderIcon id={id} model={Model.gpt56} />
      ));
      await vi.waitFor(() =>
        expect(
          container.querySelector('[data-ai-provider="openai"]')
        ).not.toBeNull()
      );
    }
  );

  it('reacts to per-chat selections without changing another row', () => {
    const { container } = render(() => (
      <>
        <ChatProviderIcon id="selected-chat" model={Model.gpt56} />
        <ChatProviderIcon id="other-chat" model={Model.gpt56} />
      </>
    ));
    storeChatStateImmediate('selected-chat', { model: Model.sonnet55 });
    expect(
      Array.from(container.querySelectorAll('[data-ai-provider]'), (el) =>
        el.getAttribute('data-ai-provider')
      )
    ).toEqual(['anthropic', 'openai']);
    storeChatStateImmediate('selected-chat', { model: Model.gpt56 });
    expect(
      container.querySelector('[data-ai-provider="anthropic"]')
    ).toBeNull();
  });

  it.each([undefined, null, '', 'unknown-provider/model'])(
    'shows the standard chat icon when the model is %s',
    async (model) => {
      const { container } = render(() => (
        <ChatProviderIcon id="unloaded-chat" model={model} />
      ));
      expect(container.querySelector('[data-ai-provider]')).toBeNull();
      expect(
        container.querySelector('[data-entity-type="chat"]')
      ).not.toBeNull();
    }
  );
});