Unit Test with Injecting

package ru.mitrakov.test.controllers

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.language.postfixOps

import akka.util.Timeout
import play.api.http.Status._
import play.api.libs.ws.WSClient
import play.api.mvc.{AnyContent, ControllerComponents, Headers}
import play.api.test.{FakeRequest, Helpers, Injecting}

import org.mockito.Mockito._
import org.scalatest.mockito.MockitoSugar
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import org.scalatestplus.play.PlaySpec

import co.tala.kycqueue.helpers.{KycAttemptHelper, KycAttempts}
import co.tala.kycqueue.model.PersonInfo
import co.tala.kycqueue.services.{Person, ServerApiClient, TokenAuthenticationService}


/**
  * Class for testing KycAjaxController
  * @author Artem Mitrakov (amitrakov@tala.co)
  */
class KycAjaxControllerSpec extends PlaySpec with GuiceOneAppPerSuite with Injecting with MockitoSugar {
  /** arbitrary person ID */
  private val personId = 357

  /** implicit timeout for Helpers methods */
  private implicit val timeout: Timeout = Timeout(1 second)

  // create a Controller, substituting KycAttemptHelper and ServerApiClient with corresponding Mocks
  private val ws = inject[WSClient]
  private val cc = inject[ControllerComponents]
  private val authService = inject[TokenAuthenticationService]
  private val kycHelper = mock[KycAttemptHelper]
  private val serverHelper = mock[ServerApiClient]
  private val controller = new KycAjaxController(ws, authService, kycHelper, serverHelper, cc)

  // set up our Mocks to return fake data instead of requesting actual DB
  when(serverHelper.getPerson(personId))  thenReturn Future.successful{Some(Person("Tom Brown", "Tom", "1989-12-07"))}
  when(kycHelper.getKycAttempt(personId)) thenReturn Future.successful{Some(KycAttempts(3, 9, Nil, Seq(3, 3, 4)))}
  when(serverHelper.getSmsTemplates)      thenReturn Future.successful{Map("438" -> "Verified", "439" -> "Blur image")}
  when(serverHelper.getPerson(0))         thenReturn Future.successful{None}
  when(kycHelper.getKycAttempt(0))        thenReturn Future.successful{None}

  "KycAjaxController#getPersonInfo" when {
    "request received with EXISTING personId" should {
      "return an actual result" in {
        val request = FakeRequest(Helpers.GET, s"/api/v1/person/$personId/info", Headers(), AnyContent())
        val result = controller.getPersonInfo(personId).apply(request)

        val status = Helpers.status(result)
        status mustBe OK

        val info = Helpers.contentAsJson(result).as[PersonInfo]
        info.name mustBe "Tom Brown"
        info.birthday mustBe "1989-12-07"
        info.status mustBe 3
        info.identificationTypeId mustBe 9
        info.sms must have size 2
        info.sms must contain key "438"
        info.sms must contain key "439"
      }
    }

    "request received with NON-EXISTING personId" should {
      "return result with N/A parameters" in {
        val request = FakeRequest(Helpers.GET, s"/api/v1/person/0/info", Headers(), AnyContent())
        val result = controller.getPersonInfo(0).apply(request)

        val status = Helpers.status(result)
        status mustBe OK

        val info = Helpers.contentAsJson(result).as[PersonInfo]
        info.name mustBe "N/A"
        info.birthday mustBe "N/A"
        info.status mustBe 0
        info.identificationTypeId mustBe 0
        info.sms must have size 2
        info.sms must contain key "438"
        info.sms must contain key "439"
      }
    }
  }
}