diff options
Diffstat (limited to 'tests/src/test/scala/com')
8 files changed, 0 insertions, 1000 deletions
diff --git a/tests/src/test/scala/com/softwaremill/sttp/BasicTests.scala b/tests/src/test/scala/com/softwaremill/sttp/BasicTests.scala deleted file mode 100644 index 55e21b8..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/BasicTests.scala +++ /dev/null @@ -1,702 +0,0 @@ -package com.softwaremill.sttp - -import java.io.{ByteArrayInputStream, IOException} -import java.nio.ByteBuffer -import java.nio.file.Paths -import java.time.{ZoneId, ZonedDateTime} - -import akka.http.scaladsl.coding.{Deflate, Gzip, NoCoding} -import akka.http.scaladsl.model._ -import akka.http.scaladsl.model.headers.CacheDirectives._ -import akka.http.scaladsl.model.headers._ -import akka.http.scaladsl.server.Directives._ -import akka.http.scaladsl.server.Route -import akka.http.scaladsl.server.directives.Credentials -import akka.util.ByteString -import better.files._ -import com.softwaremill.sttp.akkahttp.AkkaHttpBackend -import com.softwaremill.sttp.asynchttpclient.cats.AsyncHttpClientCatsBackend -import com.softwaremill.sttp.asynchttpclient.future.AsyncHttpClientFutureBackend -import com.softwaremill.sttp.asynchttpclient.monix.AsyncHttpClientMonixBackend -import com.softwaremill.sttp.asynchttpclient.scalaz.AsyncHttpClientScalazBackend -import com.softwaremill.sttp.impl.cats.convertCatsIOToFuture -import com.softwaremill.sttp.impl.monix.convertMonixTaskToFuture -import com.softwaremill.sttp.impl.scalaz.convertScalazTaskToFuture -import com.softwaremill.sttp.okhttp.monix.OkHttpMonixBackend -import com.softwaremill.sttp.okhttp.{OkHttpFutureBackend, OkHttpSyncBackend} -import com.softwaremill.sttp.testing.streaming.ConvertToFuture -import com.typesafe.scalalogging.StrictLogging -import org.scalatest.concurrent.{IntegrationPatience, ScalaFutures} -import org.scalatest.{path => _, _} - -import scala.concurrent.ExecutionContext.Implicits.global -import scala.concurrent.Future -import scala.concurrent.duration._ -import scala.language.higherKinds - -class BasicTests - extends FlatSpec - with Matchers - with BeforeAndAfterAll - with ScalaFutures - with OptionValues - with StrictLogging - with IntegrationPatience - with TestHttpServer - with ForceWrapped - with BeforeAndAfterEach { - - override def afterEach() { - val file = File(outPath) - if (file.exists) file.delete() - } - - private def paramsToString(m: Map[String, String]): String = - m.toList.sortBy(_._1).map(p => s"${p._1}=${p._2}").mkString(" ") - - private val textFile = - new java.io.File("tests/src/test/resources/textfile.txt") - private val binaryFile = - new java.io.File("tests/src/test/resources/binaryfile.jpg") - private val outPath = Paths.get("out") - private val textWithSpecialCharacters = "Żółć!" - - override val serverRoutes: Route = - pathPrefix("echo") { - pathPrefix("form_params") { - formFieldMap { params => - path("as_string") { - complete(paramsToString(params)) - } ~ - path("as_params") { - complete(FormData(params)) - } - } - } ~ get { - parameterMap { params => - complete(List("GET", "/echo", paramsToString(params)) - .filter(_.nonEmpty) - .mkString(" ")) - } - } ~ - post { - parameterMap { params => - entity(as[String]) { body: String => - complete(List("POST", "/echo", paramsToString(params), body) - .filter(_.nonEmpty) - .mkString(" ")) - } - } - } - } ~ path("set_headers") { - get { - respondWithHeader(`Cache-Control`(`max-age`(1000L))) { - respondWithHeader(`Cache-Control`(`no-cache`)) { - complete("ok") - } - } - } - } ~ pathPrefix("set_cookies") { - path("with_expires") { - setCookie(HttpCookie("c", "v", expires = Some(DateTime(1997, 12, 8, 12, 49, 12)))) { - complete("ok") - } - } ~ get { - setCookie(HttpCookie("cookie1", "value1", secure = true, httpOnly = true, maxAge = Some(123L))) { - setCookie(HttpCookie("cookie2", "value2")) { - setCookie(HttpCookie("cookie3", "", domain = Some("xyz"), path = Some("a/b/c"))) { - complete("ok") - } - } - } - } - } ~ path("secure_basic") { - authenticateBasic("test realm", { - case c @ Credentials.Provided(un) if un == "adam" && c.verify("1234") => - Some(un) - case _ => None - }) { userName => - complete(s"Hello, $userName!") - } - } ~ path("compress") { - encodeResponseWith(Gzip, Deflate, NoCoding) { - complete("I'm compressed!") - } - } ~ pathPrefix("download") { - path("binary") { - getFromFile(binaryFile) - } ~ path("text") { - getFromFile(textFile) - } - } ~ pathPrefix("multipart") { - entity(as[akka.http.scaladsl.model.Multipart.FormData]) { fd => - complete { - fd.parts - .mapAsync(1) { p => - val fv = p.entity.dataBytes.runFold(ByteString())(_ ++ _) - fv.map(_.utf8String) - .map(v => p.name + "=" + v + p.filename.fold("")(fn => s" ($fn)")) - } - .runFold(Vector.empty[String])(_ :+ _) - .map(v => v.mkString(", ")) - } - } - } ~ pathPrefix("redirect") { - path("r1") { - redirect("/redirect/r2", StatusCodes.TemporaryRedirect) - } ~ - path("r2") { - redirect("/redirect/r3", StatusCodes.PermanentRedirect) - } ~ - path("r3") { - redirect("/redirect/r4", StatusCodes.Found) - } ~ - path("r4") { - complete("819") - } ~ - path("loop") { - redirect("/redirect/loop", StatusCodes.Found) - } - } ~ pathPrefix("timeout") { - complete { - akka.pattern.after(1.second, using = actorSystem.scheduler)(Future.successful("Done")) - } - } ~ path("empty_unauthorized_response") { - post { - import akka.http.scaladsl.model._ - complete( - HttpResponse( - status = StatusCodes.Unauthorized, - headers = Nil, - entity = HttpEntity.Empty, - protocol = HttpProtocols.`HTTP/1.1` - )) - } - } ~ path("respond_with_iso_8859_2") { - get { ctx => - val entity = - HttpEntity(MediaTypes.`text/plain`.withCharset(HttpCharset.custom("ISO-8859-2")), textWithSpecialCharacters) - ctx.complete(HttpResponse(200, entity = entity)) - } - } - - override def port = 51823 - - var closeBackends: List[() => Unit] = Nil - - runTests("HttpURLConnection")(HttpURLConnectionBackend(), ConvertToFuture.id) - runTests("TryHttpURLConnection")(TryHttpURLConnectionBackend(), ConvertToFuture.scalaTry) - runTests("Akka HTTP")(AkkaHttpBackend.usingActorSystem(actorSystem), ConvertToFuture.future) - runTests("Async Http Client - Future")(AsyncHttpClientFutureBackend(), ConvertToFuture.future) - runTests("Async Http Client - Scalaz")(AsyncHttpClientScalazBackend(), convertScalazTaskToFuture) - runTests("Async Http Client - Monix")(AsyncHttpClientMonixBackend(), convertMonixTaskToFuture) - runTests("Async Http Client - Cats IO")(AsyncHttpClientCatsBackend[cats.effect.IO](), convertCatsIOToFuture) - runTests("OkHttpSyncClientHandler")(OkHttpSyncBackend(), ConvertToFuture.id) - runTests("OkHttpAsyncClientHandler - Future")(OkHttpFutureBackend(), ConvertToFuture.future) - runTests("OkHttpAsyncClientHandler - Monix")(OkHttpMonixBackend(), convertMonixTaskToFuture) - - def runTests[R[_]](name: String)(implicit - backend: SttpBackend[R, Nothing], - convertToFuture: ConvertToFuture[R]): Unit = { - - closeBackends = (() => backend.close()) :: closeBackends - - val postEcho = sttp.post(uri"$endpoint/echo") - val testBody = "this is the body" - val testBodyBytes = testBody.getBytes("UTF-8") - val expectedPostEchoResponse = "POST /echo this is the body" - - val sttpIgnore = com.softwaremill.sttp.ignore - - parseResponseTests() - parameterTests() - bodyTests() - headerTests() - errorsTests() - cookiesTests() - authTests() - compressionTests() - downloadFileTests() - multipartTests() - redirectTests() - timeoutTests() - emptyResponseTests() - encodingTests() - - def parseResponseTests(): Unit = { - name should "parse response as string" in { - val response = postEcho.body(testBody).send().force() - response.unsafeBody should be(expectedPostEchoResponse) - } - - name should "parse response as string with mapping using map" in { - val response = postEcho - .body(testBody) - .response(asString.map(_.length)) - .send() - .force() - response.unsafeBody should be(expectedPostEchoResponse.length) - } - - name should "parse response as string with mapping using mapResponse" in { - val response = postEcho - .body(testBody) - .mapResponse(_.length) - .send() - .force() - response.unsafeBody should be(expectedPostEchoResponse.length) - } - - name should "parse response as a byte array" in { - val response = - postEcho.body(testBody).response(asByteArray).send().force() - val fc = new String(response.unsafeBody, "UTF-8") - fc should be(expectedPostEchoResponse) - } - - name should "parse response as parameters" in { - val params = List("a" -> "b", "c" -> "d", "e=" -> "&f") - val response = sttp - .post(uri"$endpoint/echo/form_params/as_params") - .body(params: _*) - .response(asParams) - .send() - .force() - response.unsafeBody.toList should be(params) - } - } - - def parameterTests(): Unit = { - name should "make a get request with parameters" in { - val response = sttp - .get(uri"$endpoint/echo?p2=v2&p1=v1") - .send() - .force() - - response.unsafeBody should be("GET /echo p1=v1 p2=v2") - } - } - - def bodyTests(): Unit = { - name should "post a string" in { - val response = postEcho.body(testBody).send().force() - response.unsafeBody should be(expectedPostEchoResponse) - } - - name should "post a byte array" in { - val response = - postEcho.body(testBodyBytes).send().force() - response.unsafeBody should be(expectedPostEchoResponse) - } - - name should "post an input stream" in { - val response = postEcho - .body(new ByteArrayInputStream(testBodyBytes)) - .send() - .force() - response.unsafeBody should be(expectedPostEchoResponse) - } - - name should "post a byte buffer" in { - val response = postEcho - .body(ByteBuffer.wrap(testBodyBytes)) - .send() - .force() - response.unsafeBody should be(expectedPostEchoResponse) - } - - name should "post a file" in { - val f = File.newTemporaryFile().write(testBody) - try { - val response = postEcho.body(f.toJava).send().force() - response.unsafeBody should be(expectedPostEchoResponse) - } finally f.delete() - } - - name should "post a path" in { - val f = File.newTemporaryFile().write(testBody) - try { - val response = - postEcho.body(f.toJava.toPath).send().force() - response.unsafeBody should be(expectedPostEchoResponse) - } finally f.delete() - } - - name should "post form data" in { - val response = sttp - .post(uri"$endpoint/echo/form_params/as_string") - .body("a" -> "b", "c" -> "d") - .send() - .force() - response.unsafeBody should be("a=b c=d") - } - - name should "post form data with special characters" in { - val response = sttp - .post(uri"$endpoint/echo/form_params/as_string") - .body("a=" -> "/b", "c:" -> "/d") - .send() - .force() - response.unsafeBody should be("a==/b c:=/d") - } - - name should "post without a body" in { - val response = postEcho.send().force() - response.unsafeBody should be("POST /echo") - } - } - - def headerTests(): Unit = { - val getHeaders = sttp.get(uri"$endpoint/set_headers") - - name should "read response headers" in { - val response = getHeaders.response(sttpIgnore).send().force() - response.headers should have length (6) - response.headers("Cache-Control").toSet should be(Set("no-cache", "max-age=1000")) - response.header("Server") should be('defined) - response.header("server") should be('defined) - response.header("Server").get should startWith("akka-http") - response.contentType should be(Some("text/plain; charset=UTF-8")) - response.contentLength should be(Some(2L)) - } - } - - def errorsTests(): Unit = { - val getHeaders = sttp.post(uri"$endpoint/set_headers") - - name should "return 405 when method not allowed" in { - val response = getHeaders.response(sttpIgnore).send().force() - response.code should be(405) - response.isClientError should be(true) - response.body should be('left) - } - } - - def cookiesTests(): Unit = { - name should "read response cookies" in { - val response = - sttp - .get(uri"$endpoint/set_cookies") - .response(sttpIgnore) - .send() - .force() - response.cookies should have length (3) - response.cookies.toSet should be( - Set( - Cookie("cookie1", "value1", secure = true, httpOnly = true, maxAge = Some(123L)), - Cookie("cookie2", "value2"), - Cookie("cookie3", "", domain = Some("xyz"), path = Some("a/b/c")) - )) - } - - name should "read response cookies with the expires attribute" in { - val response = sttp - .get(uri"$endpoint/set_cookies/with_expires") - .response(sttpIgnore) - .send() - .force() - response.cookies should have length (1) - val c = response.cookies(0) - - c.name should be("c") - c.value should be("v") - c.expires.map(_.toInstant.toEpochMilli) should be( - Some( - ZonedDateTime - .of(1997, 12, 8, 12, 49, 12, 0, ZoneId.of("GMT")) - .toInstant - .toEpochMilli - )) - } - } - - def authTests(): Unit = { - val secureBasic = sttp.get(uri"$endpoint/secure_basic") - - name should "return a 401 when authorization fails" in { - val req = secureBasic - val resp = req.send().force() - resp.code should be(401) - resp.header("WWW-Authenticate") should be(Some("""Basic realm="test realm",charset=UTF-8""")) - } - - name should "perform basic authorization" in { - val req = secureBasic.auth.basic("adam", "1234") - val resp = req.send().force() - resp.code should be(200) - resp.unsafeBody should be("Hello, adam!") - } - } - - def compressionTests(): Unit = { - val compress = sttp.get(uri"$endpoint/compress") - val decompressedBody = "I'm compressed!" - - name should "decompress using the default accept encoding header" in { - val req = compress - val resp = req.send().force() - resp.unsafeBody should be(decompressedBody) - } - - name should "decompress using gzip" in { - val req = - compress.header("Accept-Encoding", "gzip", replaceExisting = true) - val resp = req.send().force() - resp.unsafeBody should be(decompressedBody) - } - - name should "decompress using deflate" in { - val req = - compress.header("Accept-Encoding", "deflate", replaceExisting = true) - val resp = req.send().force() - resp.unsafeBody should be(decompressedBody) - } - - name should "work despite providing an unsupported encoding" in { - val req = - compress.header("Accept-Encoding", "br", replaceExisting = true) - val resp = req.send().force() - resp.unsafeBody should be(decompressedBody) - } - } - - def downloadFileTests(): Unit = { - import CustomMatchers._ - - name should "download a binary file using asFile" in { - val file = outPath.resolve("binaryfile.jpg").toFile - val req = - sttp.get(uri"$endpoint/download/binary").response(asFile(file)) - val resp = req.send().force() - - resp.unsafeBody shouldBe file - file should exist - file should haveSameContentAs(binaryFile) - } - - name should "download a text file using asFile" in { - val file = outPath.resolve("textfile.txt").toFile - val req = - sttp.get(uri"$endpoint/download/text").response(asFile(file)) - val resp = req.send().force() - - resp.unsafeBody shouldBe file - file should exist - file should haveSameContentAs(textFile) - } - - name should "download a binary file using asPath" in { - val path = outPath.resolve("binaryfile.jpg") - val req = - sttp.get(uri"$endpoint/download/binary").response(asPath(path)) - val resp = req.send().force() - - resp.unsafeBody shouldBe path - path.toFile should exist - path.toFile should haveSameContentAs(binaryFile) - } - - name should "download a text file using asPath" in { - val path = outPath.resolve("textfile.txt") - val req = - sttp.get(uri"$endpoint/download/text").response(asPath(path)) - val resp = req.send().force() - - resp.unsafeBody shouldBe path - path.toFile should exist - path.toFile should haveSameContentAs(textFile) - } - - name should "fail at trying to save file to a restricted location" in { - val path = Paths.get("/").resolve("textfile.txt") - val req = - sttp.get(uri"$endpoint/download/text").response(asPath(path)) - val caught = intercept[IOException] { - req.send().force() - } - - caught.getMessage shouldBe "Permission denied" - } - - name should "fail when file exists and overwrite flag is false" in { - val path = outPath.resolve("textfile.txt") - path.toFile.getParentFile.mkdirs() - path.toFile.createNewFile() - val req = - sttp.get(uri"$endpoint/download/text").response(asPath(path)) - - val caught = intercept[IOException] { - req.send().force() - } - - caught.getMessage shouldBe s"File ${path.toFile.getAbsolutePath} exists - overwriting prohibited" - - } - - name should "not fail when file exists and overwrite flag is true" in { - val path = outPath.resolve("textfile.txt") - path.toFile.getParentFile.mkdirs() - path.toFile.createNewFile() - val req = - sttp - .get(uri"$endpoint/download/text") - .response(asPath(path, overwrite = true)) - val resp = req.send().force() - - resp.unsafeBody shouldBe path - path.toFile should exist - path.toFile should haveSameContentAs(textFile) - } - } - - def multipartTests(): Unit = { - val mp = sttp.post(uri"$endpoint/multipart") - - name should "send a multipart message" in { - val req = mp.multipartBody(multipart("p1", "v1"), multipart("p2", "v2")) - val resp = req.send().force() - resp.unsafeBody should be("p1=v1, p2=v2") - } - - name should "send a multipart message with filenames" in { - val req = mp.multipartBody(multipart("p1", "v1").fileName("f1"), multipart("p2", "v2").fileName("f2")) - val resp = req.send().force() - resp.unsafeBody should be("p1=v1 (f1), p2=v2 (f2)") - } - - name should "send a multipart message with a file" in { - val f = File.newTemporaryFile().write(testBody) - try { - val req = - mp.multipartBody(multipart("p1", f.toJava), multipart("p2", "v2")) - val resp = req.send().force() - resp.unsafeBody should be(s"p1=$testBody (${f.name}), p2=v2") - } finally f.delete() - } - } - - def redirectTests(): Unit = { - val r1 = sttp.post(uri"$endpoint/redirect/r1") - val r2 = sttp.post(uri"$endpoint/redirect/r2") - val r3 = sttp.post(uri"$endpoint/redirect/r3") - val r4response = "819" - val loop = sttp.post(uri"$endpoint/redirect/loop") - - name should "not redirect when redirects shouldn't be followed (temporary)" in { - val resp = r1.followRedirects(false).send().force() - resp.code should be(307) - resp.body should be('left) - resp.history should be('empty) - } - - name should "not redirect when redirects shouldn't be followed (permanent)" in { - val resp = r2.followRedirects(false).send().force() - resp.code should be(308) - resp.body should be('left) - } - - name should "redirect when redirects should be followed" in { - val resp = r2.send().force() - resp.code should be(200) - resp.unsafeBody should be(r4response) - } - - name should "redirect twice when redirects should be followed" in { - val resp = r1.send().force() - resp.code should be(200) - resp.unsafeBody should be(r4response) - } - - name should "redirect when redirects should be followed, and the response is parsed" in { - val resp = r2.response(asString.map(_.toInt)).send().force() - resp.code should be(200) - resp.unsafeBody should be(r4response.toInt) - } - - name should "keep a single history entry of redirect responses" in { - val resp = r3.send().force() - resp.code should be(200) - resp.unsafeBody should be(r4response) - resp.history should have size (1) - resp.history(0).code should be(302) - } - - name should "keep whole history of redirect responses" in { - val resp = r1.send().force() - resp.code should be(200) - resp.unsafeBody should be(r4response) - resp.history should have size (3) - resp.history(0).code should be(307) - resp.history(1).code should be(308) - resp.history(2).code should be(302) - } - - name should "break redirect loops" in { - val resp = loop.send().force() - resp.code should be(0) - resp.history should have size (FollowRedirectsBackend.MaxRedirects) - } - - name should "break redirect loops after user-specified count" in { - val maxRedirects = 10 - val resp = loop.maxRedirects(maxRedirects).send().force() - resp.code should be(0) - resp.history should have size (maxRedirects) - } - - name should "not redirect when maxRedirects is less than or equal to 0" in { - val resp = loop.maxRedirects(-1).send().force() - resp.code should be(302) - resp.body should be('left) - resp.history should be('empty) - } - } - - def timeoutTests(): Unit = { - name should "fail if read timeout is not big enough" in { - val request = sttp - .get(uri"$endpoint/timeout") - .readTimeout(200.milliseconds) - .response(asString) - - intercept[Throwable] { - request.send().force() - } - } - - name should "not fail if read timeout is big enough" in { - val request = sttp - .get(uri"$endpoint/timeout") - .readTimeout(5.seconds) - .response(asString) - - request.send().force().unsafeBody should be("Done") - } - } - - def emptyResponseTests(): Unit = { - val postEmptyResponse = sttp - .post(uri"$endpoint/empty_unauthorized_response") - .body("{}") - .contentType("application/json") - - name should "parse an empty error response as empty string" in { - val response = postEmptyResponse.send().force() - response.body should be(Left("")) - } - } - - def encodingTests(): Unit = { - name should "read response body encoded using ISO-8859-2, as specified in the header, overriding the default" in { - val request = sttp.get(uri"$endpoint/respond_with_iso_8859_2") - - request.send().force().unsafeBody should be(textWithSpecialCharacters) - } - } - } - - override protected def afterAll(): Unit = { - closeBackends.foreach(_()) - super.afterAll() - } -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/IllTypedTests.scala b/tests/src/test/scala/com/softwaremill/sttp/IllTypedTests.scala deleted file mode 100644 index 881c60e..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/IllTypedTests.scala +++ /dev/null @@ -1,34 +0,0 @@ -package com.softwaremill.sttp - -import org.scalatest.{FlatSpec, Matchers} - -import scala.tools.reflect.ToolBoxError - -class IllTypedTests extends FlatSpec with Matchers { - "compilation" should "fail when trying to stream using the default backend" in { - val thrown = intercept[ToolBoxError] { - EvalScala(""" - import com.softwaremill.sttp._ - import akka.stream.scaladsl.Source - import akka.util.ByteString - implicit val sttpBackend = HttpURLConnectionBackend() - sttp.get(uri"http://example.com").response(asStream[Source[ByteString, Any]]).send() - """) - } - - thrown.getMessage should include( - "could not find implicit value for parameter backend: com.softwaremill.sttp.SttpBackend[R,akka.stream.scaladsl.Source[akka.util.ByteString,Any]]") - } - - "compilation" should "fail when trying to send a request without giving an URL" in { - val thrown = intercept[ToolBoxError] { - EvalScala(""" - import com.softwaremill.sttp._ - implicit val sttpBackend = HttpURLConnectionBackend() - sttp.send() - """) - } - - thrown.getMessage should include("This is a partial request, the method & url are not specified") - } -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/StreamingTests.scala b/tests/src/test/scala/com/softwaremill/sttp/StreamingTests.scala deleted file mode 100644 index b2b44a2..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/StreamingTests.scala +++ /dev/null @@ -1,87 +0,0 @@ -package com.softwaremill.sttp - -import akka.http.scaladsl.server.Directives._ -import akka.http.scaladsl.server.Route -import com.softwaremill.sttp.streaming._ -import com.softwaremill.sttp.testing.streaming.TestStreamingBackend -import com.typesafe.scalalogging.StrictLogging -import org.scalatest.{BeforeAndAfterAll, FlatSpec, Matchers} - -import scala.language.higherKinds - -class StreamingTests - extends FlatSpec - with Matchers - with BeforeAndAfterAll - with StrictLogging - with TestHttpServer - with ForceWrapped { - - override val serverRoutes: Route = - path("echo") { - post { - parameterMap { _ => - entity(as[String]) { body: String => - complete(body) - } - } - } - } - - override def port = 51824 - - val body = "streaming test" - - var closeBackends: List[() => Unit] = Nil - - runTests("Akka Http", new AkkaHttpStreamingTests(actorSystem)) - runTests("Monix Async Http Client", new AsyncHttpClientMonixStreamingTests) - runTests("Monix OkHttp", new OkHttpMonixStreamingTests) - runTests("fs2 Async Http Client", new AsyncHttpClientFs2StreamingTests) - - def runTests[R[_], S](name: String, testStreamingBackend: TestStreamingBackend[R, S]): Unit = { - import testStreamingBackend._ - - closeBackends = (() => backend.close()) :: closeBackends - - name should "stream request body" in { - val response = sttp - .post(uri"$endpoint/echo") - .streamBody(bodyProducer(body)) - .send() - .force() - - response.unsafeBody shouldBe body - } - - it should "receive a stream" in { - val response = sttp - .post(uri"$endpoint/echo") - .body(body) - .response(asStream[S]) - .send() - .force() - - bodyConsumer(response.unsafeBody).force() shouldBe body - } - - it should "receive a stream from an https site" in { - val response = sttp - // of course, you should never rely on the internet being available - // in tests, but that's so much easier than setting up an https - // testing server - .get(uri"https://softwaremill.com") - .response(asStream[S]) - .send() - .force() - - bodyConsumer(response.unsafeBody).force() should include("</div>") - } - } - - override protected def afterAll(): Unit = { - closeBackends.foreach(_()) - super.afterAll() - } - -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/streaming/AkkaHttpStreamingTests.scala b/tests/src/test/scala/com/softwaremill/sttp/streaming/AkkaHttpStreamingTests.scala deleted file mode 100644 index 691df81..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/streaming/AkkaHttpStreamingTests.scala +++ /dev/null @@ -1,29 +0,0 @@ -package com.softwaremill.sttp.streaming - -import akka.NotUsed -import akka.actor.ActorSystem -import akka.stream.Materializer -import akka.stream.scaladsl.Source -import akka.util.ByteString -import com.softwaremill.sttp.SttpBackend -import com.softwaremill.sttp.akkahttp.AkkaHttpBackend -import com.softwaremill.sttp.testing.streaming.{ConvertToFuture, TestStreamingBackend} - -import scala.concurrent.Future - -class AkkaHttpStreamingTests(actorSystem: ActorSystem)(implicit materializer: Materializer) - extends TestStreamingBackend[Future, Source[ByteString, Any]] { - - override implicit val backend: SttpBackend[Future, Source[ByteString, Any]] = - AkkaHttpBackend.usingActorSystem(actorSystem) - - override implicit val convertToFuture: ConvertToFuture[Future] = - ConvertToFuture.future - - override def bodyProducer(body: String): Source[ByteString, NotUsed] = - Source.single(ByteString(body)) - - override def bodyConsumer(stream: Source[ByteString, Any]): Future[String] = - stream.map(_.utf8String).runReduce(_ + _) - -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientFs2StreamingTests.scala b/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientFs2StreamingTests.scala deleted file mode 100644 index 8959ccc..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientFs2StreamingTests.scala +++ /dev/null @@ -1,30 +0,0 @@ -package com.softwaremill.sttp.streaming - -import java.nio.ByteBuffer - -import cats.effect._ -import cats.instances.string._ -import com.softwaremill.sttp.SttpBackend -import com.softwaremill.sttp.asynchttpclient.fs2.AsyncHttpClientFs2Backend -import com.softwaremill.sttp.impl.cats.convertCatsIOToFuture -import com.softwaremill.sttp.testing.streaming.{ConvertToFuture, TestStreamingBackend} -import fs2.{Chunk, Stream, text} - -class AsyncHttpClientFs2StreamingTests extends TestStreamingBackend[IO, Stream[IO, ByteBuffer]] { - - override implicit val backend: SttpBackend[IO, Stream[IO, ByteBuffer]] = - AsyncHttpClientFs2Backend[IO]() - - override implicit val convertToFuture: ConvertToFuture[IO] = convertCatsIOToFuture - - override def bodyProducer(body: String): Stream[IO, ByteBuffer] = - Stream.emits(body.getBytes("utf-8").map(b => ByteBuffer.wrap(Array(b)))) - - override def bodyConsumer(stream: Stream[IO, ByteBuffer]): IO[String] = - stream - .map(bb => Chunk.array(bb.array)) - .through(text.utf8DecodeC) - .compile - .foldMonoid - -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientMonixStreamingTests.scala b/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientMonixStreamingTests.scala deleted file mode 100644 index faebf8b..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/streaming/AsyncHttpClientMonixStreamingTests.scala +++ /dev/null @@ -1,18 +0,0 @@ -package com.softwaremill.sttp.streaming - -import java.nio.ByteBuffer - -import com.softwaremill.sttp.SttpBackend -import com.softwaremill.sttp.asynchttpclient.monix.AsyncHttpClientMonixBackend -import com.softwaremill.sttp.impl.monix.MonixTestStreamingBackend -import monix.eval.Task -import monix.reactive.Observable - -class AsyncHttpClientMonixStreamingTests extends MonixTestStreamingBackend { - - import monix.execution.Scheduler.Implicits.global - - override implicit val backend: SttpBackend[Task, Observable[ByteBuffer]] = - AsyncHttpClientMonixBackend() - -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/streaming/OkHttpMonixStreamingTests.scala b/tests/src/test/scala/com/softwaremill/sttp/streaming/OkHttpMonixStreamingTests.scala deleted file mode 100644 index 27a4517..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/streaming/OkHttpMonixStreamingTests.scala +++ /dev/null @@ -1,18 +0,0 @@ -package com.softwaremill.sttp.streaming - -import java.nio.ByteBuffer - -import com.softwaremill.sttp.SttpBackend -import com.softwaremill.sttp.impl.monix.MonixTestStreamingBackend -import com.softwaremill.sttp.okhttp.monix.OkHttpMonixBackend -import monix.eval.Task -import monix.reactive.Observable - -class OkHttpMonixStreamingTests extends MonixTestStreamingBackend { - - import monix.execution.Scheduler.Implicits.global - - override implicit val backend: SttpBackend[Task, Observable[ByteBuffer]] = - OkHttpMonixBackend() - -} diff --git a/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala b/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala deleted file mode 100644 index 12fe770..0000000 --- a/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala +++ /dev/null @@ -1,82 +0,0 @@ -package com.softwaremill.sttp - -import java.nio.file.{Files, Paths} -import java.{io, util} - -import akka.actor.ActorSystem -import akka.http.scaladsl.Http -import akka.http.scaladsl.server.Route -import akka.stream.ActorMaterializer -import org.scalatest.concurrent.{PatienceConfiguration, ScalaFutures} -import org.scalatest.exceptions.TestFailedException -import org.scalatest.matchers.{MatchResult, Matcher} -import org.scalatest.{BeforeAndAfterAll, Suite} - -import scala.concurrent.duration._ -import scala.language.higherKinds - -trait TestHttpServer extends BeforeAndAfterAll with ScalaFutures with TestingPatience { - this: Suite => - protected implicit val actorSystem: ActorSystem = ActorSystem("sttp-test") - import actorSystem.dispatcher - - protected implicit val materializer = ActorMaterializer() - protected val endpoint = uri"http://localhost:$port" - - override protected def beforeAll(): Unit = { - Http().bindAndHandle(serverRoutes, "localhost", port).futureValue - } - - override protected def afterAll(): Unit = { - actorSystem.terminate().futureValue - } - - def serverRoutes: Route - def port: Int -} - -trait ForceWrapped extends ScalaFutures with TestingPatience { this: Suite => - type ConvertToFuture[R[_]] = - com.softwaremill.sttp.testing.streaming.ConvertToFuture[R] - - implicit class ForceDecorator[R[_], T](wrapped: R[T]) { - def force()(implicit ctf: ConvertToFuture[R]): T = { - try { - ctf.toFuture(wrapped).futureValue - } catch { - case e: TestFailedException if e.getCause != null => throw e.getCause - } - } - } -} - -object EvalScala { - import scala.tools.reflect.ToolBox - - def apply(code: String): Any = { - val m = scala.reflect.runtime.currentMirror - val tb = m.mkToolBox() - tb.eval(tb.parse(code)) - } -} - -object CustomMatchers { - class FileContentsMatch(file: java.io.File) extends Matcher[java.io.File] { - override def apply(left: io.File): MatchResult = { - val inBA = Files.readAllBytes(Paths.get(left.getAbsolutePath)) - val expectedBA = Files.readAllBytes(Paths.get(file.getAbsolutePath)) - MatchResult( - util.Arrays.equals(inBA, expectedBA), - "The files' contents are not the same", - "The files' contents are the same" - ) - } - } - - def haveSameContentAs(file: io.File) = new FileContentsMatch(file) -} - -trait TestingPatience extends PatienceConfiguration { - override implicit val patienceConfig: PatienceConfig = - PatienceConfig(timeout = 5.seconds, interval = 150.milliseconds) -} |