use std::rc::Rc;
use std::sync::Arc;
use zero_client::client::{Deferred, Zero, ZeroOptions};
use zero_client::json::{self, Value};
use zero_client::schema::Schema;
use zero_client::testing::{ManualScheduler, MockSocket, MockSocketFactory, RecordingLogSink};
struct Harness {
zero: Zero,
scheduler: Rc<ManualScheduler>,
factory: Rc<MockSocketFactory>,
}
impl Harness {
fn new() -> Self {
let schema = Schema::from_json(
&json::parse(
r#"{"tables": {"issue": {"name": "issue", "primaryKey": ["id"],
"columns": {"id": {"type": "string"}}}}}"#,
)
.unwrap(),
)
.unwrap();
let scheduler = ManualScheduler::new(1_700_000_000_000.0);
let factory = MockSocketFactory::new();
let options = ZeroOptions {
cache_url: Some("http://zero.test".into()),
user_id: Some("u1".into()),
log_sink: Some(Rc::new(RecordingLogSink::default())),
..ZeroOptions::default()
};
let zero = Zero::new(
Arc::new(schema),
(),
vec![],
options,
scheduler.clone(),
Some(factory.clone()),
)
.unwrap();
let h = Harness {
zero,
scheduler,
factory,
};
h.settle();
h
}
fn settle(&self) {
self.zero.dispatch(|| {});
self.scheduler.run_due_timers();
}
fn socket(&self) -> Rc<MockSocket> {
self.factory.sockets().last().cloned().expect("a socket")
}
fn connect(&self) {
self.socket().receive_text(r#"["connected",{"wsid":"w1"}]"#);
self.settle();
}
fn last_request(&self) -> (String, String) {
let m = self
.socket()
.messages()
.into_iter()
.rev()
.find(|m| m.starts_with(r#"["inspect""#))
.expect("an inspect request");
let v = json::parse(&m).unwrap();
let body = v.at(1).unwrap();
let s = |k: &str| body.get(k).and_then(Value::as_str).unwrap().to_owned();
(s("op"), s("id"))
}
fn answer(&self, id: &str, op: &str, value: &str) {
self.socket().receive_text(&format!(
r#"["inspect",{{"op":"{op}","id":"{id}","value":{value}}}]"#
));
self.settle();
}
}
fn rejection<T: Clone + 'static>(d: &Deferred<T>) -> String {
match d.result() {
Some(Err(e)) => e.message(),
Some(Ok(_)) => panic!("resolved"),
None => panic!("pending"),
}
}
#[test]
fn a_sent_request_fails_when_the_connection_drops() {
let h = Harness::new();
h.connect();
let version = h.zero.inspector().server_version();
h.settle();
assert_eq!(h.last_request().0, "version");
h.socket().server_close(1006, "", false);
h.settle();
let message = rejection(&version);
assert!(
message.contains("the connection to zero-cache closed"),
"{message}"
);
}
#[test]
fn a_request_waits_for_the_connection_and_fails_when_the_client_closes() {
let h = Harness::new();
let version = h.zero.inspector().server_version();
h.settle();
assert!(!version.is_settled(), "waits for the connection");
h.zero.close();
h.settle();
assert_eq!(rejection(&version), "Zero instance closed by user");
let late = h.zero.inspector().metrics();
h.settle();
assert_eq!(rejection(&late), "Zero instance closed by user");
}
#[test]
fn a_refused_request_says_to_authenticate() {
let h = Harness::new();
h.connect();
let version = h.zero.inspector().server_version();
h.settle();
let (_, id) = h.last_request();
h.answer(&id, "authenticated", "false");
let message = rejection(&version);
assert!(message.starts_with("Authentication failed"), "{message}");
assert!(message.contains("authenticate(password)"), "{message}");
let inspector = h.zero.inspector();
let ok = inspector.authenticate("pw");
h.settle();
let (op, id) = h.last_request();
assert_eq!(op, "authenticate");
h.answer(&id, "authenticated", "true");
assert!(matches!(ok.result(), Some(Ok(true))));
let version = inspector.server_version();
h.settle();
h.answer(&h.last_request().1, "authenticated", "false");
let (op, id) = h.last_request();
assert_eq!(op, "authenticate");
h.answer(&id, "authenticated", "true");
let (op, id) = h.last_request();
assert_eq!(op, "version");
h.answer(&id, "version", r#""1.2.3""#);
assert_eq!(version.result().unwrap().unwrap(), "1.2.3");
}