85 lines
3.2 KiB
Rust
85 lines
3.2 KiB
Rust
use super::*;
|
|
|
|
#[test]
|
|
fn fixed_execution_decode_preserves_strict_fields() {
|
|
use dever_runtime::wire;
|
|
for source in [
|
|
r#"{"kind":"System","tenant":null,"tenant":1}"#,
|
|
r#"{"kind":"System","kind":"System","tenant":null}"#,
|
|
r#"{"kind":"System","tenant":null,"extra":0}"#,
|
|
r#"{"kind":"System","tenant":"1"}"#,
|
|
r#"{"kind":"User","provider":"local"}"#,
|
|
] {
|
|
assert!(wire::decode::<Execution>(source).is_err(), "{source}");
|
|
assert!(wire::decode_fixed::<Execution>(source).is_err(), "{source}");
|
|
}
|
|
for source in [
|
|
r#"{"kind":"System","tenant":null}"#,
|
|
r#"{"kind":"System","tenant":42}"#,
|
|
] {
|
|
let original: Execution = wire::decode(source).unwrap();
|
|
let fixed: Execution = wire::decode_fixed(source).unwrap();
|
|
assert_eq!(original.tenant(), fixed.tenant());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn shared_queue_keeps_execution_tenants_in_distinct_idempotency_domains() {
|
|
let directory = Directory::new();
|
|
Runtime::new(Limits::default())
|
|
.unwrap()
|
|
.run(async |scope| {
|
|
let database = Database::open(&directory.0, options(), scope)
|
|
.await
|
|
.unwrap();
|
|
let mut executor = database.executor().await.unwrap();
|
|
executor
|
|
.schema(scope, job::schema::TABLE, job::schema::SQL)
|
|
.await
|
|
.unwrap();
|
|
let mut ids = Vec::new();
|
|
for tenant in [None, Some(1), Some(2)] {
|
|
let identity = Execution::System { tenant };
|
|
let mut request = submission("one-business-key");
|
|
request.execution = &identity;
|
|
let first = job::enqueue(&mut executor, scope, request, 1000)
|
|
.await
|
|
.unwrap()
|
|
.into_text();
|
|
let mut request = submission("one-business-key");
|
|
request.execution = &identity;
|
|
let second = job::enqueue(&mut executor, scope, request, 1000)
|
|
.await
|
|
.unwrap()
|
|
.into_text();
|
|
assert_eq!(first, second);
|
|
assert!(!ids.contains(&first));
|
|
ids.push(first);
|
|
}
|
|
let mut tenants = Vec::new();
|
|
for _ in 0..3 {
|
|
let claim = job::claim(&mut executor, scope, 1000, 1000)
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
let identity: Execution = dever_runtime::wire::decode(&claim.execution).unwrap();
|
|
assert_eq!(identity.tenant().unwrap_or(0), claim.execution_tenant);
|
|
tenants.push(claim.execution_tenant);
|
|
job::complete(&mut executor, scope, &claim, 1001)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
tenants.sort_unstable();
|
|
assert_eq!(tenants, [0, 1, 2]);
|
|
let identity = Execution::System { tenant: Some(0) };
|
|
let mut request = submission("invalid");
|
|
request.execution = &identity;
|
|
assert!(
|
|
job::enqueue(&mut executor, scope, request, 1000)
|
|
.await
|
|
.is_err()
|
|
);
|
|
})
|
|
.unwrap();
|
|
}
|