vyre-driver 0.4.1

//! Failure-oriented tests for backend capability negotiation.
//!
//! Guarantees:
//! - Unknown backends report conservative defaults (no dispatch, lowest precedence)
//! - The `Backend` blanket impl for `VyreBackend` never drifts
//! - Capability traits are object-safe so routers can hold `dyn` pointers

use vyre_driver::backend::{
    backend_dispatches, backend_precedence, registered_backends, registered_backends_by_precedence,
    Backend, BackendError, DispatchConfig, Executable, Streamable, VyreBackend,
};
use vyre_foundation::ir::Program;

struct MinimalBackend;

impl vyre_driver::backend::private::Sealed for MinimalBackend {}

impl VyreBackend for MinimalBackend {
    fn id(&self) -> &'static str {
        "minimal"
    }

    fn dispatch(
        &self,
        _program: &Program,
        _inputs: &[Vec<u8>],
        _config: &DispatchConfig,
    ) -> Result<Vec<Vec<u8>>, BackendError> {
        Ok(vec![])
    }
}

#[test]
fn unknown_backend_reports_no_dispatch_capability() {
    assert!(
        !backend_dispatches("nonexistent-backend"),
        "Fix: unknown backends must report dispatches=false"
    );
}

#[test]
fn unknown_backend_gets_lowest_precedence() {
    assert_eq!(
        backend_precedence("nonexistent-backend"),
        u32::MAX,
        "Fix: unknown backends must get lowest precedence"
    );
}

#[test]
fn empty_registry_by_precedence_is_empty() {
    // vyre-driver has no backend dependencies, so the in-crate view is empty
    let sorted = registered_backends_by_precedence();
    assert!(
        sorted.is_empty(),
        "Fix: vyre-driver alone must see zero backends; sorted list was non-empty"
    );
}

#[test]
fn empty_registry_iter_is_empty() {
    assert!(
        registered_backends().is_empty(),
        "Fix: vyre-driver alone must see zero backends"
    );
}

#[test]
fn backend_trait_blanket_impl_for_vyre_backend() {
    let backend = MinimalBackend;
    // These compile only if the blanket impl is alive.
    let as_backend: &dyn Backend = &backend;
    assert_eq!(as_backend.id(), "minimal");
    assert_eq!(as_backend.version(), "unspecified");
    // default_supported_ops returns the core op set; we only check it doesn't panic
    let _ = as_backend.supported_ops();
}

#[test]
fn backend_trait_is_object_safe() {
    // Compilation guard — if Backend ever loses object safety this test stops compiling.
    let _: Option<Box<dyn Backend>> = None;
}

#[test]
fn executable_trait_is_object_safe() {
    // Compilation guard — if Executable ever loses object safety this test stops compiling.
    let _: Option<Box<dyn Executable>> = None;
}

#[test]
fn streamable_trait_is_object_safe() {
    // Compilation guard — if Streamable ever loses object safety this test stops compiling.
    let _: Option<Box<dyn Streamable>> = None;
}