Merge pull request #739 from gmazzo/master

Moves `MockKExtension`'s `unmockkAll` behavior to the `afterAll` callback

README.md

@@ -226,6 +226,11 @@ fun calculateAddsValues1(@MockK car1: Car, @RelaxedMockK car2: Car) {
 }
 ```
 
+Finally, this extension will call `unmockkAll` in a `@AfterAll` callback, ensuring your test environment is clean after
+each test class execution.
+You can disable this behavior by adding the `@MockKExtension.KeepMocks` annotation to your class or globally by setting 
+the `mockk.junit.extension.keepmocks=true` property
+
 ### Spy
 
 Spies allow you to mix mocks and real objects.

mockk/jvm/src/main/kotlin/io/mockk/junit5/MockKExtension.kt

@@ -8,19 +8,26 @@ import io.mockk.impl.annotations.SpyK
 import io.mockk.mockkClass
 import io.mockk.unmockkAll
 import org.junit.jupiter.api.extension.*
+import java.lang.annotation.Inherited
+import java.lang.reflect.AnnotatedElement
 import java.lang.reflect.Parameter
+import java.util.Optional
 
 /**
  * JUnit5 extension.
  *
  * Parameters can use [MockK] and [RelaxedMockK].
  * Class properties can use [MockK], [RelaxedMockK] and [SpyK]
+ * [unmockkAll] will be called after test class execution (*)
  *
  * Usage: declare @ExtendWith(MockKExtension.class) on a test class
  *
  * Alternatively –Djunit.extensions.autodetection.enabled=true may be placed on a command line.
+ *
+ * (*) [unmockkAll] default behavior can be disabled by adding [KeepMocks] to your test class or method or
+ * –Dmockk.junit.extension.keepmocks=true on a command line
  */
-class MockKExtension : TestInstancePostProcessor, ParameterResolver, AfterEachCallback {
+class MockKExtension : TestInstancePostProcessor, ParameterResolver, AfterAllCallback {
     override fun supportsParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Boolean {
         return getMockKAnnotation(parameterContext) != null
     }
@@ -68,16 +75,39 @@ class MockKExtension : TestInstancePostProcessor, ParameterResolver, AfterEachCa
     }
 
     private fun moreInterfaces(parameter: ParameterContext) =
-            parameter.findAnnotation(AdditionalInterface::class.java)
-                    .map { it.type }
-                    .map { arrayOf(it) }
-                    .orElseGet { emptyArray() }
+        parameter.findAnnotation(AdditionalInterface::class.java)
+            .map { it.type }
+            .map { arrayOf(it) }
+            .orElseGet { emptyArray() }
 
     override fun postProcessTestInstance(testInstance: Any, context: ExtensionContext) {
         MockKAnnotations.init(testInstance)
     }
 
-    override fun afterEach(context: ExtensionContext?) {
-        unmockkAll()
+    override fun afterAll(context: ExtensionContext) {
+        if (!context.keepMocks) {
+            unmockkAll()
+        }
+    }
+
+    private val ExtensionContext.keepMocks: Boolean
+        get() = testClass.keepMocks || testMethod.keepMocks ||
+                getConfigurationParameter(KEEP_MOCKS_PROPERTY).map { it.toBoolean() }.orElse(false)
+
+    private val Optional<out AnnotatedElement>.keepMocks
+        get() = map { it.getAnnotation(KeepMocks::class.java) != null }
+            .orElse(false)
+
+    /***
+     * Prevent calling [unmockkAll] after each test execution
+     */
+    @Inherited
+    @Retention(AnnotationRetention.RUNTIME)
+    @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+    annotation class KeepMocks
+
+    companion object {
+        const val KEEP_MOCKS_PROPERTY = "mockk.junit.extension.keepmocks"
     }
+
 }

mockk/jvm/src/test/kotlin/io/mockk/junit5/MockKExtensionAfterAllTestTest.kt

@@ -0,0 +1,72 @@
+package io.mockk.junit5
+
+import io.mockk.isMockKMock
+import io.mockk.junit5.MockKExtension.Companion.KEEP_MOCKS_PROPERTY
+import io.mockk.mockkObject
+import io.mockk.unmockkObject
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.AfterAllCallback
+import org.junit.jupiter.api.extension.BeforeAllCallback
+import org.junit.jupiter.api.extension.ExtendWith
+import org.junit.jupiter.api.extension.ExtensionContext
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+abstract class MockKExtensionAfterAllTestTest {
+
+    @Test
+    open fun prepareAfterAllUnmockTest() {
+        mockkObject(TestMock)
+        assertTrue(isMockKMock(TestMock, objectMock = true))
+    }
+
+    @ExtendWith(CheckIsNotMock::class, MockKExtension::class)
+    class AfterAllClearMocks : MockKExtensionAfterAllTestTest()
+
+    @MockKExtension.KeepMocks
+    @ExtendWith(CheckIsStillMock::class, MockKExtension::class)
+    class AnnotatedClassAfterAllKeepMocks : MockKExtensionAfterAllTestTest()
+
+    @ExtendWith(CheckIsStillMock::class, MockKExtension::class)
+    class AnnotatedMethodAfterAllKeepMocks : MockKExtensionAfterAllTestTest() {
+
+        @MockKExtension.KeepMocks
+        override fun prepareAfterAllUnmockTest() = super.prepareAfterAllUnmockTest()
+
+    }
+
+    @ExtendWith(CheckIsStillMock::class, PropertyExtension::class, MockKExtension::class)
+    class PropertyAfterAllKeepMocks : MockKExtensionAfterAllTestTest()
+
+    object TestMock
+
+    class CheckIsNotMock : AfterAllCallback {
+
+        override fun afterAll(context: ExtensionContext) {
+            assertFalse(isMockKMock(TestMock, objectMock = true))
+        }
+
+    }
+
+    class CheckIsStillMock : AfterAllCallback {
+
+        override fun afterAll(context: ExtensionContext) {
+            assertTrue(isMockKMock(TestMock, objectMock = true))
+            unmockkObject(TestMock)
+        }
+
+    }
+
+    class PropertyExtension : BeforeAllCallback, AfterAllCallback {
+
+        override fun beforeAll(context: ExtensionContext?) {
+            System.setProperty(KEEP_MOCKS_PROPERTY, "true")
+        }
+
+        override fun afterAll(context: ExtensionContext) {
+            System.clearProperty(KEEP_MOCKS_PROPERTY)
+        }
+
+    }
+
+}

mockk/jvm/src/test/kotlin/io/mockk/junit5/MockKExtensionTest.kt

@@ -1,18 +1,15 @@
 @file:Suppress("UNUSED_PARAMETER")
+
 package io.mockk.junit5
 
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
 import io.mockk.impl.annotations.RelaxedMockK
 import io.mockk.impl.annotations.SpyK
-import io.mockk.isMockKMock
-import io.mockk.mockkObject
 import io.mockk.verify
-import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import kotlin.test.assertEquals
-import kotlin.test.assertFalse
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
@@ -55,10 +52,10 @@ class MockKExtensionTest {
     fun injectsValidMockInMethods(@MockK car: Car) {
         every {
             car.recordTelemetry(
-                    speed = more(50),
-                    direction = Direction.NORTH,
-                    lat = any(),
-                    long = any()
+                speed = more(50),
+                direction = Direction.NORTH,
+                lat = any(),
+                long = any()
             )
         } returns Outcome.RECORDED
 
@@ -71,10 +68,10 @@ class MockKExtensionTest {
     fun injectsValidMockInClass() {
         every {
             car2.recordTelemetry(
-                    speed = more(50),
-                    direction = Direction.NORTH,
-                    lat = any(),
-                    long = any()
+                speed = more(50),
+                direction = Direction.NORTH,
+                lat = any(),
+                long = any()
             )
         } returns Outcome.RECORDED
 
@@ -106,19 +103,4 @@ class MockKExtensionTest {
         verify { carSpy.relaxedTest() }
     }
 
-    companion object {
-        object TestMock
-
-        @AfterAll
-        @JvmStatic
-        internal fun afterAll() {
-            assertFalse(isMockKMock(TestMock, objectMock = true))
-        }
-    }
-
-    @Test
-    fun prepareAfterAllUnmockTest() {
-        mockkObject(TestMock)
-        assertTrue(isMockKMock(TestMock, objectMock = true))
-    }
 }