use std::sync::{Arc, Mutex};
use type_bridge_orm::OrmError;
use type_bridge_orm::session::backend::{
BoxFuture, DriverBackend, QueryResult, TransactionOps, TxType,
};
#[path = "../../tests/support/purchase_models.rs"]
mod models;
use models::*;
use crate::Database;
use crate::plan::Plan;
use crate::staged::{PendingError, PlanAnswer, TransactionKind, TransactionOptions};
#[test]
fn builder_purchase_bytes_equal_the_hand_built_plan() {
let built = purchase_plan(&package(), "O1", "I1", "A1").unwrap();
let hand = hand_built_purchase("O1", "I1", "A1");
assert_eq!(
built.canonical_bytes().unwrap(),
hand.canonical_bytes().unwrap()
);
assert!(built.writes());
}
#[test]
fn builder_reports_invalid_calls_and_unbuildable_packages() {
let mut plan = Plan::<Shop>::builder();
let item = plan.exact::<Item>();
plan.input::<String>("item");
plan.returning([item]);
let error = plan.build(&package()).unwrap_err();
assert_eq!(error.code(), Some("query_plan_builder_duplicate_name"));
let full = package();
let without_authority = crate::SchemaPackage::<Shop>::new(
full.semantic_fingerprint_json(),
full.projection_fingerprint_json(),
full.runtime_projection_json(),
);
let mut plan = Plan::<Shop>::builder();
let item = plan.exact::<Item>();
plan.returning([item]);
assert!(plan.build(&without_authority).is_err());
let mut plan = Plan::<Shop>::builder();
let item = plan.exact::<Item>();
plan.update(item, ItemType::stock, "none".to_owned());
assert!(plan.build(&package()).is_err());
}
#[test]
fn builds_verify_a_package_authority_once_and_a_tampered_one_every_time() {
let verifications = || crate::schema::AUTHORITY_VERIFICATIONS.with(std::cell::Cell::get);
let item_plan = || {
let mut plan = Plan::<Shop>::builder();
let item = plan.exact::<Item>();
plan.returning([item]);
plan
};
let package = package();
let start = verifications();
item_plan().build(&package).unwrap();
item_plan().build(&package).unwrap();
let copy = package;
item_plan().build(©).unwrap();
assert_eq!(verifications() - start, 1);
let tampered = tampered_package();
let start = verifications();
let first = item_plan().build(&tampered).unwrap_err();
let second = item_plan().build(&tampered).unwrap_err();
assert_eq!(verifications() - start, 2);
assert_eq!(first.to_string(), second.to_string());
assert!(
first
.to_string()
.contains("disagrees with its extracted query evidence"),
"{first}"
);
}
#[test]
fn reads_choose_rows_count_and_exists() {
let read = |terminal: fn(&mut crate::plan::PlanBuilder<Shop>)| {
let mut plan = Plan::<Shop>::builder();
let item = plan.exact::<Item>();
let stock = plan.field(item, ItemType::stock);
plan.where_(stock.ge(1_i64)).returning([stock]);
terminal(&mut plan);
plan.build(&package()).unwrap()
};
assert!(!read(|_| {}).writes());
assert!(
!read(|plan| {
plan.count();
})
.writes()
);
let exists = read(|plan| {
plan.exists();
});
assert_ne!(
exists.canonical_bytes().unwrap(),
read(|_| {}).canonical_bytes().unwrap()
);
}
#[derive(Default)]
struct Log(Vec<String>);
struct Backend(Arc<Mutex<Log>>);
struct Tx(Arc<Mutex<Log>>);
impl DriverBackend for Backend {
fn open_transaction(
&self,
_db: &str,
ty: TxType,
) -> BoxFuture<'_, Result<Box<dyn TransactionOps>, OrmError>> {
self.0.lock().unwrap().0.push(format!("open {ty:?}"));
let tx = Tx(Arc::clone(&self.0));
Box::pin(async move { Ok(Box::new(tx) as Box<dyn TransactionOps>) })
}
fn is_open(&self) -> bool {
true
}
}
impl TransactionOps for Tx {
fn query(&mut self, q: &str) -> BoxFuture<'_, Result<QueryResult, OrmError>> {
self.0.lock().unwrap().0.push(format!("query {q}"));
Box::pin(async { Ok(QueryResult::Rows(vec![serde_json::json!({})])) })
}
fn commit(&mut self) -> BoxFuture<'_, Result<(), OrmError>> {
self.0.lock().unwrap().0.push("commit".into());
Box::pin(async { Ok(()) })
}
fn rollback(&mut self) -> BoxFuture<'_, Result<(), OrmError>> {
self.0.lock().unwrap().0.push("rollback".into());
Box::pin(async { Ok(()) })
}
fn close(&mut self) -> BoxFuture<'_, Result<(), OrmError>> {
self.0.lock().unwrap().0.push("close".into());
Box::pin(async { Ok(()) })
}
}
fn database() -> (Database<Shop>, Arc<Mutex<Log>>) {
let log = Arc::new(Mutex::new(Log::default()));
let inner = type_bridge_orm::Database::with_backend(Box::new(Backend(Arc::clone(&log))), "t");
let database = Database::from_orm_database(inner)
.with_schema(package())
.unwrap();
(database, log)
}
fn restock() -> Plan<Shop> {
let mut plan = Plan::builder();
let item = plan.exact::<Item>();
let stock = plan.field(item, ItemType::stock);
plan.where_(stock.eq(0_i64))
.update(item, ItemType::stock, 10_i64);
plan.build(&package()).unwrap()
}
#[tokio::test]
async fn direct_transaction_stages_until_commit_and_rollback_keeps_it() {
let (db, log) = database();
let mut tx = db.transaction(TransactionOptions::default());
let discarded = tx.stage(&restock()).unwrap();
tx.rollback().unwrap();
assert_eq!(discarded.get().unwrap_err(), PendingError::RolledBack);
assert!(
log.lock().unwrap().0.is_empty(),
"nothing opens before commit"
);
let answer = tx.stage(&restock()).unwrap();
assert_eq!(answer.get().unwrap_err(), PendingError::NotCommitted);
tx.commit().await.unwrap();
assert_eq!(*answer.get().unwrap(), PlanAnswer::Matched(1));
let events = log.lock().unwrap().0.clone();
assert_eq!(events.first().map(String::as_str), Some("open Write"));
assert!(events.iter().any(|event| event == "commit"));
tx.close().unwrap();
assert_eq!(tx.stage(&restock()).unwrap_err(), PendingError::Closed);
}
#[tokio::test]
async fn transaction_kinds_refuse_plans_they_cannot_run() {
let (db, _) = database();
let mut read = db.transaction(TransactionOptions::default().with_kind(TransactionKind::Read));
assert_eq!(read.stage(&restock()).unwrap_err(), PendingError::ReadOnly);
let mut schema =
db.transaction(TransactionOptions::default().with_kind(TransactionKind::Schema));
let mut stock = Plan::<Shop>::builder();
let item = stock.exact::<Item>();
stock.returning([item]).count();
let stock = stock.build(&package()).unwrap();
assert!(matches!(
schema.stage(&stock).unwrap_err(),
PendingError::NotAllowedInKind(_)
));
assert!(
read.stage(&stock).is_ok(),
"a read transaction stages reads"
);
}