dave - usage of type aliases

src/main/scala/io/github/daviddenton/fintrospect/testing/TestingFintrospectRoute.scala

@@ -3,10 +3,10 @@ package io.github.daviddenton.fintrospect.testing
 import java.util.concurrent.TimeUnit
 
 import com.twitter.finagle.http.path.Root
-import com.twitter.finagle.http.{Request, Response}
 import com.twitter.util.Await
+import io.github.daviddenton.fintrospect.FinagleTypeAliases.{Request, Response}
 import io.github.daviddenton.fintrospect.renderers.SimpleJson
-import io.github.daviddenton.fintrospect.{Route, FintrospectModule}
+import io.github.daviddenton.fintrospect.{FintrospectModule, Route}
 
 import scala.concurrent.duration.Duration
 

src/test/scala/examples/BookAdd.scala

@@ -1,8 +1,7 @@
 package examples
 
-import com.twitter.finagle.Service
-import com.twitter.finagle.http.{Request, Response}
 import com.twitter.util.Future
+import io.github.daviddenton.fintrospect.FinagleTypeAliases.{Response, Request, Service}
 import io.github.daviddenton.fintrospect._
 import io.github.daviddenton.fintrospect.parameters.{Body, Path}
 import io.github.daviddenton.fintrospect.util.ResponseBuilder
@@ -15,7 +14,7 @@ class BookAdd(books: Books) {
   private val bookExistsResponse = Error(CONFLICT, "Book with that ISBN exists")
   private val body = Body.json(Some("book content"), exampleBook.toJson)
 
-  private def addBook(isbn: String) = new Service[Request, Response] {
+  private def addBook(isbn: String) = new Service {
     override def apply(request: Request): Future[Response] =
       books.lookup(isbn) match {
         case Some(_) => bookExistsResponse

src/test/scala/examples/BookLookupTest.scala

@@ -1,8 +1,10 @@
 package examples
 
 import com.twitter.finagle.http.Request
+import com.twitter.io.Charsets
 import io.github.daviddenton.fintrospect.testing.TestingFintrospectRoute
 import io.github.daviddenton.fintrospect.util.ArgoUtil._
+import org.jboss.netty.handler.codec.http.HttpResponseStatus
 import org.scalatest.{FunSpec, ShouldMatchers}
 
 /*
@@ -14,11 +16,11 @@ class BookLookupTest extends FunSpec with ShouldMatchers with TestingFintrospect
 
   describe("Book Lookup") {
     it("can lookup an existing book") {
-      parse(responseFor(Request("/book/hp1")).contentString) shouldEqual Book("hairy porker", "j.k oinking", 799).toJson
+      parse(responseFor(Request("/book/hp1")).getContent.toString(Charsets.Utf8)) shouldEqual Book("hairy porker", "j.k oinking", 799).toJson
     }
   }
 
   it("non-existing book") {
-    responseFor(Request("/book/hp8")).getStatusCode() shouldEqual 404
+    responseFor(Request("/book/hp8")).getStatus shouldEqual HttpResponseStatus.NOT_FOUND
   }
 }

src/test/scala/examples/BookSearch.scala

@@ -1,9 +1,9 @@
 package examples
 
+import io.github.daviddenton.fintrospect.FinagleTypeAliases.{Response, Request}
 import io.github.daviddenton.fintrospect.util.ResponseBuilder
 import ResponseBuilder._
 import com.twitter.finagle.Service
-import com.twitter.finagle.http.{Request, Response}
 import com.twitter.util.Future
 import io.github.daviddenton.fintrospect.ContentTypes.APPLICATION_JSON
 import io.github.daviddenton.fintrospect._

src/test/scala/examples/LibraryApp.scala

@@ -30,7 +30,7 @@ object LibraryApp extends App {
   val statusModule = FintrospectModule(Root / "internal", SimpleJson())
     .withRoute(new Ping().route)
 
-  val service = FintrospectModule.toService(libraryModule combine statusModule)
+  val service: FinagleTypeAliases.Service = FintrospectModule.toService(libraryModule combine statusModule)
 
   ServerBuilder()
     .codec(RichHttp[Request](Http()))

src/test/scala/io/github/daviddenton/fintrospect/FintrospectModuleTest.scala

@@ -1,27 +1,24 @@
 package io.github.daviddenton.fintrospect
 
-import com.twitter.finagle.Service
-import com.twitter.finagle.http.path.Root
 import com.twitter.finagle.http.{Request, Response}
+import com.twitter.finagle.http.path.Root
 import com.twitter.io.Charsets._
 import com.twitter.util.{Await, Future}
+import io.github.daviddenton.fintrospect.FinagleTypeAliases._
 import io.github.daviddenton.fintrospect.FintrospectModule._
 import io.github.daviddenton.fintrospect.parameters.Header
 import io.github.daviddenton.fintrospect.parameters.Path._
 import io.github.daviddenton.fintrospect.renderers.SimpleJson
 import io.github.daviddenton.fintrospect.util.ResponseBuilder
-import org.jboss.netty.buffer.ChannelBuffers._
 import org.jboss.netty.handler.codec.http.HttpMethod._
+import org.jboss.netty.handler.codec.http.HttpResponseStatus
 import org.scalatest.{FunSpec, ShouldMatchers}
 
 class FintrospectModuleTest extends FunSpec with ShouldMatchers {
 
-  case class AService(segments: Seq[String]) extends Service[Request, Response] {
+  case class AService(segments: Seq[String]) extends FinagleTypeAliases.Service {
     def apply(request: Request): Future[Response] = {
-      val response = Response()
-      response.setStatusCode(200)
-      response.setContent(copiedBuffer(segments.mkString(","), Utf8))
-      Future.value(response)
+      ResponseBuilder.Ok(segments.mkString(","))
     }
   }
 
@@ -54,22 +51,22 @@ class FintrospectModuleTest extends FunSpec with ShouldMatchers {
     describe("can combine more than 2 modules") {
       it("can get to all routes") {
         def module(path: String) = {
-          FintrospectModule(Root / path, SimpleJson()).withRoute(DescribedRoute("").at(GET) bindTo (() => new Service[Request, Response]() {
+          FintrospectModule(Root / path, SimpleJson()).withRoute(DescribedRoute("").at(GET) bindTo (() => new Service() {
             def apply(request: Request): Future[Response] = ResponseBuilder.Ok(path)
           }))
         }
         val totalService = FintrospectModule.toService(combine(module("rita"), module("bob"), module("sue")))
 
-        Await.result(totalService.apply(Request("/rita"))).content.toString(Utf8) shouldEqual "rita"
-        Await.result(totalService.apply(Request("/bob"))).content.toString(Utf8) shouldEqual "bob"
-        Await.result(totalService.apply(Request("/sue"))).content.toString(Utf8) shouldEqual "sue"
+        Await.result(totalService.apply(Request("/rita"))).getContent.toString(Utf8) shouldEqual "rita"
+        Await.result(totalService.apply(Request("/bob"))).getContent.toString(Utf8) shouldEqual "bob"
+        Await.result(totalService.apply(Request("/sue"))).getContent.toString(Utf8) shouldEqual "sue"
       }
     }
 
     describe("when a route path cannot be found") {
       it("returns a 404") {
         val result = Await.result(FintrospectModule(Root, SimpleJson()).toService.apply(Request("/svc/noSuchRoute")))
-        result.status.getCode shouldEqual 404
+        result.getStatus shouldEqual HttpResponseStatus.NOT_FOUND
       }
     }
 
@@ -79,22 +76,20 @@ class FintrospectModuleTest extends FunSpec with ShouldMatchers {
 
       it("it returns a 400 when the param is missing") {
         val request = Request("/svc")
-        val result = Await.result(m.toService.apply(request))
-        result.status.getCode shouldEqual 400
+        Await.result(m.toService.apply(request)).getStatus shouldEqual HttpResponseStatus.BAD_REQUEST
       }
 
       it("it returns a 400 when the param is not the correct type") {
         val request = Request("/svc")
         request.headers().add("aNumberHeader", "notANumber")
-        val result = Await.result(m.toService.apply(request))
-        result.status.getCode shouldEqual 400
+        Await.result(m.toService.apply(request)).getStatus shouldEqual HttpResponseStatus.BAD_REQUEST
       }
     }
   }
 
   def assertOkResponse(module: FintrospectModule, segments: Seq[String]): Unit = {
     val result = Await.result(module.toService.apply(Request("/svc/" + segments.mkString("/"))))
-    result.status.getCode shouldEqual 200
-    result.content.toString(Utf8) shouldEqual segments.mkString(",")
+    result.getStatus shouldEqual HttpResponseStatus.OK
+    result.getContent.toString(Utf8) shouldEqual segments.mkString(",")
   }
 }