Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

8.0 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import {
  hasPositiveHostedReviewNumberLink,
  hasResolvableHostedReviewPushTargetLink,
  hasUsableHostedReviewPushTarget,
  resolveHostedReviewActionUpstreamStatus,
  resolveHostedReviewStateForActions
} from './hosted-review-push-target'

const unrelatedUpstream = {
  hasUpstream: true,
  upstreamName: 'origin/helper-branch',
  ahead: 1,
  behind: 0
}

describe('resolveHostedReviewActionUpstreamStatus', () => {
  it('blocks action status from using a local upstream while linked review state is loading', () => {
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: false,
        hostedReviewState: null,
        isHostedReviewStateLoading: true,
        canUseHostedReviewPushTarget: false,
        upstreamStatus: unrelatedUpstream
      })
    ).toEqual({ hasUpstream: false, ahead: 0, behind: 0 })
  })

  it('blocks action status from using a local upstream for open reviews without a target', () => {
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: false,
        hostedReviewState: 'open',
        isHostedReviewStateLoading: false,
        canUseHostedReviewPushTarget: false,
        upstreamStatus: unrelatedUpstream
      })
    ).toEqual({ hasUpstream: false, ahead: 0, behind: 0 })
  })

  it('blocks explicit linked review metadata even when review state is unavailable', () => {
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: true,
        hostedReviewState: null,
        isHostedReviewStateLoading: false,
        canUseHostedReviewPushTarget: false,
        upstreamStatus: unrelatedUpstream
      })
    ).toEqual({ hasUpstream: false, ahead: 0, behind: 0 })
  })

  it('does not block unknown-state review links when no target lookup exists', () => {
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: false,
        hostedReviewState: null,
        isHostedReviewStateLoading: false,
        canUseHostedReviewPushTarget: false,
        upstreamStatus: unrelatedUpstream
      })
    ).toBe(unrelatedUpstream)
  })

  it('does not alter status for closed reviews', () => {
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: true,
        hostedReviewState: 'closed',
        isHostedReviewStateLoading: false,
        canUseHostedReviewPushTarget: false,
        upstreamStatus: unrelatedUpstream
      })
    ).toBe(unrelatedUpstream)
  })
})

describe('hasResolvableHostedReviewPushTargetLink', () => {
  it('accepts only hosted-review links with supported target lookup APIs', () => {
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitHubPR: 12 })).toBe(true)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitLabMR: 34 })).toBe(true)
    // Why: a queue-discovered same-repo PR (no persisted linkedPR) is resolvable.
    expect(hasResolvableHostedReviewPushTargetLink({ fallbackGitHubPR: 8333 })).toBe(true)
    expect(
      hasResolvableHostedReviewPushTargetLink({ linkedGitHubPR: null, fallbackGitHubPR: 8333 })
    ).toBe(true)
    expect(hasResolvableHostedReviewPushTargetLink({ fallbackGitHubPR: 0 })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitHubPR: null })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitHubPR: 0 })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitLabMR: -1 })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitLabMR: 1.5 })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({ linkedGitHubPR: Number.NaN })).toBe(false)
    expect(hasResolvableHostedReviewPushTargetLink({})).toBe(false)
  })
})

describe('hasPositiveHostedReviewNumberLink', () => {
  it('blocks resolver-less providers without treating them as resolvable', () => {
    // Providers without resolvers still block unsafe pushes; keep resolvable links a strict subset of positive links.
    for (const provider of ['linkedBitbucketPR', 'linkedAzureDevOpsPR', 'linkedGiteaPR'] as const) {
      const args = { [provider]: 42 }
      expect(hasPositiveHostedReviewNumberLink(args)).toBe(true)
      expect(hasResolvableHostedReviewPushTargetLink(args)).toBe(false)
    }
  })
})

describe('resolveHostedReviewStateForActions', () => {
  it('treats explicit linked review metadata as open when live state is unavailable', () => {
    expect(
      resolveHostedReviewStateForActions({
        hostedReviewState: null,
        hasResolvableHostedReviewPushTargetLink: true
      })
    ).toBe('open')
  })
})

describe('hasUsableHostedReviewPushTarget', () => {
  it('accepts either persisted target metadata or branch-configured push metadata', () => {
    expect(
      hasUsableHostedReviewPushTarget({
        pushTarget: { remoteName: 'fork', branchName: 'feature' }
      })
    ).toBe(true)
    expect(
      hasUsableHostedReviewPushTarget({
        pushTarget: { remoteName: 'fork', branchName: 'feature' },
        upstreamStatus: {
          hasUpstream: true,
          upstreamName: 'fork/feature',
          ahead: 1,
          behind: 0
        }
      })
    ).toBe(true)
    expect(
      hasUsableHostedReviewPushTarget({
        upstreamStatus: {
          hasUpstream: false,
          ahead: 0,
          behind: 0,
          hasConfiguredPushTarget: true
        }
      })
    ).toBe(true)
    expect(
      hasUsableHostedReviewPushTarget({
        hasResolvableHostedReviewPushTargetLink: true,
        upstreamStatus: {
          hasUpstream: false,
          ahead: 0,
          behind: 0,
          hasConfiguredPushTarget: true
        }
      })
    ).toBe(false)
    expect(
      hasUsableHostedReviewPushTarget({
        pushTarget: { remoteName: 'fork', branchName: 'feature' },
        upstreamStatus: unrelatedUpstream
      })
    ).toBe(false)
    expect(hasUsableHostedReviewPushTarget({ upstreamStatus: unrelatedUpstream })).toBe(false)
  })

  it('keeps blocking a review whose upstream tracks an unrelated fork/helper head', () => {
    expect(
      hasUsableHostedReviewPushTarget({
        hasResolvableHostedReviewPushTargetLink: true,
        branchName: 'feature',
        upstreamStatus: unrelatedUpstream
      })
    ).toBe(false)
  })

  it('keeps blocking a resolvable review with no real upstream', () => {
    expect(
      hasUsableHostedReviewPushTarget({
        hasResolvableHostedReviewPushTargetLink: true,
        branchName: 'feature',
        upstreamStatus: { hasUpstream: false, ahead: 0, behind: 0 }
      })
    ).toBe(false)
  })
})

describe('resolveHostedReviewActionUpstreamStatus with a same-repo upstream', () => {
  it('does not block push for a queue-discovered open PR whose upstream tracks the branch', () => {
    // Queue-discovered PRs lack persisted links but still resolve matching upstream targets; missing that wrongly disabled Push.
    const realUpstream = {
      hasUpstream: true,
      upstreamName: 'origin/fix-f1-codex-wsl-path-trust',
      ahead: 1,
      behind: 0
    }
    const hasResolvable = hasResolvableHostedReviewPushTargetLink({
      linkedGitHubPR: null,
      fallbackGitHubPR: 8333,
      linkedGitLabMR: null
    })
    expect(hasResolvable).toBe(true)
    const canUseHostedReviewPushTarget = hasUsableHostedReviewPushTarget({
      hasResolvableHostedReviewPushTargetLink: hasResolvable,
      branchName: 'fix-f1-codex-wsl-path-trust',
      upstreamStatus: realUpstream
    })
    expect(canUseHostedReviewPushTarget).toBe(true)
    expect(
      resolveHostedReviewActionUpstreamStatus({
        hasHostedReviewLink: true,
        hasResolvableHostedReviewPushTargetLink: hasResolvable,
        hostedReviewState: 'open',
        isHostedReviewStateLoading: false,
        canUseHostedReviewPushTarget,
        upstreamStatus: realUpstream
      })
    ).toBe(realUpstream)
  })
})