Added method to cancel timed cache invalidation

src/main/scala/org/github/mjftw/scache/Cache.scala

@@ -9,6 +9,7 @@ trait Cache[F[_], K, V] {
   def put(key: K, value: V): F[Unit]
   def putWithExpiry(key: K, value: V, expireAfter: FiniteDuration): F[Unit]
   def get(key: K): F[Option[V]]
+  def cancelExpiry(key: K): F[Boolean]
 }
 
 object Cache {
@@ -38,6 +39,24 @@ object Cache {
           /** Retrieve a value from the cache */
           def get(key: K): F[Option[V]] = ref.get.map(_.get(key).map { case (value, _) => value })
 
+          /** Prevent a cache entry at a given key from expiring.
+            * Returns true if the key was found in the cache, false otherwise.
+            */
+          def cancelExpiry(key: K): F[Boolean] =
+            for {
+              oldCache <- ref.getAndUpdate(cache =>
+                cache.get(key) match {
+                  case Some((value, _)) =>
+                    cache + (key -> Tuple2(value, Fiber(Sync[F].unit, Sync[F].unit)))
+                  case None => cache
+                }
+              )
+              wasFound <- oldCache.get(key) match {
+                case Some((_, oldFiber)) => oldFiber.cancel.as(true)
+                case None                => Sync[F].unit.as(false)
+              }
+            } yield wasFound
+
           /** Put replace the value and fiber at a key and cancel the old fiber */
           private def putValueAndFiber(key: K, value: V, fiber: CacheFiber[F]) =
             for {

src/test/scala/org/github/mjftw/scache/CacheSpec.scala

@@ -131,4 +131,45 @@ class CacheSpec extends AnyFlatSpec with Matchers {
     result.value should be(Some(Success((Some(1), None))))
   }
 
+  "cancelExpiry" should "remove the invalidation timer on cache entries" in {
+    val result = (for {
+      cache <- Cache.make[IO, String, Int]
+      _ <- cache.putWithExpiry("foo", 1, 1.second)
+      _ <- IO.sleep(500.millis)
+      _ <- cache.cancelExpiry("foo")
+      _ <- IO.sleep(1.second)
+      x <- cache.get("foo")
+    } yield x).unsafeToFuture
+
+    ctx.tick(2.second)
+
+    result.value should be(Some(Success(Some(1))))
+  }
+
+  it should "return true if the key was not found in the cache" in {
+    val result = (for {
+      cache <- Cache.make[IO, String, Int]
+      _ <- cache.putWithExpiry("foo", 1, 1.second)
+      _ <- IO.sleep(500.millis)
+      x <- cache.cancelExpiry("foo")
+    } yield x).unsafeToFuture
+
+    ctx.tick(2.second)
+
+    result.value should be(Some(Success(true)))
+  }
+
+  it should "return false if the key was not found in the cache" in {
+    val result = (for {
+      cache <- Cache.make[IO, String, Int]
+      _ <- cache.putWithExpiry("bar", 1, 1.second)
+      _ <- IO.sleep(500.millis)
+      x <- cache.cancelExpiry("foo")
+    } yield x).unsafeToFuture
+
+    ctx.tick(2.second)
+
+    result.value should be(Some(Success(false)))
+  }
+
 }