Initial Dever 0.0.1

test/rust/runtime/job/identity.rs

@@ -0,0 +1,84 @@
+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();
+}