"uk.org.devthings" %% "scala-wiremock-api" % "{version-from-above}" % Test

"scenario" should {
  "handle sequential calls to an api so we can mimic things like retrying" in {
    import WireMockExpectation.ops._

    val (expectedJsonResponseBody1, expectation1) = generateAnyExpectation(0)
    val (expectedJsonResponseBody2, expectation2) = generateAnyExpectation(1)
    val (expectedJsonResponseBody3, expectation3) = generateAnyExpectation(2)

    List(
      expectation1,
      expectation2,
      expectation3
    ).applyAsScenario(wireMock.server)

    val request = basicRequest.get(uri"${wireMock.baseRequestUrl}/")
    val response1 = request.send(sttpBackend)
    val response2 = request.send(sttpBackend)
    val response3 = request.send(sttpBackend)

    response1.code.code shouldBe 200
    response2.code.code shouldBe 201
    response3.code.code shouldBe 202

    response1.body.flatMap(json.parse) shouldBe Right(expectedJsonResponseBody1)
    response2.body.flatMap(json.parse) shouldBe Right(expectedJsonResponseBody2)
    response3.body.flatMap(json.parse) shouldBe Right(expectedJsonResponseBody3)

  }

  def generateAnyExpectation(index: Int): (Json, WireMockExpectation) = {
    // language=json
    val jsonResponseBody = json.unsafeParse(s"""
        |{
        |   "body" :  "body-$index"
        |}
        |""".stripMargin)

    jsonResponseBody -> WireMockExpectation
      .willRespondStatus(200 + index)
      .willRespondWithBody(
         jsonResponseBody.spaces2.asJsonResponse
      )
  }
}

applyAsScenario

  val default: ScenarioInfoGenerator = new ScenarioInfoGenerator {
    override val scenarioName: String = "auto-generated-scenario"

    def createScenarioInfo(scenarioName: String, index: Int, maxIndex: Int): ScenarioInfo = {
      if (index == 0) {
        ScenarioInfo(scenarioName = scenarioName, expectedCurrentState = Scenario.STARTED, nextState = createName(1))
      } else {
        ScenarioInfo(
          scenarioName = scenarioName,
          expectedCurrentState = createName(index),
          nextState = createName(index + 1)
        )
      }
    }

    private def createName(index: Int): String =
      s"wiremock-step-$index"

  }

BodyValueExpectation.equalsJson("{}")

BodyValueExpectation.equalsJson("{}").withDisabledAutoHeader

case class JsonResponseBody(value: String) extends ResponseBody {
  val jsonHeader: (String, String) = "content-type" -> "application/json"
}

class LooseWireMockExpectationTightVerificationExampleSpec extends BaseSpec {

  before {
    reset()
  }

  // Simple example where 404's could lead to confusion.
  "Using a loose expectation and tight verification" should {
    import WireMockExpectation.ops._

    "create a test we can be sure is correct easily" in {

      // language=json
      val expectedBody1 =
        """
          |{"payload-1" : "value-1"}
          |""".stripMargin

      // language=json
      val expectedBody2 =
        """
          |{"payload-2" : "value-2"}
          |""".stripMargin

      // We do not care about header checks and body checks at this point, body checks are pretty troublesome
      // as people can use the string expectation instead of the json expectation meaning the expectation is not
      // json formatting safe.
      val firstCallLooseExpectation =
        WireMockExpectation.willRespondOk
          .expectsMethod(Post) // we could skip the method here and add it later but method is pretty hard to fail on
          .expectsUrl("/api-path-1".asUrlPathEquals)

      val secondCallLooseExpectation =
        WireMockExpectation.willRespondOk
          .expectsMethod(Post) // we could skip the method here and add it later but method is pretty hard to fail on
          .expectsUrl("/api-path-2".asUrlPathEquals)

      wireMock.stubExpectation(firstCallLooseExpectation)
      wireMock.stubExpectation(secondCallLooseExpectation)

      val result = for {
        _ <- callServer(path = "api-path-1", body = expectedBody1)
        _ <- callServer(path = "api-path-2", body = expectedBody2)
      } yield true

      import uk.org.devthings.scala.wiremockapi.remapping.WireMockExpectation.ops._

      val paramExpectation = ("param1" -> "paramValue1").asEqualTo

      // Do verifies first as the shouldBe failure will be non-informative in this case
      wireMock.verify(
        firstCallLooseExpectation
          .expectsBody(BodyValueExpectation.equalsJson(expectedBody1))
          .expectsQueryParam(paramExpectation)
      )

      wireMock.verify(
        secondCallLooseExpectation
          .expectsBody(BodyValueExpectation.equalsJson(expectedBody2))
          .expectsQueryParam(paramExpectation)
      )

      // A None can be cause by either call failing
      result shouldBe Some(true)

    }
  }

  /**
    * An auth check could just return a boolean/empty list etc. And auth checks can chain.
    *
    * @param path
    * @param body
    * @return
    */
  def callServer(path: String, body: String): Option[Boolean] = {
    import sttp.client3._
    val response = basicRequest
      .post(uri"${wireMock.baseRequestUrl}/$path?param1=paramValue1")
      .contentType("application/json") // this is auto-checked by BodyValueExpectation.equalsJson
      .body(body)
      .send(sttpBackend)

    if (response.code.code == 200) {
      Some(true)
    } else {
      None
    }
  }
}