use serde::{Deserialize, Serialize};
use std::mem;
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct Session {
id: String,
sequence: u64,
}
impl Session {
pub const fn new(sequence: u64, session_id: String) -> Self {
Self {
sequence,
id: session_id,
}
}
pub fn id(&self) -> &str {
&self.id
}
pub const fn sequence(&self) -> u64 {
self.sequence
}
pub(crate) fn set_sequence(&mut self, sequence: u64) -> u64 {
mem::replace(&mut self.sequence, sequence)
}
}
#[cfg(test)]
mod tests {
use super::Session;
use serde::{Deserialize, Serialize};
use serde_test::Token;
use static_assertions::assert_impl_all;
use std::fmt::Debug;
assert_impl_all!(
Session: Clone,
Debug,
Deserialize<'static>,
Eq,
PartialEq,
Send,
Serialize,
Sync
);
#[test]
fn serde() {
const SEQUENCE: u64 = 56_132;
const SESSION_ID: &str = "thisisanid";
let value = Session::new(SEQUENCE, SESSION_ID.to_owned());
serde_test::assert_tokens(
&value,
&[
Token::Struct {
name: "Session",
len: 2,
},
Token::Str("id"),
Token::Str(SESSION_ID),
Token::Str("sequence"),
Token::U64(SEQUENCE),
Token::StructEnd,
],
);
}
#[test]
fn session() {
const SESSIONS: [(u64, &str); 2] = [(1, "a"), (2, "b")];
for (sequence, session_id) in SESSIONS {
let session = Session::new(sequence, session_id.to_owned());
assert_eq!(session.sequence(), sequence);
assert_eq!(session.id(), session_id);
}
}
#[test]
fn set_sequence() {
const SEQUENCE_INITIAL: u64 = 1;
const SEQUENCE_NEXT: u64 = SEQUENCE_INITIAL + 1;
const SEQUENCE_SKIPPED: u64 = SEQUENCE_NEXT + 3;
let mut session = Session::new(SEQUENCE_INITIAL, String::new());
let old = session.set_sequence(SEQUENCE_NEXT);
assert_eq!(old, SEQUENCE_INITIAL);
let skipped_old = session.set_sequence(SEQUENCE_SKIPPED);
assert_eq!(skipped_old, SEQUENCE_NEXT);
}
}