use serde_json::Value;
use std::collections::HashMap;
pub const PROTOCOL_VERSION: i64 = 1;
#[derive(Debug, Clone)]
pub struct Envelope<T> {
pub v: i64,
pub id: Option<String>,
pub seq: Option<u64>,
pub msg_type: String,
pub payload: T,
}
impl<T> Envelope<T> {
pub fn into_payload(self) -> T {
self.payload
}
pub fn payload(&self) -> &T {
&self.payload
}
}
#[derive(Debug, serde::Deserialize)]
struct WireEnvelope {
v: i64,
id: Option<String>,
seq: Option<u64>,
#[serde(rename = "type")]
msg_type: String,
payload: Value,
}
pub trait MessagePayload: Sized {
fn msg_type(&self) -> &str;
fn serialize_payload(&self) -> Result<Value, ProtocolError>;
fn deserialize_payload(msg_type: &str, payload: Value) -> Result<Self, ProtocolError>;
}
pub fn parse_line<T: MessagePayload>(line: &str) -> Result<Envelope<T>, ProtocolError> {
let trimmed = line.trim();
if trimmed.is_empty() {
return Err(ProtocolError::new(ErrorCode::InvalidMessage, "empty line"));
}
let wire: WireEnvelope = serde_json::from_str(trimmed).map_err(|e| {
ProtocolError::new(
ErrorCode::InvalidMessage,
format!("JSON parse error: {}", e),
)
})?;
if wire.v < 1 {
return Err(ProtocolError::new(
ErrorCode::InvalidMessage,
format!("unsupported protocol version: {}", wire.v),
));
}
let payload = T::deserialize_payload(&wire.msg_type, wire.payload)?;
Ok(Envelope {
v: wire.v,
id: wire.id,
seq: wire.seq,
msg_type: wire.msg_type,
payload,
})
}
pub fn to_json_line<T: MessagePayload>(envelope: &Envelope<T>) -> Result<String, ProtocolError> {
let mut map = serde_json::Map::new();
map.insert("v".to_string(), Value::from(envelope.v));
if let Some(id) = &envelope.id {
map.insert("id".to_string(), Value::String(id.clone()));
}
if let Some(seq) = envelope.seq {
map.insert("seq".to_string(), Value::from(seq));
}
map.insert("type".to_string(), Value::String(envelope.msg_type.clone()));
let payload = envelope.payload.serialize_payload()?;
map.insert("payload".to_string(), payload);
serde_json::to_string(&Value::Object(map)).map_err(|e| {
ProtocolError::new(
ErrorCode::InvalidMessage,
format!("envelope serialization error: {}", e),
)
})
}
#[derive(Debug, Clone)]
pub enum Request {
Hello {
version: i64,
},
Command {
name: String,
args: Vec<String>,
target: Option<String>,
},
Input {
kind: InputKind,
value: String,
},
Focus {
view: String,
},
Resize {
rows: u16,
cols: u16,
},
ViewAction {
view: String,
action: String,
args: HashMap<String, Value>,
},
ViewSubscribe {
view: String,
},
ViewUnsubscribe {
view: String,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum InputKind {
Key,
Text,
Ping,
}
impl Request {
pub fn msg_type(&self) -> &str {
match self {
Request::Hello { .. } => "hello",
Request::Command { .. } => "command",
Request::Input { .. } => "input",
Request::Focus { .. } => "focus",
Request::Resize { .. } => "resize",
Request::ViewAction { .. } => "view.action",
Request::ViewSubscribe { .. } => "view.subscribe",
Request::ViewUnsubscribe { .. } => "view.unsubscribe",
}
}
pub fn hello(version: i64) -> Self {
Request::Hello { version }
}
pub fn command(name: String, args: Vec<String>, target: Option<String>) -> Self {
Request::Command { name, args, target }
}
pub fn input(kind: InputKind, value: String) -> Self {
Request::Input { kind, value }
}
pub fn focus(view: String) -> Self {
Request::Focus { view }
}
pub fn resize(rows: u16, cols: u16) -> Self {
Request::Resize { rows, cols }
}
pub fn view_action(view: String, action: String, args: HashMap<String, Value>) -> Self {
Request::ViewAction { view, action, args }
}
pub fn view_subscribe(view: String) -> Self {
Request::ViewSubscribe { view }
}
pub fn view_unsubscribe(view: String) -> Self {
Request::ViewUnsubscribe { view }
}
pub fn command_fields(&self) -> Option<(&str, &[String], Option<&str>)> {
if let Request::Command { name, args, target } = self {
Some((name.as_str(), args.as_slice(), target.as_deref()))
} else {
None
}
}
pub fn input_fields(&self) -> Option<(InputKind, &str)> {
if let Request::Input { kind, value } = self {
Some((*kind, value.as_str()))
} else {
None
}
}
pub fn view_id(&self) -> Option<&str> {
match self {
Request::Focus { view }
| Request::ViewAction { view, .. }
| Request::ViewSubscribe { view }
| Request::ViewUnsubscribe { view } => Some(view.as_str()),
_ => None,
}
}
}
impl Envelope<Request> {
pub fn from_request(req: Request, id: String) -> Envelope<Request> {
Envelope {
v: PROTOCOL_VERSION,
id: Some(id),
seq: None,
msg_type: req.msg_type().to_string(),
payload: req,
}
}
}
impl MessagePayload for Request {
fn msg_type(&self) -> &str {
match self {
Request::Hello { .. } => "hello",
Request::Command { .. } => "command",
Request::Input { .. } => "input",
Request::Focus { .. } => "focus",
Request::Resize { .. } => "resize",
Request::ViewAction { .. } => "view.action",
Request::ViewSubscribe { .. } => "view.subscribe",
Request::ViewUnsubscribe { .. } => "view.unsubscribe",
}
}
fn serialize_payload(&self) -> Result<Value, ProtocolError> {
let val = match self {
Request::Hello { version } => serde_json::json!({ "version": version }),
Request::Command { name, args, target } => {
serde_json::json!({ "name": name, "args": args, "target": target })
}
Request::Input { kind, value } => {
serde_json::json!({ "kind": kind, "value": value })
}
Request::Focus { view } => serde_json::json!({ "view": view }),
Request::Resize { rows, cols } => serde_json::json!({ "rows": rows, "cols": cols }),
Request::ViewAction { view, action, args } => {
serde_json::json!({ "view": view, "action": action, "args": args })
}
Request::ViewSubscribe { view } => serde_json::json!({ "view": view }),
Request::ViewUnsubscribe { view } => serde_json::json!({ "view": view }),
};
Ok(val)
}
fn deserialize_payload(msg_type: &str, payload: Value) -> Result<Self, ProtocolError> {
match msg_type {
"hello" => {
let version = payload
.get("version")
.and_then(|v| v.as_i64())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "hello: missing version")
})?;
Ok(Request::Hello { version })
}
"command" => {
let name = payload
.get("name")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "command: missing name")
})?
.to_string();
let args = payload
.get("args")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(String::from))
.collect()
})
.unwrap_or_default();
let target = payload
.get("target")
.and_then(|v| v.as_str())
.map(String::from);
Ok(Request::Command { name, args, target })
}
"input" => {
let kind_str = payload
.get("kind")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "input: missing kind")
})?;
let kind = match kind_str {
"key" => InputKind::Key,
"text" => InputKind::Text,
"ping" => InputKind::Ping,
_ => {
return Err(ProtocolError::new(
ErrorCode::BadRequest,
format!("input: unknown kind: {}", kind_str),
))
}
};
let value = payload
.get("value")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "input: missing value")
})?
.to_string();
Ok(Request::Input { kind, value })
}
"focus" => {
let view = payload
.get("view")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "focus: missing view")
})?
.to_string();
Ok(Request::Focus { view })
}
"resize" => {
let rows = payload
.get("rows")
.and_then(|v| v.as_u64())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "resize: missing rows")
})? as u16;
let cols = payload
.get("cols")
.and_then(|v| v.as_u64())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "resize: missing cols")
})? as u16;
Ok(Request::Resize { rows, cols })
}
"view.action" => {
let view = payload
.get("view")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "view.action: missing view")
})?
.to_string();
let action = payload
.get("action")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "view.action: missing action")
})?
.to_string();
let args = payload
.get("args")
.and_then(|v| v.as_object())
.map(|obj| obj.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
.unwrap_or_default();
Ok(Request::ViewAction { view, action, args })
}
"view.subscribe" => {
let view = payload
.get("view")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "view.subscribe: missing view")
})?
.to_string();
Ok(Request::ViewSubscribe { view })
}
"view.unsubscribe" => {
let view = payload
.get("view")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "view.unsubscribe: missing view")
})?
.to_string();
Ok(Request::ViewUnsubscribe { view })
}
_ => Err(ProtocolError::new(
ErrorCode::UnknownType,
format!("unknown request type: {}", msg_type),
)),
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Cursor {
pub row: u64,
pub col: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum NotificationLevel {
Info,
Warning,
Error,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum ErrorCode {
InvalidMessage,
UnknownType,
UnsupportedVersion,
BadRequest,
UnknownView,
UnknownCommand,
CapabilityDenied,
Internal,
}
impl ErrorCode {
pub fn as_str(&self) -> &'static str {
match self {
ErrorCode::InvalidMessage => "invalid_message",
ErrorCode::UnknownType => "unknown_type",
ErrorCode::UnsupportedVersion => "unsupported_version",
ErrorCode::BadRequest => "bad_request",
ErrorCode::UnknownView => "unknown_view",
ErrorCode::UnknownCommand => "unknown_command",
ErrorCode::CapabilityDenied => "capability_denied",
ErrorCode::Internal => "internal",
}
}
}
impl std::fmt::Display for ErrorCode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone)]
pub struct ProtocolError {
pub code: ErrorCode,
pub message: String,
}
impl ProtocolError {
pub fn new(code: ErrorCode, message: impl Into<String>) -> Self {
ProtocolError {
code,
message: message.into(),
}
}
}
impl std::fmt::Display for ProtocolError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}: {}", self.code, self.message)
}
}
impl std::error::Error for ProtocolError {}
#[derive(Debug, Clone)]
pub enum Response {
Reply {
ok: bool,
result: Value,
},
Error {
code: String,
message: String,
},
Event {
name: String,
data: Value,
},
State {
view: String,
lines: Vec<String>,
cursor: Cursor,
file_path: Option<String>,
mode: String,
},
Notification {
level: NotificationLevel,
message: String,
},
Layout {
root: String,
children: Vec<String>,
},
}
impl Response {
pub fn msg_type(&self) -> &str {
match self {
Response::Reply { .. } => "reply",
Response::Error { .. } => "error",
Response::Event { .. } => "event",
Response::State { .. } => "state",
Response::Notification { .. } => "notification",
Response::Layout { .. } => "layout",
}
}
pub fn is_error(&self) -> bool {
matches!(self, Response::Error { .. })
}
pub fn error_code(&self) -> Option<ErrorCode> {
if let Response::Error { code, .. } = self {
match code.as_str() {
"invalid_message" => Some(ErrorCode::InvalidMessage),
"unknown_type" => Some(ErrorCode::UnknownType),
"unsupported_version" => Some(ErrorCode::UnsupportedVersion),
"bad_request" => Some(ErrorCode::BadRequest),
"unknown_view" => Some(ErrorCode::UnknownView),
"unknown_command" => Some(ErrorCode::UnknownCommand),
"capability_denied" => Some(ErrorCode::CapabilityDenied),
"internal" => Some(ErrorCode::Internal),
_ => None,
}
} else {
None
}
}
pub fn state_payload(&self) -> Option<Value> {
if let Response::State {
view,
lines,
cursor,
file_path,
mode,
} = self
{
Some(serde_json::json!({
"view": view,
"lines": lines,
"cursor": cursor,
"file_path": file_path,
"mode": mode,
}))
} else {
None
}
}
pub fn reply(result: Value) -> Self {
Response::Reply { ok: true, result }
}
pub fn error(code: ErrorCode, message: &str) -> Self {
Response::Error {
code: code.as_str().to_string(),
message: message.to_string(),
}
}
pub fn event(name: &str, data: Value) -> Self {
Response::Event {
name: name.to_string(),
data,
}
}
pub fn state(data: Value) -> Self {
let view = data
.get("view")
.and_then(|v| v.as_str())
.unwrap_or("view:buffer")
.to_string();
let lines = data
.get("lines")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(String::from))
.collect()
})
.unwrap_or_default();
let cursor = data
.get("cursor")
.map(|v| {
let row = v.get("row").and_then(|n| n.as_u64()).unwrap_or(0);
let col = v.get("col").and_then(|n| n.as_u64()).unwrap_or(0);
Cursor { row, col }
})
.unwrap_or(Cursor { row: 0, col: 0 });
let file_path = data
.get("file_path")
.and_then(|v| v.as_str().map(String::from));
let mode = data
.get("mode")
.and_then(|v| v.as_str())
.unwrap_or("normal")
.to_string();
Response::State {
view,
lines,
cursor,
file_path,
mode,
}
}
pub fn notification(level: NotificationLevel, message: &str) -> Self {
Response::Notification {
level,
message: message.to_string(),
}
}
pub fn layout(root: &str, children: Vec<String>) -> Self {
Response::Layout {
root: root.to_string(),
children,
}
}
}
impl Envelope<Response> {
pub fn from_response_with_id(resp: Response, id: String) -> Envelope<Response> {
Envelope {
v: PROTOCOL_VERSION,
id: Some(id),
seq: None,
msg_type: resp.msg_type().to_string(),
payload: resp,
}
}
pub fn from_response(resp: Response) -> Envelope<Response> {
Envelope {
v: PROTOCOL_VERSION,
id: None,
seq: None,
msg_type: resp.msg_type().to_string(),
payload: resp,
}
}
pub fn with_id(mut self, id: String) -> Self {
self.id = Some(id);
self
}
pub fn with_seq(mut self, seq: u64) -> Self {
self.seq = Some(seq);
self
}
}
impl MessagePayload for Response {
fn msg_type(&self) -> &str {
match self {
Response::Reply { .. } => "reply",
Response::Error { .. } => "error",
Response::Event { .. } => "event",
Response::State { .. } => "state",
Response::Notification { .. } => "notification",
Response::Layout { .. } => "layout",
}
}
fn serialize_payload(&self) -> Result<Value, ProtocolError> {
let val = match self {
Response::Reply { ok, result, .. } => serde_json::json!({ "ok": ok, "result": result }),
Response::Error { code, message, .. } => {
serde_json::json!({ "ok": false, "code": code, "message": message })
}
Response::Event { name, data } => serde_json::json!({ "name": name, "data": data }),
Response::State {
view,
lines,
cursor,
file_path,
mode,
} => serde_json::json!({
"view": view,
"lines": lines,
"cursor": cursor,
"file_path": file_path,
"mode": mode,
}),
Response::Notification { level, message } => {
serde_json::json!({ "level": level, "message": message })
}
Response::Layout { root, children } => {
serde_json::json!({ "root": root, "children": children })
}
};
Ok(val)
}
fn deserialize_payload(msg_type: &str, payload: Value) -> Result<Self, ProtocolError> {
match msg_type {
"reply" => {
let ok = payload.get("ok").and_then(|v| v.as_bool()).unwrap_or(true);
let result = payload.get("result").cloned().unwrap_or(Value::Null);
Ok(Response::Reply { ok, result })
}
"error" => {
let code = payload
.get("code")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "error: missing code")
})?
.to_string();
let message = payload
.get("message")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "error: missing message")
})?
.to_string();
Ok(Response::Error { code, message })
}
"event" => {
let name = payload
.get("name")
.and_then(|v| v.as_str())
.ok_or_else(|| {
ProtocolError::new(ErrorCode::BadRequest, "event: missing name")
})?
.to_string();
let data = payload.get("data").cloned().unwrap_or(Value::Null);
Ok(Response::Event { name, data })
}
"state" => {
let view = payload
.get("view")
.and_then(|v| v.as_str())
.unwrap_or("view:buffer")
.to_string();
let lines = payload
.get("lines")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(String::from))
.collect()
})
.unwrap_or_default();
let cursor = payload
.get("cursor")
.map(|v| {
let row = v.get("row").and_then(|n| n.as_u64()).unwrap_or(0);
let col = v.get("col").and_then(|n| n.as_u64()).unwrap_or(0);
Cursor { row, col }
})
.unwrap_or(Cursor { row: 0, col: 0 });
let file_path = payload
.get("file_path")
.and_then(|v| v.as_str().map(String::from));
let mode = payload
.get("mode")
.and_then(|v| v.as_str())
.unwrap_or("normal")
.to_string();
Ok(Response::State {
view,
lines,
cursor,
file_path,
mode,
})
}
"notification" => {
let level_str = payload
.get("level")
.and_then(|v| v.as_str())
.unwrap_or("info");
let level = match level_str {
"info" => NotificationLevel::Info,
"warning" => NotificationLevel::Warning,
"error" => NotificationLevel::Error,
_ => NotificationLevel::Info,
};
let message = payload
.get("message")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
Ok(Response::Notification { level, message })
}
"layout" => {
let root = payload
.get("root")
.and_then(|v| v.as_str())
.unwrap_or("workspace")
.to_string();
let children = payload
.get("children")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|v| v.as_str().map(String::from))
.collect()
})
.unwrap_or_default();
Ok(Response::Layout { root, children })
}
_ => Err(ProtocolError::new(
ErrorCode::UnknownType,
format!("unknown response type: {}", msg_type),
)),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SessionState {
WaitingHello,
Ready,
Closed,
}
#[derive(Debug)]
pub struct Session {
version: i64,
state: SessionState,
next_seq: u64,
last_error: Option<ProtocolError>,
}
impl Session {
pub fn new(supported_version: i64) -> Self {
Session {
version: supported_version,
state: SessionState::WaitingHello,
next_seq: 1,
last_error: None,
}
}
pub fn state(&self) -> SessionState {
self.state.clone()
}
pub fn last_error(&self) -> Option<&ProtocolError> {
self.last_error.as_ref()
}
pub fn handle_request(&mut self, env: &Envelope<Request>) -> Result<(), ProtocolError> {
if env.v != self.version {
self.last_error = Some(ProtocolError::new(
ErrorCode::UnsupportedVersion,
format!(
"client version {} not supported; server supports {}",
env.v, self.version
),
));
self.state = SessionState::Closed;
return Err(self.last_error.clone().unwrap());
}
if self.state == SessionState::WaitingHello && env.msg_type != "hello" {
self.last_error = Some(ProtocolError::new(
ErrorCode::BadRequest,
format!("expected hello, got {}", env.msg_type),
));
return Err(self.last_error.clone().unwrap());
}
let known_types = [
"hello",
"command",
"input",
"focus",
"resize",
"view.action",
"view.subscribe",
"view.unsubscribe",
];
if !known_types.contains(&env.msg_type.as_str()) {
self.last_error = Some(ProtocolError::new(
ErrorCode::UnknownType,
format!("unknown request type: {}", env.msg_type),
));
return Err(self.last_error.clone().unwrap());
}
match env.msg_type.as_str() {
"hello" => {
if let Request::Hello { version } = &env.payload {
if *version != self.version {
self.last_error = Some(ProtocolError::new(
ErrorCode::UnsupportedVersion,
format!(
"client version {} not supported; server supports {}",
version, self.version
),
));
self.state = SessionState::Closed;
return Err(self.last_error.clone().unwrap());
}
}
self.state = SessionState::Ready;
}
_ => {
if self.state != SessionState::Ready {
self.last_error = Some(ProtocolError::new(
ErrorCode::BadRequest,
format!("session not ready for {}", env.msg_type),
));
return Err(self.last_error.clone().unwrap());
}
}
}
Ok(())
}
pub fn build_reply(&mut self, resp: Response) -> Envelope<Response> {
let seq = self.next_seq;
self.next_seq += 1;
Envelope::from_response(resp).with_seq(seq)
}
pub fn build_response(&mut self, resp: Response, id: &str) -> Envelope<Response> {
let seq = self.next_seq;
self.next_seq += 1;
Envelope::from_response(resp)
.with_seq(seq)
.with_id(id.to_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_line_valid_request() {
let json = r#"{"v":1,"id":"h-001","type":"hello","payload":{"version":1}}"#;
let env = parse_line::<Request>(json).unwrap();
assert_eq!(env.v, 1);
assert_eq!(env.id.as_deref(), Some("h-001"));
assert_eq!(env.msg_type, "hello");
assert_eq!(env.payload.msg_type(), "hello");
if let Request::Hello { version } = &env.payload {
assert_eq!(*version, 1);
} else {
panic!("expected Hello variant");
}
}
#[test]
fn test_to_json_line_matches_expected_shape() {
let req = Request::hello(1);
let env = Envelope::from_request(req, "h-001".to_string());
let json = to_json_line(&env).unwrap();
assert!(!json.contains('\n'));
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["v"], 1);
assert_eq!(parsed["id"], "h-001");
assert_eq!(parsed["type"], "hello");
assert_eq!(parsed["payload"]["version"], 1);
assert!(parsed.get("seq").is_none());
}
#[test]
fn test_error_code_display() {
assert_eq!(ErrorCode::UnknownCommand.as_str(), "unknown_command");
assert_eq!(format!("{}", ErrorCode::BadRequest), "bad_request");
}
#[test]
fn test_notification_level_serializes_lowercase() {
let json = serde_json::to_string(&NotificationLevel::Warning).unwrap();
assert_eq!(json, "\"warning\"");
}
#[test]
fn test_input_kind_serializes_lowercase() {
assert_eq!(serde_json::to_string(&InputKind::Text).unwrap(), "\"text\"");
}
#[test]
fn test_response_state_extracts_view() {
let data = serde_json::json!({
"view": "view:status",
"lines": ["a"],
"cursor": {"row": 0, "col": 0},
"file_path": null,
"mode": "normal"
});
let state = Response::state(data.clone());
assert_eq!(state.msg_type(), "state");
let payload = state.state_payload().unwrap();
assert_eq!(payload["view"], "view:status");
}
#[test]
fn test_session_hello_transitions_to_ready() {
let mut sess = Session::new(1);
let req =
parse_line::<Request>(r#"{"v":1,"id":"h-001","type":"hello","payload":{"version":1}}"#)
.unwrap();
assert!(sess.handle_request(&req).is_ok());
assert_eq!(sess.state(), SessionState::Ready);
}
#[test]
fn test_session_monotonic_seq() {
let mut sess = Session::new(1);
let req =
parse_line::<Request>(r#"{"v":1,"id":"h-001","type":"hello","payload":{"version":1}}"#)
.unwrap();
sess.handle_request(&req).unwrap();
let e1 = sess.build_reply(Response::notification(NotificationLevel::Info, "msg1"));
assert_eq!(e1.seq, Some(1));
let e2 = sess.build_reply(Response::notification(NotificationLevel::Info, "msg2"));
assert_eq!(e2.seq, Some(2));
}
}