क्लाइंट-साइड अक्का HTTP

Question

का परीक्षण कैसे करें मैंने अभी Akka HTTP Request-Level Client-Side API (Future-Based) का परीक्षण करना शुरू कर दिया है। एक बात यह है कि मैं यह समझने के लिए संघर्ष कर रहा हूं कि इसके लिए यूनिट टेस्ट कैसे लिखना है। प्रतिक्रिया का नकल करने का कोई तरीका है और वास्तव में HTTP अनुरोध करने के बिना भविष्य पूरा हो गया है?

मैं, एपीआई और testkit पैकेज देख रहा था मैं यह कैसे इस्तेमाल कर सकते हैं, केवल डॉक्स में पता लगाने के लिए कि यह वास्तव में कहते हैं देखने के लिए कोशिश कर रहा है:

अक्का-http-testkit एक परीक्षण दोहन ​​और पुष्टि सर्वर साइड सेवा कार्यान्वयन

मैं कुछ TestServer (अक्का स्ट्रीम के लिए TestSource की तरह थोड़े) सोच रहा था के लिए उपयोगिताओं के सेट और उम्मीद प्रतिक्रिया बनाने के लिए सर्वर साइड मार्ग डीएसएल का उपयोग करें और किसी भी तरह इस ऊपर हुक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

मैं सामान्य शब्दों आप पहले से ही तथ्य यह है कि सबसे अच्छा तरीका प्रतिक्रिया उपहास करने के लिए है पर पहुंच जाते हैं में लगता है:

यहाँ समारोह क्या करता है कि मैं परीक्षण करना चाहते हैं की एक सरल उदाहरण है। स्काला में, इस स्काला नकली http://scalamock.org/

का उपयोग कर आप अपने कोड की व्यवस्था तो किया जा सकता है ताकि akka.http.scaladsl.HttpExt के अपने उदाहरण निर्भरता कोड है जो इसे इस्तेमाल करता है में इंजेक्ट किया जाता है (जैसे एक निर्माता पैरामीटर के रूप में), तो परीक्षण के दौरान आप एक इंजेक्षन कर सकते हैं Http का उपयोग करके निर्मित एक के बजाय mock[HttpExt] का उदाहरण लागू करें।

संपादित करें: मुझे लगता है कि यह पर्याप्त विशिष्ट नहीं होने के कारण मतदान किया गया था। यहां बताया गया है कि मैं आपके परिदृश्य की नकल कैसे करूंगा। यह सभी implicitis द्वारा थोड़ा और जटिल बना दिया गया है।

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 ग्राहक के लिए एक इकाई परीक्षण लिखना चाहते हैं आपको नाटक करना चाहिए कि कोई आर नहीं है ईल सर्वर और नेटवर्क सीमा पार नहीं, अन्यथा आप स्पष्ट रूप से एकीकरण परीक्षण करेंगे। इस तरह के मामलों में यूनिट-टेस्टेबल अलगाव को लागू करने के लिए एक लंबी ज्ञात नुस्खा इंटरफेस और कार्यान्वयन को विभाजित करना है। बस एक बाहरी 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 = ??? 
} 

में के रूप में अपनी असली और नकली कार्यान्वयन को परिभाषित करने और FakeServer साथ संयोजन के रूप में अपने HTTPClientActor का परीक्षण करें।

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 प्रदान कर सकता हूं।