liminal-server 0.25.4

use super::fixture::{Fixture, ISSUED_AT, LIFETIME, NOW, Result};
use super::{LinkAction, LinkRights, Rights};
use crate::auth_lys::{RefusalCause, SubjectBinding};
use std::sync::atomic::Ordering;

#[derive(PartialEq, Eq)]
struct RedactedPass<'a>(&'a str);

impl std::fmt::Debug for RedactedPass<'_> {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter.write_str("<redacted pass>")
    }
}

#[test]
fn an_hour_old_importer_uses_its_renewed_pass_on_the_first_inbound_open() -> Result {
    let fixture = Fixture::new(true, false)?;
    const { assert!(NOW - ISSUED_AT > LIFETIME) };
    let result = fixture
        .session()?
        .open_link(&Fixture::link(), LinkAction::Export, NOW);
    assert!(
        result.is_ok(),
        "link_refused:{}",
        serde_json::to_string(&result.err().ok_or("no refusal")?.refusal)?
    );
    assert!(matches!(
        result?,
        crate::auth_lys::DeliberateDecision::Outright(_)
    ));
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_eq!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    let bound = SubjectBinding::link(
        "network".to_owned(),
        super::fixture::LINK.to_owned(),
        "health".to_owned(),
    )?;
    Rights(fixture.authority.clone()).holds(LinkAction::Import, &bound, NOW)?;
    fixture.finish()
}

#[test]
fn a_renewed_importer_pass_without_the_link_grant_is_refused_by_name() -> Result {
    let fixture = Fixture::new(false, false)?;
    let refused = fixture
        .authority
        .open(&Fixture::link(), LinkAction::Export, NOW)
        .err()
        .ok_or("renewed pass without grant admitted")?;
    assert_eq!(refused.refusal.refused.action, "link_import");
    assert_eq!(refused.cause.to_string(), "renewed-without-grant");
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_eq!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    fixture.finish()
}

#[test]
fn an_expired_outbound_pass_is_presented_renewed_on_the_same_open() -> Result {
    let fixture = Fixture::new(true, false)?;
    let token = fixture.authority.pass.for_open_at(NOW)?;
    assert_eq!(
        RedactedPass(token.as_str()),
        RedactedPass(fixture.renewed.as_str()),
        "open did not present the renewed token"
    );
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    fixture.finish()
}

#[test]
fn a_failed_importer_renewal_keeps_the_open_refused() -> Result {
    let fixture = Fixture::new(true, true)?;
    let refused = fixture
        .authority
        .open(&Fixture::link(), LinkAction::Export, NOW)
        .err()
        .ok_or("failed renewal admitted")?;
    assert_eq!(refused.cause, RefusalCause::DeliberateUnavailable);
    assert_eq!(refused.refusal.refused.action, "link_import");
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_ne!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    fixture.finish()
}

/// ACCESS-009 R1: a boot whose ask Lys refused holds no pass; its first
/// open asks, and the issued pass is held and presented without another ask.
#[test]
fn a_boot_whose_ask_was_refused_asks_on_its_first_open_and_holds_the_issued_pass() -> Result {
    let fixture = Fixture::unissued(false)?;
    let result = fixture
        .session()?
        .open_link(&Fixture::link(), LinkAction::Export, NOW);
    assert!(
        result.is_ok(),
        "link_refused:{}",
        serde_json::to_string(&result.err().ok_or("no refusal")?.refusal)?
    );
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_eq!(
        RedactedPass(fixture.authority.pass.for_open_at(NOW)?.as_str()),
        RedactedPass(fixture.renewed.as_str()),
        "the open did not present the issued pass"
    );
    assert_eq!(
        fixture.calls.load(Ordering::Relaxed),
        1,
        "a held pass was asked for again"
    );
    fixture.finish()
}

/// ACCESS-009 R1: while Lys keeps refusing, every open is refused by
/// Lys's name and asks again; nothing is held between them.
#[test]
fn a_boot_whose_ask_was_refused_is_refused_by_name_and_asks_again_on_the_next_open() -> Result {
    let fixture = Fixture::unissued(true)?;
    for opens in 1..=2 {
        let refused = fixture
            .authority
            .open(&Fixture::link(), LinkAction::Export, NOW)
            .err()
            .ok_or("an open with no pass was admitted")?;
        assert_eq!(refused.cause, RefusalCause::DeliberateUnavailable);
        assert_eq!(refused.refusal.refused.action, "link_import");
        assert_eq!(fixture.calls.load(Ordering::Relaxed), opens);
    }
    assert!(
        fixture.authority.pass.current()?.is_empty(),
        "a refused ask left a pass held"
    );
    fixture.finish()
}