Как протестировать клиентскую сторону Akka HTTP

Question

Я только что начал тестировать Akka HTTP Request-Level Client-Side API (Future-Based). Одна вещь, которую я пытался выяснить, - это написать единичный тест для этого. Есть ли способ издеваться над ответом и завершить будущее без фактического выполнения HTTP-запроса?

Я смотрел на API и пакете тестового набора, пытаясь понять, как я мог бы использовать это, только чтобы найти в документации, что он на самом деле говорит:

Акка-HTTP-тестовый набор тест жгут и набор утилит для проверки реализаций

я что-то TestServer (вроде как TestSource для Akka Streams) мышления услуг на стороне сервера и использовать DSL на стороне сервера маршрутизации для создания ожидаемого ответа и каким-то образом подключить это вверх поHttp объект.

Вот упрощенный пример того, что функция делает, что я хочу, чтобы тест:

object S3Bucket { 

    def sampleTextFile(uri: Uri)(
    implicit akkaSystem: ActorSystem, 
    akkaMaterializer: ActorMaterializer 
): Future[String] = { 
    val request = Http().singleRequest(HttpRequest(uri = uri)) 
    request.map { response => Unmarshal(response.entity).to[String] } 
    } 
} 

Answer 1

Я думаю, что в общих чертах вы уже попали на тот факт, что лучший подход должен издеваться ответ. В Scala, это можно сделать с помощью Scala Mock http://scalamock.org/

Если вы устраиваете свой код, чтобы ваш экземпляр akka.http.scaladsl.HttpExt является зависимость впрыскивается в код, который использует его (например, в качестве параметра конструктора), то во время тестирования вы можете инжектировать экземпляр mock[HttpExt], а не один, построенный с использованием метода применения Http.

EDIT: Я думаю, это было отклонено за то, что он не был достаточно конкретным. Вот как я бы структурировал насмешку над вашим сценарием. Все имплициты усложняется.

Код в main:

import akka.actor.ActorSystem 
import akka.http.scaladsl.Http 
import akka.http.scaladsl.model.{Uri, HttpResponse, HttpRequest} 
import akka.http.scaladsl.unmarshalling.Unmarshal 
import akka.stream.ActorMaterializer 

import scala.concurrent.{ExecutionContext, Future} 

trait S3BucketTrait { 

    type HttpResponder = HttpRequest => Future[HttpResponse] 

    def responder: HttpResponder 

    implicit def actorSystem: ActorSystem 

    implicit def actorMaterializer: ActorMaterializer 

    implicit def ec: ExecutionContext 

    def sampleTextFile(uri: Uri): Future[String] = { 

    val responseF = responder(HttpRequest(uri = uri)) 
    responseF.flatMap { response => Unmarshal(response.entity).to[String] } 
    } 
} 

class S3Bucket(implicit val actorSystem: ActorSystem, val actorMaterializer: ActorMaterializer) extends S3BucketTrait { 

    override val ec: ExecutionContext = actorSystem.dispatcher 

    override def responder = Http().singleRequest(_) 
} 

Код в test:

import akka.actor.ActorSystem 
import akka.http.scaladsl.model._ 
import akka.stream.ActorMaterializer 
import akka.testkit.TestKit 
import org.scalatest.{BeforeAndAfterAll, WordSpecLike, Matchers} 
import org.scalamock.scalatest.MockFactory 
import scala.concurrent._ 
import scala.concurrent.duration._ 
import scala.concurrent.Future 

class S3BucketSpec extends TestKit(ActorSystem("S3BucketSpec")) 
with WordSpecLike with Matchers with MockFactory with BeforeAndAfterAll { 


    class MockS3Bucket(reqRespPairs: Seq[(Uri, String)]) extends S3BucketTrait{ 

    override implicit val actorSystem = system 

    override implicit val ec = actorSystem.dispatcher 

    override implicit val actorMaterializer = ActorMaterializer()(system) 

    val mock = mockFunction[HttpRequest, Future[HttpResponse]] 

    override val responder: HttpResponder = mock 

    reqRespPairs.foreach{ 
     case (uri, respString) => 
     val req = HttpRequest(HttpMethods.GET, uri) 
     val resp = HttpResponse(status = StatusCodes.OK, entity = respString) 
     mock.expects(req).returning(Future.successful(resp)) 
    } 
    } 

    "S3Bucket" should { 

    "Marshall responses to Strings" in { 
     val mock = new MockS3Bucket(Seq((Uri("http://example.com/1"), "Response 1"), (Uri("http://example.com/2"), "Response 2"))) 
     Await.result(mock.sampleTextFile("http://example.com/1"), 1 second) should be ("Response 1") 
     Await.result(mock.sampleTextFile("http://example.com/2"), 1 second) should be ("Response 2") 
    } 
    } 

    override def afterAll(): Unit = { 
    val termination = system.terminate() 
    Await.ready(termination, Duration.Inf) 
    } 
} 

build.sbt зависимостей:

libraryDependencies += "com.typesafe.akka" % "akka-http-experimental_2.11" % "2.0.1" 

libraryDependencies += "org.scalamock" %% "scalamock-scalatest-support" % "3.2" % "test" 

libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.6" 

libraryDependencies += "com.typesafe.akka" % "akka-testkit_2.11" % "2.4.1" 

Answer 2

Учитывая, что вы действительно хотите, чтобы написать модульный тест для клиента HTTP вы должны притворяться, что нет r eal server, а не пересекать границу сети, иначе вы, очевидно, будете проводить интеграционные тесты. Длинный известный рецепт принудительного разделения, подлежащего тестированию, в таких случаях, как ваш, заключается в разделении интерфейса и реализации. Просто определить интерфейс абстрагирования доступа к внешнему серверу HTTP и его реальные и поддельные реализации, как в следующем эскизе

import akka.actor.Actor 
import akka.pattern.pipe 
import akka.http.scaladsl.HttpExt 
import akka.http.scaladsl.model.{HttpRequest, HttpResponse, StatusCodes} 
import scala.concurrent.Future 

trait HTTPServer { 
    def sendRequest: Future[HttpResponse] 
} 

class FakeServer extends HTTPServer { 
    override def sendRequest: Future[HttpResponse] = 
    Future.successful(HttpResponse(StatusCodes.OK)) 
} 

class RealServer extends HTTPServer { 

    def http: HttpExt = ??? //can be passed as a constructor parameter for example 

    override def sendRequest: Future[HttpResponse] = 
    http.singleRequest(HttpRequest(???)) 
} 

class HTTPClientActor(httpServer: HTTPServer) extends Actor { 

    override def preStart(): Unit = { 
    import context.dispatcher 
    httpServer.sendRequest pipeTo self 
    } 

    override def receive: Receive = ??? 
} 

и протестировать HTTPClientActor в сочетании с FakeServer.

Answer 3

Я надеялся, что там может быть путь к повышению эффективности своего рода тестовой системы актера, но и в отсутствии такового (или каким-либо другой идиоматических пути) Я, вероятно, буду делать что-то вроде этого:

object S3Bucket { 

    type HttpResponder = HttpRequest => Future[HttpResponse] 

    def defaultResponder = Http().singleRequest(_) 

    def sampleTextFile(uri: Uri)(
    implicit akkaSystem: ActorSystem, 
    akkaMaterializer: ActorMaterializer, 
    responder: HttpResponder = defaultResponder 
): Future[String] = { 
    val request = responder(HttpRequest(uri = uri)) 
    request.map { response => Unmarshal(response.entity).to[String] } 
    } 
} 

Тогда в моем тесте я могу просто дать макет HttpResponder.