Fix Expiration of Caffeine Cache

modules/caffeine/src/main/scala/scalacache/caffeine/CaffeineCache.scala

@@ -30,7 +30,7 @@ class CaffeineCache[F[_]: Sync, V](val underlying: CCache[String, Entry[V]])(imp
   def doGet(key: String): F[Option[V]] = {
     F.delay {
       Option(underlying.getIfPresent(key))
-    }.flatMap(_.filterA(Entry.isExpired[F, V]))
+    }.flatMap(_.filterA(Entry.isBeforeExpiration[F, V]))
       .map(_.map(_.value))
       .flatTap { result =>
         logCacheHitOrMiss(key, result)

modules/caffeine/src/test/scala/scalacache/caffeine/CaffeineCacheSpec.scala

@@ -59,10 +59,11 @@ class CaffeineCacheSpec extends AnyFlatSpec with Matchers with BeforeAndAfter wi
     newIOCache(underlying).get("non-existent key").map(_ shouldBe None)
   }
 
-  it should "return None if the given key exists but the value has expired" in ticked { _ =>
+  it should "return None if the given key exists but the value has expired" in ticked { ticker =>
+    val ctx        = ticker.ctx
     val underlying = newCCache
     val expiredEntry =
-      Entry("hello", expiresAt = Some(Instant.now.minusSeconds(1)))
+      Entry("hello", expiresAt = Some(Instant.ofEpochMilli(ctx.now().toMillis).minusSeconds(1)))
     underlying.put("key1", expiredEntry)
     newIOCache(underlying).get("key1").map(_ shouldBe None)
   }

modules/core/src/main/scala/scalacache/Entry.scala

@@ -13,17 +13,13 @@ case class Entry[+A](value: A, expiresAt: Option[Instant])
 
 object Entry {
 
-  /** Has the entry expired yet?
-    */
-  def isExpired[F[_], A](entry: Entry[A])(implicit clock: Clock[F], applicative: Applicative[F]): F[Boolean] =
+  def isBeforeExpiration[F[_], A](entry: Entry[A])(implicit clock: Clock[F], applicative: Applicative[F]): F[Boolean] =
     entry.expiresAt
       .traverse { expiration =>
-        val now = clock.monotonic.map(m => Instant.ofEpochMilli(m.toMillis))
-
-        now.map(expiration.isBefore(_))
-      }
-      .map {
-        case None | Some(true) => true
-        case Some(false)       => false
+        clock.realTimeInstant.map(_.isBefore(expiration))
       }
+      .map(_.getOrElse(true))
+
+  def isExpired[F[_], A](entry: Entry[A])(implicit clock: Clock[F], applicative: Applicative[F]): F[Boolean] =
+    isBeforeExpiration[F, A](entry).map(b => !b)
 }