Require an http4s client to provide more flexibility, fixes #371

github4s/src/main/scala/github4s/Github.scala

@@ -16,19 +16,18 @@
 
 package github4s
 
-import java.util.concurrent.TimeUnit.MILLISECONDS
-import cats.effect.ConcurrentEffect
+import cats.effect.Sync
 import github4s.algebras._
 import github4s.modules._
-import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.Duration
+import org.http4s.client.Client
 
-class Github[F[_]: ConcurrentEffect](accessToken: Option[String], timeout: Option[Duration])(
-    implicit ec: ExecutionContext
+class Github[F[_]: Sync](
+    client: Client[F],
+    accessToken: Option[String]
 ) {
 
   private lazy val module: GithubAPIs[F] =
-    new GithubAPIv3[F](accessToken, timeout.getOrElse(Duration(1000L, MILLISECONDS)))
+    new GithubAPIv3[F](client, accessToken)
 
   lazy val users: Users[F]                 = module.users
   lazy val repos: Repositories[F]          = module.repos
@@ -45,10 +44,10 @@ class Github[F[_]: ConcurrentEffect](accessToken: Option[String], timeout: Optio
 
 object Github {
 
-  def apply[F[_]: ConcurrentEffect](
-      accessToken: Option[String] = None,
-      timeout: Option[Duration] = None
-  )(implicit ec: ExecutionContext): Github[F] =
-    new Github[F](accessToken, timeout)
+  def apply[F[_]: Sync](
+      client: Client[F],
+      accessToken: Option[String] = None
+  ): Github[F] =
+    new Github[F](client, accessToken)
 
 }

github4s/src/main/scala/github4s/http/Http4sSyntax.scala

@@ -16,7 +16,6 @@
 
 package github4s.http
 
-import cats.effect.ConcurrentEffect
 import org.http4s._
 import org.http4s.MediaType
 import org.http4s.Headers
@@ -26,7 +25,7 @@ import org.http4s.headers.`Content-Type`
 
 object Http4sSyntax {
 
-  implicit class RequestOps[F[_]: ConcurrentEffect](self: Request[F]) {
+  implicit class RequestOps[F[_]](self: Request[F]) {
     def withJsonBody[T](maybeData: Option[T])(implicit enc: Encoder[T]): Request[F] =
       maybeData.fold(self)(data =>
         self

github4s/src/main/scala/github4s/http/HttpClient.scala

@@ -16,21 +16,18 @@
 
 package github4s.http
 
+import cats.effect.Sync
+import cats.syntax.either._
+import cats.syntax.functor._
+import io.circe.{Decoder, Encoder}
+import github4s.GithubResponses.{GHResponse, JsonParsingException}
 import github4s.domain.Pagination
+import github4s.http.Http4sSyntax._
 import org.http4s.Request
-import org.http4s.client.blaze.BlazeClientBuilder
-import cats.effect.{ConcurrentEffect, Resource}
-import github4s.GithubResponses.{GHResponse, JsonParsingException}
-import cats.implicits._
-import io.circe.{Decoder, Encoder}
 import org.http4s.circe.CirceEntityDecoder._
-import github4s.http.Http4sSyntax._
 import org.http4s.client.Client
 
-import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.Duration
-
-class HttpClient[F[_]: ConcurrentEffect](connTimeout: Duration)(implicit ec: ExecutionContext) {
+class HttpClient[F[_]: Sync](client: Client[F]) {
 
   val urls: GithubAPIv3Config = GithubAPIv3Config()
 
@@ -132,33 +129,29 @@ class HttpClient[F[_]: ConcurrentEffect](connTimeout: Duration)(implicit ec: Exe
   val defaultPagination   = Pagination(1, 1000)
   val defaultPage: Int    = 1
   val defaultPerPage: Int = 30
-  val resource: Resource[F, Client[F]] = BlazeClientBuilder[F](ec)
-    .withConnectTimeout(connTimeout)
-    .resource
 
   private def buildURL(method: String): String = urls.baseUrl + method
 
-  private def run[Req: Encoder, Res: Decoder](request: RequestBuilder[Req]): F[GHResponse[Res]] =
-    resource
-      .use(
-        _.run(
-          Request[F]()
-            .withMethod(request.httpVerb)
-            .withUri(request.toUri(urls))
-            .withHeaders(request.toHeaderList: _*)
-            .withJsonBody(request.data)
-        ).use(response =>
-          response
-            .attemptAs[Res]
-            .value
-            .map { e =>
-              GHResponse(
-                e.leftMap(e => JsonParsingException(e.message, request.data.toString)),
-                response.status.code,
-                response.headers.toMap
-              )
-            }
-        )
+  private def run[Req: Encoder, Res: Decoder](request: RequestBuilder[Req]): F[GHResponse[Res]] = {
+    client
+      .run(
+        Request[F]()
+          .withMethod(request.httpVerb)
+          .withUri(request.toUri(urls))
+          .withHeaders(request.toHeaderList: _*)
+          .withJsonBody(request.data)
       )
-
+      .use { response =>
+        response
+          .attemptAs[Res]
+          .value
+          .map { e =>
+            GHResponse(
+              e.leftMap(e => JsonParsingException(e.message, request.data.toString)),
+              response.status.code,
+              response.headers.toMap
+            )
+          }
+      }
+  }
 }

github4s/src/main/scala/github4s/interpreters/ProjectsInterpreter.scala

@@ -18,7 +18,7 @@ package github4s.interpreters
 
 import github4s.GithubResponses.GHResponse
 import github4s.algebras.Projects
-import github4s.domain.{Column, Card, Pagination, Project}
+import github4s.domain.{Card, Column, Pagination, Project}
 import github4s.http.HttpClient
 import github4s.Decoders._
 

github4s/src/main/scala/github4s/modules/GithubAPIs.scala

@@ -16,13 +16,11 @@
 
 package github4s.modules
 
-import cats.effect.ConcurrentEffect
+import cats.effect.Sync
 import github4s.algebras._
 import github4s.http.HttpClient
 import github4s.interpreters._
-
-import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.Duration
+import org.http4s.client.Client
 
 sealed trait GithubAPIs[F[_]] {
   def users: Users[F]
@@ -38,12 +36,11 @@ sealed trait GithubAPIs[F[_]] {
   def projects: Projects[F]
 }
 
-class GithubAPIv3[F[_]: ConcurrentEffect](accessToken: Option[String] = None, timeout: Duration)(
-    implicit ec: ExecutionContext
-) extends GithubAPIs[F] {
+class GithubAPIv3[F[_]: Sync](client: Client[F], accessToken: Option[String] = None)
+    extends GithubAPIs[F] {
 
-  implicit val client = new HttpClient[F](timeout)
-  implicit val at     = accessToken
+  implicit val httpClient = new HttpClient[F](client)
+  implicit val at         = accessToken
 
   override val users: Users[F]                 = new UsersInterpreter[F]
   override val repos: Repositories[F]          = new RepositoriesInterpreter[F]

github4s/src/test/scala/github4s/integration/GHActivitiesSpec.scala

@@ -19,36 +19,41 @@ package github4s.integration
 import cats.effect.IO
 import github4s.Github
 import github4s.domain._
-
 import github4s.utils.{BaseIntegrationSpec, Integration}
 
 trait GHActivitiesSpec extends BaseIntegrationSpec {
 
   "Activity >> Set a thread subscription" should "return expected response when a valid thread id is provided" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .setThreadSub(validThreadId, true, false, headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .setThreadSub(validThreadId, true, false, headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsRight[Subscription](response)
     response.statusCode shouldBe okStatusCode
   }
 
   it should "return error when an invalid thread id is passed" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .setThreadSub(invalidThreadId, true, false, headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .setThreadSub(invalidThreadId, true, false, headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsLeft(response)
     response.statusCode shouldBe notFoundStatusCode
   }
 
   "Activity >> ListStargazers" should "return the expected list of starrers for valid data" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStargazers(validRepoOwner, validRepoName, false, None, headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStargazers(validRepoOwner, validRepoName, false, None, headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsRight[List[Stargazer]](response, { r =>
       r.nonEmpty shouldBe true
@@ -58,10 +63,12 @@ trait GHActivitiesSpec extends BaseIntegrationSpec {
   }
 
   it should "return the expected list of starrers for valid data with dates if timeline" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStargazers(validRepoOwner, validRepoName, true, None, headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStargazers(validRepoOwner, validRepoName, true, None, headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsRight[List[Stargazer]](response, { r =>
       r.nonEmpty shouldBe true
@@ -71,20 +78,24 @@ trait GHActivitiesSpec extends BaseIntegrationSpec {
   }
 
   it should "return error for invalid repo name" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStargazers(invalidRepoName, validRepoName, false, None, headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStargazers(invalidRepoName, validRepoName, false, None, headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsLeft(response)
     response.statusCode shouldBe notFoundStatusCode
   }
 
   "Activity >> ListStarredRepositories" should "return the expected list of starred repos" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStarredRepositories(validUsername, false, headers = headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStarredRepositories(validUsername, false, headers = headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsRight[List[StarredRepository]](response, { r =>
       r.nonEmpty shouldBe true
@@ -94,10 +105,12 @@ trait GHActivitiesSpec extends BaseIntegrationSpec {
   }
 
   it should "return the expected list of starred repos with dates if timeline" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStarredRepositories(validUsername, true, headers = headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStarredRepositories(validUsername, true, headers = headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsRight[List[StarredRepository]](response, { r =>
       r.nonEmpty shouldBe true
@@ -107,10 +120,12 @@ trait GHActivitiesSpec extends BaseIntegrationSpec {
   }
 
   it should "return error for invalid username" taggedAs Integration in {
-    val response =
-      Github[IO](accessToken).activities
-        .listStarredRepositories(invalidUsername, false, headers = headerUserAgent)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client, accessToken).activities
+          .listStarredRepositories(invalidUsername, false, headers = headerUserAgent)
+      }
+      .unsafeRunSync()
 
     testIsLeft(response)
     response.statusCode shouldBe notFoundStatusCode

github4s/src/test/scala/github4s/integration/GHAuthSpec.scala

@@ -25,34 +25,49 @@ trait GHAuthSpec extends BaseIntegrationSpec {
 
   "Auth >> NewAuth" should "return error on Left when invalid credential is provided" taggedAs Integration in {
 
-    val response = Github[IO]().auth
-      .newAuth(
-        validUsername,
-        invalidPassword,
-        validScopes,
-        validNote,
-        validClientId,
-        invalidClientSecret,
-        headerUserAgent
-      )
+    val response = clientResource
+      .use { client =>
+        Github[IO](client).auth
+          .newAuth(
+            validUsername,
+            invalidPassword,
+            validScopes,
+            validNote,
+            validClientId,
+            invalidClientSecret,
+            headerUserAgent
+          )
+      }
       .unsafeRunSync()
 
     testIsLeft(response)
   }
 
   "Auth >> AuthorizeUrl" should "return the expected URL for valid username" taggedAs Integration in {
-    val response =
-      Github[IO]().auth
-        .authorizeUrl(validClientId, validRedirectUri, validScopes)
-        .unsafeRunSync()
+    val response = clientResource
+      .use { client =>
+        Github[IO](client).auth
+          .authorizeUrl(validClientId, validRedirectUri, validScopes)
+      }
+      .unsafeRunSync()
 
     testIsRight[Authorize](response, r => r.url.contains(validRedirectUri) shouldBe true)
     response.statusCode shouldBe okStatusCode
   }
 
   "Auth >> GetAccessToken" should "return error on Left for invalid code value" taggedAs Integration in {
-    val response = Github[IO]().auth
-      .getAccessToken(validClientId, invalidClientSecret, "", validRedirectUri, "", headerUserAgent)
+    val response = clientResource
+      .use { client =>
+        Github[IO](client).auth
+          .getAccessToken(
+            validClientId,
+            invalidClientSecret,
+            "",
+            validRedirectUri,
+            "",
+            headerUserAgent
+          )
+      }
       .unsafeRunSync()
 
     testIsLeft(response)