feat: Support mixing pact and non-pact test methods with @PactIgnore annotation #1674

Author: rholshausen

consumer/README.md

@@ -653,3 +653,9 @@ and [#1383](https://github.com/pact-foundation/pact-jvm/issues/1383).
 One option (if the HTTP client supports it, Apache HTTP Client does) is to set the system property `http.keepAlive` to `false` in 
 the test JVM. The other option is to set `pact.mockserver.addCloseHeader` to `true` to force the mock server to
 send a `Connection: close` header with every response (supported with Pact-JVM 4.2.7+).
+
+# Mixing Pact and non-Pact test methods in the same test class
+
+By default, the Pact lifecycle will be invoked for every test method and will expect there to be a method annotated
+with `@Pact` for each test method invoked. To add non-Pact tests, just annotate the non-Pact test method with the
+`@PactIgnore` annotation.

consumer/junit5/src/main/kotlin/au/com/dius/pact/consumer/junit5/Annotations.kt

@@ -0,0 +1,14 @@
+package au.com.dius.pact.consumer.junit5
+
+/**
+ * Marks a injected MockServer parameter as for a particular provider. This is used when there is more than one
+ * provider setup for the test.
+ */
+@Target(AnnotationTarget.VALUE_PARAMETER)
+annotation class ForProvider(val value: String)
+
+/**
+ * Marks a test as a non-pact test. This will cause the normal Pact lifecycle to be skipped for that test.
+ */
+@Target(AnnotationTarget.FUNCTION)
+annotation class PactIgnore

consumer/junit5/src/main/kotlin/au/com/dius/pact/consumer/junit5/ForProvider.kt

@@ -210,20 +210,28 @@ class PactConsumerTestExt : Extension, BeforeTestExecutionCallback, BeforeAllCal
   }
 
   override fun beforeTestExecution(context: ExtensionContext) {
-    for ((providerInfo, pactMethod) in lookupProviderInfo(context)) {
-      logger.debug { "providerInfo = $providerInfo" }
-
-      if (mockServerConfigured(context) ||
-        providerInfo.providerType == null ||
-        providerInfo.providerType == ProviderType.SYNCH ||
-        providerInfo.providerType == ProviderType.UNSPECIFIED) {
-        val mockServer = setupMockServerForProvider(providerInfo, pactMethod, context)
-        mockServer.start()
-        mockServer.waitForServer()
+    if (!ignoredTest(context)) {
+      for ((providerInfo, pactMethod) in lookupProviderInfo(context)) {
+        logger.debug { "providerInfo = $providerInfo" }
+
+        if (mockServerConfigured(context) ||
+          providerInfo.providerType == null ||
+          providerInfo.providerType == ProviderType.SYNCH ||
+          providerInfo.providerType == ProviderType.UNSPECIFIED
+        ) {
+          val mockServer = setupMockServerForProvider(providerInfo, pactMethod, context)
+          mockServer.start()
+          mockServer.waitForServer()
+        }
       }
     }
   }
 
+  private fun ignoredTest(context: ExtensionContext): Boolean {
+    return context.testMethod.isPresent &&
+      AnnotationSupport.isAnnotated(context.testMethod.get(), PactIgnore::class.java)
+  }
+
   private fun setupMockServerForProvider(
     providerInfo: ProviderInfo,
     pactMethod: String,
@@ -527,30 +535,32 @@ class PactConsumerTestExt : Extension, BeforeTestExecutionCallback, BeforeAllCal
   }
 
   override fun afterTestExecution(context: ExtensionContext) {
-    val store = context.getStore(NAMESPACE)
+    if (!ignoredTest(context)) {
+      val store = context.getStore(NAMESPACE)
 
-    val providers = store["providers"] as List<Pair<ProviderInfo, String>>
-    for ((provider, _) in providers) {
-      val pact = store["pact:${provider.providerName}"] as BasePact?
-      Metrics.sendMetrics(MetricEvent.ConsumerTestRun(pact?.interactions?.size ?: 0, "junit5"))
-    }
+      val providers = store["providers"] as List<Pair<ProviderInfo, String>>
+      for ((provider, _) in providers) {
+        val pact = store["pact:${provider.providerName}"] as BasePact?
+        Metrics.sendMetrics(MetricEvent.ConsumerTestRun(pact?.interactions?.size ?: 0, "junit5"))
+      }
 
-    for ((provider, _) in providers) {
-      if (store["mockServer:${provider.providerName}"] != null) {
-        val mockServer = store["mockServer:${provider.providerName}"] as JUnit5MockServerSupport
-        Thread.sleep(100) // give the mock server some time to have consistent state
-        mockServer.close()
-        val result = mockServer.validateMockServerState(null)
-        if (result is PactVerificationResult.Ok) {
+      for ((provider, _) in providers) {
+        if (store["mockServer:${provider.providerName}"] != null) {
+          val mockServer = store["mockServer:${provider.providerName}"] as JUnit5MockServerSupport
+          Thread.sleep(100) // give the mock server some time to have consistent state
+          mockServer.close()
+          val result = mockServer.validateMockServerState(null)
+          if (result is PactVerificationResult.Ok) {
+            if (!context.executionException.isPresent) {
+              storePactForWrite(store, provider, mockServer)
+            }
+          } else {
+            JUnitTestSupport.validateMockServerResult(result)
+          }
+        } else if (provider.providerType == ProviderType.ASYNCH || provider.providerType == ProviderType.SYNCH_MESSAGE) {
           if (!context.executionException.isPresent) {
-            storePactForWrite(store, provider, mockServer)
+            storePactForWrite(store, provider, null)
           }
-        } else {
-          JUnitTestSupport.validateMockServerResult(result)
-        }
-      } else if (provider.providerType == ProviderType.ASYNCH || provider.providerType == ProviderType.SYNCH_MESSAGE) {
-        if (!context.executionException.isPresent) {
-          storePactForWrite(store, provider, null)
         }
       }
     }

consumer/junit5/src/main/kotlin/au/com/dius/pact/consumer/junit5/PactConsumerTestExt.kt

@@ -258,6 +258,9 @@ class PactConsumerTestExtSpec extends Specification {
     @MockServerConfig(providerName = 'a', port = '1238')
     @MockServerConfig(providerName = 'b', port = '1239')
     def pactTestForMethod() { }
+
+    @PactIgnore
+    def nonPactTestMethod() { }
   }
 
   def 'mockServerConfigured - returns true when there are multiple MockServerConfig annotations on the test class'() {
@@ -352,4 +355,22 @@ class PactConsumerTestExtSpec extends Specification {
     then:
     config.port == 1239
   }
+
+  def 'ignoredTest - returns false for a normal test method'() {
+    given:
+    requiredTestClass = TestClass6
+    testMethod = TestClass6.getMethod('pactTestForMethod')
+
+    expect:
+    !testExt.ignoredTest(mockContext)
+  }
+
+  def 'ignoredTest - returns true for a test method annotated with PactIgnore'() {
+    given:
+    requiredTestClass = TestClass6
+    testMethod = TestClass6.getMethod('nonPactTestMethod')
+
+    expect:
+    testExt.ignoredTest(mockContext)
+  }
 }

consumer/junit5/src/test/groovy/au/com/dius/pact/consumer/junit5/PactConsumerTestExtSpec.groovy

@@ -0,0 +1,53 @@
+package au.com.dius.pact.consumer.junit5;
+
+import au.com.dius.pact.consumer.MockServer;
+import au.com.dius.pact.consumer.dsl.PactDslWithProvider;
+import au.com.dius.pact.core.model.PactSpecVersion;
+import au.com.dius.pact.core.model.RequestResponsePact;
+import au.com.dius.pact.core.model.annotations.Pact;
+import org.apache.hc.client5.http.fluent.Request;
+import org.apache.hc.core5.http.ContentType;
+import org.apache.hc.core5.http.HttpResponse;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.io.IOException;
+
+import static au.com.dius.pact.consumer.dsl.LambdaDsl.newJsonArrayMinLike;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(PactConsumerTestExt.class)
+@PactTestFor(pactVersion = PactSpecVersion.V3)
+class MixedPactAndNonPactTest {
+  @Pact(consumer = "ApiConsumer")
+  public RequestResponsePact defaultValues(PactDslWithProvider builder) {
+    return builder
+      .uponReceiving("GET request to retrieve default values")
+      .path("/api/test")
+      .willRespondWith()
+      .status(200)
+      .body(newJsonArrayMinLike(1, values -> values.object(value -> {
+          value.numberType("id", 32432);
+          value.stringType("name", "testId254");
+          value.numberType("size", 1445211);
+        }
+      )).build())
+      .toPact();
+  }
+
+  @Test
+  @PactTestFor(pactMethod = "defaultValues")
+  void testDefaultValues(MockServer mockServer) throws IOException {
+    HttpResponse response = Request.get(mockServer.getUrl() + "/api/test").execute().returnResponse();
+    assertEquals(response.getCode(), 200);
+  }
+
+  @Test
+  @PactIgnore
+  void nonPactTest() {
+    assertThat(true, is(not(false))); // otherwise, the universe will end
+  }
+}