Scalatest Plus Play Spec to test the WSMultipartHandler

WSMultipartHandlerSpec.scala

package wsmultipart

import org.scalatestplus.play.{PlaySpec, OneServerPerSuite}
import org.scalatest.EitherValues
import play.api.mvc.Action
import play.api.mvc.Results._
import play.api.libs.iteratee.{Done, Input, Cont, Iteratee, Enumerator}
import play.api.test.Helpers._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.collection.mutable
import play.api.test.FakeApplication
import play.api.libs.ws.WS
import WSMultipartHandler._

class WSMultipartHandlerSpec extends PlaySpec with OneServerPerSuite with EitherValues {

  private val multipartContent =
    """--frontier
      |Content-Disposition: inline
      |Content-Transfer-Encoding: 8bit
      |Content-Type: text/plain
      |
      |foo
      |--frontier
      |Content-Disposition: inline
      |Content-Transfer-Encoding: 8bit
      |Content-Type: text/plain
      |
      |bar
      |--frontier--
    """.stripMargin.trim().replaceAll("\n", "\r\n")

  implicit override lazy val app: FakeApplication =
    FakeApplication(
      withRoutes = {
        case ("GET", "/") => Action {
          Ok(multipartContent).as("multipart/package; boundary=\"frontier\"")
        }
      }
    )

  "WSMultipartHandler" should {

    "consume multipart response for WS.get" in {

      val parts = mutable.ArrayBuffer[String]()

      def partConsumer(headers: Map[String, String]): Iteratee[Array[Byte], Unit] = {
        if(headers.isEmpty) Done((), Input.Empty)
        else {
          var buffer = Array[Byte]()
          lazy val it: Iteratee[Array[Byte], Unit] = Cont {
            case e@Input.EOF =>
              parts += new String(buffer, "utf-8")
              Done((), e)
            case Input.El(data) =>
              buffer ++= data
              it
            case Input.Empty => it
          }
          it
        }
      }

      val futureResponse = WS.url(s"http://localhost:$port")
        .get(consumeMultipart(partConsumer))
        .flatMap(_.run)

      val response = await(futureResponse)

      response.right.value._1.status mustBe OK
      response.right.value._2 mustBe 2

      parts mustBe mutable.ArrayBuffer("foo", "bar")
    }

    "check response status and reject non-200s" in {
      val futureResponse = WS.url(s"http://localhost:$port/missingRoute").get(
        consumeMultipart(ps => /*unused*/ ???)
      ).flatMap(_.run)

      val response = await(futureResponse)

      response.left.value.status mustBe NOT_FOUND
    }

  }

}