Function full_failover_sequence

crates/openshell-server/src/compute/lease.rs:448–478

()

    #[tokio::test]
    async fn full_failover_sequence() {
        let store = test_store().await;
        // Both use TTL=0 so steals succeed immediately. The TTL on the
        // stealer determines whether *it* can be stolen, so TTL=0 means
        // the "can't steal back" check needs a separate lease with a
        // long TTL to observe AlreadyHeld from the stealer's perspective.
        let l1 = lease(store.clone(), "replica-1", Duration::ZERO);
        let l2 = lease(store.clone(), "replica-2", Duration::ZERO);

        // Replica-1 acquires and renews once
        let mut guard1 = l1.try_acquire().await.unwrap();
        l1.renew(&mut guard1).await.unwrap();

        // Replica-2 steals the expired lease
        let mut guard2 = l2.acquire_or_steal().await.unwrap();

        // Replica-1 detects the loss on its next renew
        let err = l1.renew(&mut guard1).await.unwrap_err();
        assert!(matches!(err, LeaseError::Conflict));

        // Replica-2 can renew successfully
        l2.renew(&mut guard2).await.unwrap();

        // Replica-1 cannot re-acquire (lease exists)
        let l1_retry = lease(store.clone(), "replica-1", Duration::from_secs(60));
        let err = l1_retry.try_acquire().await.unwrap_err();
        assert!(matches!(err, LeaseError::AlreadyHeld));

        let record = l2.read().await.unwrap().unwrap();
        assert_eq!(record.holder, "replica-2");
    }

    #[tokio::test]
    async fn concurrent_steal_exactly_one_wins() {