Use Global EC for CatsResource

scalatest/shared/src/main/scala/cats/effect/testing/scalatest/CatsResource.scala

@@ -73,11 +73,18 @@ trait CatsResource[F[_], A] extends BeforeAndAfterAll { this: FixtureAsyncTestSu
   }
 
   override def afterAll(): Unit = {
-    UnsafeRun[F].unsafeToFuture(shutdown, finiteResourceTimeout)
-
-    gate = None
-    value = None
-    shutdown = ().pure[F]
+    UnsafeRun[F].unsafeToFuture(
+      for {
+        _ <- shutdown
+        _ <- Sync[F] delay {
+          gate = None
+          value = None
+          shutdown = ().pure[F]
+        }
+      } yield (),
+      finiteResourceTimeout
+    )
+    ()
   }
 
   override type FixtureParam = A

scalatest/shared/src/main/scala/cats/effect/testing/scalatest/CatsResourceIO.scala

@@ -22,11 +22,13 @@ import cats.effect.unsafe.IORuntime
 
 import org.scalatest.FixtureAsyncTestSuite
 
-import scala.concurrent.Future
+import scala.concurrent.{ExecutionContext, Future}
 import scala.concurrent.duration._
 
 trait CatsResourceIO[A] extends CatsResource[IO, A] with RuntimePlatform { this: FixtureAsyncTestSuite =>
 
+  override implicit def executionContext: ExecutionContext = ExecutionContext.global
+
   final def ResourceAsync = Async[IO]
 
   final def ResourceUnsafeRun = _ResourceUnsafeRun

scalatest/shared/src/test/scala/cats/effect/testing/scalatest/CatsResourceAllocationSpecs.scala

@@ -0,0 +1,53 @@
+package cats.effect.testing.scalatest
+
+import cats.effect.{IO, Resource}
+import org.scalatest.concurrent.Eventually
+import org.scalatest.events.Event
+import org.scalatest.{Args, Reporter}
+import org.scalatest.matchers.must.Matchers._
+import org.scalatest.wordspec.{AsyncWordSpec, FixtureAsyncWordSpec}
+
+import scala.concurrent.duration._
+
+class CatsResourceAllocationSpecs extends AsyncWordSpec with Eventually {
+
+  override implicit def patienceConfig: PatienceConfig =
+    super.patienceConfig.copy(timeout = 1.second)
+
+  @volatile
+  var beforeCalled: Int = 0
+
+  @volatile
+  var afterCalled: Int = 0
+
+  class ResourceSpec
+      extends FixtureAsyncWordSpec
+      with AsyncIOSpec
+      with CatsResourceIO[Unit] {
+
+    override val resource: Resource[IO, Unit] =
+      Resource.make { IO.delay { beforeCalled += 1 } } { _ =>
+        IO.delay { afterCalled += 1 }
+      }
+
+    "test" should {
+      "doFoo" in { _ => true mustBe true }
+    }
+  }
+
+  val reporter: Reporter = (_: Event) => ()
+
+  "cats resource allocation" should {
+    "release the resource" in {
+
+      val outerResourceSpec = new ResourceSpec
+
+      outerResourceSpec.run(None, Args(reporter))
+
+      eventually {
+        beforeCalled mustBe 1
+        afterCalled mustBe 1
+      }
+    }
+  }
+}