tests: EventsBySlice spec hardening

Was expecting that the cache was updated in sequence, but it is a side effect.

Author: johanandren

core/src/test/scala/akka/persistence/r2dbc/query/EventsBySliceSpec.scala

@@ -348,36 +348,37 @@ class EventsBySliceSpec
         val timestamp1 = queryWithCache.latestEventTimestamp(entityType, slice, slice).futureValue
         timestamp1 shouldBe expectedTimestamp1
 
-        persister ! PersistWithAck("e2", probe.ref)
-        probe.expectMessage(Done)
-
-        // second query will return cached result (when still within TTL of 2 seconds)
+        // second query will return same result within TTL; note that the cache update is a side effect of
+        // the first query's future, so it may or may not have been applied yet - we avoid persisting new
+        // events between the two calls so the result is the same whether the cache was hit or not
         val timestamp2 = queryWithCache.latestEventTimestamp(entityType, slice, slice).futureValue
         timestamp2 shouldBe timestamp1
 
         // after clearing cache, will fetch the latest timestamp
+        persister ! PersistWithAck("e2", probe.ref)
+        probe.expectMessage(Done)
         queryWithCache.clearLatestEventTimestampCache()
         val expectedTimestamp3 = queryWithCache.timestampOf(pid, 2L).futureValue
         val timestamp3 = queryWithCache.latestEventTimestamp(entityType, slice, slice).futureValue
         timestamp3 shouldBe expectedTimestamp3
 
+        // make sure cached value has expired
         persister ! PersistWithAck("e3", probe.ref)
         probe.expectMessage(Done)
-
-        // make sure cached value has expired
         Thread.sleep(2000)
 
         // new result fetched from database after cache expiry
         val expectedTimestamp4 = queryWithCache.timestampOf(pid, 3L).futureValue
         val timestamp4 = queryWithCache.latestEventTimestamp(entityType, slice, slice).futureValue
         timestamp4 shouldBe expectedTimestamp4
 
-        persister ! PersistWithAck("e4", probe.ref)
-        probe.expectMessage(Done)
-
-        // next query will return cached result again (when still within TTL of 2 seconds)
+        // next query will return same result within TTL; same reasoning as above - cache update is a side
+        // effect so we avoid persisting new events between the two calls
         val timestamp5 = queryWithCache.latestEventTimestamp(entityType, slice, slice).futureValue
         timestamp5 shouldBe timestamp4
+
+        persister ! PersistWithAck("e4", probe.ref)
+        probe.expectMessage(Done)
       }
 
       "support LoadEventQuery" in new Setup {