Play framework WSClient testing - scala

Question

I have a service class in my code, for example, UserService. It has a WSClient member which makes calls to a web service. I would like to write test cases for the UserService methods.
I did some research on testing WSClient but did not find any use case like mine. Should I establish a live test service, or do mocking? This is another question.
class UserService #Inject()(ws: WSClient) {
def getUser(userId: UUID) = {// some code}
def createUser(obj: User) = {// another piece of code}
These methods use the WSClient to call the web service endpoints.
I would like to write test cases for these methods. Which is the best, setting up a test service and call that or mocking the WSClient?

Answer 1

I have created a CustomWSClient, CustomWSRequest and CustomWSResponse for testing purposes as follows.
package unittest
import play.api.http.Writeable
import play.api.libs.iteratee.Enumerator
import play.api.libs.json.{JsValue, Json}
import play.api.libs.ws._
import scala.concurrent.Future
import scala.xml.Elem
class CustomWSClient extends WSClient {
var t: ResponseObject = new ResponseObject(Json.toJson("Success"), Map("trial" -> Seq("value")), 200)
override def underlying[T]: T = underlying.asInstanceOf[T]
override def url(url: String): WSRequest = {
var c: CustomWSRequest = CustomWSRequest(url, t)
c.setResponse(t)
c
}
override def close(): Unit = {}
def setResponse(t: ResponseObject) = {
this.t = t
}
}
case class CustomWSRequest(inputUrl: String, t: ResponseObject) extends WSRequest {
override val url: String = inputUrl
override def withHeaders(hdrs: (String, String)*): WSRequest = { this }
override def withAuth(username: String, password: String, scheme: WSAuthScheme): WSRequest = { this }
override def withQueryString(parameters: (String, String)*): WSRequest = { this }
override def execute(): Future[WSResponse] = { Future.successful(CustomWSResponse(t)) }
override def sign(calc: WSSignatureCalculator): WSRequest = { this }
override def stream(): Future[(WSResponseHeaders, Enumerator[Array[Byte]])] = null
override def withVirtualHost(vh: String): WSRequest = { this }
override def withMethod(method: String): WSRequest = { this }
override def withRequestTimeout(timeout: Long): WSRequest = { this }
override def withProxyServer(proxyServer: WSProxyServer): WSRequest = { this }
override def withFollowRedirects(follow: Boolean): WSRequest = { this }
override def withBody(body: WSBody): WSRequest = { this }
override def get(): Future[WSResponse] = { Future.successful(CustomWSResponse(t)) }
override def post[T](body: T)(implicit wrt: Writeable[T]) = { Future.successful(CustomWSResponse(t)) }
//override def put[T](body: T)(implicit wrt: Writeable[T]) = {Future.successful( CustomWSResponse(t))}
def setResponse(t: ResponseObject) = {
t
}
override val calc: Option[WSSignatureCalculator] = None
override val queryString: Map[String, Seq[String]] = Map("trial" -> Seq("value"))
override val method: String = "TestMethod"
override val followRedirects: Option[Boolean] = None
override val body: WSBody = null
override val requestTimeout: Option[Int] = None
override val virtualHost: Option[String] = None
override val proxyServer: Option[WSProxyServer] = None
override val auth: Option[(String, String, WSAuthScheme)] = None
override val headers: Map[String, Seq[String]] = Map("trial" -> Seq("value"))
}
case class CustomWSResponse(t: ResponseObject) extends play.api.libs.ws.WSResponse {
def allHeaders: Map[String, Seq[String]] = { t.headers }
def statusText: String = { "success" }
def underlying[T]: T = underlying.asInstanceOf[T]
def body: String = { t.json.toString() }
def header(key: String): Option[String] = Option(t.headers.get(key).headOption.get.apply(0))
def cookie(name: String): Option[WSCookie] = Some(CustomWSCookie("test"))
def status: Int = { t.status }
def json: JsValue = t.json
override def cookies: Seq[WSCookie] = Seq(CustomWSCookie("test"))
override def xml: Elem = null
override def bodyAsBytes: Array[Byte] = null
}
case class CustomWSCookie(t: String) extends play.api.libs.ws.WSCookie {
override def underlying[T]: T = this.underlying
override def domain: String = "test"
override def name: Option[String] = Some("test")
override def value: Option[String] = Some("test")
override def path: String = "test"
override def expires: Option[Long] = Some(2L)
override def maxAge: Option[Int] = Some(5)
override def secure: Boolean = true
}
case class ResponseObject(json: JsValue, headers: Map[String, Seq[String]], status: Int)
I have created a mock where ever ws object is used.
class TranslationsActorSpec extends ServiceOneAppPerSuite with LazyLogging {
override val ws = mock[CustomWSClient]
val mockWSRequest = mock[CustomWSRequest]
val mockWSResponse = mock[CustomWSResponse]
when(ws.url("https://getCallToMyService")) thenReturn (mockWSRequest)
when(mockWSRequest.withHeaders(
"Authorization" -> "token somevalue"
)) thenReturn (mockWSRequest)
when(mockWSRequest.get()) thenReturn (Future.successful(mockWSResponse))
when(mockWSResponse.status) thenReturn (200)
//write your testcase and pass ws object to it, it will get the mocked response for the service call
}