Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

4.9 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'

const planDb = vi.hoisted(() => ({
  upsert: vi.fn(),
  findMany: vi.fn(),
  updateMany: vi.fn(),
  update: vi.fn(),
}))
const fetchPlans = vi.hoisted(() => vi.fn())

vi.mock('../../config/env.js', () => ({
  env: {
    HARNESS_BILLING_ENABLED: true,
    HARNESS_CAMPAIGN_CODE: 'ai-harness-device',
    AUTONOMOUS_BFF_URL: 'https://apiv2.autonomous.ai',
  },
}))
vi.mock('../autonomousBff.js', () => ({ fetchCampaignPlans: fetchPlans }))
vi.mock('../prisma.js', () => ({ prisma: { subscriptionPlan: planDb } }))
vi.mock('../../utils/logger.js', () => ({ logger: { info: vi.fn(), warn: vi.fn() } }))

import { ensurePlansForEnvironment } from './seed.js'

describe('campaign catalog cache isolation', () => {
  beforeEach(() => {
    vi.clearAllMocks()
    planDb.upsert.mockResolvedValue({})
    planDb.updateMany.mockResolvedValue({ count: 0 })
    planDb.update.mockResolvedValue({})
    fetchPlans.mockResolvedValue([])
  })

  it('hides staging cached plans when the production catalog cannot be refreshed', async () => {
    planDb.findMany.mockResolvedValue([
      { name: 'Free', available: true, externalPlanId: 37, campaignCode: 'ai-harness-device', catalogSource: 'https://apiv2.staging.autonomousdev.xyz' },
      { name: 'Pro', available: true, externalPlanId: 38, campaignCode: 'ai-harness-device', catalogSource: 'https://apiv2.staging.autonomousdev.xyz' },
      { name: 'Max', available: true, externalPlanId: 39, campaignCode: 'ai-harness-device', catalogSource: 'https://apiv2.staging.autonomousdev.xyz' },
      { name: 'Remote', available: true, externalPlanId: 40, campaignCode: 'ai-harness-device', catalogSource: 'https://apiv2.staging.autonomousdev.xyz' },
      { name: 'Provider', available: true, externalPlanId: 45, campaignCode: 'ai-harness-device', catalogSource: 'https://apiv2.staging.autonomousdev.xyz' },
    ])

    await ensurePlansForEnvironment('prod')

    expect(planDb.updateMany).toHaveBeenCalledWith({
      where: { autonomousEnv: 'prod', name: { in: ['Free', 'Pro', 'Max', 'Remote', 'Provider'] } },
      data: { available: false, isDefault: false },
    })
    expect(planDb.update).not.toHaveBeenCalled()
  })

  /** The live catalog, verified 2026-08-04: five tiers, Provider at $10/month (prod plan_id 45). */
  const FULL_CATALOG = [
    { code: 'free', id: 41, amount: 0, currency: 'USD', name: 'Free', metadata: {} },
    { code: 'pro', id: 42, amount: 20, currency: 'USD', name: 'Pro', metadata: {} },
    { code: 'max', id: 43, amount: 100, currency: 'USD', name: 'Max', metadata: {} },
    { code: 'remote', id: 44, amount: 10, currency: 'USD', name: 'Remote', metadata: {} },
    { code: 'provider', id: 45, amount: 10, currency: 'USD', name: 'Provider', metadata: {} },
  ]

  it('synchronizes Remote only when the same environment returns the complete catalog', async () => {
    fetchPlans.mockResolvedValue(FULL_CATALOG)

    await ensurePlansForEnvironment('prod')

    expect(planDb.upsert).toHaveBeenCalledWith(expect.objectContaining({
      where: { autonomousEnv_name: { autonomousEnv: 'prod', name: 'Remote' } },
      update: expect.objectContaining({
        authMode: 'remote',
        priceUsd: 10,
        dailyVoiceLimitSeconds: 3600,
        externalPlanId: 44,
        available: true,
      }),
    }))
    expect(planDb.update).toHaveBeenCalledWith({
      where: { autonomousEnv_name: { autonomousEnv: 'prod', name: 'Free' } },
      data: { isDefault: true },
    })
  })

  it('synchronizes Provider with its upstream plan id', async () => {
    fetchPlans.mockResolvedValue(FULL_CATALOG)

    await ensurePlansForEnvironment('prod')

    expect(planDb.upsert).toHaveBeenCalledWith(expect.objectContaining({
      where: { autonomousEnv_name: { autonomousEnv: 'prod', name: 'Provider' } },
      update: expect.objectContaining({ authMode: 'provider', priceUsd: 10, externalPlanId: 45, available: true }),
    }))
  })

  it('refuses the WHOLE catalog when one tier price disagrees with upstream', async () => {
    // The trap this guards: `completeCatalog` validates every tier's price, so a local price that
    // drifts from upstream does not disable one plan — it silently takes Free/Pro/Max/Remote down
    // with it, falling back to cache or hiding everything.
    fetchPlans.mockResolvedValue(FULL_CATALOG.map((p) => (p.code === 'provider' ? { ...p, amount: 20 } : p)))
    planDb.findMany.mockResolvedValue([]) // no cache, so the hide path runs

    await ensurePlansForEnvironment('prod')

    expect(planDb.upsert).not.toHaveBeenCalledWith(expect.objectContaining({
      where: { autonomousEnv_name: { autonomousEnv: 'prod', name: 'Remote' } },
      update: expect.objectContaining({ available: true }),
    }))
    expect(planDb.updateMany).toHaveBeenCalledWith({
      where: { autonomousEnv: 'prod', name: { in: ['Free', 'Pro', 'Max', 'Remote', 'Provider'] } },
      data: { available: false, isDefault: false },
    })
  })
})