use serde::{Deserialize, Serialize};
use crate::kind::UnitKind;
use crate::time::Timestamp;
const DAY: u64 = 86_400;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
pub struct StalenessPolicy {
pub pitfall_days: u32,
pub workaround_days: u32,
pub tool_recommendation_days: u32,
pub tool_gap_signal_days: u32,
}
impl Default for StalenessPolicy {
fn default() -> Self {
Self {
pitfall_days: 365,
workaround_days: 60,
tool_recommendation_days: 180,
tool_gap_signal_days: 90,
}
}
}
impl StalenessPolicy {
pub const fn uniform(days: u32) -> Self {
Self {
pitfall_days: days,
workaround_days: days,
tool_recommendation_days: days,
tool_gap_signal_days: days,
}
}
pub const fn days_for(&self, kind: UnitKind) -> u32 {
match kind {
UnitKind::Pitfall => self.pitfall_days,
UnitKind::Workaround => self.workaround_days,
UnitKind::ToolRecommendation => self.tool_recommendation_days,
UnitKind::ToolGapSignal => self.tool_gap_signal_days,
}
}
pub fn token_for(&self, kind: UnitKind) -> String {
format!("confirm_or_decay_after_{}d", self.days_for(kind))
}
pub const fn is_stale(
&self,
kind: UnitKind,
last_confirmed: Timestamp,
now: Timestamp,
) -> bool {
let days = self.days_for(kind);
if days == 0 {
return false;
}
last_confirmed.elapsed_to(now) > days as u64 * DAY
}
pub fn freshness(&self, kind: UnitKind, last_confirmed: Timestamp, now: Timestamp) -> f64 {
let days = self.days_for(kind);
if days == 0 {
return 1.0;
}
let span = (days as u64 * DAY * 2) as f64;
let age = last_confirmed.elapsed_to(now) as f64;
(1.0 - age / span).clamp(0.0, 1.0)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn at(days: i64) -> Timestamp {
Timestamp::from_secs(days * DAY as i64)
}
#[test]
fn defaults_follow_the_ladder() {
let p = StalenessPolicy::default();
let periods: Vec<u32> = UnitKind::ALL.iter().map(|k| p.days_for(*k)).collect();
assert_eq!(periods, vec![365, 60, 180, 90]);
assert!(
p.days_for(UnitKind::Pitfall) > p.days_for(UnitKind::ToolRecommendation)
&& p.days_for(UnitKind::ToolRecommendation) > p.days_for(UnitKind::Workaround),
"permanence must buy a longer unattended life"
);
}
#[test]
fn staleness_flips_exactly_after_the_period() {
let p = StalenessPolicy::default();
let c = at(0);
assert!(
!p.is_stale(UnitKind::Workaround, c, at(60)),
"not yet at the boundary"
);
assert!(p.is_stale(UnitKind::Workaround, c, at(61)));
assert!(!p.is_stale(UnitKind::Pitfall, c, at(61)));
}
#[test]
fn freshness_is_half_at_the_period_and_zero_at_twice_it() {
let p = StalenessPolicy::default();
let c = at(0);
let f = p.freshness(UnitKind::ToolGapSignal, c, at(90));
assert!((f - 0.5).abs() < 1e-9, "expected 0.5, got {f}");
assert_eq!(p.freshness(UnitKind::ToolGapSignal, c, at(180)), 0.0);
assert_eq!(p.freshness(UnitKind::ToolGapSignal, c, at(500)), 0.0);
assert_eq!(p.freshness(UnitKind::ToolGapSignal, c, at(0)), 1.0);
}
#[test]
fn zero_days_switches_decay_off() {
let p = StalenessPolicy::uniform(0);
assert!(!p.is_stale(UnitKind::Workaround, at(0), at(100_000)));
assert_eq!(p.freshness(UnitKind::Workaround, at(0), at(100_000)), 1.0);
}
#[test]
fn tokens_match_the_cq_spelling() {
let p = StalenessPolicy::uniform(90);
assert_eq!(
p.token_for(UnitKind::Workaround),
"confirm_or_decay_after_90d"
);
}
}