use super::create_test_endpoint;
use crate::sip::headers::*;
use crate::transaction::{
key::{TransactionKey, TransactionRole},
transaction::Transaction,
TransactionState, TransactionTimer, TransactionType,
};
use crate::transport::udp::UdpConnection;
use crate::transport::SipConnection;
fn create_test_request(method: crate::sip::Method, branch: &str) -> crate::sip::Request {
let cseq_header = CSeq::new(format!("1 {}", method)).into();
crate::sip::Request {
method,
uri: crate::sip::Uri::try_from("sip:test.example.com:5060").unwrap(),
headers: vec![
Via::new(format!(
"SIP/2.0/UDP test.example.com:5060;branch={}",
branch
))
.into(),
cseq_header,
From::new("Alice <sip:alice@example.com>;tag=1928301774").into(),
To::new("Bob <sip:bob@example.com>").into(),
CallId::new("a84b4c76e66710@pc33.atlanta.com").into(),
MaxForwards::new("70").into(),
]
.into(),
version: crate::sip::Version::V2,
body: Default::default(),
}
}
#[tokio::test]
async fn test_client_invite_transaction_creation() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bKnashds");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Client)?;
let tx = Transaction::new_client(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
None, );
assert_eq!(tx.state, TransactionState::Nothing);
assert_eq!(tx.transaction_type, TransactionType::ClientInvite);
Ok(())
}
#[tokio::test]
async fn test_client_non_invite_transaction_creation() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let register_req = create_test_request(crate::sip::Method::Register, "z9hG4bKnashds");
let key = TransactionKey::from_request(®ister_req, TransactionRole::Client)?;
let tx = Transaction::new_client(
key.clone(),
register_req.clone(),
endpoint.inner.clone(),
None,
);
assert_eq!(tx.state, TransactionState::Nothing);
assert_eq!(tx.transaction_type, TransactionType::ClientNonInvite);
Ok(())
}
#[tokio::test]
async fn test_server_invite_transaction_creation() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bKnashds");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
None,
);
assert_eq!(tx.state, TransactionState::Trying);
assert_eq!(tx.transaction_type, TransactionType::ServerInvite);
Ok(())
}
#[tokio::test]
async fn test_server_non_invite_transaction_creation() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let register_req = create_test_request(crate::sip::Method::Register, "z9hG4bKnashds");
let key = TransactionKey::from_request(®ister_req, TransactionRole::Server)?;
let tx = Transaction::new_server(
key.clone(),
register_req.clone(),
endpoint.inner.clone(),
None,
);
assert_eq!(tx.state, TransactionState::Trying);
assert_eq!(tx.transaction_type, TransactionType::ServerNonInvite);
Ok(())
}
#[tokio::test]
async fn test_transaction_key_generation() -> crate::Result<()> {
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bKnashds");
let client_key = TransactionKey::from_request(&invite_req, TransactionRole::Client)?;
let server_key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
assert_ne!(client_key, server_key);
let client_key2 = TransactionKey::from_request(&invite_req, TransactionRole::Client)?;
assert_eq!(client_key, client_key2);
Ok(())
}
#[tokio::test]
async fn test_transaction_types() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bKnashds");
let invite_key = TransactionKey::from_request(&invite_req, TransactionRole::Client)?;
let invite_tx = Transaction::new_client(invite_key, invite_req, endpoint.inner.clone(), None);
assert_eq!(invite_tx.transaction_type, TransactionType::ClientInvite);
let register_req = create_test_request(crate::sip::Method::Register, "z9hG4bKnashds2");
let register_key = TransactionKey::from_request(®ister_req, TransactionRole::Client)?;
let register_tx =
Transaction::new_client(register_key, register_req, endpoint.inner.clone(), None);
assert_eq!(
register_tx.transaction_type,
TransactionType::ClientNonInvite
);
Ok(())
}
async fn mock_udp_connection() -> crate::Result<SipConnection> {
let conn = UdpConnection::create_connection("127.0.0.1:0".parse()?, None, None).await?;
Ok(conn.into())
}
#[test]
fn test_rfc6026_accepted_state_display() {
assert_eq!(
format!("{}", TransactionState::Accepted),
"Accepted",
"TransactionState::Accepted must Display as `Accepted` (RFC 6026 §7.1/§7.2)",
);
}
#[test]
fn test_rfc6026_timer_l_display() {
let request = crate::sip::Request {
method: crate::sip::Method::Invite,
uri: crate::sip::Uri::try_from("sip:bob@example.com").unwrap(),
headers: vec![
Via::new("SIP/2.0/UDP example.com:5060;branch=z9hG4bKtimerL").into(),
CSeq::new("1 INVITE").into(),
From::new("Alice <sip:alice@example.com>;tag=t1").into(),
CallId::new("call-l@example.com").into(),
]
.into(),
version: crate::sip::Version::V2,
body: Default::default(),
};
let key = TransactionKey::from_request(&request, TransactionRole::Server).unwrap();
let timer = TransactionTimer::TimerL(key.clone());
assert_eq!(format!("{}", timer), format!("TimerL: {}", key));
}
#[test]
fn test_rfc6026_timer_m_display() {
let request = crate::sip::Request {
method: crate::sip::Method::Invite,
uri: crate::sip::Uri::try_from("sip:bob@example.com").unwrap(),
headers: vec![
Via::new("SIP/2.0/UDP example.com:5060;branch=z9hG4bKtimerM").into(),
CSeq::new("1 INVITE").into(),
From::new("Alice <sip:alice@example.com>;tag=t1").into(),
CallId::new("call-m@example.com").into(),
]
.into(),
version: crate::sip::Version::V2,
body: Default::default(),
};
let key = TransactionKey::from_request(&request, TransactionRole::Client).unwrap();
let timer = TransactionTimer::TimerM(key.clone());
assert_eq!(format!("{}", timer), format!("TimerM: {}", key));
}
#[tokio::test]
async fn test_rfc6026_server_invite_2xx_routes_to_accepted_with_timer_l() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srv2xx");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx.reply(crate::sip::StatusCode::OK).await?;
assert_eq!(
tx.state,
TransactionState::Accepted,
"server INVITE 2xx must route to Accepted per RFC 6026 §7.1, not Completed",
);
assert!(
tx.timer_l.is_some(),
"Accepted state must arm Timer L (= 64*T1) per RFC 6026 §7.1",
);
assert!(
tx.timer_g.is_some(),
"Accepted state arms Timer G (documented deviation): the dialog layer does not retransmit 2xx, so the transaction keeps the RFC 3261 §13.3.1.4 retransmission",
);
Ok(())
}
#[tokio::test]
async fn test_rfc6026_server_invite_4xx_still_routes_to_completed() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srv404");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx.reply(crate::sip::StatusCode::NotFound).await?;
assert_eq!(
tx.state,
TransactionState::Completed,
"server INVITE 4xx must continue to route to Completed (RFC 3261 §17.2.1 retained)",
);
Ok(())
}
#[tokio::test]
async fn test_rfc6026_server_invite_accepted_registers_waiting_ack() -> crate::Result<()> {
use crate::dialog::DialogId;
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srvack");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx.reply(crate::sip::StatusCode::OK).await?;
let last_response = tx
.last_response
.as_ref()
.expect("respond() must store the 2xx in last_response");
let dialog_id = DialogId::try_from((last_response, TransactionRole::Server))?;
let registered = endpoint.inner.waiting_ack.get(&dialog_id);
assert!(
registered.is_some(),
"Accepted-state entry must register the dialog in waiting_ack for ACK routing per RFC 6026 §7.1",
);
assert_eq!(
registered.expect("registered"),
key,
"waiting_ack entry must point back to this transaction key",
);
Ok(())
}
#[tokio::test]
async fn test_rfc6026_server_invite_3xx_still_arms_timer_g() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srvtimerg");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx.reply(crate::sip::StatusCode::ServerInternalError)
.await?;
assert_eq!(tx.state, TransactionState::Completed);
assert!(
tx.timer_g.is_some(),
"non-2xx final must continue to arm Timer G (RFC 3261 §17.2.1 retained; RFC 6026 §7.1 only prohibits 2xx retransmits)",
);
Ok(())
}
#[tokio::test]
async fn test_rfc6026_server_invite_accepted_absorbs_duplicate_2xx() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srvdup");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
let response_1 = tx.reply(crate::sip::StatusCode::OK).await;
response_1?;
assert_eq!(tx.state, TransactionState::Accepted);
tx.reply(crate::sip::StatusCode::OK).await?;
assert_eq!(
tx.state,
TransactionState::Accepted,
"duplicate 2xx in Accepted must keep the transaction in Accepted, not raise a transition error",
);
Ok(())
}
#[tokio::test]
async fn test_rfc6026_server_invite_accepted_rejects_3xx_transition() -> crate::Result<()> {
let endpoint = create_test_endpoint(Some("127.0.0.1:0")).await?;
let conn = mock_udp_connection().await?;
let invite_req = create_test_request(crate::sip::Method::Invite, "z9hG4bK6026srvreject");
let key = TransactionKey::from_request(&invite_req, TransactionRole::Server)?;
let mut tx = Transaction::new_server(
key.clone(),
invite_req.clone(),
endpoint.inner.clone(),
Some(conn),
);
tx.destination = Some(crate::transport::SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx.reply(crate::sip::StatusCode::OK).await?;
assert_eq!(tx.state, TransactionState::Accepted);
let err = tx.reply(crate::sip::StatusCode::BusyHere).await;
assert!(
err.is_err(),
"reply() must reject Accepted → Completed (no such edge in can_transition matrix)",
);
Ok(())
}
#[tokio::test]
async fn test_server_non_invite_timer_j_is_zero_on_reliable_transport() -> crate::Result<()> {
use crate::transport::{channel::ChannelConnection, SipAddr};
use tokio::sync::mpsc::unbounded_channel;
let endpoint_tcp = create_test_endpoint(Some("127.0.0.1:0")).await?;
let (to_net_tx, _to_net_rx) = unbounded_channel();
let (_from_net_tx, from_net_rx) = unbounded_channel();
let tcp_conn: SipConnection = ChannelConnection::create_connection(
from_net_rx,
to_net_tx,
SipAddr {
r#type: Some(crate::sip::Transport::Tcp),
addr: "127.0.0.1:5060".try_into()?,
},
None,
)
.await?
.into();
assert!(tcp_conn.is_reliable());
let register_req = create_test_request(crate::sip::Method::Register, "z9hG4bKtimerjtcp");
let key_tcp = TransactionKey::from_request(®ister_req, TransactionRole::Server)?;
let mut tx_tcp = Transaction::new_server(
key_tcp,
register_req.clone(),
endpoint_tcp.inner.clone(),
Some(tcp_conn),
);
tx_tcp.reply(crate::sip::StatusCode::OK).await?;
assert_eq!(tx_tcp.state, TransactionState::Terminated);
assert_eq!(
endpoint_tcp.inner.get_stats().finished_transactions,
0,
"Timer J must be 0 on reliable transports (RFC 3261 §17.2.2)"
);
let endpoint_udp = create_test_endpoint(Some("127.0.0.1:0")).await?;
let udp_conn = mock_udp_connection().await?;
assert!(!udp_conn.is_reliable());
let key_udp = TransactionKey::from_request(®ister_req, TransactionRole::Server)?;
let mut tx_udp = Transaction::new_server(
key_udp,
register_req,
endpoint_udp.inner.clone(),
Some(udp_conn),
);
tx_udp.destination = Some(SipAddr::from(
"127.0.0.1:1".parse::<std::net::SocketAddr>()?,
));
tx_udp.reply(crate::sip::StatusCode::OK).await?;
assert_eq!(tx_udp.state, TransactionState::Terminated);
assert_eq!(
endpoint_udp.inner.get_stats().finished_transactions,
1,
"Timer J must retain the final response for 64*T1 on UDP (RFC 3261 §17.2.2)"
);
Ok(())
}