Akka HTTPリクエストレベルのクライアント側API(Futureベース) のテストを開始しました。私が理解するのに苦労してきたことの1つは、このための単体テストを作成する方法です。実際にHTTPリクエストを行わなくても、応答をモックして未来を完成させる方法はありますか?
私はAPIとテストキットパッケージを見て、それをどのように使用できるかを確認しようとしましたが、実際に次のようにドキュメントで見つけました。
akka-http-testkitサーバー側サービスの実装を検証するためのテストハーネスとユーティリティセット
私は何かTestServer
(Akka StreamsのTestSource
のようなもの)を考えていて、サーバー側のルーティング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] }
}
}
一般的に言って、あなたはすでに、最善のアプローチは応答を模倣することであるという事実に出くわしたと思います。 Scalaでは、これはScala Mock http://scalamock.org/ を使用して実行できます。
akka.http.scaladsl.HttpExt
のインスタンスがそれを使用するコードに依存性注入されるようにコードを調整する場合(たとえば、コンストラクターパラメーターとして)、テスト中に、ビルドされたインスタンスではなくmock[HttpExt]
のインスタンスを注入できます。 Http
applyメソッドを使用します。
編集:私はこれが十分に特定されていないために投票されたと思います。これが私があなたのシナリオのモックを構成する方法です。それはすべての暗黙によって少し複雑になります。
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"
実際にHTTPクライアントの単体テストを作成することを考えると、実サーバーはなく、ネットワーク境界を越えていないふりをする必要があります。そうでない場合は、明らかに統合テストを実行します。あなたのような場合に単体テスト可能な分離を強制する長い間知られているレシピは、インターフェースと実装を分割することです。次のスケッチのように、外部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
を組み合わせてテストします。
ある種のテストアクターシステムを活用する方法があるのではないかと期待していましたが、それがない場合(または他の慣用的な方法)、おそらく次のようにします。
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
を提供することができます。