Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

4.0 KB
Raw Blame
// @vitest-environment jsdom
// PR #7031: unit/jsdom coverage through the real hook. Existing service tests cannot
// catch renderer results surviving an engine/connection change or a disabled query.
import { act, cleanup, renderHook } from '@testing-library/react';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import type { AgentKind, ProviderView } from '@cindy/model-providers';
import type { ProviderAccountUsageResult } from '../../../shared/providerAccountUsage';
import { useProviderAccountUsage } from '../useProviderAccountUsage';

const provider = {
  id: 'deepseek',
  auth: { method: 'apiKey' },
  routing: {
    'claude-code': { upstream: 'https://api.deepseek.com/anthropic' },
    pi: { upstream: 'https://api.deepseek.com' },
  },
} as ProviderView;
const ready: ProviderAccountUsageResult = {
  status: 'ready',
  stale: false,
  agent: 'claude-code',
  snapshot: {
    kind: 'deepseek-balance',
    isAvailable: true,
    fetchedAt: 1,
    balances: [
      { currency: 'CNY', totalBalance: '123', grantedBalance: '0', toppedUpBalance: '123' },
    ],
  },
};
const fetchUsage = vi.fn<() => Promise<ProviderAccountUsageResult>>();

beforeEach(() => {
  vi.useFakeTimers();
  fetchUsage.mockReset();
  Object.defineProperty(window, 'electronAPI', {
    configurable: true,
    value: { maker: { fetchProviderAccountUsage: fetchUsage } },
  });
});
afterEach(() => {
  cleanup();
  vi.useRealTimers();
});

it.each([
  { name: 'engine', nextProvider: provider, nextAgent: 'pi' as AgentKind },
  {
    name: 'connection',
    nextProvider: { ...provider, id: 'deepseek-b' },
    nextAgent: 'claude-code' as AgentKind,
  },
  {
    name: 'route',
    nextProvider: {
      ...provider,
      routing: {
        ...provider.routing,
        'claude-code': {
          ...provider.routing['claude-code']!,
          upstream: 'https://api.deepseek.com/v1',
        },
      },
    },
    nextAgent: 'claude-code' as AgentKind,
  },
])('hides the old account while the new $name is loading', async ({ nextProvider, nextAgent }) => {
  let resolveNext!: (result: ProviderAccountUsageResult) => void;
  fetchUsage.mockResolvedValueOnce(ready).mockImplementationOnce(
    () =>
      new Promise((resolve) => {
        resolveNext = resolve;
      }),
  );
  const hook = renderHook(({ source, agent }) => useProviderAccountUsage(source, agent), {
    initialProps: { source: provider, agent: 'claude-code' as AgentKind },
  });
  await act(async () => {});
  expect(hook.result.current.result).toEqual(ready);
  hook.rerender({ source: nextProvider, agent: nextAgent });
  expect(hook.result.current.result).toBeNull();
  await act(async () => resolveNext({ status: 'unavailable', error: 'auth' }));
  expect(hook.result.current.result).toEqual({ status: 'unavailable', error: 'auth' });
});

it('supports the official Zhipu Anthropic upstream with a trailing slash and fetches usage', async () => {
  const zhipuProvider = {
    ...provider,
    id: 'custom-zhipu',
    routing: { 'claude-code': { upstream: 'https://open.bigmodel.cn/api/anthropic/' } },
  } as ProviderView;
  fetchUsage.mockResolvedValueOnce(ready);
  const hook = renderHook(() => useProviderAccountUsage(zhipuProvider, 'claude-code'));
  await act(async () => {});
  expect(hook.result.current.supported).toBe(true);
  expect(fetchUsage).toHaveBeenCalledWith({
    providerId: 'custom-zhipu',
    forceRefresh: false,
    agent: 'claude-code',
  });
});

it('discards a pending result after the query becomes unsupported', async () => {
  let resolvePending!: (result: ProviderAccountUsageResult) => void;
  fetchUsage.mockImplementationOnce(
    () =>
      new Promise((resolve) => {
        resolvePending = resolve;
      }),
  );
  const hook = renderHook(({ source }) => useProviderAccountUsage(source, 'pi'), {
    initialProps: { source: provider as ProviderView | undefined },
  });
  hook.rerender({ source: undefined });
  await act(async () => resolvePending(ready));
  expect(hook.result.current.supported).toBe(false);
  expect(hook.result.current.result).toBeNull();
  expect(hook.result.current.busy).toBe(false);
});