Retention deletes the history your app treats as storage

"""Measure how far back this workspace's history actually goes.

Read only. conversations.list, conversations.history, files.list and auth.test
are reads; nothing here writes, deletes or downloads anything, and no file
bytes and no url_private are ever fetched.

Retention policies delete messages and files on a schedule that no API reports.
There is no field to query and no error to catch: content stops existing, and
history calls answer ok with an empty array. So the policy is measured from its
effect, by asking about progressively older windows until the answers stop, and
the finding is an age in days.

The trap is that a quiet channel is also empty. That is why nothing here draws
a conclusion from one channel.
"""
import argparse
import logging
import os
import sys
import time

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("slack_retention_horizon")

API = "https://slack.com/api/"
DAY = 86400

# Ages to probe, in days, newest first. A ladder rather than a bisection: the
# same six reads, and every intermediate answer stays meaningful when the shape
# turns out to be ragged rather than a clean edge.
LADDER = (30, 60, 90, 180, 365, 730)

# The round numbers retention settings are actually set to. A measurement of 88
# days is a 90 day policy, and saying so is what makes the finding actionable.
POLICY_VALUES = (30, 60, 90, 180, 365)


def probe_windows(now, ladder=LADDER, span_days=7):
    """The windows to ask about. Pure. Returns [(age_days, oldest, latest), ...].

    A window rather than an open-ended oldest, because "everything since two
    years ago" returns the most recent page and tells you nothing about two
    years ago. A week is wide enough that an active channel has something in it
    and narrow enough that the edge stays sharp.
    """
    try:
        base = int(now)
    except (TypeError, ValueError):
        return []
    out = []
    for age in sorted({int(a) for a in ladder if int(a) > 0}):
        oldest = base - age * DAY
        out.append((age, oldest, oldest + span_days * DAY))
    return out


def horizon(probes):
    """Where does the history stop? Pure. Returns (verdict, boundary_days, detail).

    probes is [(age_days, count), ...] in any order. Five outcomes and only one
    of them is a finding:

      boundary     results at some ages and none beyond a point. The edge.
      no-boundary  results at every age probed, so nothing was found in range.
      silent       nothing at any age, including the newest. The channel is
                   quiet and this probe has decided precisely nothing.
      ragged       history reappears past an empty window. Retention is
                   monotonic, so this is a quiet stretch and evidence against a
                   horizon rather than noise inside one.
      undecidable  fewer than two probes to compare.
    """
    rows = sorted((int(a), int(c)) for a, c in (probes or []))
    if len(rows) < 2:
        return ("undecidable", 0, "at least two ages are needed to find an edge")
    if all(c <= 0 for _a, c in rows):
        return ("silent", 0, "every window was empty, including the newest. This "
                             "channel is quiet and the probe decides nothing")
    if all(c > 0 for _a, c in rows):
        return ("no-boundary", 0, "history came back at every age probed, out to %d "
                                  "day(s). Nothing here indicates a horizon in that "
                                  "range" % rows[-1][0])
    first_empty = next(a for a, c in rows if c <= 0)
    if any(c > 0 for a, c in rows if a > first_empty):
        return ("ragged", 0, "history reappears past an empty window at %d day(s). "
                             "Retention is monotonic, so this is a quiet stretch "
                             "rather than an edge" % first_empty)
    last_full = max(a for a, c in rows if c > 0)
    return ("boundary", first_empty, "history stops between %d and %d day(s)"
                                     % (last_full, first_empty))


def agreement(answers):
    """Do the channels agree on the same edge? Pure.

    answers is [(channel, verdict, days), ...]. One channel cannot distinguish
    a retention policy from a channel nobody used, so this is where an
    ambiguous per-channel reading becomes a workspace-level one, or is refused.

    Returns (verdict, days, detail).
    """
    rows = list(answers or [])
    edges = [(c, d) for c, v, d in rows if v == "boundary" and d]
    if any(v == "no-boundary" for _c, v, _d in rows) and edges:
        return ("contradicted", 0, "at least one channel still returns history older "
                                   "than the edge the others show, so this is not a "
                                   "workspace-wide policy")
    if len(edges) < 2:
        return ("insufficient", 0, "%d channel(s) produced an edge. Two that agree are "
                                   "the minimum for calling this a policy" % len(edges))
    days = sorted(d for _c, d in edges)
    if days[0] != days[-1]:
        return ("disagreement", 0, "the channels stop at different ages (%d to %d "
                                   "day(s)), which is what a set of quiet channels "
                                   "looks like" % (days[0], days[-1]))
    return ("policy", days[0], "%d channel(s) stop at the same age, which is a "
                               "workspace setting rather than %d quiet channels"
                               % (len(edges), len(edges)))


def snap_to_policy(days):
    """Name the setting a measured boundary probably is. Pure.

    Returns (label, detail). Ninety carries an extra sentence because ninety is
    also where a free workspace stops returning history, and from an app's side
    a plan limit and a deletion policy are the same empty array.
    """
    try:
        n = int(days)
    except (TypeError, ValueError):
        return ("unknown", "no boundary to name")
    if n <= 0:
        return ("unknown", "no boundary to name")
    nearest = min(POLICY_VALUES, key=lambda v: abs(v - n))
    if abs(nearest - n) > nearest * 0.25:
        return ("custom", "%d day(s) is not near any of the usual settings, so ask for "
                          "the configured value rather than guessing at it" % n)
    if nearest == 90:
        return ("90 days", "also the free plan's visible history limit; this probe "
                           "cannot tell a retention policy from a plan limit, and the "
                           "two want different conversations")
    return ("%d days" % nearest, "a measured edge at %d day(s), which is the %d day "
                                 "setting" % (n, nearest))


def expectation_gap(retention_days, lookback_days):
    """What does your app assume, against what the workspace keeps? Pure.

    Returns (verdict, shortfall_days, detail). losing with a number is the
    sentence that belongs in the ticket, because it says how much of every
    backfill was already gone before the backfill started.
    """
    try:
        keeps = int(retention_days)
        wants = int(lookback_days)
    except (TypeError, ValueError):
        return ("unknown", 0, "both the measured horizon and the app's lookback are "
                              "needed")
    if keeps <= 0 or wants <= 0:
        return ("unknown", 0, "both the measured horizon and the app's lookback are "
                              "needed")
    if keeps >= wants * 1.5:
        return ("covered", 0, "the workspace keeps %d day(s) and the app reads back "
                              "%d" % (keeps, wants))
    if keeps >= wants:
        return ("tight", 0, "the workspace keeps %d day(s) and the app reads back %d. "
                            "One policy change closes that" % (keeps, wants))
    return ("losing", wants - keeps, "the app backfills %d day(s) and the workspace "
                                     "keeps about %d; %d day(s) of every backfill were "
                                     "gone before it ran"
                                     % (wants, keeps, wants - keeps))


def count_window(session, channel, oldest, latest, limit=10):
    """How many messages are in this window? A read."""
    body = session.get(API + "conversations.history", timeout=30, params={
        "channel": channel, "oldest": str(oldest), "latest": str(latest),
        "limit": str(limit), "inclusive": "true"}).json()
    if body.get("ok") is not True:
        return None, str(body.get("error") or "")
    return len(body.get("messages") or []), ""


def count_files(session, oldest, latest, limit=10):
    """How many files are in this window? A read, and no bytes are fetched."""
    body = session.get(API + "files.list", timeout=30, params={
        "ts_from": str(oldest), "ts_to": str(latest), "count": str(limit),
        "types": "all"}).json()
    if body.get("ok") is not True:
        return None, str(body.get("error") or "")
    return len(body.get("files") or []), ""


def member_channels(session, wanted):
    """Channels to probe: the ones asked for, or the ones the bot is in. A read."""
    if wanted:
        return [c.strip() for c in wanted.split(",") if c.strip()]
    body = session.get(API + "conversations.list", timeout=30, params={
        "types": "public_channel", "exclude_archived": "true", "limit": "200"}).json()
    if body.get("ok") is not True:
        log.error("conversations.list unavailable    %s", body.get("error"))
        return []
    return [c.get("id") for c in body.get("channels") or [] if c.get("is_member")]


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--token-env", default="SLACK_BOT_TOKEN",
                    help="environment variable holding the bot token")
    ap.add_argument("--channels", default="",
                    help="comma separated channel ids; defaults to the bot's channels")
    ap.add_argument("--max-channels", type=int, default=3,
                    help="how many channels to probe; two is the minimum that decides")
    ap.add_argument("--lookback-days", type=int, default=0,
                    help="how far back your app assumes it can read")
    ap.add_argument("--span-days", type=int, default=7,
                    help="width of each probe window")
    ap.add_argument("--skip-files", action="store_true",
                    help="probe messages only")
    args = ap.parse_args()

    token = os.environ.get(args.token_env)
    if not token:
        log.error("set %s to a bot token with channels:history", args.token_env)
        return 2

    s = requests.Session()
    s.headers.update({"Authorization": "Bearer " + token})
    who = s.get(API + "auth.test", timeout=30).json()
    if who.get("ok") is not True:
        log.error("auth.test  unavailable    %s", who.get("error"))
        return 2
    log.info("identity   %s (%s) in %s", who.get("user_id"), who.get("user"),
             who.get("team"))

    channels = member_channels(s, args.channels)[:max(1, args.max_channels)]
    if not channels:
        log.error("channels   none to probe; pass --channels or invite the bot")
        return 2

    windows = probe_windows(time.time(), LADDER, args.span_days)
    answers = []
    for channel in channels:
        probes, cells = [], []
        for age, oldest, latest in windows:
            count, error = count_window(s, channel, oldest, latest)
            if count is None:
                log.warning("probe      %s  %dd unavailable: %s", channel, age, error)
                continue
            probes.append((age, count))
            cells.append("%dd:%d" % (age, count))
        log.info("probe      %s  %s", channel, " ".join(cells))
        verdict, days, detail = horizon(probes)
        answers.append((channel, verdict, days))
        (log.warning if verdict == "boundary" else log.info)(
            "horizon    %-14s %s  %s", verdict, channel, detail)

    state, days, detail = agreement(answers)
    (log.warning if state == "policy" else log.info)(
        "agreement  %-14s %s", state, detail)

    if state == "policy":
        label, note = snap_to_policy(days)
        log.warning("policy     %-14s %s", label, note)

    if not args.skip_files:
        probes = []
        for age, oldest, latest in windows:
            count, error = count_files(s, oldest, latest)
            if count is None:
                log.info("files      %dd unavailable: %s", age, error)
                continue
            probes.append((age, count))
        fverdict, fdays, fdetail = horizon(probes)
        log.info("files      %-14s %s", fverdict, fdetail)
        if fverdict == "boundary" and state != "policy":
            days = days or fdays

    if args.lookback_days and days:
        gap, shortfall, gdetail = expectation_gap(days, args.lookback_days)
        (log.warning if gap == "losing" else log.info)("gap        %-14s %s", gap,
                                                       gdetail)
        if gap == "losing":
            log.warning("  repair: copy message text with its ts, and file bytes "
                        "through the authenticated download, into your own store at "
                        "ingestion time")
            log.warning("  repair: ask an admin for the configured retention setting "
                        "rather than inferring it, and record %d day(s) as the number "
                        "the app may assume", days)
            log.warning("  repair: where retention is a compliance requirement, that "
                        "is what Grid's Discovery and audit surfaces are for")
            return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())

/**
 * Measure how far back this workspace's history actually goes.
 *
 * Read only. conversations.list, conversations.history, files.list and
 * auth.test are reads; nothing here writes, deletes or downloads anything, and
 * no file bytes and no url_private are ever fetched.
 *
 * Retention policies delete messages and files on a schedule that no API
 * reports, so the policy is measured from its effect: ask about progressively
 * older windows until the answers stop. The trap is that a quiet channel is
 * also empty, which is why nothing here concludes anything from one channel.
 */

const API = 'https://slack.com/api/';
const DAY = 86400;

/** Ages to probe, in days. A ladder rather than a bisection. */
export const LADDER = [30, 60, 90, 180, 365, 730];
/** The round numbers retention settings are actually set to. */
export const POLICY_VALUES = [30, 60, 90, 180, 365];

/**
 * The windows to ask about. Pure. Returns [[ageDays, oldest, latest], ...].
 * A window rather than an open-ended oldest, because "everything since two
 * years ago" returns the most recent page and says nothing about two years ago.
 */
export function probeWindows(now, ladder = LADDER, spanDays = 7) {
  const base = Number.parseInt(now, 10);
  if (!Number.isFinite(base)) return [];
  const ages = [...new Set((ladder ?? []).map((a) => Number.parseInt(a, 10)))]
    .filter((a) => Number.isFinite(a) && a > 0).sort((a, b) => a - b);
  return ages.map((age) => {
    const oldest = base - age * DAY;
    return [age, oldest, oldest + spanDays * DAY];
  });
}

/**
 * Where does the history stop? Pure. Returns [verdict, boundaryDays, detail].
 * Five outcomes and only boundary is a finding: silent means the channel was
 * quiet, and ragged means history reappears past an empty window, which is
 * evidence against a horizon rather than noise inside one.
 */
export function horizon(probes) {
  const rows = (probes ?? []).map(([a, c]) => [Number.parseInt(a, 10),
    Number.parseInt(c, 10)]).sort((x, y) => x[0] - y[0]);
  if (rows.length < 2) {
    return ['undecidable', 0, 'at least two ages are needed to find an edge'];
  }
  if (rows.every(([, c]) => c <= 0)) {
    return ['silent', 0, 'every window was empty, including the newest. This channel '
      + 'is quiet and the probe decides nothing'];
  }
  if (rows.every(([, c]) => c > 0)) {
    return ['no-boundary', 0, `history came back at every age probed, out to `
      + `${rows[rows.length - 1][0]} day(s). Nothing here indicates a horizon in that `
      + 'range'];
  }
  const firstEmpty = rows.find(([, c]) => c <= 0)[0];
  if (rows.some(([a, c]) => a > firstEmpty && c > 0)) {
    return ['ragged', 0, `history reappears past an empty window at ${firstEmpty} `
      + 'day(s). Retention is monotonic, so this is a quiet stretch rather than an '
      + 'edge'];
  }
  const lastFull = Math.max(...rows.filter(([, c]) => c > 0).map(([a]) => a));
  return ['boundary', firstEmpty, `history stops between ${lastFull} and ${firstEmpty} `
    + 'day(s)'];
}

/**
 * Do the channels agree on the same edge? Pure. Returns [verdict, days, detail].
 * One channel cannot tell a retention policy from a channel nobody used.
 */
export function agreement(answers) {
  const rows = answers ?? [];
  const edges = rows.filter(([, v, d]) => v === 'boundary' && d);
  if (rows.some(([, v]) => v === 'no-boundary') && edges.length) {
    return ['contradicted', 0, 'at least one channel still returns history older than '
      + 'the edge the others show, so this is not a workspace-wide policy'];
  }
  if (edges.length < 2) {
    return ['insufficient', 0, `${edges.length} channel(s) produced an edge. Two that `
      + 'agree are the minimum for calling this a policy'];
  }
  const days = edges.map(([, , d]) => d).sort((a, b) => a - b);
  if (days[0] !== days[days.length - 1]) {
    return ['disagreement', 0, `the channels stop at different ages (${days[0]} to `
      + `${days[days.length - 1]} day(s)), which is what a set of quiet channels looks `
      + 'like'];
  }
  return ['policy', days[0], `${edges.length} channel(s) stop at the same age, which is `
    + `a workspace setting rather than ${edges.length} quiet channels`];
}

/**
 * Name the setting a measured boundary probably is. Pure.
 * Ninety carries an extra sentence: it is also where a free workspace stops
 * returning history, and a plan limit and a deletion policy look identical.
 */
export function snapToPolicy(days) {
  const n = Number.parseInt(days, 10);
  if (!Number.isFinite(n) || n <= 0) return ['unknown', 'no boundary to name'];
  const nearest = POLICY_VALUES.reduce((best, v) => (Math.abs(v - n)
    < Math.abs(best - n) ? v : best), POLICY_VALUES[0]);
  if (Math.abs(nearest - n) > nearest * 0.25) {
    return ['custom', `${n} day(s) is not near any of the usual settings, so ask for `
      + 'the configured value rather than guessing at it'];
  }
  if (nearest === 90) {
    return ['90 days', 'also the free plan visible history limit; this probe cannot '
      + 'tell a retention policy from a plan limit, and the two want different '
      + 'conversations'];
  }
  return [`${nearest} days`, `a measured edge at ${n} day(s), which is the ${nearest} `
    + 'day setting'];
}

/**
 * What does your app assume, against what the workspace keeps? Pure.
 * Returns [verdict, shortfallDays, detail].
 */
export function expectationGap(retentionDays, lookbackDays) {
  const keeps = Number.parseInt(retentionDays, 10);
  const wants = Number.parseInt(lookbackDays, 10);
  if (!Number.isFinite(keeps) || !Number.isFinite(wants) || keeps <= 0 || wants <= 0) {
    return ['unknown', 0, 'both the measured horizon and the app lookback are needed'];
  }
  if (keeps >= wants * 1.5) {
    return ['covered', 0, `the workspace keeps ${keeps} day(s) and the app reads back `
      + `${wants}`];
  }
  if (keeps >= wants) {
    return ['tight', 0, `the workspace keeps ${keeps} day(s) and the app reads back `
      + `${wants}. One policy change closes that`];
  }
  return ['losing', wants - keeps, `the app backfills ${wants} day(s) and the workspace `
    + `keeps about ${keeps}; ${wants - keeps} day(s) of every backfill were gone before `
    + 'it ran'];
}

function arg(args, name, fallback = null) {
  const i = args.indexOf(name);
  return i === -1 ? fallback : args[i + 1];
}

async function countWindow(headers, channel, oldest, latest, limit = 10) {
  const params = new URLSearchParams({
    channel, oldest: String(oldest), latest: String(latest), limit: String(limit),
    inclusive: 'true',
  });
  const body = await (await fetch(`${API}conversations.history?${params}`,
    { headers })).json();
  if (body.ok !== true) return [null, String(body.error ?? '')];
  return [(body.messages ?? []).length, ''];
}

async function countFiles(headers, oldest, latest, limit = 10) {
  const params = new URLSearchParams({
    ts_from: String(oldest), ts_to: String(latest), count: String(limit), types: 'all',
  });
  const body = await (await fetch(`${API}files.list?${params}`, { headers })).json();
  if (body.ok !== true) return [null, String(body.error ?? '')];
  return [(body.files ?? []).length, ''];
}

async function memberChannels(headers, wanted) {
  if (wanted) return wanted.split(',').map((c) => c.trim()).filter(Boolean);
  const params = new URLSearchParams({
    types: 'public_channel', exclude_archived: 'true', limit: '200',
  });
  const body = await (await fetch(`${API}conversations.list?${params}`,
    { headers })).json();
  if (body.ok !== true) {
    console.error(`conversations.list unavailable    ${body.error}`);
    return [];
  }
  return (body.channels ?? []).filter((c) => c.is_member).map((c) => c.id);
}

async function main() {
  const args = process.argv.slice(2);
  const tokenEnv = arg(args, '--token-env', 'SLACK_BOT_TOKEN');
  const token = process.env[tokenEnv];
  if (!token) {
    console.error(`set ${tokenEnv} to a bot token with channels:history`);
    process.exitCode = 2;
    return;
  }
  const headers = { Authorization: `Bearer ${token}` };
  const who = await (await fetch(`${API}auth.test`, { headers })).json();
  if (who.ok !== true) {
    console.error(`auth.test  unavailable    ${who.error}`);
    process.exitCode = 2;
    return;
  }
  console.log(`identity   ${who.user_id} (${who.user}) in ${who.team}`);

  const maxChannels = Math.max(1, Number(arg(args, '--max-channels', 3)));
  const channels = (await memberChannels(headers, arg(args, '--channels', '')))
    .slice(0, maxChannels);
  if (!channels.length) {
    console.error('channels   none to probe; pass --channels or invite the bot');
    process.exitCode = 2;
    return;
  }

  const windows = probeWindows(Math.floor(Date.now() / 1000), LADDER,
    Number(arg(args, '--span-days', 7)));
  const answers = [];
  for (const channel of channels) {
    const probes = [];
    const cells = [];
    for (const [age, oldest, latest] of windows) {
      const [count, error] = await countWindow(headers, channel, oldest, latest);
      if (count === null) {
        console.warn(`probe      ${channel}  ${age}d unavailable: ${error}`);
        continue;
      }
      probes.push([age, count]);
      cells.push(`${age}d:${count}`);
    }
    console.log(`probe      ${channel}  ${cells.join(' ')}`);
    const [verdict, days, detail] = horizon(probes);
    answers.push([channel, verdict, days]);
    const line = `horizon    ${verdict.padEnd(14)} ${channel}  ${detail}`;
    if (verdict === 'boundary') console.warn(line); else console.log(line);
  }

  const [state, days, detail] = agreement(answers);
  const line = `agreement  ${state.padEnd(14)} ${detail}`;
  if (state === 'policy') console.warn(line); else console.log(line);
  if (state === 'policy') {
    const [label, note] = snapToPolicy(days);
    console.warn(`policy     ${label.padEnd(14)} ${note}`);
  }

  let horizonDays = days;
  if (!args.includes('--skip-files')) {
    const probes = [];
    for (const [age, oldest, latest] of windows) {
      const [count, error] = await countFiles(headers, oldest, latest);
      if (count === null) {
        console.log(`files      ${age}d unavailable: ${error}`);
        continue;
      }
      probes.push([age, count]);
    }
    const [fverdict, fdays, fdetail] = horizon(probes);
    console.log(`files      ${fverdict.padEnd(14)} ${fdetail}`);
    if (fverdict === 'boundary' && state !== 'policy') horizonDays = horizonDays || fdays;
  }

  const lookback = Number(arg(args, '--lookback-days', 0));
  if (lookback && horizonDays) {
    const [gap, , gdetail] = expectationGap(horizonDays, lookback);
    const gline = `gap        ${gap.padEnd(14)} ${gdetail}`;
    if (gap === 'losing') console.warn(gline); else console.log(gline);
    if (gap === 'losing') {
      console.warn('  repair: copy message text with its ts, and file bytes through '
        + 'the authenticated download, into your own store at ingestion time');
      console.warn('  repair: ask an admin for the configured retention setting rather '
        + `than inferring it, and record ${horizonDays} day(s) as the assumption`);
      process.exitCode = 1;
    }
  }
}

// Only run when invoked directly, so importing this module in the tests does
// not execute main() and fail the file on a missing token.
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((err) => { console.error(err.message); process.exitCode = 2; });
}

from slack_retention_horizon import (agreement, expectation_gap, horizon,
                                     probe_windows, snap_to_policy)

DAY = 86400


def test_the_windows_are_bounded_rather_than_open_ended():
    got = probe_windows(1000000, ladder=(30,), span_days=7)
    assert got == [(30, 1000000 - 30 * DAY, 1000000 - 30 * DAY + 7 * DAY)]


def test_the_ladder_is_sorted_and_deduplicated():
    assert [a for a, _o, _l in probe_windows(1000000, ladder=(90, 30, 30))] == [30, 90]


def test_a_bad_clock_produces_no_windows_rather_than_raising():
    assert probe_windows(None) == []


def test_an_edge_is_reported_between_the_two_ages_that_bracket_it():
    verdict, days, detail = horizon([(30, 10), (90, 7), (180, 0), (365, 0)])
    assert (verdict, days) == ("boundary", 180)
    assert "between 90 and 180" in detail


def test_history_at_every_age_is_not_a_boundary():
    assert horizon([(30, 10), (365, 4), (730, 2)])[0] == "no-boundary"


def test_a_quiet_channel_is_silent_rather_than_an_edge_at_thirty_days():
    verdict, _days, detail = horizon([(30, 0), (90, 0), (365, 0)])
    assert verdict == "silent"
    assert "decides nothing" in detail


def test_history_reappearing_past_an_empty_window_is_ragged():
    verdict, days, _detail = horizon([(30, 8), (90, 0), (365, 6)])
    assert (verdict, days) == ("ragged", 0)


def test_one_probe_cannot_find_an_edge():
    assert horizon([(30, 10)])[0] == "undecidable"
    assert horizon([])[0] == "undecidable"


def test_two_channels_stopping_at_the_same_age_is_a_policy():
    verdict, days, detail = agreement([("C1", "boundary", 180),
                                       ("C2", "boundary", 180)])
    assert (verdict, days) == ("policy", 180)
    assert "workspace setting" in detail


def test_one_channel_is_never_enough_to_call_it_a_policy():
    assert agreement([("C1", "boundary", 180)])[0] == "insufficient"


def test_channels_stopping_at_different_ages_are_just_quiet():
    assert agreement([("C1", "boundary", 90), ("C2", "boundary", 365)])[0] == \
        "disagreement"


def test_a_channel_with_older_history_disproves_the_whole_finding():
    verdict, _days, detail = agreement([("C1", "boundary", 180),
                                        ("C2", "boundary", 180),
                                        ("C3", "no-boundary", 0)])
    assert verdict == "contradicted"
    assert "not a workspace-wide policy" in detail


def test_a_measured_edge_snaps_to_the_setting_it_probably_is():
    label, _detail = snap_to_policy(188)
    assert label == "180 days"


def test_ninety_days_carries_the_free_plan_caveat():
    label, detail = snap_to_policy(88)
    assert label == "90 days"
    assert "plan limit" in detail


def test_an_edge_near_nothing_familiar_is_not_forced_onto_a_setting():
    assert snap_to_policy(500)[0] == "custom"
    assert snap_to_policy(0)[0] == "unknown"


def test_a_backfill_longer_than_the_horizon_is_losing_data_every_day():
    verdict, shortfall, detail = expectation_gap(180, 365)
    assert (verdict, shortfall) == ("losing", 185)
    assert "before it ran" in detail


def test_a_horizon_that_only_just_covers_the_lookback_is_tight():
    assert expectation_gap(400, 365)[0] == "tight"


def test_plenty_of_room_is_reported_as_covered():
    assert expectation_gap(730, 30)[0] == "covered"


def test_the_gap_needs_both_numbers():
    assert expectation_gap(0, 365)[0] == "unknown"
    assert expectation_gap(180, None)[0] == "unknown"

import { test } from 'node:test';
import assert from 'node:assert/strict';
import {
  agreement, expectationGap, horizon, probeWindows, snapToPolicy,
} from './slack-retention-horizon.mjs';

const DAY = 86400;

test('the windows are bounded rather than open ended', () => {
  assert.deepEqual(probeWindows(1000000, [30], 7),
    [[30, 1000000 - 30 * DAY, 1000000 - 30 * DAY + 7 * DAY]]);
});

test('the ladder is sorted and deduplicated', () => {
  assert.deepEqual(probeWindows(1000000, [90, 30, 30]).map(([a]) => a), [30, 90]);
});

test('a bad clock produces no windows rather than throwing', () => {
  assert.deepEqual(probeWindows(null), []);
});

test('an edge is reported between the two ages that bracket it', () => {
  const [verdict, days, detail] = horizon([[30, 10], [90, 7], [180, 0], [365, 0]]);
  assert.equal(verdict, 'boundary');
  assert.equal(days, 180);
  assert.match(detail, /between 90 and 180/);
});

test('history at every age is not a boundary', () => {
  assert.equal(horizon([[30, 10], [365, 4], [730, 2]])[0], 'no-boundary');
});

test('a quiet channel is silent rather than an edge at thirty days', () => {
  const [verdict, , detail] = horizon([[30, 0], [90, 0], [365, 0]]);
  assert.equal(verdict, 'silent');
  assert.match(detail, /decides nothing/);
});

test('history reappearing past an empty window is ragged', () => {
  const [verdict, days] = horizon([[30, 8], [90, 0], [365, 6]]);
  assert.equal(verdict, 'ragged');
  assert.equal(days, 0);
});

test('one probe cannot find an edge', () => {
  assert.equal(horizon([[30, 10]])[0], 'undecidable');
  assert.equal(horizon([])[0], 'undecidable');
});

test('two channels stopping at the same age is a policy', () => {
  const [verdict, days, detail] = agreement([['C1', 'boundary', 180],
    ['C2', 'boundary', 180]]);
  assert.equal(verdict, 'policy');
  assert.equal(days, 180);
  assert.match(detail, /workspace setting/);
});

test('one channel is never enough to call it a policy', () => {
  assert.equal(agreement([['C1', 'boundary', 180]])[0], 'insufficient');
});

test('channels stopping at different ages are just quiet', () => {
  assert.equal(agreement([['C1', 'boundary', 90], ['C2', 'boundary', 365]])[0],
    'disagreement');
});

test('a channel with older history disproves the whole finding', () => {
  const [verdict, , detail] = agreement([['C1', 'boundary', 180],
    ['C2', 'boundary', 180], ['C3', 'no-boundary', 0]]);
  assert.equal(verdict, 'contradicted');
  assert.match(detail, /not a workspace-wide policy/);
});

test('a measured edge snaps to the setting it probably is', () => {
  assert.equal(snapToPolicy(188)[0], '180 days');
});

test('ninety days carries the free plan caveat', () => {
  const [label, detail] = snapToPolicy(88);
  assert.equal(label, '90 days');
  assert.match(detail, /plan limit/);
});

test('an edge near nothing familiar is not forced onto a setting', () => {
  assert.equal(snapToPolicy(500)[0], 'custom');
  assert.equal(snapToPolicy(0)[0], 'unknown');
});

test('a backfill longer than the horizon is losing data every day', () => {
  const [verdict, shortfall, detail] = expectationGap(180, 365);
  assert.equal(verdict, 'losing');
  assert.equal(shortfall, 185);
  assert.match(detail, /before it ran/);
});

test('a horizon that only just covers the lookback is tight', () => {
  assert.equal(expectationGap(400, 365)[0], 'tight');
});

test('plenty of room is reported as covered', () => {
  assert.equal(expectationGap(730, 30)[0], 'covered');
});

test('the gap needs both numbers', () => {
  assert.equal(expectationGap(0, 365)[0], 'unknown');
  assert.equal(expectationGap(180, null)[0], 'unknown');
});