Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

24.5 KB
Raw Blame
use super::*;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};

#[test]
fn repeated_grant_request_revoke_and_disconnect_releases_state_and_budgets() {
    let fixture = Fixture::new();
    let budgets = crate::budget::Budgets::with_clock(fixture.clock.clone()).unwrap();
    for second in 1..=100 {
        fixture.clock.set(second);
        let route = fixture.authority.register_route().unwrap();
        let budget = budgets.open_route(route.id()).unwrap();
        let grant = fixture
            .authority
            .prepare(&route, vec![fixture.target], Permission::Read, 60, None)
            .unwrap()
            .authenticated()
            .unwrap()
            .grant;
        let request = Request {
            grant,
            target: fixture.target,
            operation: Operation::Read,
            sequence: 1,
        };
        let permit = fixture.endpoint.accept(&route, request).unwrap();
        let reservation = budget.acquire(4096).unwrap();
        permit.execute(fixture.target, || ()).unwrap();
        fixture.authority.revoke(grant).unwrap();
        assert!(permit.execute(fixture.target, || ()).is_err());
        drop((permit, reservation, budget, route));
        assert_eq!(budgets.retained().unwrap(), (0, 0));
        let state = fixture.authority.shared.state.lock().unwrap();
        assert!(state.grants.is_empty());
        assert!(state.pending.is_none());
        assert_eq!(state.routes.len(), 1);
    }
}

#[test]
fn closing_the_authority_invalidates_work_and_cannot_be_reopened() {
    let fixture = Fixture::new();
    let grant = fixture.grant();
    let permit = fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 1))
        .unwrap();
    let pending = fixture.pending(Some(grant));
    fixture.authority.close();
    assert!(permit.execute(fixture.target, || ()).is_err());
    assert!(pending.authenticated().is_err());
    assert!(fixture.endpoint.list(&fixture.route).is_err());
    assert!(fixture.authority.register_route().is_err());
    assert!(fixture.authority.start_monitor().is_err());
    fixture.authority.close();
}

#[test]
fn missing_native_monitor_heartbeat_revokes_at_the_execution_boundary() {
    let fixture = Fixture::new();
    let monitor = fixture.authority.start_monitor().unwrap();
    let grant = fixture.grant();
    let permit = fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 1))
        .unwrap();
    fixture.clock.set(5);
    let called = AtomicBool::new(false);
    assert!(permit
        .execute(fixture.target, || called.store(true, Ordering::Relaxed))
        .is_err());
    assert!(!called.load(Ordering::Relaxed));
    assert!(monitor.heartbeat().is_err());
    assert!(fixture.endpoint.list(&fixture.route).is_err());
}

#[test]
fn old_monitor_cannot_revoke_or_extend_a_replacement_session() {
    let fixture = Fixture::new();
    let old = fixture.authority.start_monitor().unwrap();
    let current = fixture.authority.start_monitor().unwrap();
    let grant = fixture.grant();
    assert!(old.heartbeat().is_err());
    drop(old);
    let permit = fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 1))
        .unwrap();
    assert!(permit.execute(fixture.target, || ()).is_ok());
    current.close();
    assert!(permit.execute(fixture.target, || ()).is_err());
}

#[test]
fn cancelling_native_work_also_revokes_a_result_not_yet_delivered_to_the_ui() {
    let fixture = Fixture::new();
    let approval = fixture.pending(None);
    let cancellation = approval.cancellation();
    let grant = approval.authenticated().unwrap().grant;
    cancellation.cancel();
    assert!(fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 1))
        .is_err());
    let pending = fixture.pending(None);
    let cancellation = pending.cancellation();
    cancellation.cancel();
    assert!(pending.authenticated().is_err());
}

#[derive(Default)]
struct TestClock {
    seconds: AtomicU64,
    failed: AtomicBool,
}

impl Clock for TestClock {
    fn now(&self) -> Result<Tick> {
        if self.failed.load(Ordering::Relaxed) {
            return Err(Error::Clock);
        }
        Ok(Tick::seconds(self.seconds.load(Ordering::Relaxed)))
    }
}

impl TestClock {
    fn set(&self, seconds: u64) {
        self.seconds.store(seconds, Ordering::Relaxed);
    }
}

struct Fixture {
    authority: Authority,
    endpoint: Endpoint,
    clock: Arc<TestClock>,
    route: Route,
    target: Target,
}

#[test]
fn all_local_membership_changes_preserve_expiry_and_reject_old_work() {
    let fixture = Fixture::new();
    let approval = fixture
        .authority
        .prepare_all_local(&fixture.route, Permission::ReadAndInput, 60, None)
        .unwrap();
    assert_eq!(
        approval.details().unwrap().scope,
        GrantScope::AllLocalTerminals
    );
    let info = approval.authenticated().unwrap();
    assert!(info.targets.is_empty());
    let grant = info.grant;
    assert!(fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 1))
        .is_err());
    fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![fixture.target])
        .unwrap();
    let permit = fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 2))
        .unwrap();
    assert!(permit.execute(fixture.target, || ()).is_ok());
    fixture.clock.set(10);
    fixture.authority.invalidate_target(fixture.target).unwrap();
    let remaining = fixture.endpoint.list(&fixture.route).unwrap();
    assert_eq!(remaining.len(), 1);
    assert!(remaining[0].targets.is_empty());
    assert_eq!(remaining[0].remaining, Duration::from_secs(50));
    assert!(permit.execute(fixture.target, || ()).is_err());

    let replacement = Target::new(fixture.target.pane, fixture.target.owner).unwrap();
    fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![replacement])
        .unwrap();
    let request = Request {
        target: replacement,
        ..fixture.request(grant, 3)
    };
    let permit = fixture.endpoint.accept(&fixture.route, request).unwrap();
    assert!(permit.execute(replacement, || ()).is_ok());
    assert!(fixture.endpoint.accept(&fixture.route, request).is_err());
    assert!(fixture
        .endpoint
        .accept(&fixture.route, fixture.request(grant, 4))
        .is_err());
    fixture.clock.set(60);
    assert!(fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![replacement])
        .is_err());
    assert!(permit.execute(replacement, || ()).is_err());
}

#[test]
fn all_local_refresh_cannot_widen_selected_grants_or_cross_routes() {
    let fixture = Fixture::new();
    let selected = fixture.grant();
    assert!(fixture
        .authority
        .replace_all_local_targets(&fixture.route, selected, vec![])
        .is_err());
    assert!(fixture
        .authority
        .prepare_all_local(&fixture.route, Permission::Read, 60, Some(selected))
        .is_err());
    fixture.authority.revoke(selected).unwrap();
    let grant = fixture
        .authority
        .prepare_all_local(&fixture.route, Permission::Read, 60, None)
        .unwrap()
        .authenticated()
        .unwrap()
        .grant;
    let other = fixture.authority.register_route().unwrap();
    assert!(fixture
        .authority
        .replace_all_local_targets(&other, grant, vec![fixture.target])
        .is_err());
    assert!(fixture
        .authority
        .prepare(
            &fixture.route,
            vec![fixture.target],
            Permission::Read,
            60,
            Some(grant)
        )
        .is_err());
    assert!(fixture
        .authority
        .prepare(
            &fixture.route,
            vec![fixture.target],
            Permission::Read,
            60,
            None
        )
        .is_err());
    assert!(fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![fixture.target; 2])
        .is_err());
    let oversized = (0..=MAX_TARGETS)
        .map(|pane| Target {
            pane: pane as u64,
            ..fixture.target
        })
        .collect();
    assert_eq!(
        fixture
            .authority
            .replace_all_local_targets(&fixture.route, grant, oversized),
        Err(Error::TooLarge)
    );
    fixture
        .authority
        .revoke_current(&fixture.route, grant.id)
        .unwrap();
    assert!(fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![fixture.target])
        .is_err());
}

#[test]
fn all_local_renewal_retains_scope_and_invalidates_previous_membership() {
    let fixture = Fixture::new();
    let grant = fixture
        .authority
        .prepare_all_local(&fixture.route, Permission::Read, 60, None)
        .unwrap()
        .authenticated()
        .unwrap()
        .grant;
    fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![fixture.target])
        .unwrap();
    let renewal = fixture
        .authority
        .prepare_all_local(&fixture.route, Permission::Read, 60, Some(grant))
        .unwrap()
        .authenticated()
        .unwrap();
    assert_eq!(renewal.scope, GrantScope::AllLocalTerminals);
    assert!(renewal.targets.is_empty());
    assert!(fixture
        .authority
        .replace_all_local_targets(&fixture.route, grant, vec![fixture.target])
        .is_err());
    fixture
        .authority
        .replace_all_local_targets(&fixture.route, renewal.grant, vec![fixture.target])
        .unwrap();
    assert!(fixture
        .endpoint
        .accept(
            &fixture.route,
            Request {
                operation: Operation::Read,
                ..fixture.request(renewal.grant, 1)
            }
        )
        .is_ok());
    assert!(fixture
        .endpoint
        .accept(&fixture.route, fixture.request(renewal.grant, 2))
        .is_err());
}

impl Fixture {
    fn new() -> Self {
        let clock = Arc::new(TestClock::default());
        let (authority, endpoint) = Authority::with_clock(clock.clone());
        authority.session_changed(true).unwrap();
        let route = authority.register_route().unwrap();
        let target = Target::new(1, Id::from_bytes([1; 16])).unwrap();
        Self {
            authority,
            endpoint,
            clock,
            route,
            target,
        }
    }

    fn pending(&self, renewal: Option<GrantRef>) -> Approval {
        self.authority
            .prepare(
                &self.route,
                vec![self.target],
                Permission::ReadAndInput,
                60,
                renewal,
            )
            .unwrap()
    }

    fn grant(&self) -> GrantRef {
        self.pending(None).authenticated().unwrap().grant
    }

    fn request(&self, grant: GrantRef, sequence: u64) -> Request {
        Request {
            grant,
            target: self.target,
            operation: Operation::Input,
            sequence,
        }
    }
}

#[test]
fn rejected_or_abandoned_approval_creates_no_grant() {
    let f = Fixture::new();
    f.pending(None).reject();
    assert!(f.endpoint.list(&f.route).unwrap().is_empty());
    drop(f.pending(None));
    assert!(f.endpoint.list(&f.route).unwrap().is_empty());
    assert!(f.pending(None).authenticated().is_ok());
}

#[test]
fn failed_renewal_keeps_the_original_scope_and_deadline() {
    let f = Fixture::new();
    let grant = f.grant();
    f.clock.set(30);
    f.pending(Some(grant)).reject();
    let grants = f.endpoint.list(&f.route).unwrap();
    assert_eq!(grants[0].grant, grant);
    assert_eq!(grants[0].remaining, Duration::from_secs(30));
    f.clock.set(60);
    assert!(f.endpoint.list(&f.route).unwrap().is_empty());
}

#[test]
fn expired_or_revoked_grant_cannot_be_revived_by_a_late_renewal() {
    for revoke in [false, true] {
        let f = Fixture::new();
        let grant = f.grant();
        let pending = f.pending(Some(grant));
        if revoke {
            f.authority.revoke(grant).unwrap();
        } else {
            f.clock.set(60);
        }
        assert!(matches!(pending.authenticated(), Err(Error::StaleApproval)));
        assert!(f.endpoint.list(&f.route).unwrap().is_empty());
    }
}

#[test]
fn explicit_revocation_covers_a_renewal_completed_after_the_ui_snapshot() {
    for operation in [Operation::Read, Operation::Input] {
        let f = Fixture::new();
        let displayed = f.grant();
        let renewed = f.pending(Some(displayed)).authenticated().unwrap().grant;
        let mut request = f.request(renewed, 1);
        request.operation = operation;
        let permit = f.endpoint.accept(&f.route, request).unwrap();
        permit.execute(f.target, || ()).unwrap();

        f.authority.revoke_current(&f.route, displayed.id).unwrap();

        let mut submitted = false;
        assert!(permit.execute(f.target, || submitted = true).is_err());
        assert!(!submitted);
        assert!(f.endpoint.list(&f.route).unwrap().is_empty());
        assert!(f.endpoint.accept(&f.route, f.request(renewed, 2)).is_err());
        f.authority.revoke_current(&f.route, displayed.id).unwrap();
    }
}

#[test]
fn explicit_revocation_cancels_pending_renewals_of_any_version() {
    for renew_first in [false, true] {
        let f = Fixture::new();
        let displayed = f.grant();
        let current = if renew_first {
            f.pending(Some(displayed)).authenticated().unwrap().grant
        } else {
            displayed
        };
        let pending = f.pending(Some(current));
        f.authority.revoke_current(&f.route, displayed.id).unwrap();
        assert!(matches!(pending.authenticated(), Err(Error::StaleApproval)));
        assert!(f.endpoint.list(&f.route).unwrap().is_empty());
        assert!(f.pending(None).authenticated().is_ok());
    }
}

#[test]
fn explicit_revocation_leaves_other_grants_and_approvals_intact() {
    for renewal in [false, true] {
        let f = Fixture::new();
        let displayed = f.grant();
        let other_target = Target::new(2, f.target.owner).unwrap();
        let other = if renewal {
            Some(
                f.authority
                    .prepare(&f.route, vec![other_target], Permission::Read, 60, None)
                    .unwrap()
                    .authenticated()
                    .unwrap()
                    .grant,
            )
        } else {
            None
        };
        let pending = f
            .authority
            .prepare(&f.route, vec![other_target], Permission::Read, 60, other)
            .unwrap();
        f.authority.revoke_current(&f.route, displayed.id).unwrap();
        let approved = pending.authenticated().unwrap();
        let grants = f.endpoint.list(&f.route).unwrap();
        assert_eq!(grants.len(), 1);
        assert_eq!(grants[0].grant, approved.grant);
        assert_eq!(grants[0].targets, [other_target]);
    }
}

#[test]
fn explicit_revocation_cannot_cross_route_or_authority_boundaries() {
    let f = Fixture::new();
    let current = f.grant();
    let pending = f.pending(Some(current));
    let other_route = f.authority.register_route().unwrap();
    f.authority
        .revoke_current(&other_route, current.id)
        .unwrap();
    let other_authority = Fixture::new();
    assert!(f
        .authority
        .revoke_current(&other_authority.route, current.id)
        .is_err());
    let permit = f.endpoint.accept(&f.route, f.request(current, 1)).unwrap();
    assert!(permit.execute(f.target, || ()).is_ok());
    assert!(pending.authenticated().is_ok());
}

#[test]
fn version_specific_cleanup_preserves_a_replacement_and_its_pending_renewal() {
    let f = Fixture::new();
    let old = f.grant();
    let current = f.pending(Some(old)).authenticated().unwrap().grant;
    let pending = f.pending(Some(current));
    f.authority.revoke(old).unwrap();
    let permit = f.endpoint.accept(&f.route, f.request(current, 1)).unwrap();
    assert!(permit.execute(f.target, || ()).is_ok());
    assert!(pending.authenticated().is_ok());
}

#[test]
fn lock_and_unlock_invalidate_the_old_authentication_callback() {
    let f = Fixture::new();
    let pending = f.pending(None);
    f.authority.session_changed(false).unwrap();
    f.authority.session_changed(true).unwrap();
    assert!(matches!(pending.authenticated(), Err(Error::StaleApproval)));
    assert!(f.endpoint.list(&f.route).unwrap().is_empty());
}

#[test]
fn authentication_has_an_absolute_deadline() {
    let f = Fixture::new();
    let pending = f.pending(None);
    f.clock.set(AUTH_TIMEOUT_SECS);
    assert!(matches!(pending.authenticated(), Err(Error::StaleApproval)));
}

#[test]
fn input_is_checked_again_at_each_submission_step() {
    let f = Fixture::new();
    let grant = f.grant();
    let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
    let mut submissions = vec![];
    permit
        .execute(f.target, || submissions.push("text"))
        .unwrap();
    f.authority.revoke(grant).unwrap();
    assert!(permit
        .execute(f.target, || submissions.push("enter"))
        .is_err());
    assert_eq!(submissions, ["text"]);
}

#[test]
fn snapshot_revoked_before_send_is_not_released() {
    let f = Fixture::new();
    let grant = f.grant();
    let mut request = f.request(grant, 1);
    request.operation = Operation::Read;
    let permit = f.endpoint.accept(&f.route, request).unwrap();
    let body = permit.execute(f.target, || "example output").unwrap();
    f.authority.invalidate_target(f.target).unwrap();
    let mut released = false;
    assert!(permit
        .execute(f.target, || {
            let _ = body;
            released = true;
        })
        .is_err());
    assert!(!released);
}

#[test]
fn renewal_invalidates_queued_work_without_resetting_the_replay_watermark() {
    let f = Fixture::new();
    let old = f.grant();
    let permit = f.endpoint.accept(&f.route, f.request(old, 7)).unwrap();
    let new = f.pending(Some(old)).authenticated().unwrap().grant;
    assert_eq!(new.id, old.id);
    assert_eq!(new.version, old.version + 1);
    assert!(permit.execute(f.target, || ()).is_err());
    assert!(matches!(
        f.endpoint.accept(&f.route, f.request(new, 7)),
        Err(Error::Replay)
    ));
    assert!(f.endpoint.accept(&f.route, f.request(new, 8)).is_ok());
}

#[test]
fn dropping_a_request_does_not_make_input_retryable() {
    let f = Fixture::new();
    let grant = f.grant();
    drop(f.endpoint.accept(&f.route, f.request(grant, 42)).unwrap());
    assert!(matches!(
        f.endpoint.accept(&f.route, f.request(grant, 42)),
        Err(Error::Replay)
    ));
}

#[test]
fn route_shutdown_cancels_pending_approval_and_queued_requests() {
    let f = Fixture::new();
    let grant = f.grant();
    let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
    let pending = f.pending(Some(grant));
    drop(f.route);
    assert!(permit.execute(f.target, || ()).is_err());
    assert!(matches!(pending.authenticated(), Err(Error::StaleApproval)));
}

#[test]
fn an_identical_pane_number_on_another_route_or_incarnation_is_denied() {
    let f = Fixture::new();
    let grant = f.grant();
    let other = f.authority.register_route().unwrap();
    assert!(f.endpoint.accept(&other, f.request(grant, 1)).is_err());
    let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
    let new = Target::new(f.target.pane, f.target.owner).unwrap();
    assert!(permit.execute(new, || ()).is_err());
    let new_owner = Target {
        owner: Id::from_bytes([2; 16]),
        ..f.target
    };
    assert!(permit.execute(new_owner, || ()).is_err());
}

#[test]
fn unavailable_clock_or_backwards_time_revokes_existing_authorization() {
    for backwards in [false, true] {
        let f = Fixture::new();
        f.clock.set(10);
        let grant = f.grant();
        let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
        if backwards {
            f.clock.set(9);
        } else {
            f.clock.failed.store(true, Ordering::Relaxed);
        }
        assert!(matches!(permit.execute(f.target, || ()), Err(Error::Clock)));
        f.clock.failed.store(false, Ordering::Relaxed);
        f.clock.set(11);
        f.authority.session_changed(true).unwrap();
        assert!(f.endpoint.list(&f.route).unwrap().is_empty());
    }
}

#[test]
fn a_pending_request_cannot_extend_its_deadline_by_making_progress() {
    let f = Fixture::new();
    let grant = f.grant();
    let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
    for second in 0..REQUEST_TIMEOUT_SECS {
        f.clock.set(second);
        permit.execute(f.target, || ()).unwrap();
    }
    f.clock.set(REQUEST_TIMEOUT_SECS);
    assert!(matches!(
        permit.execute(f.target, || ()),
        Err(Error::Timeout)
    ));
}

#[test]
fn read_only_grants_cannot_be_used_for_input() {
    let f = Fixture::new();
    let grant = f
        .authority
        .prepare(&f.route, vec![f.target], Permission::Read, 60, None)
        .unwrap()
        .authenticated()
        .unwrap()
        .grant;
    assert!(f.endpoint.accept(&f.route, f.request(grant, 1)).is_err());
    let mut request = f.request(grant, 1);
    request.operation = Operation::Read;
    assert!(f.endpoint.accept(&f.route, request).is_ok());
}

#[test]
fn a_route_has_one_round_trippable_export_per_pane() {
    let f = Fixture::new();
    let grant = f.grant();
    let captured_again = Target::new(f.target.pane, Id::from_bytes([9; 16])).unwrap();
    assert!(matches!(
        f.authority
            .prepare(&f.route, vec![captured_again], Permission::Read, 60, None),
        Err(Error::Busy)
    ));
    assert!(f
        .authority
        .prepare(
            &f.route,
            vec![captured_again],
            Permission::Read,
            60,
            Some(grant)
        )
        .is_ok());
}

#[test]
fn forwarding_may_shorten_but_cannot_extend_executor_deadlines() {
    let f = Fixture::new();
    let grant = f.grant();
    assert!(f
        .endpoint
        .accept_for(&f.route, f.request(grant, 1), Duration::from_secs(11))
        .is_err());
    let permit = f
        .endpoint
        .accept_for(&f.route, f.request(grant, 1), Duration::from_secs(2))
        .unwrap();
    let list = f
        .endpoint
        .accept_list_for(&f.route, 2, Duration::from_secs(1))
        .unwrap();
    f.clock.set(1);
    assert!(list.execute(&[(grant, f.target)], || ()).is_err());
    assert!(permit.execute(f.target, || ()).is_ok());
    f.clock.set(2);
    assert_eq!(permit.execute(f.target, || ()), Err(Error::Timeout));
}

#[test]
fn repeated_authorize_request_revoke_disconnect_cycles_release_all_permits() {
    use crate::budget::Budgets;
    use crate::wire::Assembly;
    let clock = Arc::new(TestClock::default());
    let (authority, endpoint) = Authority::with_clock(clock.clone());
    let budgets = Budgets::with_clock(clock.clone()).unwrap();
    authority.session_changed(true).unwrap();
    for cycle in 0..100 {
        clock.set(cycle * 20);
        let route = authority.register_route().unwrap();
        let budget = budgets.open_route(route.id()).unwrap();
        let target = Target::new(cycle, Id::from_bytes([1; 16])).unwrap();
        let grant = authority
            .prepare(&route, vec![target], Permission::ReadAndInput, 60, None)
            .unwrap()
            .authenticated()
            .unwrap()
            .grant;
        let request = Request {
            grant,
            target,
            operation: Operation::Input,
            sequence: 1,
        };
        let permit = endpoint.accept(&route, request).unwrap();
        let mut body = Assembly::input(7, &budget).unwrap();
        body.append(0, b"example").unwrap();
        let body = body.finish().unwrap();
        assert_eq!(permit.execute(target, || body.text().len()).unwrap(), 7);
        authority.revoke(grant).unwrap();
        assert!(permit.execute(target, || ()).is_err());
        assert!(endpoint.accept(&route, request).is_err());
        drop((body, permit, route, budget));
        assert_eq!(budgets.retained().unwrap(), (0, 0));
        let state = authority.shared.state.lock().unwrap();
        assert!(state.grants.is_empty());
        assert!(state.routes.is_empty());
        assert!(state.pending.is_none());
    }
}

#[test]
fn authority_exit_revokes_even_when_the_data_plane_remains_alive() {
    let f = Fixture::new();
    let grant = f.grant();
    let permit = f.endpoint.accept(&f.route, f.request(grant, 1)).unwrap();
    drop(f.authority);
    assert!(permit.execute(f.target, || ()).is_err());
}

#[test]
fn another_authority_cannot_register_a_route_or_target_for_this_one() {
    let f = Fixture::new();
    let other = Fixture::new();
    assert!(f
        .authority
        .prepare(&other.route, vec![f.target], Permission::Read, 60, None)
        .is_err());
    assert!(f.endpoint.list(&other.route).is_err());
}