What is the correct way to test an Actor?

[nsengupta]

I have a regular Actor. It specifies a vocabulary, which is an enum.

#[derive(RactorMessage)]
pub enum ElevatorVocabulary {
    DoorClosed(u8, ActorRef<ElevatorVocabulary>),
    OpenTheDoor(u8,ActorRef<ElevatorVocabulary>),
    MoveToFloor(u8, ActorRef<ElevatorVocabulary>),
    Stop(u8,ActorRef<ElevatorVocabulary>),
    Stay(u8,ActorRef<ElevatorVocabulary>),
    PowerOn(Option<ActorRef<ElevatorVocabulary>>),
    PowerOff(Option<ActorRef<ElevatorVocabulary>>),
}

#[cfg(feature = "cluster")]
impl ractor::Message for ElevatorVocabulary {}

The handler loop is quite ordinary too:

pub struct ElevatorInstallation;
#[async_trait]
impl Actor for ElevatorInstallation {
    type Msg = ElevatorVocabulary;
    type State = Carriage<ElevatorStateMachine>;
    type Arguments = u16;

    async fn pre_start(&self, myself: ActorRef<Self::Msg>, args: Self::Arguments) -> 
        Result<Self::State, ActorProcessingErr> {
            // ..
            Ok(/* something */)
    }

    async fn handle(
        &self,
        myself: ActorRef<Self::Msg>,
        message: Self::Msg,
        carriage: &mut Self::State,
    ) -> Result<(), ActorProcessingErr> {

        match message {
            ElevatorVocabulary::PowerOn(reply_to) => {
                let outcome = some_function(carriage);
                
                match outcome {
                    (_, Some(Elevator::SettleAtGroundFloor)) => {
                        reply_to.map(|target| target.cast(MoveToFloor(0, myself.clone()))); // I need to test this.
                    },
                    (_, None)   => { /* ...  */ },
                }
            },
          // ....

My test driver is structured this way:

  
     use ractor::Actor;
     use ractor::call_t;
     use crate::elevator_service::ElevatorVocabulary;
     use super::ElevatorInstallation;

  #[tokio::test]
    async fn when_powered_on_elev_should_goto_ground_floor() -> () {
        let (actor_ref, actor_handle) = 
            Actor::spawn(
                Some(String::from("Elevator-Actor")),
                ElevatorInstallation,
                0
            ).await
            .expect("Failed to start actor"); 

        // The following line fails to compile!
        let resp1 = call_t!(actor_ref,ElevatorVocabulary::PowerOn(None),1).unwrap();  // Problem!

        assert_eq!(
                  match resp1 {
                              ElevatorVocabulary::MoveToFloor(0,_) => true,
                              _ => false
                    }, 
                   true
         );
    }

The compiler says (screenshot):

It seems to me that I am missing something crucial about RpcReplyPort but the error message baffles me. Am I missing something obvious?

I have been following the documentation of call_t! : here

In case the context helps, my intention is to draw a pattern of 'testing' Actors, much in the line of Akka's TestActor.

[slawlor]

You shouldnt be sending an actor handle as the reply, this is what RpcReplyPort is specifically for. It's a channel to receive the reply of a defined message type. It's what all the call macros are expecting as the last argument of the tuple including ActorRef.call.

If you look at the source code for the crate, the tests for the rpc module should show you how the usage is expected to be defined.

Additionally your test comparison would be a bit easier to reason about with assert!(matches!(ExpectedPattern, result))