resolvers += "mDialog releases" at "http://mdialog.github.com/releases/"

libraryDependencies += "com.mdialog" %% "smoke" % "0.1.0"

import smoke._

object BasicExampleApp extends Smoke {    
  onRequest {
    case GET(Path("/example")) => reply {
      Thread.sleep(1000)
      Response(Ok, body="It took me a second to build this response.\n")
    }
    case _ => reply(Response(NotFound))
  }
}

sbt run

implicit val config = ConfigFactory.load()
implicit val system = ActorSystem("Smoke", config)
implicit val dispatcher = system.dispatcher
implicit val timeout = Timeout(timeoutDuration milliseconds)

onRequest {
  case GET(Path("/example")) => Future {
    Thread.sleep(1000)
    Response(Ok, body="It took me a second to build this response.\n")
  }
  case _ => reply(Response(NotFound))
}

case GET(Path(Seg("resources" :: id :: Nil))) => ...
case POST(Path("/resources")) & Params(p) => ...

case GET(Path("/example")) => reply {
  Thread.sleep(1000)
  Response(Ok, body="It took me a second.\n")
}

case _ => reply(Response(NotFound))

class Responder extends Actor {
  def receive = {
    case GET(Path("/example")) => 
      Thread.sleep(1000)
      sender ! Response(Ok, body="It took me a second.\n")
    case _ => sender ! Response(NotFound)
  }
}

object ActorExampleApp extends Smoke {
  val actor = system.actorOf(Props[Responder])

  onRequest (actor ? _ mapTo manifest[Response])
}

class DataSource extends Actor {
  def receive = {
    case _ => sender ! "Some data"
  }
}

class ResponseBuilder extends Actor {
  def receive = {
    case s: String => sender ! ("Found: " + s)
  }
}

object ChainedActorExampleApp extends Smoke {
  val dataSource = system.actorOf(Props[DataSource])
  val builder = system.actorOf(Props[ResponseBuilder])

  onRequest { request =>
    for {
      data <- dataSource ? request
      response <- builder ? data mapTo manifest[String]
    } yield Response(Ok, body = response)
  }
}

Response(Ok, Map("Location" -> resource.location), resource.toJson)

after { resp =>
  val headers = resp.headers -> ("Server" -> "ExampleApp/0.0.1")
  Response(resp.status, headers, resp.body)
}

onRequest {
  case _ => fail(NotFoundException)
}

onError {
  case NotFoundException => Response(NotFound)
}

def application = before andThen onRequest andThen { f => 
  f recover(onError) map after 
}

beforeShutdown {
  println("Getting ready to shutdown")
}

afterShutdown {
  println("No longer responding to requests.")
}

import smoke.mongrel2.Mongrel2Server

object BasicExampleApp extends Smoke {    
  override val server = new Mongrel2Server
  ...
}

smoke {
  timeout = 2s

  log-type = "stdout" # alternatively, set to "file" 
  log-file = "access.log" # if log-type is "file"

  # By default, Smoke uses Netty
  netty {
    port = 7771
  }

  # For Mongrel2 users
  mongrel2 {
    recvAddress = "ipc:///tmp/SmokeMongrel2Request"
    sendAddress = "ipc:///tmp/SmokeMongrel2Response"
  } 
}

sbt run

curl -i http://localhost:7771/example

case class TestRequest(uriString: String,
                       method: String = "GET",
                       headers: Map[String, String] = Map.empty,
                       body: String = "",
                       keepAlive: Boolean = true) extends Request

import org.scalatest.{ FunSpec, BeforeAndAfterAll }

import akka.dispatch.Await
import akka.util.duration._

import smoke._
import smoke.test._

class BasicExampleAppTest extends FunSpec with BeforeAndAfterAll {

  val app = BasicExampleApp

  override def beforeAll { app.init() }
  override def afterAll { app.shutdown() }  

  describe("GET /example") {    
    it("should respond with 200") {
      val request = TestRequest("/example")
      val response = Await.result(app.application(request), 2 seconds)
      assert(response.status === Ok)
    }
  }

  describe("POST /unknown-path") {
    it("should respond with 404") {
      val request = TestRequest("/unknown-path", "POST")
      val response = Await.result(app.application(request), 2 seconds)
      assert(response.status === NotFound)
    }
  }
}