#![cfg(all(feature = "sqlite", feature = "sync-http"))]
#[path = "../examples/model_sync/support.rs"]
mod notes;
use che_orm::ModelRole;
use che_orm::{OrmError, Uuid};
use che_rest::{
RestModelWrite, Server,
sync_http::{RestModelTransport, RestResource},
};
use che_sync::{ModelLogClient, ModelLogTransport, TransportFuture, model_log::*};
use serde_json::json;
use std::sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
};
struct LostReply {
inner: RestModelTransport,
lose: AtomicBool,
requests: Arc<Mutex<Vec<RestModelWrite>>>,
}
impl ModelLogTransport for LostReply {
fn id(&self) -> &'static str {
self.inner.id()
}
fn legacy_payload_key(&self, operation: Uuid) -> Option<String> {
self.inner.legacy_payload_key(operation)
}
fn prepare_write(&self, write: &ModelWrite) -> Result<serde_json::Value, OrmError> {
self.inner.prepare_write(write)
}
fn write<'a>(
&'a self,
write: &'a ModelWrite,
payload: &'a serde_json::Value,
) -> TransportFuture<'a, ModelWriteResult> {
Box::pin(async move {
self.requests
.lock()
.unwrap()
.push(serde_json::from_value(payload.clone()).unwrap());
let result = self.inner.write(write, payload).await?;
if self.lose.swap(false, Ordering::SeqCst) {
Err(OrmError::Interaction("lost reply after commit".into()))
} else {
Ok(result)
}
})
}
fn changes<'a>(
&'a self,
model: &'a str,
after: i64,
limit: u32,
) -> TransportFuture<'a, ModelChanges> {
self.inner.changes(model, after, limit)
}
}
#[tokio::test]
async fn offline_coalescing_lost_reply_and_restart_use_immutable_rest_requests() {
immutable_retry_scenario(false).await;
}
#[tokio::test]
async fn previously_submitted_rest_payload_is_retried_without_reencoding() {
immutable_retry_scenario(true).await;
}
async fn immutable_retry_scenario(legacy_payload: bool) {
let (state, token) = notes::demo_state().await.unwrap();
let router = Server::new(state.clone())
.install(notes::apps())
.build()
.await
.unwrap();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}/api", listener.local_addr().unwrap());
let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
let http = reqwest::Client::builder()
.default_headers({
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", format!("Token {token}").parse().unwrap());
headers
})
.build()
.unwrap();
let transport = || {
RestModelTransport::new(
&base,
http.clone(),
vec![RestResource::new::<notes::Note, notes::NoteSerializer>("notes").unwrap()],
)
.unwrap()
};
let db = notes::database(ModelRole::Client).await.unwrap();
let client = ModelLogClient::open(db.clone(), notes::registry(ModelRole::Client))
.await
.unwrap();
let requests = Arc::new(Mutex::new(vec![]));
let engine = client.engine(LostReply {
inner: transport(),
lose: AtomicBool::new(true),
requests: requests.clone(),
});
engine.pull().await.unwrap();
let mut note = notes::Note {
id: Uuid::now_v7(),
title: "first".into(),
done: false,
document: Some(che_orm::JsonField(json!(null))),
number: i64::MAX,
};
for n in 0..10 {
note.title = format!("offline {n}");
client.save(¬e).await.unwrap();
}
assert!(engine.flush().await.is_err());
assert_eq!(
state
.database()
.get::<notes::Note>(note.id)
.await
.unwrap()
.unwrap()
.title,
"offline 9"
);
if legacy_payload {
let frozen = requests.lock().unwrap()[0].clone();
db.execute_sql(
"DELETE FROM _sync_meta WHERE key = $1",
vec![che_orm::DatabaseValue::Text(format!(
"submitted-write:{}",
frozen.operation_id
))],
)
.await
.unwrap();
db.execute_sql(
"INSERT INTO _sync_meta (key, value) VALUES ($1, $2)",
vec![
che_orm::DatabaseValue::Text(format!("rest-request:{}", frozen.operation_id)),
che_orm::DatabaseValue::Text(serde_json::to_string(&frozen).unwrap()),
],
)
.await
.unwrap();
}
note.title = "after submission".into();
client.save(¬e).await.unwrap();
drop(engine);
drop(client);
let client = ModelLogClient::open(db, notes::registry(ModelRole::Client))
.await
.unwrap();
let unauthenticated = client.engine(
RestModelTransport::new(
&base,
reqwest::Client::new(),
vec![RestResource::new::<notes::Note, notes::NoteSerializer>("notes").unwrap()],
)
.unwrap(),
);
assert!(unauthenticated.flush().await.is_err());
assert!(client.conflicts().await.unwrap().is_empty());
drop(unauthenticated);
let engine = client.engine(LostReply {
inner: RestModelTransport::new(
&base,
http.clone(),
vec![RestResource::new::<notes::Note, notes::NoteSerializer>("renamed-notes").unwrap()],
)
.unwrap(),
lose: AtomicBool::new(false),
requests: requests.clone(),
});
assert_eq!(engine.flush().await.unwrap().accepted_operations, 1);
{
let sent = requests.lock().unwrap();
assert_eq!(sent.len(), 2);
assert_eq!(sent[0], sent[1]);
}
let page = transport().changes("notes.note", 0, 100).await.unwrap();
assert_eq!(page.operations.len(), 1);
assert_eq!(page.operations[0].kind, ChangeKind::Create);
drop(engine);
let engine = client.engine(LostReply {
inner: transport(),
lose: AtomicBool::new(false),
requests: requests.clone(),
});
assert_eq!(engine.flush().await.unwrap().accepted_operations, 1);
let saved = state
.database()
.get::<notes::Note>(note.id)
.await
.unwrap()
.unwrap();
assert_eq!(saved.title, "after submission");
assert_eq!(saved.number, i64::MAX);
assert_eq!(saved.document, Some(che_orm::JsonField(json!(null))));
let page = transport().changes("notes.note", 0, 100).await.unwrap();
assert_eq!(page.operations.len(), 2);
assert_eq!(page.operations[1].diff.len(), 1);
assert_eq!(page.operations[1].diff[0].field, "title");
engine.pull().await.unwrap();
let temporary = notes::Note {
id: Uuid::now_v7(),
..note.clone()
};
client.save(&temporary).await.unwrap();
client.delete::<notes::Note>(temporary.id).await.unwrap();
assert_eq!(engine.flush().await.unwrap().accepted_operations, 0);
assert_eq!(requests.lock().unwrap().len(), 3);
client.delete::<notes::Note>(note.id).await.unwrap();
assert_eq!(engine.flush().await.unwrap().accepted_operations, 1);
let page = transport().changes("notes.note", 0, 100).await.unwrap();
assert_eq!(page.operations.len(), 3);
assert_eq!(page.operations[2].kind, ChangeKind::Delete);
server.abort();
}
#[tokio::test]
async fn model_journal_routes_require_auth_and_generate_typed_changes_clients() {
use axum::{
body::{Body, to_bytes},
http::{Request, StatusCode},
};
use tower::ServiceExt;
let (state, token) = notes::demo_state().await.unwrap();
let metadata = notes::apps().api_endpoints(state.clone());
let endpoint = metadata
.iter()
.find(|endpoint| endpoint.resource == "notes")
.unwrap();
assert_eq!(endpoint.extensions.len(), 1);
assert_eq!(endpoint.extensions[0].id, "model-sync");
assert_eq!(endpoint.extensions[0].operations.len(), 1);
let output = std::env::temp_dir().join(format!("model-sync-types-{}", Uuid::now_v7()));
che_rest::generate_ts::generate(&output, &metadata, &[], false).unwrap();
let models = std::fs::read_to_string(output.join("models.ts")).unwrap();
assert!(models.contains("export interface ModelChanges"));
assert!(models.contains("old_value?: JsonValue"));
let api = std::fs::read_to_string(output.join("api.ts")).unwrap();
assert!(api.contains("sync/changes/"));
assert!(!api.contains("sync/pull/"));
std::fs::remove_dir_all(output).unwrap();
let router = Server::new(state)
.install(notes::apps())
.build()
.await
.unwrap();
for (query, authenticated, expected) in [
("after=0&limit=1", false, StatusCode::UNAUTHORIZED),
("after=0&limit=1", true, StatusCode::OK),
("after=-1&limit=1", true, StatusCode::BAD_REQUEST),
("after=0&limit=0", true, StatusCode::BAD_REQUEST),
("after=invalid", true, StatusCode::BAD_REQUEST),
] {
let mut request = Request::builder().uri(format!("/api/notes/sync/changes/?{query}"));
if authenticated {
request = request.header("authorization", format!("Token {token}"));
}
let response = router
.clone()
.oneshot(request.body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), expected, "{query}");
if expected == StatusCode::OK {
let page: ModelChanges =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap())
.unwrap();
assert_eq!(page.model, "notes.note");
assert_eq!(page.next_cursor, 0);
assert!(page.operations.is_empty());
assert!(!page.has_more);
}
}
}
#[derive(Clone)]
struct EffectNotes {
order: Vec<&'static str>,
fail: Arc<AtomicBool>,
completed: Arc<Mutex<Vec<String>>>,
}
struct CleanupHook {
id: &'static str,
fail: Arc<AtomicBool>,
completed: Arc<Mutex<Vec<String>>>,
}
impl che_rest::MutationHook<EffectNotes> for CleanupHook {
fn id(&self) -> &'static str {
self.id
}
fn prepare_delete(&self, note: ¬es::Note) -> serde_json::Value {
json!({"version": 1, "owner": self.id, "key": note.id})
}
fn after_delete(
&self,
_: &che_rest::AppState,
payload: &serde_json::Value,
) -> che_rest::AppResult<()> {
assert_eq!(payload["version"], 1);
assert_eq!(
payload["owner"], self.id,
"cleanup payload changed ownership"
);
assert!(payload["key"].as_str().unwrap().parse::<Uuid>().is_ok());
if self.fail.load(Ordering::SeqCst) {
return Err(che_rest::AppError::BadRequest(
"external service unavailable".into(),
));
}
self.completed.lock().unwrap().push(self.id.into());
Ok(())
}
}
impl che_rest::ViewSet for EffectNotes {
type Model = notes::Note;
type Serializer = notes::NoteSerializer;
type ListSerializer = notes::NoteSerializer;
type QuerySet = che_orm::DatabaseQuery<notes::Note>;
type FilterSet = che_rest::FilterSet<notes::Note>;
type Permission = che_rest::IsAuthenticated;
fn path(&self) -> &'static str {
"/notes"
}
fn get_queryset(&self) -> Self::QuerySet {
use che_orm::Model;
che_orm::DatabaseQuery::new(notes::Note::query())
}
fn configure(&self, config: &mut che_rest::ViewSetConfig<Self>) -> che_rest::AppResult<()> {
for id in &self.order {
config.mutation_hook(CleanupHook {
id,
fail: self.fail.clone(),
completed: self.completed.clone(),
})?;
}
config.extend(che_rest::ModelSyncEndpoints::new(self.clone()))
}
}
impl che_rest::SyncViewSet for EffectNotes {
fn sync_registry(&self) -> che_rest::AppResult<che_sync::Registry> {
Ok(notes::registry(ModelRole::Server))
}
}
impl che_rest::AppModule for EffectNotes {
fn name(&self) -> &'static str {
"notes"
}
fn schema(&self) -> che_orm::SchemaSet {
che_orm::SchemaSet::new().server_model::<notes::Note>()
}
fn sync_registry(&self) -> Option<che_sync::Registry> {
Some(notes::registry(ModelRole::Server))
}
fn init(&self, context: &mut che_rest::ModuleContext) {
context.viewset_with(self.clone());
}
}
#[tokio::test]
async fn cleanup_survives_restart_missing_handlers_and_hook_reordering_without_new_requests() {
use axum::{
body::{Body, to_bytes},
http::{Request, StatusCode},
};
use tower::ServiceExt;
let (state, token) = notes::demo_state().await.unwrap();
let hooks = EffectNotes {
order: vec!["storage-cleanup", "search-cleanup"],
fail: Arc::new(AtomicBool::new(true)),
completed: Arc::default(),
};
let router = Server::new(state.clone())
.install(
che_rest::InstalledApps::new()
.add(che_rest::auth::module())
.add(hooks.clone()),
)
.build()
.await
.unwrap();
let response = router
.clone()
.oneshot(
Request::builder()
.method("POST")
.uri("/api/notes/")
.header("authorization", format!("Token {token}"))
.header("content-type", "application/json")
.body(Body::from(
json!({"title":"cleanup", "done":false, "number":17, "document":null})
.to_string(),
))
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::CREATED);
let created: serde_json::Value =
serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap();
let response = router
.oneshot(
Request::builder()
.method("DELETE")
.uri(format!("/api/notes/{}/", created["id"].as_str().unwrap()))
.header("authorization", format!("Token {token}"))
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::NO_CONTENT);
let pending = state
.database()
.query_sql("SELECT payload FROM _sync_effects ORDER BY id", vec![])
.await
.unwrap()
.iter()
.map(|row| row.get::<String>(0).unwrap())
.collect::<Vec<_>>();
assert_eq!(pending.len(), 2);
assert!(hooks.completed.lock().unwrap().is_empty());
let restarted = che_rest::AppState::from_database(state.database().clone());
let _router = Server::new(restarted.clone())
.install(che_rest::InstalledApps::new().add(EffectNotes {
order: vec![],
..hooks.clone()
}))
.build()
.await
.unwrap();
assert_eq!(
che_rest::sync::retry_model_effects(&restarted)
.await
.unwrap(),
0
);
assert_eq!(
restarted
.database()
.query_sql("SELECT payload FROM _sync_effects ORDER BY id", vec![])
.await
.unwrap()
.iter()
.map(|row| row.get::<String>(0).unwrap())
.collect::<Vec<_>>(),
pending
);
let restarted = che_rest::AppState::from_database(state.database().clone());
hooks.fail.store(false, Ordering::SeqCst);
let _router = Server::new(restarted.clone())
.install(che_rest::InstalledApps::new().add(EffectNotes {
order: vec!["search-cleanup", "storage-cleanup"],
..hooks.clone()
}))
.build()
.await
.unwrap();
assert_eq!(
che_rest::sync::retry_model_effects(&restarted)
.await
.unwrap(),
2
);
let mut completed = hooks.completed.lock().unwrap().clone();
completed.sort();
assert_eq!(completed, vec!["search-cleanup", "storage-cleanup"]);
assert_eq!(
che_rest::sync::retry_model_effects(&restarted)
.await
.unwrap(),
0
);
assert!(
restarted
.database()
.query_sql("SELECT id FROM _sync_effects", vec![])
.await
.unwrap()
.is_empty()
);
assert_eq!(
restarted
.database()
.query_sql("SELECT id FROM notes_sync_log", vec![])
.await
.unwrap()
.len(),
2
);
}
#[tokio::test]
async fn large_model_page_limit_preserves_cursor_and_reports_decode_context() {
use axum::{Json, Router, extract::Query, routing::get};
use std::collections::HashMap;
let router = Router::new().route(
"/notes/sync/changes/",
get(|Query(query): Query<HashMap<String, String>>| async move {
assert_eq!(query["after"], "42");
assert_eq!(query["limit"], "1");
Json(json!({"model":"notes.note", "history":"invalid"}))
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
let resource = RestResource::new::<notes::Note, notes::NoteSerializer>("notes").unwrap();
assert!(resource.clone().with_page_size_limit(0).is_err());
assert!(resource.clone().with_page_size_limit(1001).is_err());
let transport = RestModelTransport::new(
&base,
reqwest::Client::new(),
vec![resource.with_page_size_limit(1).unwrap()],
)
.unwrap();
let error = transport
.changes("notes.note", 42, 100)
.await
.unwrap_err()
.to_string();
assert!(
error.contains("sync changes notes.note after 42"),
"{error}"
);
assert!(error.contains("invalid sync JSON"), "{error}");
server.abort();
}
#[tokio::test]
async fn interrupted_response_body_is_reported_as_timeout_with_model_context() {
use axum::{Router, body::Body, routing::get};
let router = Router::new().route(
"/notes/sync/changes/",
get(|| async {
Body::from_stream(futures_util::stream::once(async {
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
Ok::<_, std::io::Error>("{}")
}))
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_millis(200))
.build()
.unwrap();
let transport = RestModelTransport::new(
&base,
client,
vec![RestResource::new::<notes::Note, notes::NoteSerializer>("notes").unwrap()],
)
.unwrap();
let error = transport
.changes("notes.note", 0, 100)
.await
.unwrap_err()
.to_string();
assert!(error.contains("sync changes notes.note after 0"), "{error}");
assert!(error.contains("response body timed out"), "{error}");
server.abort();
}
#[tokio::test]
async fn batch_download_sends_explicit_positions_and_preserves_resource_cap() {
use axum::{Json, Router, routing::post};
let seen = Arc::new(Mutex::new(Vec::<serde_json::Value>::new()));
let captured = seen.clone();
let app = Router::new().route("/api/sync/changes/", post(move |headers: axum::http::HeaderMap, Json(body): Json<serde_json::Value>| {
let captured = captured.clone();
async move {
assert_eq!(headers["authorization"], "Token secret");
captured.lock().unwrap().push(body.clone());
Json(json!({"models":[{"model":body["models"][0]["model"],"status":"reset_required"}]}))
}
}));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}/api", listener.local_addr().unwrap());
let serving = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let resource = RestResource::new::<notes::Note, notes::NoteSerializer>("notes")
.unwrap()
.with_page_size_limit(3)
.unwrap();
let model = resource.model_name().to_string();
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "Token secret".parse().unwrap());
let client = reqwest::Client::builder()
.default_headers(headers)
.build()
.unwrap();
let transport = RestModelTransport::new(&base, client, vec![resource]).unwrap();
let history = Uuid::now_v7();
let request = vec![ModelJournalRequest {
model,
cursor: Some(ModelJournalCursor {
history,
after: 9007199254740993,
}),
}];
assert!(
transport
.changes_many(request.clone(), 100)
.await
.unwrap()
.is_none()
);
assert!(seen.lock().unwrap().is_empty());
let pages = transport
.with_batched_changes()
.changes_many(request, 100)
.await
.unwrap()
.unwrap();
assert!(matches!(pages[0], ModelJournalPage::ResetRequired { .. }));
let seen = seen.lock().unwrap();
assert_eq!(seen.len(), 1);
assert_eq!(seen[0]["limit"], 3);
assert_eq!(seen[0]["models"][0]["cursor"]["after"], "9007199254740993");
assert_eq!(
seen[0]["models"][0]["cursor"]["history"],
history.to_string()
);
serving.abort();
}