For Kotlin, any opinions on a Lambda DSL for the actual

uponReceiving ... willRespondWith ...

part? I noticed that some examples in the docs indent the parts to visually separate the request and the response:

builder
  .given("foo")
  .uponReceiving("something")
    .path("ping/pong")
    .method("POST")
    .body("Hello")
  .willRespondWith()
    .successStatus()
    .body("World")
  .build()

But with most auto-formatting tools (IDE, Spotless, ...) this might not always be possible to achieve and it will just collapse back to:

builder
  .given("foo")
  .uponReceiving("something")
  .path("ping/pong")
  .method("POST")
  .body("Hello")
  .willRespondWith()
  .successStatus()
  .body("World")
  .build()

Now, it is fairly simple to add a Lambda DSL to achieve this indents:

builder
  .given("foo")
  .uponReceiving("something")
  .path("ping/pong") {
    method("POST")
    body("Hello")
  }.willRespondWith()
    successStatus()
    body("World")
  }.build()

Should I invest time into creating a PR, or am I overlooking something here? (I noticed one issue between

uponReceiving

and

path

though, since they are changing types from

...WithoutPath

to

...WithPath

, so I only managed to make the DSL cut at the

path

method)

PRs that make things better are always welcome

awesome. will look into it, thanks 👍

Those DSLs are really old. They were written in 2014, and have just been added to over the years. I was planning on creating a new DSL for the V4 Pact format which has separate builders for the different types.

ah, sounds cool. looking forward to that 👍

Like it @Daniel Tischner thanks for sharing for thoughts with the group and for any additions in the future. We look forward to supporting you with any PR’s! Very neat thought, and will making grokking code in an IDE much nicer 👌

I have some similar helper functions, I can share them here (or in PR comments) if you'd like more ideas :)

Spread the helper love @Boris 💛 - I’m sure you’ve many little gems from over the years

Pretty sure I've shared these before, but here's my most recent sample :)

import au.com.dius.pact.consumer.ConsumerPactBuilder
import au.com.dius.pact.consumer.MockServer
import au.com.dius.pact.consumer.PactTestExecutionContext
import au.com.dius.pact.consumer.PactTestRun
import au.com.dius.pact.consumer.PactVerificationResult
import au.com.dius.pact.consumer.PactVerificationResult.Ok
import au.com.dius.pact.consumer.dsl.LambdaDsl
import au.com.dius.pact.consumer.dsl.LambdaDslJsonBody
import au.com.dius.pact.consumer.dsl.LambdaDslObject
import au.com.dius.pact.consumer.dsl.PactDslRequestWithPath
import au.com.dius.pact.consumer.dsl.PactDslResponse
import au.com.dius.pact.consumer.dsl.PactDslWithProvider
import au.com.dius.pact.consumer.dsl.PactDslWithState
import au.com.dius.pact.consumer.dsl.newJsonArray
import au.com.dius.pact.consumer.dsl.newObject
import au.com.dius.pact.consumer.model.MockProviderConfig
import au.com.dius.pact.consumer.runConsumerTest
import au.com.dius.pact.core.model.BasePact
import au.com.dius.pact.core.model.RequestResponsePact
import io.kotest.matchers.shouldNotBe
import retrofit2.Call
import retrofit2.Response
import java.time.ZonedDateTime
import java.util.Base64

fun pactBuilder() = ConsumerPactBuilder
  .consumer("[redacted]-consumer")
  .hasPactWith("[redacted]-api")

fun buildPact(
  builder: PactDslWithProvider.() -> PactDslResponse
): RequestResponsePact = pactBuilder().builder().toPact()

fun buildPact(
  given: String,
  builder: PactDslWithState.() -> PactDslResponse
): RequestResponsePact = pactBuilder().given(given).builder().toPact()

operator fun <R> BasePact.invoke(auth: Boolean = true, createCall: RedactedClient.() -> Call<R>): R? {
  println()
  val result: PactVerificationResult = runConsumerTest(
    this,
    MockProviderConfig.createDefault(),
    object : PactTestRun<Response<R>> {
      override fun run(mockServer: MockServer, context: PactTestExecutionContext?): Response<R> {
        val client = buildClient<RedactedClient>(mockServer.getUrl(), auth)
        return client.createCall().execute()
      }
    }
  )
  println("testPact result: $result")
  return ((result as? Ok)?.result as? Response<R>?)?.body()
}

fun PactDslRequestWithPath.jsonHeader() =
  matchHeader("Content-Type", "^application/json.*$", "application/json; charset utf-8")

fun PactDslRequestWithPath.authHeader(user: String = "admin", pass: String = "admin") =
  matchHeader("Authorization", "^Basic .*$", "Basic ${"$user:$pass".base64}")

val String.base64: String
  get() = Base64.getEncoder().encodeToString(encodeToByteArray())

fun oneOf(vararg values: String): String = values.joinToString("|")

fun LambdaDslObject.zonedDateTime(
  fieldName: String,
  example: String = "2021-04-28T00:32:16.450595Z"
): LambdaDslObject = datetime(
  fieldName,
  "YYYY-MM-dd'T'HH:mm:ss.SSSSSSXXX",
  ZonedDateTime.parse(example)
)

fun LambdaDslJsonBody.arrayLike(fieldName: String, eachBuilder: LambdaDslObject.() -> Unit): LambdaDslObject =
  minArrayLike(fieldName, 1) { eachBuilder(it) }

infix fun PactDslRequestWithPath.jsonBody(bodyBuilder: LambdaDslJsonBody.() -> Unit): PactDslRequestWithPath =
  body(LambdaDsl.newJsonBody(bodyBuilder).build())

infix fun PactDslResponse.jsonBody(bodyBuilder: LambdaDslJsonBody.() -> Unit): PactDslResponse =
  body(LambdaDsl.newJsonBody(bodyBuilder).build())

fun PactDslResponse.jsonArray(times: Int = 1, body: LambdaDslObject.() -> Unit): PactDslResponse =
  body(newJsonArray { repeat(times) { newObject(body).build() } })

fun PactDslResponse.jsonArray(vararg body: LambdaDslObject.() -> Unit): PactDslResponse =
  body(newJsonArray { body.map { newObject(it).build() } })

infix fun <T> Iterable<T>.shouldContainMatch(findMatch: T.()->Boolean) =
  find(findMatch) shouldNotBe null

(for visibility) i opened a PR now: https://github.com/pact-foundation/pact-jvm/pull/1598

oh, forgot to include the call-site examples . . . they'd answer your original query a bit better . . .

@Boris i like that

arrayLike

, will use that in my own code base until u add it to pact directly. thanks

ok, I've gone and got some call-site examples for you 🙂

yeah. looks cool. thank you 🙂

Could definitely be improved with a native Kotlin DSL, instead of just a hack on top. But that was good enough while I haven't had time to contribute to the core libs.