use std::sync::Arc;
use super::walk;
use crate::client::{MuseClient, StartSessionOptions, lock};
use crate::msp::{SessionDurability, ViewPageParams};
use crate::session::Session;
use crate::session::state::tests::StartsOneSession;
use crate::turn::TurnWaitError;
#[tokio::test(flavor = "current_thread")]
async fn a_walk_that_meets_a_closing_client_leaves_its_session_to_close() -> Result<(), String> {
let client = MuseClient::new(StartsOneSession::new(), SessionDurability::Durable);
let session = client
.start_session(StartSessionOptions::default())
.await
.map_err(|error| error.to_string())?;
let unsettled = Session::from_opening(
Arc::clone(&session.inner.client),
session.opening().clone(),
&[],
None,
);
client.close().await;
assert!(
matches!(
lock(&session.inner.state).event_source_failure,
Some(TurnWaitError::ClientClosed)
),
"control: close() settles the session it reaches as ClientClosed"
);
walk(
Arc::downgrade(&unsettled.inner),
ViewPageParams {
session_id: "session-1".to_owned(),
cursor: Some("cursor-1".to_owned()),
anchor: None,
direction: None,
limit: 1,
},
)
.await;
let failure = lock(&unsettled.inner.state).event_source_failure.clone();
assert!(
failure.is_none(),
"a walk that meets a closing client must leave its session to close(): {failure:?}"
);
Ok(())
}
struct StartsThenEnds {
inbound: tokio::sync::mpsc::UnboundedReceiver<String>,
replies: Option<tokio::sync::mpsc::UnboundedSender<String>>,
}
impl crate::DuplexTransport for StartsThenEnds {
fn read_chunk(
&mut self,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = std::io::Result<Option<String>>> + Send + '_>,
> {
Box::pin(async { Ok(self.inbound.recv().await) })
}
fn write(
&mut self,
frame: &str,
) -> std::pin::Pin<Box<dyn std::future::Future<Output = std::io::Result<()>> + Send + '_>> {
let request = serde_json::from_str::<serde_json::Value>(frame.trim()).ok();
let starts = request
.as_ref()
.is_some_and(|request| request["method"] == "session/start");
if !starts {
self.replies = None;
} else if let (Some(request), Some(replies)) = (request, self.replies.as_ref()) {
let reply = serde_json::json!({
"jsonrpc": "2.0",
"id": request["id"],
"result": {
"session": {
"sessionId": "session-1",
"path": "/tmp/session.jsonl",
"status": "idle",
"activeTurnId": null,
"createdAt": "2026-09-29T00:00:00Z",
"updatedAt": "2026-09-29T00:00:00Z",
"workspaceRoot": null,
"providerId": null,
"modelId": null,
"turnCount": 0,
"forkedFrom": null
},
"viewCursor": "cursor-1"
}
});
let _ = replies.send(format!("{reply}\n"));
}
Box::pin(async { Ok(()) })
}
}
#[tokio::test(flavor = "current_thread")]
async fn a_walk_that_meets_an_ended_transport_leaves_its_session_to_the_sweep() -> Result<(), String>
{
let (replies, inbound) = tokio::sync::mpsc::unbounded_channel();
let client = MuseClient::new(
StartsThenEnds {
inbound,
replies: Some(replies),
},
SessionDurability::Durable,
);
let session = client
.start_session(StartSessionOptions::default())
.await
.map_err(|error| error.to_string())?;
let unsettled = Session::from_opening(
Arc::clone(&session.inner.client),
session.opening().clone(),
&[],
None,
);
let ended = session
.send_user_turn(crate::session::SendUserTurnOptions::default())
.await
.err();
assert!(
matches!(ended, Some(crate::client::FacadeError::TransportEnded)),
"control: the request observes the ended transport, got {ended:?}"
);
assert!(
matches!(
lock(&session.inner.state).event_source_failure,
Some(TurnWaitError::SourceClosed)
),
"control: the sweep settles the session it reaches as SourceClosed (TransportEnded), got {:?}",
lock(&session.inner.state).event_source_failure
);
walk(
Arc::downgrade(&unsettled.inner),
ViewPageParams {
session_id: "session-1".to_owned(),
cursor: Some("cursor-1".to_owned()),
anchor: None,
direction: None,
limit: 1,
},
)
.await;
let failure = lock(&unsettled.inner.state).event_source_failure.clone();
assert!(
failure.is_none(),
"a walk that meets an ended transport must leave its session to the sweep: {failure:?}"
);
Ok(())
}