chore: import upstream snapshot with attribution

apps/sim/lib/billing/organizations/provision-seat.test.ts

@@ -0,0 +1,247 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockGetOrganizationSubscription,
+  mockGetHighestPriorityPersonalSubscription,
+  mockEnsureOrganizationForTeamSubscription,
+  mockGetPlanByName,
+  enqueueMock,
+  updateCalls,
+} = vi.hoisted(() => ({
+  mockGetOrganizationSubscription: vi.fn(),
+  mockGetHighestPriorityPersonalSubscription: vi.fn(),
+  mockEnsureOrganizationForTeamSubscription: vi.fn(),
+  mockGetPlanByName: vi.fn(),
+  enqueueMock: vi.fn(),
+  updateCalls: { value: [] as Array<Record<string, unknown>> },
+}))
+
+vi.mock('@sim/db', () => {
+  const update = () => ({
+    set: (values: Record<string, unknown>) => {
+      updateCalls.value.push(values)
+      return { where: () => Promise.resolve([]) }
+    },
+  })
+  const txMock = { update }
+  const dbMock = {
+    update,
+    transaction: async (cb: (tx: typeof txMock) => Promise<unknown>) => cb(txMock),
+  }
+  return { db: dbMock }
+})
+
+vi.mock('@/lib/billing/core/billing', () => ({
+  getOrganizationSubscription: mockGetOrganizationSubscription,
+}))
+
+vi.mock('@/lib/billing/core/plan', () => ({
+  getHighestPriorityPersonalSubscription: mockGetHighestPriorityPersonalSubscription,
+}))
+
+vi.mock('@/lib/billing/organization', () => ({
+  ensureOrganizationForTeamSubscription: mockEnsureOrganizationForTeamSubscription,
+}))
+
+vi.mock('@/lib/billing/plans', () => ({
+  getPlanByName: mockGetPlanByName,
+}))
+
+vi.mock('@/lib/core/outbox/service', () => ({
+  enqueueOutboxEvent: enqueueMock,
+}))
+
+vi.mock('@/lib/billing/webhooks/outbox-handlers', () => ({
+  OUTBOX_EVENT_TYPES: {
+    STRIPE_SYNC_CANCEL_AT_PERIOD_END: 'stripe.sync-cancel-at-period-end',
+    STRIPE_SYNC_SUBSCRIPTION_SEATS: 'stripe.sync-subscription-seats',
+  },
+}))
+
+import { ensureTeamOrganizationForAcceptance } from '@/lib/billing/organizations/provision-seat'
+
+describe('ensureTeamOrganizationForAcceptance', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    updateCalls.value = []
+    mockGetPlanByName.mockReturnValue({
+      priceId: 'price_team_month',
+      annualDiscountPriceId: 'price_team_year',
+    })
+  })
+
+  it('is a no-op for enterprise organizations (fixed seats)', async () => {
+    mockGetOrganizationSubscription.mockResolvedValue({
+      id: 'sub-ent',
+      plan: 'enterprise',
+      status: 'active',
+      stripeSubscriptionId: 'stripe_sub',
+      seats: 5,
+    })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: 'org-1',
+    })
+
+    expect(result).toEqual({ success: true, organizationId: 'org-1', fixedSeats: true })
+    expect(updateCalls.value).toHaveLength(0)
+  })
+
+  it('is a no-op for an existing Team organization (org + plan already correct)', async () => {
+    mockGetOrganizationSubscription.mockResolvedValue({
+      id: 'sub-team',
+      plan: 'team_6000',
+      status: 'active',
+      seats: 1,
+      stripeSubscriptionId: 'stripe_sub',
+    })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: 'org-1',
+    })
+
+    expect(result).toEqual({ success: true, organizationId: 'org-1', fixedSeats: false })
+    expect(updateCalls.value).toHaveLength(0)
+  })
+
+  it('moves an org-scoped Pro subscription to the equivalent Team plan', async () => {
+    mockGetOrganizationSubscription.mockResolvedValue({
+      id: 'sub-pro',
+      plan: 'pro_6000',
+      status: 'active',
+      seats: 1,
+      stripeSubscriptionId: 'stripe_sub',
+    })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: 'org-1',
+    })
+
+    expect(result).toEqual({ success: true, organizationId: 'org-1', fixedSeats: false })
+    expect(updateCalls.value).toContainEqual(expect.objectContaining({ plan: 'team_6000' }))
+    // The Pro→Team price migration is durably enqueued at conversion time.
+    expect(enqueueMock).toHaveBeenCalledWith(
+      expect.anything(),
+      'stripe.sync-subscription-seats',
+      expect.objectContaining({ subscriptionId: 'sub-pro' })
+    )
+  })
+
+  it('returns upgrade-required when the personal owner has no usable subscription', async () => {
+    mockGetHighestPriorityPersonalSubscription.mockResolvedValue(null)
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: null,
+    })
+
+    expect(result).toEqual({ success: false, failureCode: 'upgrade-required' })
+    expect(mockEnsureOrganizationForTeamSubscription).not.toHaveBeenCalled()
+  })
+
+  it('converts a personal Pro subscription into a Team organization', async () => {
+    mockGetHighestPriorityPersonalSubscription.mockResolvedValue({
+      id: 'sub-pro',
+      plan: 'pro_6000',
+      status: 'active',
+      stripeSubscriptionId: 'stripe_sub',
+      cancelAtPeriodEnd: false,
+    })
+    mockEnsureOrganizationForTeamSubscription.mockResolvedValue({ referenceId: 'org-new' })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: null,
+    })
+
+    expect(result).toEqual({ success: true, organizationId: 'org-new', fixedSeats: false })
+    expect(updateCalls.value).toContainEqual(
+      expect.objectContaining({ plan: 'team_6000', cancelAtPeriodEnd: false })
+    )
+    expect(mockEnsureOrganizationForTeamSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({ plan: 'team_6000', referenceId: 'owner-1' })
+    )
+    // The plan change enqueues the price seat-sync...
+    expect(enqueueMock).toHaveBeenCalledWith(
+      expect.anything(),
+      'stripe.sync-subscription-seats',
+      expect.objectContaining({ subscriptionId: 'sub-pro' })
+    )
+    // ...but with no scheduled cancellation there is no cancel-sync event.
+    expect(enqueueMock).not.toHaveBeenCalledWith(
+      expect.anything(),
+      'stripe.sync-cancel-at-period-end',
+      expect.anything()
+    )
+  })
+
+  it('clears a scheduled cancellation when converting a Pro subscription', async () => {
+    mockGetHighestPriorityPersonalSubscription.mockResolvedValue({
+      id: 'sub-pro',
+      plan: 'pro_6000',
+      status: 'active',
+      stripeSubscriptionId: 'stripe_sub',
+      cancelAtPeriodEnd: true,
+    })
+    mockEnsureOrganizationForTeamSubscription.mockResolvedValue({ referenceId: 'org-new' })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: null,
+    })
+
+    expect(result.success).toBe(true)
+    expect(enqueueMock).toHaveBeenCalledWith(
+      expect.anything(),
+      'stripe.sync-cancel-at-period-end',
+      expect.objectContaining({ stripeSubscriptionId: 'stripe_sub', subscriptionId: 'sub-pro' })
+    )
+  })
+
+  it('provisions an org for a legacy personal-scoped Team subscription without a plan change', async () => {
+    mockGetHighestPriorityPersonalSubscription.mockResolvedValue({
+      id: 'sub-team',
+      plan: 'team',
+      status: 'active',
+      stripeSubscriptionId: 'stripe_sub',
+    })
+    mockEnsureOrganizationForTeamSubscription.mockResolvedValue({ referenceId: 'org-new' })
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: null,
+    })
+
+    expect(result).toEqual({ success: true, organizationId: 'org-new', fixedSeats: false })
+    expect(mockEnsureOrganizationForTeamSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({ plan: 'team', referenceId: 'owner-1' })
+    )
+    // No plan change and no scheduled cancellation: nothing to push to Stripe.
+    expect(enqueueMock).not.toHaveBeenCalled()
+  })
+
+  it('returns upgrade-required (no downgrade) when no eligible Team tier exists', async () => {
+    mockGetHighestPriorityPersonalSubscription.mockResolvedValue({
+      id: 'sub-max',
+      plan: 'pro_25000',
+      status: 'active',
+      stripeSubscriptionId: 'stripe_sub',
+    })
+    // Team Max price is unconfigured in this deployment.
+    mockGetPlanByName.mockReturnValue(undefined)
+
+    const result = await ensureTeamOrganizationForAcceptance({
+      billingOwnerUserId: 'owner-1',
+      workspaceOrganizationId: null,
+    })
+
+    expect(result).toEqual({ success: false, failureCode: 'upgrade-required' })
+    expect(mockEnsureOrganizationForTeamSubscription).not.toHaveBeenCalled()
+  })
+})