Server: deflake test_lock (#989)

## Motivation

This test repeatedly fails, but not always. A real frustration!

## Solution

Rephrasing the assertions may help. Instead of using fixed deadlines,
assert based on relative durations between the first and second.

Author: svix-onelson

server/svix-server/src/core/idempotency.rs

@@ -526,10 +526,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_lock() {
-        // The sleep interval is 200ms, so have it wait 300ms causing it to sleep twice. This
-        // means it should take at least 400ms for the second task to respond.
-        let (_jh, endpoint, _count) =
-            start_service(Some(std::time::Duration::from_millis(300))).await;
+        let sleep_duration = std::time::Duration::from_millis(300);
+
+        let (_jh, endpoint, _count) = start_service(Some(sleep_duration)).await;
         let client = Client::new();
 
         // Generate a new token so that keys are unique
@@ -564,8 +563,11 @@ mod tests {
         let resp_2 = resp_2_jh.await.unwrap().unwrap();
         let resp_2_instant = std::time::Instant::now();
 
-        assert!(resp_1_instant - start < std::time::Duration::from_millis(350));
-        assert!(resp_2_instant - start > std::time::Duration::from_millis(400));
+        // resp_1 should take some variable amount of time thanks to the sleep.
+        assert!(resp_1_instant - start >= sleep_duration);
+        // resp_2 should take less than the sleep (300) since it's just waiting for the same
+        // response given to the first request.
+        assert!(resp_2_instant - resp_1_instant < sleep_duration);
 
         // And the responses should be equivalent
         assert_eq!(resp_1.status(), resp_2.status());