Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

7.3 KB
Raw Blame
import { describe, it, expect } from "vitest"
import {
  POLL_INTERVAL_MS, OFFLINE_THRESHOLD_MS, EVENT_POLL_INTERVAL_MS, AGENT_HANDLE_MIN_LENGTH,
  COMMUNITY_MACHINE_HEARTBEAT_MS, COMMUNITY_MACHINE_OFFLINE_THRESHOLD_MS,
  TaskStatus, TERMINAL_TASK_STATUSES, isTerminalTaskStatus,
  IssueStatus, ACTIVE_ISSUE_STATUSES, TERMINAL_ISSUE_STATUSES, isTerminalIssueStatus,
  MeetingStatus, TERMINAL_MEETING_STATUSES,
} from "../src/constants"
import {
  NOTIF_LEVELS, NOTIFICATION_LEVEL_VALUES, notifLevelDisplay, normalizeNotifLevel,
  PARTICIPANT_SOURCE, MENTION_KIND,
} from "../src/constants/community"
import { communityMention } from "../src/db/community-schema"

describe("constants", () => {
  it("OFFLINE_THRESHOLD_MS is 30s", () => expect(OFFLINE_THRESHOLD_MS).toBe(30_000))
  it("AGENT_HANDLE_MIN_LENGTH is 4", () => expect(AGENT_HANDLE_MIN_LENGTH).toBe(4))
  it("EVENT_POLL < POLL_INTERVAL", () => expect(EVENT_POLL_INTERVAL_MS).toBeLessThan(POLL_INTERVAL_MS))
  // Derived-pair invariant: the DO alarm re-arms on the heartbeat cadence and
  // only flips a machine offline after the offline threshold elapses, so the
  // heartbeat MUST be strictly less than the offline threshold or machines
  // flap offline at the heartbeat boundary.
  it("machine heartbeat < machine offline threshold", () =>
    expect(COMMUNITY_MACHINE_HEARTBEAT_MS).toBeLessThan(COMMUNITY_MACHINE_OFFLINE_THRESHOLD_MS))
  it("machine offline threshold is derived as 3× heartbeat", () =>
    expect(COMMUNITY_MACHINE_OFFLINE_THRESHOLD_MS).toBe(3 * COMMUNITY_MACHINE_HEARTBEAT_MS))
})

describe("TaskStatus", () => {
  it("includes superseded", () => {
    expect(TaskStatus.SUPERSEDED).toBe("superseded")
  })

  it("TERMINAL_TASK_STATUSES includes all terminal statuses", () => {
    expect(TERMINAL_TASK_STATUSES).toContain("completed")
    expect(TERMINAL_TASK_STATUSES).toContain("failed")
    expect(TERMINAL_TASK_STATUSES).toContain("cancelled")
    expect(TERMINAL_TASK_STATUSES).toContain("superseded")
  })

  it("TERMINAL_TASK_STATUSES does not include active statuses", () => {
    expect(TERMINAL_TASK_STATUSES).not.toContain("queued")
    expect(TERMINAL_TASK_STATUSES).not.toContain("dispatched")
    expect(TERMINAL_TASK_STATUSES).not.toContain("running")
  })

  it("isTerminalTaskStatus returns true for terminal statuses", () => {
    expect(isTerminalTaskStatus("completed")).toBe(true)
    expect(isTerminalTaskStatus("failed")).toBe(true)
    expect(isTerminalTaskStatus("cancelled")).toBe(true)
    expect(isTerminalTaskStatus("superseded")).toBe(true)
  })

  it("isTerminalTaskStatus returns false for active statuses", () => {
    expect(isTerminalTaskStatus("queued")).toBe(false)
    expect(isTerminalTaskStatus("dispatched")).toBe(false)
    expect(isTerminalTaskStatus("running")).toBe(false)
  })
})

describe("IssueStatus", () => {
  it("has all expected status values", () => {
    expect(IssueStatus.TODO).toBe("todo")
    expect(IssueStatus.IN_PROGRESS).toBe("in_progress")
    expect(IssueStatus.REVIEW).toBe("review")
    expect(IssueStatus.DONE).toBe("done")
    expect(IssueStatus.CLOSED).toBe("closed")
    expect(IssueStatus.CANCELED).toBe("canceled")
    expect(IssueStatus.FAILED).toBe("failed")
  })

  it("ACTIVE_ISSUE_STATUSES contains non-terminal statuses", () => {
    expect(ACTIVE_ISSUE_STATUSES).toContain("todo")
    expect(ACTIVE_ISSUE_STATUSES).toContain("in_progress")
    expect(ACTIVE_ISSUE_STATUSES).toContain("review")
    expect(ACTIVE_ISSUE_STATUSES).not.toContain("done")
  })

  it("TERMINAL_ISSUE_STATUSES contains terminal statuses", () => {
    expect(TERMINAL_ISSUE_STATUSES).toContain("done")
    expect(TERMINAL_ISSUE_STATUSES).toContain("closed")
    expect(TERMINAL_ISSUE_STATUSES).toContain("canceled")
    expect(TERMINAL_ISSUE_STATUSES).toContain("failed")
  })

  it("isTerminalIssueStatus returns true for terminal statuses", () => {
    expect(isTerminalIssueStatus("done")).toBe(true)
    expect(isTerminalIssueStatus("closed")).toBe(true)
    expect(isTerminalIssueStatus("canceled")).toBe(true)
    expect(isTerminalIssueStatus("failed")).toBe(true)
  })

  it("isTerminalIssueStatus returns false for active statuses", () => {
    expect(isTerminalIssueStatus("todo")).toBe(false)
    expect(isTerminalIssueStatus("in_progress")).toBe(false)
    expect(isTerminalIssueStatus("review")).toBe(false)
  })
})

describe("MeetingStatus", () => {
  it("has expected status values", () => {
    expect(MeetingStatus.PENDING).toBe("pending")
    expect(MeetingStatus.SCHEDULED).toBe("scheduled")
    expect(MeetingStatus.JOINING).toBe("joining")
    expect(MeetingStatus.RECORDING).toBe("recording")
    expect(MeetingStatus.COMPLETED).toBe("completed")
    expect(MeetingStatus.FAILED).toBe("failed")
  })

  it("TERMINAL_MEETING_STATUSES contains only completed and failed", () => {
    expect(TERMINAL_MEETING_STATUSES).toHaveLength(2)
    expect(TERMINAL_MEETING_STATUSES).toContain("completed")
    expect(TERMINAL_MEETING_STATUSES).toContain("failed")
  })
})

describe("notification-level bijection (single source)", () => {
  it("NOTIF_LEVELS values exactly match the DB enum NOTIFICATION_LEVEL_VALUES", () => {
    expect(NOTIF_LEVELS.map((l) => l.value)).toEqual([...NOTIFICATION_LEVEL_VALUES])
  })

  it("every level has a unique, non-empty display string (no drift/dupes)", () => {
    const displays = NOTIF_LEVELS.map((l) => l.display)
    expect(new Set(displays).size).toBe(displays.length)
    for (const d of displays) expect(d.length).toBeGreaterThan(0)
  })

  it("notifLevelDisplay maps each value to its display; unknown passes through", () => {
    expect(notifLevelDisplay("all")).toBe("All Messages")
    expect(notifLevelDisplay("mentions")).toBe("Only @mentions")
    expect(notifLevelDisplay("nothing")).toBe("Nothing")
    expect(notifLevelDisplay("bogus")).toBe("bogus")
  })

  it("normalizeNotifLevel round-trips display→value and value→value", () => {
    for (const l of NOTIF_LEVELS) {
      expect(normalizeNotifLevel(l.display)).toBe(l.value) // display → value
      expect(normalizeNotifLevel(l.value)).toBe(l.value)   // value → value (idempotent)
    }
  })

  it("normalizeNotifLevel/notifLevelDisplay are inverse for every level", () => {
    for (const l of NOTIF_LEVELS) {
      expect(normalizeNotifLevel(notifLevelDisplay(l.value))).toBe(l.value)
    }
  })

  it("normalizeNotifLevel falls back to 'all' (fail-open, NOT the old silent 'mentions' mute) on unknown input", () => {
    expect(normalizeNotifLevel("totally unknown")).toBe("all")
  })
})

describe("PARTICIPANT_SOURCE / MENTION_KIND (single source)", () => {
  it("PARTICIPANT_SOURCE carries the three participant-source values", () => {
    expect(PARTICIPANT_SOURCE.MENTION).toBe("mention")
    expect(PARTICIPANT_SOURCE.SPOKE).toBe("spoke")
    expect(PARTICIPANT_SOURCE.ADDED).toBe("added")
  })

  it("MENTION_KIND carries the two mention-kind values", () => {
    expect(MENTION_KIND.MENTION).toBe("mention")
    expect(MENTION_KIND.REPLY).toBe("reply")
  })

  // Guard against drift between the drizzle column defaults (which MUST be
  // literals in the schema) and the shared constants that now anchor them —
  // drizzle exposes the compiled default on the column object.
  it("community_mention.kind DB default equals MENTION_KIND.MENTION", () => {
    expect((communityMention.kind as { default?: unknown }).default).toBe(MENTION_KIND.MENTION)
  })

})