Refactoring

Author: sukeshni

src/main/scala/codecheck/github/operations/SearchOp.scala

@@ -6,51 +6,38 @@ import scala.concurrent.ExecutionContext.Implicits.global
 import codecheck.github.api.GitHubAPI
 import codecheck.github.models.SearchInput
 import codecheck.github.models.SearchRepositoryResult
-//import codecheck.github.models.SortDirection
 import codecheck.github.models.SearchCodeResult
 import codecheck.github.models.SearchIssueResult
 import codecheck.github.models.SearchUserResult
 
 trait SearchOp {
  self: GitHubAPI =>
 
-  def searchRepositories(input: SearchInput): Future[Option[SearchRepositoryResult]] = {
+  def searchRepositories(input: SearchInput): Future[SearchRepositoryResult] = {
     val path = s"/search/repositories?q=${input.q}&sort=${input.sort}&order=${input.order}"
     exec("GET", path ).map { res =>
-      res.statusCode match {
-        case 200 => Some(SearchRepositoryResult(res.body))
-        case 404 => None
-     }
+      SearchRepositoryResult(res.body)
    }
   }
 
-  def searchCode(input: SearchInput): Future[Option[SearchCodeResult]] = {
+  def searchCode(input: SearchInput): Future[SearchCodeResult] = {
     val path = s"/search/code?q=${input.q}&sort=${input.sort}&order=${input.order}"
     exec("GET", path ).map { res =>
-      res.statusCode match {
-        case 200 => Some(SearchCodeResult(res.body))
-        case 404 => None
-     }
+      SearchCodeResult(res.body)
     }
   }
 
-  def searchIssues(input: SearchInput): Future[Option[SearchIssueResult]] = {
+  def searchIssues(input: SearchInput): Future[SearchIssueResult] = {
     val path = s"/search/issues?q=${input.q}&sort=${input.sort}&order=${input.order}"
     exec("GET", path ).map { res =>
-      res.statusCode match {
-        case 200 => Some(SearchIssueResult(res.body))
-        case 404 => None
-     }
+      SearchIssueResult(res.body)
     }
   }
 
-  def searchUser(input: SearchInput): Future[Option[SearchUserResult]] = {
+  def searchUser(input: SearchInput): Future[SearchUserResult] = {
     val path = s"/search/users?q=${input.q}&sort=${input.sort}&order=${input.order}"
     exec("GET", path ).map { res =>
-      res.statusCode match {
-        case 200 => Some(SearchUserResult(res.body))
-        case 404 => None
-     }
+      SearchUserResult(res.body)
     }
   }
 }

src/test/scala/SearchOpSpec.scala

@@ -18,41 +18,38 @@ class SearchOpSpec extends FunSpec
       var q = "tetris language:assembly"
       val q1 = q.trim.replaceAll(" ","+");
       val input = SearchInput(q1,sort=Some(SearchSort.stars),order=SortDirection.desc)
-      Await.result(api.searchRepositories(input), TIMEOUT).map { res =>
-        assert(res.total_count >= 1)
-        assert(res.items(0).id >= 1 )
-        assert(res.items(0).name.length >= 1)
-        assert(res.items(0).full_name.length >= 1)
-        assert(res.items(0).description.isDefined)
-        assert(res.items(0).open_issues_count >= 0)
-        assert(res.items(0).language == "Assembly")
-        assert(res.items(0).stargazers_count > res.items(1).stargazers_count)
-      }
+      val res = Await.result(api.searchRepositories(input), TIMEOUT)
+      assert(res.total_count >= 1)
+      assert(res.items(0).id >= 1 )
+      assert(res.items(0).name.length >= 1)
+      assert(res.items(0).full_name.length >= 1)
+      assert(res.items(0).description.isDefined)
+      assert(res.items(0).open_issues_count >= 0)
+      assert(res.items(0).language == "Assembly")
+      assert(res.items(0).stargazers_count > res.items(1).stargazers_count)
     }
     it("with valid changed query(q) SearchInput should succeed") {
       var q = "jquery in:name,description"
       val q1 = q.trim.replaceAll(" ","+");
       val input = SearchInput(q1,sort=Some(SearchSort.stars),order=SortDirection.desc)
-      Await.result(api.searchRepositories(input), TIMEOUT).map { res =>
-        assert(res.total_count >= 1)
-        assert(res.items(0).id >= 1 )
-        assert(res.items(0).name.length >= 1)
-        assert(res.items(0).full_name.length >= 1)
-        assert(res.items(0).description.isDefined)
-        assert(res.items(0).open_issues_count >= 0)
-      }
+      val res = Await.result(api.searchRepositories(input), TIMEOUT)
+      assert(res.total_count >= 1)
+      assert(res.items(0).id >= 1 )
+      assert(res.items(0).name.length >= 1)
+      assert(res.items(0).full_name.length >= 1)
+      assert(res.items(0).description.isDefined)
+      assert(res.items(0).open_issues_count >= 0)
     }
   }
   describe("searchCode") {
     it("with valid SearchInput q,no SortOrder should succeed") {
       var q = "addClass in:file language:js repo:jquery/jquery"
       val q1 = q.trim.replaceAll(" ","+");
       val input = SearchInput(q1,sort=None,order=SortDirection.desc)
-      Await.result(api.searchCode(input), TIMEOUT).map { res =>
-        assert(res.total_count >= 1)
-        assert(res.items(0).Repo.id >= 1 )
-        assert(res.items(0).Repo.full_name == "jquery/jquery")
-      }
+      val res = Await.result(api.searchCode(input), TIMEOUT)
+      assert(res.total_count >= 1)
+      assert(res.items(0).Repo.id >= 1 )
+      assert(res.items(0).Repo.full_name == "jquery/jquery")
     }
     //Following test results in error:
     //  "message" : "Validation Failed",
@@ -77,26 +74,23 @@ class SearchOpSpec extends FunSpec
       var q = "windows label:bug language:python state:open"
       val q1 = q.trim.replaceAll(" ","+");
       val input = SearchInput(q1,sort=Some(SearchSort.created),order=SortDirection.asc)
-      Await.result(api.searchIssues(input), TIMEOUT).map { res =>
-        assert(res.total_count >= 1)
-        assert(res.items(0).labels(0).name == "bug" )
-        assert(res.items(0).state == "open")
-        assert(((res.items(0).created_at).compareTo(res.items(1).created_at)) > 0)
-      }
+      val res = Await.result(api.searchIssues(input), TIMEOUT)
+      assert(res.total_count >= 1)
+      assert(res.items(0).labels(0).name == "bug" )
+      assert(res.items(0).state == "open")
+      assert(((res.items(0).created_at).compareTo(res.items(1).created_at)) > 0)
     }
   }
   describe("searchUser") {
     it("with valid SearchInput should succeed") {
       var q = "tom repos:>42 followers:>1000"
       q = q.trim.replaceAll(" ","+")
       val q1 = q.replaceAll(">","%3E")
-      println("QUERY: searchUser" + q1)
       val input = SearchInput(q1,sort=None,order=SortDirection.desc)
-      Await.result(api.searchUser(input), TIMEOUT).map { res =>
-        assert(res.total_count >= 1)
-        assert(res.items(0).login.length >= 1)
-        assert(res.items(0).id >= 1)
-      }
+      val res = Await.result(api.searchUser(input), TIMEOUT)
+      assert(res.total_count >= 1)
+      assert(res.items(0).login.length >= 1)
+      assert(res.items(0).id >= 1)
     }
   }
 }