Akka HttpResponse corpo leggere as String Scala

Question

Così ho una funzione con la firma (akka.http.model.HttpResponse):

def apply(query: Seq[(String, String)], accept: String): HttpResponse 

ho semplicemente ottenere un valore in un test come:

val resp = TagAPI(Seq.empty[(String, String)], api.acceptHeader) 

voglio controllare il suo corpo in un qualcosa di test come:

resp.entity.asString == "tags" 

mia domanda è come posso ottenere il corpo della risposta come stringa?

Answer 1

Poiché Akka Http è basato su flussi, anche l'entità è in streaming. Se si ha realmente bisogno l'intera stringa in una sola volta, è possibile convertire la richiesta in ingresso in un Strict uno:

Questo viene fatto utilizzando il toStrict(timeout: FiniteDuration)(mat: Materializer) API per raccogliere la richiesta in un rigoroso entità all'interno di un limite dato tempo (questo è importante dal momento che non si vuole "cercare di raccogliere l'entità sempre" nel caso in cui la richiesta in ingresso realtà non finire mai):

import akka.stream.ActorFlowMaterializer 
import akka.actor.ActorSystem 

implicit val system = ActorSystem("Sys") // your actor system, only 1 per app 
implicit val materializer = ActorFlowMaterializer() // you must provide a materializer 

import system.dispatcher 
import scala.concurrent.duration._ 
val timeout = 300.millis 

val bs: Future[ByteString] = entity.toStrict(timeout).map { _.data } 
val s: Future[String] = bs.map(_.utf8String) // if you indeed need a `String` 

Answer 2

import akka.http.scaladsl.unmarshalling.Unmarshal 


    implicit val system = ActorSystem("System") 
    implicit val materializer = ActorFlowMaterializer() 

    val responseAsString: Future[String] = Unmarshal(entity).to[String] 

Answer 3

Purtroppo nel mio caso, Unmarshal a String non funzionava correttamente lamentarsi a: Unsupported Content-Type, supported: application/json. Sarebbe una soluzione più elegante, ma ho dovuto usare un altro modo. Nella mia prova ho usato Future estratto dalla entità della risposta e di attendere (da scala.concurrent) per ottenere il risultato dal futuro:

Put("/post/item", requestEntity) ~> route ~> check { 
     val responseContent: Future[Option[String]] = 
     response.entity.dataBytes.map(_.utf8String).runWith(Sink.lastOption) 

     val content: Option[String] = Await.result(responseContent, 10.seconds) 
     content.get should be(errorMessage) 
     response.status should be(StatusCodes.InternalServerError) 
    } 

Se avete bisogno di passare attraverso tutte le linee di una risposta, è possibile utilizzare runForeach di fonte:

response.entity.dataBytes.map(_.utf8String).runForeach(data => println(data)) 

Answer 4

Si può anche provare anche questo.

responseObject.entity.dataBytes.runFold(ByteString(""))(_ ++ _).map(_.utf8String) map println