subc-client-rs 0.35.0

Shared serve + consume client for Rust subc modules.
Documentation
use super::*;
use serde_json::json;

fn fake_consumer() -> (Arc<SubcConsumer>, mpsc::Receiver<WriteCommand>) {
    let shared = Arc::new(Shared::new(PathBuf::new(), ConsumerOptions::default()));
    let (writer, rx) = mpsc::channel(1);
    shared.lock_inner().writer = Some(writer);
    shared.lock_inner().daemon_ver = "0.39.0".into();
    (Arc::new(SubcConsumer { shared }), rx)
}

async fn answer(
    consumer: &SubcConsumer,
    request: WriteCommand,
    ty: FrameType,
    body: serde_json::Value,
) {
    assert_eq!(request.frame.header.channel, 0);
    let frame = Frame::build(
        ty,
        Flags::new(false, Priority::Passive, false),
        0,
        0,
        request.frame.header.corr,
        serde_json::to_vec(&body).unwrap(),
    )
    .unwrap();
    assert!(dispatch_frame(&consumer.shared, 1, frame).await);
}

#[tokio::test]
async fn describe_connection_decodes_facts_and_only_unknown_control_op_is_older() {
    for (ty, body) in [
        (
            FrameType::Response,
            json!({"op":"connection.describe", "local":true, "operator_app":{"app":"fixture", "pid":42}}),
        ),
        (
            FrameType::Error,
            json!({"code":"unknown_control_op", "message":"unknown client control op"}),
        ),
        (
            FrameType::Error,
            json!({"code":"unsupported_control_frame", "message":"not an older client dispatcher"}),
        ),
        (
            FrameType::Error,
            json!({"code":"invalid_control_body", "message":"bad request"}),
        ),
        (FrameType::Response, json!({"op":"app.open", "local":true})),
    ] {
        let (consumer, mut rx) = fake_consumer();
        let call_consumer = consumer.clone();
        let call = tokio::spawn(async move { call_consumer.describe_connection().await });
        let request = rx.recv().await.unwrap();
        assert_eq!(
            serde_json::from_slice::<serde_json::Value>(&request.frame.body).unwrap(),
            json!({"op":"connection.describe"})
        );
        answer(&consumer, request, ty, body.clone()).await;
        let result = call.await.unwrap();
        match body["code"].as_str() {
            Some("unknown_control_op") => assert!(result.unwrap().is_none()),
            Some(code) => assert_eq!(result.unwrap_err().code(), Some(code)),
            None if body["op"] == "connection.describe" => {
                let facts = result.unwrap().unwrap();
                assert!(facts.local());
                assert_eq!(
                    facts.operator_app(),
                    Some(&subc_protocol::peer::OperatorApp::new("fixture", 42))
                );
            }
            None => assert_eq!(
                result.unwrap_err().not_sent_cause(),
                Some(NotSentCause::InvalidResponse)
            ),
        }
    }
}

#[tokio::test]
async fn app_open_preserves_successes_future_statuses_and_all_daemon_refusals() {
    for status in ["launched", "already_running", "future_status"] {
        let (consumer, mut rx) = fake_consumer();
        let caller = consumer.clone();
        let call = tokio::spawn(async move { caller.app_open("fixture").await });
        let request = rx.recv().await.unwrap();
        assert_eq!(
            serde_json::from_slice::<serde_json::Value>(&request.frame.body).unwrap(),
            json!({"op":"app.open", "app":"fixture"})
        );
        answer(
            &consumer,
            request,
            FrameType::Response,
            json!({"op":"app.open", "status":status, "pid":4242}),
        )
        .await;
        let reply = call.await.unwrap().unwrap();
        assert_eq!(serde_json::to_value(&reply).unwrap()["status"], status);
        assert_eq!(reply.pid, 4242);
    }
    for code in subc_control::APP_OPEN_ERROR_CODES
        .into_iter()
        .chain(["future_refusal", "unknown_control_op"])
    {
        let (consumer, mut rx) = fake_consumer();
        let caller = consumer.clone();
        let call = tokio::spawn(async move { caller.app_open("fixture").await });
        answer(
            &consumer,
            rx.recv().await.unwrap(),
            FrameType::Error,
            json!({"code":code, "message":"fixture refusal"}),
        )
        .await;
        assert!(
            matches!(call.await.unwrap(), Err(AppOpenError::Refused { code: actual, message }) if actual == code && message == "fixture refusal")
        );
    }
}

#[tokio::test]
async fn connection_operations_preserve_call_failures() {
    let (consumer, _rx) = fake_consumer();
    consumer.close().await;
    assert!(consumer.describe_connection().await.is_err());
    assert!(matches!(
        consumer.app_open("fixture").await,
        Err(AppOpenError::Call(_))
    ));

    let (consumer, mut rx) = fake_consumer();
    let caller = consumer.clone();
    let call = tokio::spawn(async move { caller.app_open("fixture").await });
    answer(
        &consumer,
        rx.recv().await.unwrap(),
        FrameType::Response,
        json!({"op":"wrong", "pid":42, "status":"launched"}),
    )
    .await;
    assert!(matches!(call.await.unwrap(), Err(AppOpenError::Call(_))));
}