Get the list of teams in an organization. (#350)

* initial refactoring from free monad to tagless final

* Added Algebras

* Refactored HttpClient, temporarily bypassing HttpRequestBuilderExtension, added runtime implicits, added User alg interpretation

* moving /free/domain to /taglessFinal/domain

* Adding interpreters for algebras. Interpreters target the /api classes

* reformatted/linted, remove ADTs from algebras, added more implicit runtime instnaces

* updated algebra signatures to match existing api, removed accessToken as default param, added headers as default param

*  Modified intepreters to fit new algebra definitions and take accessToken as a default parameter

* removing free monad implementation

* updating GHWorkflow and Github

* for Rafa review

* pre merge

* Updated F type constraint F[_]: Applicative -> F[_]: ConcurrentEffect

* For Rafa comment, progress on replacing scalaj-http with http4s

* For Rafa review and refactor

* applied some refactoring to have clean layers

* Adding toFutue and toId syntax for IO[A]

* removing unit tests associated with deleted classes

* For Rafa Review, unit tests

* updating unit tests for interpreters

* unit test linting

* refactoring integration test to match new api usage

* updating unit and integration test base spec

* linting and updating scala version 2.13 and blaze client

* fixing TestData for integration test

* Updateding FakeResponses for Decoder testing

* fix integration test, pull GITHUB4S_ACCESS_TOKEN from sys env

* upgrades some models

* Revert "upgrades some models"

This reverts commit 4771d05

* fixes the unit tests

* removes commented import

* fixes the decoders issue for the new http client

* proves the organization's members with the proper token

* enables commented suites

* ignores temporally a test because we are getting permission issues

* Updating documentation, initial draft

* Update contributing.md

* fixing github doc links

* cleaning interpreter imports, retarget issue for testing (123 -> 17)

* remove old api tests

* remove mock-server dependency, change http4s version

* switching to compile-only check in documentation. mdoc:silent -> mdoc:compile-only

* added GET listTeams

* Address Ben F. PR comments

* Address Lawrence's PR comments

* Address Anna M. PR Comments

* Address Ana G. PR comments

* fixes test

* added pagination

* merge with master

* Update github4s/src/main/scala/github4s/domain/Team.scala

Co-Authored-By: Juan Pedro Moreno <4879373+juanpedromoreno@users.noreply.github.com>

* Address Ben PR Comments

* optimize imports

* Address Eric Bond PR Comments

* added documentation

Co-authored-by: bond15 <bond.eric.23@gmail.com>
Co-authored-by: Rafa Paradela <rafa.p@47deg.com>
Co-authored-by: Juan Pedro Moreno <4879373+juanpedromoreno@users.noreply.github.com>

Author: 4 people

docs/docs/team.md

@@ -0,0 +1,55 @@
+---
+layout: docs
+title: Team API
+permalink: team
+---
+
+# Team API
+
+Github4s supports the [Team API](https://developer.github.com/v3/teams/). As a result,
+with Github4s, you can interact with:
+
+- [Team](#team)
+  - [List team](#list-team)
+
+The following examples assume the following imports and token:
+
+```scala mdoc:silent
+import github4s.Github
+import github4s.GithubIOSyntax._
+import cats.effect.IO
+import scala.concurrent.ExecutionContext.Implicits.global
+
+implicit val IOContextShift = IO.contextShift(global)
+val accessToken = sys.env.get("GITHUB4S_ACCESS_TOKEN")
+```
+
+They also make use of `cats.Id`, but any type container `F` implementing `ConcurrentEffect` will do.
+
+LiftIO syntax for `cats.Id` and `Future` are provided in `GithubIOSyntax`.
+
+## Team
+
+### List team
+
+You can list the teams for a particular organization with `listTeams`; it takes as arguments:
+
+- `org`: name of the organization for which we want to retrieve the teams.
+- `pagination`: Limit and Offset for pagination, optional.
+
+To list the teams for organization `47deg`:
+
+```scala mdoc:compile-only
+val listTeams = Github[IO](accessToken).teams.listTeams("47deg")
+listTeams.unsafeRunSync match {
+  case Left(e) => println(s"Something went wrong: ${e.getMessage}")
+  case Right(r) => println(r.result)
+}
+```
+
+The `result` on the right is the corresponding [List[Team]][team-scala].
+
+See [the API doc](https://developer.github.com/v3/teams/#list-teams) for full reference.
+
+
+[team-scala]: https://github.com/47deg/github4s/blob/master/github4s/src/main/scala/github4s/domain/Team.scala

docs/src/main/resources/microsite/data/menu.yml

@@ -28,3 +28,6 @@ options:
 
   - title: Organization API
     url: organization
+
+  - title: Team API
+    url: team

github4s/src/main/scala/github4s/Decoders.scala

@@ -278,4 +278,7 @@ object Decoders {
           starred_at <- c.downField("starred_at").as[String]
           user       <- c.downField("user").as[User]
         } yield Stargazer(Some(starred_at), user)))
+
+  implicit val decodeTeam: Decoder[Team] = deriveDecoder[Team]
+
 }

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

@@ -38,7 +38,7 @@ class Github[F[_]: ConcurrentEffect](accessToken: Option[String], timeout: Optio
   lazy val gitData: GitData[F]             = module.gitData
   lazy val pullRequests: PullRequests[F]   = module.pullRequests
   lazy val organizations: Organizations[F] = module.organizations
-
+  lazy val teams: Teams[F]                 = module.teams
 }
 
 object Github {

github4s/src/main/scala/github4s/algebras/Teams.scala

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016-2020 47 Degrees, LLC. <http://www.47deg.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package github4s.algebras
+
+import github4s.GithubResponses.GHResponse
+import github4s.domain._
+
+trait Teams[F[_]] {
+
+  /** List the teams for a particular organization
+   *
+   * @param org organization for which we wish to retrieve the teams
+   * @param pagination Limit and Offset for pagination
+   * @param headers optional user headers to include in the request
+   * @return GHResponse[List[Team]] the list of teams for this organization
+   */
+  def listTeams(
+      org: String,
+      pagination: Option[Pagination] = None,
+      headers: Map[String, String] = Map()): F[GHResponse[List[Team]]]
+
+}

github4s/src/main/scala/github4s/domain/Team.scala

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2016-2020 47 Degrees, LLC. <http://www.47deg.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package github4s.domain
+
+final case class Team(
+    id: Int,
+    node_id: String,
+    url: String,
+    html_url: String,
+    name: String,
+    slug: String,
+    description: Option[String],
+    privacy: String,
+    permission: String,
+    members_url: String,
+    repositories_url: String,
+    parent: Option[Team] = None
+)

github4s/src/main/scala/github4s/interpreters/TeamsInterpreter.scala

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2016-2020 47 Degrees, LLC. <http://www.47deg.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package github4s.interpreters
+
+import github4s.Decoders._
+import github4s.GithubResponses.GHResponse
+import github4s.algebras.Teams
+import github4s.domain._
+import github4s.http.HttpClient
+
+class TeamsInterpreter[F[_]](implicit client: HttpClient[F], accessToken: Option[String])
+    extends Teams[F] {
+
+  override def listTeams(
+      org: String,
+      pagination: Option[Pagination],
+      headers: Map[String, String]): F[GHResponse[List[Team]]] =
+    client.get[List[Team]](accessToken, method = s"orgs/$org/teams", headers, Map.empty, pagination)
+}

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

@@ -34,6 +34,7 @@ sealed trait GithubAPIs[F[_]] {
   def gitData: GitData[F]
   def pullRequests: PullRequests[F]
   def organizations: Organizations[F]
+  def teams: Teams[F]
 }
 
 class GithubAPIv3[F[_]: ConcurrentEffect](accessToken: Option[String] = None, timeout: Duration)(
@@ -52,4 +53,6 @@ class GithubAPIv3[F[_]: ConcurrentEffect](accessToken: Option[String] = None, ti
   override val gitData: GitData[F]             = new GitDataInterpreter[F]
   override val pullRequests: PullRequests[F]   = new PullRequestsInterpreter[F]
   override val organizations: Organizations[F] = new OrganizationsInterpreter[F]
+  override val teams: Teams[F]                 = new TeamsInterpreter[F]
+
 }

github4s/src/test/scala/github4s/integration/GHTeamsSpec.scala

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2016-2020 47 Degrees, LLC. <http://www.47deg.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package github4s.integration
+
+import cats.effect.IO
+import github4s.GithubIOSyntax._
+import github4s.Github
+import github4s.domain._
+import github4s.utils.{BaseIntegrationSpec, Integration}
+
+trait GHTeamsSpec extends BaseIntegrationSpec {
+  "Team >> ListTeams" should "return the expected teams when a valid org is provided" taggedAs Integration in {
+    val response =
+      Github[IO](accessToken).teams
+        .listTeams(validRepoOwner, headers = headerUserAgent)
+        .unsafeRunSync()
+
+    testIsRight[List[Team]](response, { r =>
+      r.result.nonEmpty shouldBe true
+      r.statusCode shouldBe okStatusCode
+    })
+  }
+
+  it should "return error when an invalid org is passed" taggedAs Integration in {
+    val response =
+      Github[IO](accessToken).teams
+        .listTeams(invalidRepoName, headers = headerUserAgent)
+        .unsafeRunSync()
+
+    testIsLeft(response)
+  }
+
+}

github4s/src/test/scala/github4s/unit/TeamsSpec.scala

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016-2020 47 Degrees, LLC. <http://www.47deg.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package github4s.unit
+
+import cats.effect.IO
+import github4s.GithubResponses.{GHResponse, GHResult}
+import github4s.domain._
+import github4s.interpreters.TeamsInterpreter
+import github4s.utils.BaseSpec
+
+class TeamsSpec extends BaseSpec {
+
+  implicit val token = sampleToken
+
+  "Teams.listTeam" should "call to httpClient.get with the right parameters" in {
+
+    val response: IO[GHResponse[List[Team]]] =
+      IO(Right(GHResult(List(team), okStatusCode, Map.empty)))
+
+    implicit val httpClientMock = httpClientMockGet[List[Team]](
+      url = s"orgs/$validRepoOwner/teams",
+      response = response
+    )
+
+    val teams = new TeamsInterpreter[IO]
+
+    teams.listTeams(validRepoOwner, headers = headerUserAgent)
+  }
+
+}