Play Framework/Scala example source code file (ResultsSpec.scala)

This example Play Framework source code file (ResultsSpec.scala) is included in my "Source Code Warehouse" project. The intent of this project is to help you more easily find Play Framework (and Scala) source code examples by using tags.

All credit for the original source code belongs to Play Framework; I'm just trying to make examples easier to find. (For my Scala work, see my Scala examples and tutorials.)

Play Framework tags/keywords

api, concurrent, content-type, cookie, fakeapplication, library, ok, play, play framework, result, seq, set-cookie, string, time, unauthorized, x-yop

The ResultsSpec.scala Play Framework example source code

/*
 * Copyright (C) 2009-2013 Typesafe Inc. <http://www.typesafe.com>
 */
package play.api.mvc

import org.specs2.mutable._
import play.api.libs.iteratee.{Iteratee, Enumerator}
import scala.concurrent.Await
import scala.concurrent.duration.Duration
import java.util.concurrent.TimeUnit
import scala.concurrent.ExecutionContext.Implicits._
import play.api.i18n.Lang
import play.api.{FakeApplication, Play}
import play.api.http.HeaderNames._
import play.api.http.Status._

object ResultsSpec extends Specification {

  import play.api.mvc.Results._

  sequential

  "Result" should {

    "have status" in {
      val Result(ResponseHeader(status, _), _, _) = Ok("hello")
      status must be_==(200)
    }

    "support Content-Type overriding" in {
      val Result(ResponseHeader(_, headers), _, _) = Ok("hello").as("text/html")
      headers must havePair("Content-Type" -> "text/html")
    }

    "support headers manipulation" in {
      val Result(ResponseHeader(_, headers), _, _) =
        Ok("hello").as("text/html").withHeaders("Set-Cookie" -> "yes", "X-YOP" -> "1", "X-Yop" -> "2")

      headers.size must be_==(3)
      headers must havePair("Content-Type" -> "text/html")
      headers must havePair("Set-Cookie" -> "yes")
      headers must not havePair("X-YOP" -> "1")
      headers must havePair("X-Yop" -> "2")
    }

    "support cookies helper" in {
      val setCookieHeader = Cookies.encode(Seq(Cookie("session", "items"), Cookie("preferences", "blue")))

      val decodedCookies = Cookies.decode(setCookieHeader).map(c => c.name -> c).toMap
      decodedCookies.size must be_==(2)
      decodedCookies("session").value must be_==("items")
      decodedCookies("preferences").value must be_==("blue")

      val newCookieHeader = Cookies.merge(setCookieHeader, Seq(Cookie("lang", "fr"), Cookie("session", "items2")))

      val newDecodedCookies = Cookies.decode(newCookieHeader).map(c => c.name -> c).toMap
      newDecodedCookies.size must be_==(3)
      newDecodedCookies("session").value must be_==("items2")
      newDecodedCookies("preferences").value must be_==("blue")
      newDecodedCookies("lang").value must be_==("fr")

      val Result(ResponseHeader(_, headers), _, _) =
        Ok("hello").as("text/html")
          .withCookies(Cookie("session", "items"), Cookie("preferences", "blue"))
          .withCookies(Cookie("lang", "fr"), Cookie("session", "items2"))
          .discardingCookies(DiscardingCookie("logged"))

      val setCookies = Cookies.decode(headers("Set-Cookie")).map(c => c.name -> c).toMap
      setCookies.size must be_==(4)
      setCookies("session").value must be_==("items2")
      setCookies("session").maxAge must beNone
      setCookies("preferences").value must be_==("blue")
      setCookies("lang").value must be_==("fr")
      setCookies("logged").maxAge must beSome
      setCookies("logged").maxAge.get must be_<=(-86000)
    }

    "support adding a language cookie using withLang" in {
      implicit val app = new FakeApplication()
      val cookie = Cookies.decode(Ok.withLang(Lang("en-AU")).header.headers("Set-Cookie")).head
      cookie.name must_== Play.langCookieName
      cookie.value must_== "en-AU"
    }

    "support clearing a language cookie using clearingLang" in {
      implicit val app = new FakeApplication()
      val cookie = Cookies.decode(Ok.clearingLang.header.headers("Set-Cookie")).head
      cookie.name must_== Play.langCookieName
      cookie.value must_== ""
    }

    "allow discarding a cookie by deprecated names method" in {
      Cookies.decode(Ok.discardingCookies(DiscardingCookie("blah")).header.headers("Set-Cookie")).head.name must_== "blah"
    }

    "allow discarding multiple cookies by deprecated names method" in {
      val cookies = Cookies.decode(Ok.discardingCookies(DiscardingCookie("foo"), DiscardingCookie("bar")).header.headers("Set-Cookie")).map(_.name)
      cookies must containTheSameElementsAs(Seq("foo", "bar"))
    }

    "support sending a file with Ok status" in {
      val file = new java.io.File("test.tmp")
      file.createNewFile()
      val rh = Ok.sendFile(file).header
      file.delete()

      (rh.status aka "status" must_== OK) and
        (rh.headers.get(CONTENT_DISPOSITION) aka "disposition" must beSome("""attachment; filename="test.tmp""""))
    }
    "support sending a file with Unauthorized status" in {
      val file = new java.io.File("test.tmp")
      file.createNewFile()
      val rh = Unauthorized.sendFile(file).header
      file.delete()

      (rh.status aka "status" must_== UNAUTHORIZED) and
        (rh.headers.get(CONTENT_DISPOSITION) aka "disposition" must beSome("""attachment; filename="test.tmp""""))
    }

    "support sending a file inline with Unauthorized status" in {
      val file = new java.io.File("test.tmp")
      file.createNewFile()
      val rh = Unauthorized.sendFile(file, inline = true).header
      file.delete()

      (rh.status aka "status" must_== UNAUTHORIZED) and
        (rh.headers.get(CONTENT_DISPOSITION) aka "disposition" must beNone)
    }
  }

  "chunking enumeratee" should {
    "chunk a stream" in {
      consume(enumerator("a", "bc", "def") &> chunk) must containTheSameElementsAs(Seq(
        "1\r\na\r\n",
        "2\r\nbc\r\n",
        "3\r\ndef\r\n",
        "0\r\n\r\n"
      ))
    }

    "support trailers" in {
      consume(enumerator("a", "bc", "def") &> chunk(Some(
        Iteratee.consume[Array[Byte]]().map(data => Seq("Full-Data" -> new String(data)))
      ))) must containTheSameElementsAs(Seq(
        "1\r\na\r\n",
        "2\r\nbc\r\n",
        "3\r\ndef\r\n",
        "0\r\nFull-Data: abcdef\r\n\r\n"
      ))
    }

  }

  "dechunking enumeratee" should {
    "dechunk a chunked stream" in {
      consume(enumerator("a", "bc", "def") &> chunk &> dechunk) must containTheSameElementsAs(Seq(
        "a", "bc", "def"
      ))
    }
    "dechunk an empty stream" in {
      consume(enumerator("0\r\n\r\n") &> dechunk) must containTheSameElementsAs(Seq())
    }
    "dechunk a stream with trailers" in {
      consume(enumerator("a", "bc", "def") &> chunk(Some(
        Iteratee.consume[Array[Byte]]().map(data => Seq("Full-Data" -> new String(data)))
      )) &> dechunk) must containTheSameElementsAs(Seq(
        "a", "bc", "def"
      ))
    }
    "dechunk a stream that is not split at chunks" in {
      consume(enumerator("1\r\na\r\n2\r\nbc\r\n3\r\ndef\r\n0\r\n\r\n") &> dechunk) must containTheSameElementsAs(Seq(
        "a", "bc", "def"
      ))
    }
    "dechunk a stream that is split at different places to the chunks" in {
      consume(enumerator(
        "1\r\na",
        "\r\n2\r\nbc\r\n3\r\nd",
        "ef\r\n0\r\n\r",
        "\n"
      ) &> dechunk) must containTheSameElementsAs(Seq(
        "a", "bc", "def"
      ))
    }
  }

  def enumerator(elems: String*) = Enumerator.enumerate(elems.map(_.getBytes))
  def consume(enumerator: Enumerator[Array[Byte]]) = Await.result(
    enumerator |>>> Iteratee.getChunks[Array[Byte]],
    Duration(5, TimeUnit.SECONDS)
  ).map(new String(_))

}