Support getting release by release Id (#497)

Author: georgeorfanidi

docs/docs/repository.md

@@ -24,6 +24,7 @@ with Github4s, you can interact with:
   - [Delete a File](#delete-a-file)
 - [Releases](#releases)
   - [List of releases](#list-of-releases)
+  - [Get a single release](#get-a-single-release)
   - [The latest release](#the-latest-release)
   - [Create a release](#create-a-release)
 - [Statuses](#statuses)
@@ -381,6 +382,31 @@ response.result match {
 
 The `result` on the right is the corresponding [List[Release]][repository-scala].
 
+### Get a single release
+
+You can get a release using `getRelease`, it takes as arguments:
+
+- the release coordinates (`releaseId` the id of the release)
+- the repository coordinates (`owner` and `name` of the repository).
+
+Get a release by release id:
+
+```scala mdoc:compile-only
+val getRelease =
+  gh.repos.getRelease(
+  123,
+  "47deg",
+  "github4s")
+val response = getRelease.unsafeRunSync()
+response.result match {
+  case Left(e) => println(s"Something went wrong: ${e.getMessage}")
+  case Right(r) => println(r)
+}
+```
+
+The `result` on the right is the corresponding [Option[Release]][repository-scala].
+
+
 ### The latest release
 
 You can get the latest release using `latestRelease`, it takes as arguments:

github4s/src/main/scala/github4s/algebras/Repositories.scala

@@ -271,6 +271,22 @@ trait Repositories[F[_]] {
       headers: Map[String, String] = Map()
   ): F[GHResponse[List[User]]]
 
+  /**
+   * Get a single release
+   *
+   * @param releaseId id of the release
+   * @param owner of the repo
+   * @param repo name of the repo
+   * @param headers optional user headers to include in the request
+   * @return a GHResponse with List[Release]
+   */
+  def getRelease(
+      releaseId: Int,
+      owner: String,
+      repo: String,
+      headers: Map[String, String] = Map()
+  ): F[GHResponse[Option[Release]]]
+
   /**
    * Latest release
    *

github4s/src/main/scala/github4s/interpreters/RepositoriesInterpreter.scala

@@ -16,14 +16,14 @@
 
 package github4s.interpreters
 
-import github4s.http.HttpClient
-import github4s.algebras.Repositories
 import cats.data.NonEmptyList
-import github4s.GHResponse
-import github4s.domain._
+import com.github.marklister.base64.Base64._
 import github4s.Decoders._
 import github4s.Encoders._
-import com.github.marklister.base64.Base64._
+import github4s.GHResponse
+import github4s.algebras.Repositories
+import github4s.domain._
+import github4s.http.HttpClient
 
 class RepositoriesInterpreter[F[_]](implicit client: HttpClient[F], accessToken: Option[String])
     extends Repositories[F] {
@@ -225,6 +225,20 @@ class RepositoriesInterpreter[F[_]](implicit client: HttpClient[F], accessToken:
     client
       .get[Option[Release]](accessToken, s"repos/$owner/$repo/releases/latest", headers, Map.empty)
 
+  override def getRelease(
+      releaseId: Int,
+      owner: String,
+      repo: String,
+      headers: Map[String, String]
+  ): F[GHResponse[Option[Release]]] =
+    client
+      .get[Option[Release]](
+        accessToken,
+        s"repos/$owner/$repo/releases/$releaseId",
+        headers,
+        Map.empty
+      )
+
   override def listReleases(
       owner: String,
       repo: String,

github4s/src/test/scala/github4s/integration/ReposSpec.scala

@@ -18,10 +18,11 @@ package github4s.integration
 
 import cats.data.NonEmptyList
 import cats.effect.{IO, Resource}
+import cats.implicits._
 import github4s.GHError.NotFoundError
-import github4s.Github
 import github4s.domain._
 import github4s.utils.{BaseIntegrationSpec, Integration}
+import github4s.{GHResponse, Github}
 
 trait ReposSpec extends BaseIntegrationSpec {
 
@@ -61,6 +62,39 @@ trait ReposSpec extends BaseIntegrationSpec {
     response.statusCode shouldBe okStatusCode
   }
 
+  "Repos >> getRelease" should "return the expected repos when a valid org is provided" taggedAs Integration in {
+
+    val responseResource = for {
+      client <- clientResource
+
+      gh: Github[IO] = Github[IO](client, accessToken)
+      releasesIO =
+        gh.repos.listReleases(validRepoOwner, validRepoName, None, headers = headerUserAgent)
+
+      releasesResponse <- Resource.liftF(releasesIO)
+
+      releases <- Resource.liftF(IO.fromEither(releasesResponse.result))
+
+      releasesAreFoundCheck: IO[List[(Release, GHResponse[Option[Release]])]] = releases.map {
+        release =>
+          val releaseIO = gh.repos
+            .getRelease(release.id, validRepoOwner, validRepoName, headers = headerUserAgent)
+          releaseIO.map(r => release -> r)
+      }.sequence
+
+    } yield releasesAreFoundCheck
+
+    val responseList: List[(Release, GHResponse[Option[Release]])] = responseResource
+      .use(identity)
+      .unsafeRunSync()
+
+    forAll(responseList) {
+      case (release, response) =>
+        testIsRight[Option[Release]](response, r => r should contain(release))
+        response.statusCode shouldBe okStatusCode
+    }
+  }
+
   "Repos >> LatestRelease" should "return the expected repos when a valid org is provided" taggedAs Integration in {
     val response = clientResource
       .use { client =>

github4s/src/test/scala/github4s/unit/ReposSpec.scala

@@ -71,6 +71,20 @@ class ReposSpec extends BaseSpec {
     repos.latestRelease(validRepoOwner, validRepoName, headers = headerUserAgent)
   }
 
+  "Repos.getRelease" should "call to httpClient.get with the right parameters" in {
+    val response: IO[GHResponse[Option[Release]]] =
+      IO(GHResponse(Option(release).asRight, okStatusCode, Map.empty))
+
+    implicit val httpClientMock = httpClientMockGet[Option[Release]](
+      url = s"repos/$validRepoOwner/$validRepoName/releases/${release.id}",
+      response = response
+    )
+
+    val repos = new RepositoriesInterpreter[IO]
+
+    repos.getRelease(release.id, validRepoOwner, validRepoName, headers = headerUserAgent)
+  }
+
   "Repos.listOrgRepos" should "call to httpClient.get with the right parameters" in {
     val response: IO[GHResponse[List[Repository]]] =
       IO(GHResponse(List(repo).asRight, okStatusCode, Map.empty))