Initial Dever 0.0.1

test/rust/runtime/job/postgres/lease.rs

@@ -0,0 +1,120 @@
+use super::*;
+use std::sync::Arc;
+
+async fn locked_claim(case: &Case, scope: &Scope<'_>) -> (Executor, Executor, Claim, bool) {
+    let mut owner = case.executor(scope).await;
+    let waiting = case.executor(scope).await;
+    job::enqueue(&mut owner, scope, submission("locked"), NOW)
+        .await
+        .unwrap();
+    let claim = job::claim(&mut owner, scope, NOW, 100)
+        .await
+        .unwrap()
+        .unwrap();
+    let transaction = owner.begin(scope).await.unwrap();
+    owner
+        .query(
+            scope,
+            "SELECT id FROM _dever_job WHERE id=$1 FOR UPDATE",
+            vec![Parameter::Text(claim.id.clone())],
+            1,
+            |row| row.get::<_, String>(0),
+        )
+        .await
+        .unwrap();
+    (owner, waiting, claim, transaction)
+}
+
+#[test]
+#[ignore = "requires explicit isolated database.postgres_test"]
+fn lease_expiration_after_row_lock_wait_rolls_back_business_writes() {
+    fixture(async |case, scope| {
+        let (mut owner, mut waiting, claim, transaction) = locked_claim(case, scope).await;
+        waiting
+            .initialize(scope, "CREATE TABLE business(id BIGINT PRIMARY KEY)")
+            .await
+            .unwrap();
+        let business = waiting.begin(scope).await.unwrap();
+        waiting
+            .execute(scope, "INSERT INTO business VALUES (1)", vec![])
+            .await
+            .unwrap();
+        let (result, ()) =
+            tokio::join!(job::complete(&mut waiting, scope, &claim, NOW + 1), async {
+                tokio::time::sleep(Duration::from_millis(250)).await;
+                owner.finish(scope, transaction, true).await.unwrap();
+            },);
+        assert!(
+            result.is_err(),
+            "lease checked before the row lock was acquired"
+        );
+        assert!(waiting.finish(scope, business, true).await.is_err());
+        assert_eq!(case.count(scope, "SELECT COUNT(*) FROM business").await, 0);
+        let retry = job::claim(&mut waiting, scope, NOW + 1000, 1000)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_ne!(retry.token, claim.token);
+        assert!(
+            job::complete(&mut waiting, scope, &claim, NOW + 1001)
+                .await
+                .is_err()
+        );
+        job::complete(&mut waiting, scope, &retry, NOW + 1001)
+            .await
+            .unwrap();
+    });
+}
+
+#[test]
+#[ignore = "requires explicit isolated database.postgres_test"]
+fn claim_clock_includes_table_lock_wait() {
+    fixture(async |case, scope| {
+        let mut owner = case.executor(scope).await;
+        let mut waiting = case.executor(scope).await;
+        job::enqueue(&mut owner, scope, submission("wait"), NOW)
+            .await
+            .unwrap();
+        let transaction = owner.begin(scope).await.unwrap();
+        owner
+            .initialize(scope, "LOCK TABLE _dever_job IN ACCESS EXCLUSIVE MODE")
+            .await
+            .unwrap();
+        let (result, ()) = tokio::join!(job::claim(&mut waiting, scope, NOW, 100), async {
+            tokio::time::sleep(Duration::from_millis(250)).await;
+            owner.finish(scope, transaction, true).await.unwrap();
+        },);
+        assert!(result.unwrap().unwrap().lease_until >= NOW + 300);
+    });
+}
+
+#[test]
+#[ignore = "requires explicit isolated database.postgres_test"]
+fn cancellation_discards_waiting_transaction_and_preserves_recovery() {
+    fixture(async |case, scope| {
+        let (mut owner, mut waiting, claim, transaction) = locked_claim(case, scope).await;
+        let claim = Arc::new(claim);
+        let copy = claim.clone();
+        let (started, ready) = tokio::sync::oneshot::channel();
+        let task = scope
+            .spawn(move |child| async move {
+                started.send(()).unwrap();
+                job::complete(&mut waiting, &child, &copy, NOW + 1).await
+            })
+            .unwrap();
+        ready.await.unwrap();
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(task.stop().await.unwrap().is_none());
+        owner.finish(scope, transaction, true).await.unwrap();
+        let mut replacement = case.executor(scope).await;
+        let next = job::claim(&mut replacement, scope, NOW + 1000, 1000)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(next.id, claim.id);
+        assert_ne!(next.token, claim.token);
+        job::complete(&mut replacement, scope, &next, NOW + 1001)
+            .await
+            .unwrap();
+    });
+}