feat(Junit5+Spring): support injecting MockHttpServletRequestBuilder …

…when using MockMvc tests #1334

provider/junit5/src/main/kotlin/au/com/dius/pact/provider/junit5/PactVerificationExtension.kt

@@ -31,13 +31,13 @@ import java.io.File
 /**
  * JUnit 5 test extension class used to inject parameters and execute the test for a Pact interaction.
  */
-class PactVerificationExtension(
-  private val pact: Pact<Interaction>,
-  private val pactSource: au.com.dius.pact.core.model.PactSource,
-  private val interaction: Interaction,
-  private val serviceName: String,
-  private val consumerName: String?,
-  private val propertyResolver: ValueResolver = SystemPropertyResolver
+open class PactVerificationExtension(
+  val pact: Pact<Interaction>,
+  val pactSource: au.com.dius.pact.core.model.PactSource,
+  val interaction: Interaction,
+  val serviceName: String,
+  val consumerName: String?,
+  val propertyResolver: ValueResolver = SystemPropertyResolver
 ) : TestTemplateInvocationContext, ParameterResolver, BeforeEachCallback, BeforeTestExecutionCallback,
   AfterTestExecutionCallback {
 

provider/junit5spring/src/main/kotlin/au/com/dius/pact/provider/spring/junit5/MockMvcTestTarget.kt

@@ -85,10 +85,11 @@ class MockMvcTestTarget @JvmOverloads constructor(
 
   private fun toMockRequestBuilder(request: Request): MockHttpServletRequestBuilder {
     val body = request.body
-    return if (body.isPresent()) {
+    val cookies = cookies(request)
+    val servletRequestBuilder: MockHttpServletRequestBuilder = if (body.isPresent()) {
       if (request.isMultipartFileUpload()) {
         val multipart = MimeMultipart(ByteArrayDataSource(body.unwrap(), request.contentTypeHeader()))
-        val multipartRequest = MockMvcRequestBuilders.fileUpload(requestUriString(request))
+        val multipartRequest = MockMvcRequestBuilders.multipart(requestUriString(request))
         var i = 0
         while (i < multipart.count) {
           val bodyPart = multipart.getBodyPart(i)
@@ -98,18 +99,20 @@ class MockMvcTestTarget @JvmOverloads constructor(
           multipartRequest.file(MockMultipartFile(name, filename, bodyPart.contentType, bodyPart.inputStream))
           i++
         }
-        multipartRequest.headers(mapHeaders(request, true)).cookie(*cookies(request))
+        multipartRequest.headers(mapHeaders(request, true))
       } else {
         MockMvcRequestBuilders.request(HttpMethod.valueOf(request.method), requestUriString(request))
           .headers(mapHeaders(request, true))
           .content(body.value)
-          .cookie(*cookies(request))
       }
     } else {
       MockMvcRequestBuilders.request(HttpMethod.valueOf(request.method), requestUriString(request))
         .headers(mapHeaders(request, false))
-        .cookie(*cookies(request))
     }
+    if (cookies.isNotEmpty()) {
+      servletRequestBuilder.cookie(*cookies)
+    }
+    return servletRequestBuilder
   }
 
   private fun cookies(request: Request): Array<Cookie> {

provider/junit5spring/src/main/kotlin/au/com/dius/pact/provider/spring/junit5/PactVerificationSpringExtension.kt

@@ -0,0 +1,38 @@
+package au.com.dius.pact.provider.spring.junit5
+
+import au.com.dius.pact.core.model.Interaction
+import au.com.dius.pact.core.model.Pact
+import au.com.dius.pact.core.model.PactSource
+import au.com.dius.pact.provider.junit5.PactVerificationContext
+import au.com.dius.pact.provider.junit5.PactVerificationExtension
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.ParameterContext
+import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder
+
+class PactVerificationSpringExtension(
+  pact: Pact<Interaction>,
+  pactSource: PactSource,
+  interaction: Interaction,
+  serviceName: String,
+  consumerName: String?
+) : PactVerificationExtension(pact, pactSource, interaction, serviceName, consumerName) {
+  constructor(context: PactVerificationExtension) : this(context.pact, context.pactSource, context.interaction,
+    context.serviceName, context.consumerName)
+
+  override fun supportsParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Boolean {
+    val store = extensionContext.getStore(ExtensionContext.Namespace.create("pact-jvm"))
+    val testContext = store.get("interactionContext") as PactVerificationContext
+    return when (parameterContext.parameter.type) {
+      MockHttpServletRequestBuilder::class.java -> testContext.target is MockMvcTestTarget
+      else -> super.supportsParameter(parameterContext, extensionContext)
+    }
+  }
+
+  override fun resolveParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Any? {
+    val store = extensionContext.getStore(ExtensionContext.Namespace.create("pact-jvm"))
+    return when (parameterContext.parameter.type) {
+      MockHttpServletRequestBuilder::class.java -> store.get("request")
+      else -> super.resolveParameter(parameterContext, extensionContext)
+    }
+  }
+}

provider/junit5spring/src/main/kotlin/au/com/dius/pact/provider/spring/junit5/PactVerificationSpringProvider.kt

@@ -1,10 +1,13 @@
 package au.com.dius.pact.provider.spring.junit5
 
 import au.com.dius.pact.core.support.expressions.ValueResolver
+import au.com.dius.pact.provider.junit5.PactVerificationExtension
 import au.com.dius.pact.provider.junit5.PactVerificationInvocationContextProvider
 import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.TestTemplateInvocationContext
 import org.springframework.test.context.TestContextManager
 import org.springframework.test.context.junit.jupiter.SpringExtension
+import java.util.stream.Stream
 
 class PactVerificationSpringProvider() : PactVerificationInvocationContextProvider() {
 
@@ -16,4 +19,14 @@ class PactVerificationSpringProvider() : PactVerificationInvocationContextProvid
     val environment = testContextManager.testContext.applicationContext.environment
     return SpringEnvironmentResolver(environment)
   }
+
+  override fun provideTestTemplateInvocationContexts(context: ExtensionContext): Stream<TestTemplateInvocationContext> {
+    return super.provideTestTemplateInvocationContexts(context).map {
+      if (it is PactVerificationExtension) {
+        PactVerificationSpringExtension(it)
+      } else {
+        it
+      }
+    }
+  }
 }

provider/junit5spring/src/test/groovy/au/com/dius/pact/provider/spring/junit5/MockMvcTestWithCookieSpec.groovy

@@ -6,41 +6,37 @@ import au.com.dius.pact.provider.junitsupport.loader.PactFolder
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.TestTemplate
 import org.junit.jupiter.api.extension.ExtendWith
-import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
 import org.springframework.http.HttpStatus
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.setup.MockMvcBuilders
+import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder
 import org.springframework.web.bind.annotation.CookieValue
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.ResponseStatus
 import org.springframework.web.bind.annotation.RestController
 
 @WebMvcTest(controllers = [ CookieResource ])
-@Provider("CookieService")
-@PactFolder("pacts")
+@Provider('CookieService')
+@PactFolder('pacts')
 class MockMvcTestWithCookieSpec {
 
-  @Autowired
-  MockMvc mockMvc
-
   @BeforeEach
   void before(PactVerificationContext context) {
     context?.target = new MockMvcTestTarget(null, [ new CookieResource() ], [], [], true)
   }
 
   @TestTemplate
   @ExtendWith(PactVerificationSpringProvider)
-  void pactVerificationTestTemplate(PactVerificationContext context) {
+  void pactVerificationTestTemplate(PactVerificationContext context, MockHttpServletRequestBuilder request) {
+    request.header('test', 'test')
     context?.verifyInteraction()
   }
 
   @RestController
   static class CookieResource {
     @GetMapping(value = '/cookie', produces = 'text/plain')
     @ResponseStatus(HttpStatus.OK)
-    String getData(@RequestParam('id') String id, @CookieValue("token") String token) {
+    String getData(@RequestParam('id') String id, @CookieValue('token') String token) {
       assert token != null && !token.empty
       "Hello $id $token"
     }