runact 1.0.0

A Rust-native actor runtime with BEAM-style processes
Documentation
use std::any::Any;
use std::time::Duration;
use runact::{Actor, ActorContext, ActorError, Runtime, ResourceHandle, Capability, ResourceRegistry};

#[derive(Debug)]
struct FileHandle {
    path: String,
    writable: bool,
}

impl ResourceHandle for FileHandle {
    fn resource_type(&self) -> &str {
        "file"
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}

struct FileReaderActor {
    file_cap: Option<Capability<FileHandle>>,
}

#[derive(Clone)]
enum FileReaderMessage {
    SetCapability(Capability<FileHandle>),
    ReadFile,
}

impl Actor for FileReaderActor {
    type Message = FileReaderMessage;

    fn handle(&mut self, msg: FileReaderMessage, ctx: &mut ActorContext) -> Result<(), ActorError> {
        match msg {
            FileReaderMessage::SetCapability(cap) => {
                self.file_cap = Some(cap);
            }
            FileReaderMessage::ReadFile => {
                if let Some(cap) = &self.file_cap {
                    let path = cap.handle().path.clone();
                    let _ = ctx.reply(path);
                } else {
                    let _ = ctx.reply("no capability".to_string());
                }
            }
        }
        Ok(())
    }
}

#[test]
fn test_capability_creation() {
    let mut runtime = Runtime::new().expect("Failed to create runtime");
    let actor = runtime.spawn(FileReaderActor { file_cap: None }).expect("Failed to spawn");

    let file = FileHandle {
        path: "/tmp/test.txt".to_string(),
        writable: false,
    };
    let cap = Capability::new(actor, file);

    assert_eq!(cap.owner(), actor);
    assert_eq!(cap.handle().path, "/tmp/test.txt");
    assert!(!cap.handle().writable);
}

#[test]
fn test_capability_clone() {
    let mut runtime = Runtime::new().expect("Failed to create runtime");
    let actor = runtime.spawn(FileReaderActor { file_cap: None }).expect("Failed to spawn");

    let file = FileHandle {
        path: "/tmp/test.txt".to_string(),
        writable: true,
    };
    let cap = Capability::new(actor, file);
    let cap2 = cap.clone();

    assert_eq!(cap.owner(), cap2.owner());
    assert_eq!(cap.handle().path, cap2.handle().path);
}

#[test]
fn test_actor_receives_capability() {
    let mut runtime = Runtime::new().expect("Failed to create runtime");
    let actor = runtime.spawn(FileReaderActor { file_cap: None }).expect("Failed to spawn");

    let file = FileHandle {
        path: "/tmp/test.txt".to_string(),
        writable: false,
    };
    let cap = Capability::new(actor, file);

    runtime.send(actor, FileReaderMessage::SetCapability(cap)).expect("Failed to send");
    std::thread::sleep(Duration::from_millis(50));

    let handle = runtime.request(actor, FileReaderMessage::ReadFile).expect("Failed to request");
    let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
    let path = reply.downcast::<String>().expect("Failed to downcast");
    assert_eq!(*path, "/tmp/test.txt");
}

#[test]
fn test_resource_registry() {
    let registry = ResourceRegistry::new();
    let mut runtime = Runtime::new().expect("Failed to create runtime");
    let actor = runtime.spawn(FileReaderActor { file_cap: None }).expect("Failed to spawn");

    let file = FileHandle {
        path: "/tmp/test.txt".to_string(),
        writable: true,
    };
    let cap = Capability::new(actor, file);
    registry.register(cap);

    let retrieved: Option<Capability<FileHandle>> = registry.get();
    assert!(retrieved.is_some());
    assert_eq!(retrieved.unwrap().handle().path, "/tmp/test.txt");
}

#[test]
fn test_resource_registry_remove() {
    let registry = ResourceRegistry::new();
    let mut runtime = Runtime::new().expect("Failed to create runtime");
    let actor = runtime.spawn(FileReaderActor { file_cap: None }).expect("Failed to spawn");

    let file = FileHandle {
        path: "/tmp/test.txt".to_string(),
        writable: false,
    };
    let cap = Capability::new(actor, file);
    registry.register(cap);

    assert!(registry.has::<FileHandle>());
    let removed: Option<Capability<FileHandle>> = registry.remove();
    assert!(removed.is_some());
    assert!(!registry.has::<FileHandle>());
}