akka HttpResponse leyó body como String scala

akka http client json

Question

Así que tengo una función con esta firma (akka.http.model.HttpResponse):

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

Simplemente obtengo un valor en una prueba como:

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

Quiero comprobar su cuerpo en una prueba algo así como:

resp.entity.asString == "tags"

Mi pregunta es ¿cómo puedo obtener el cuerpo de respuesta como una cadena?

Answer 1

Aquí está mi ejemplo de trabajo,

  import akka.actor.ActorSystem
  import akka.http.scaladsl.Http
  import akka.http.scaladsl.model._
  import akka.stream.ActorMaterializer
  import akka.util.ByteString

  import scala.concurrent.Future
  import scala.util.{ Failure, Success }

  def getDataAkkaHTTP:Unit = {

    implicit val system = ActorSystem()
    implicit val materializer = ActorMaterializer()
    // needed for the future flatMap/onComplete in the end
    implicit val executionContext = system.dispatcher

    val url = "http://localhost:8080/"
    val responseFuture: Future[HttpResponse] = Http().singleRequest(HttpRequest(uri = url))

    responseFuture.onComplete {
      case Success(res) => {
        val HttpResponse(statusCodes, headers, entity, _) = res
        println(entity)
        entity.dataBytes.runFold(ByteString(""))(_ ++ _).foreach (body => println(body.utf8String))
        system.terminate()
      }
      case Failure(_) => sys.error("something wrong")
    }


  }

Answer 2

Como Akka Http se basa en transmisiones, la entidad también está transmitiendo. Si realmente necesita toda la cadena a la vez, puede convertir la solicitud entrante en una Strict :

Esto se hace usando la toStrict(timeout: FiniteDuration)(mat: Materializer) para recopilar la solicitud en una entidad estricta dentro de un límite de tiempo dado (esto es importante ya que no quiere "tratar de recopilar la entidad para siempre" en caso de que la solicitud entrante nunca termine):

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 3

Desafortunadamente en mi caso, Unmarshal to String no funcionó correctamente quejándose en: Unsupported Content-Type, supported: application/json . Esa sería una solución más elegante, pero tenía que usar otra forma. En mi prueba usé el Futuro extraído de la entidad de la respuesta y Esperar (de scala.concurrent) para obtener el resultado del 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)
    }

Si necesita ir a través de todas las líneas en una respuesta, puede usar runForeach of Source:

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

Answer 4

También puedes probar este también.

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

Answer 5

  import akka.http.scaladsl.unmarshalling.Unmarshal


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

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

Answer 6

Unmarshaller.stringUnmarshaller(someHttpEntity)

Funciona como un amuleto, también se necesita materializador implícito.