Don't check unused or unexpected stubs for lenient mocks

core/src/main/scala/org/mockito/MockitoScalaSession.scala

@@ -1,20 +1,20 @@
 package org.mockito
 
-import org.mockito.MockitoScalaSession.{MockitoScalaSessionListener, UnexpectedInvocations}
-import org.mockito.exceptions.misusing.{UnexpectedInvocationException, UnnecessaryStubbingException}
+import org.mockito.MockitoScalaSession.{ MockitoScalaSessionListener, UnexpectedInvocations }
+import org.mockito.exceptions.misusing.{ UnexpectedInvocationException, UnnecessaryStubbingException }
 import org.mockito.internal.stubbing.StubbedInvocationMatcher
-import org.mockito.invocation.{DescribedInvocation, Invocation, Location}
+import org.mockito.invocation.{ DescribedInvocation, Invocation, Location }
 import org.mockito.listeners.MockCreationListener
 import org.mockito.mock.MockCreationSettings
 import org.mockito.quality.Strictness
 import org.mockito.quality.Strictness.STRICT_STUBS
 import org.mockito.session.MockitoSessionLogger
 
-import scala.collection.mutable
 import scala.collection.JavaConverters._
+import scala.collection.mutable
 
 class MockitoScalaSession(name: String, strictness: Strictness, logger: MockitoSessionLogger) {
-  private val listener       = new MockitoScalaSessionListener
+  private val listener       = new MockitoScalaSessionListener(strictness)
   private val mockitoSession = Mockito.mockitoSession().name(name).logger(logger).strictness(strictness).startMocking()
 
   Mockito.framework().addListener(listener)
@@ -110,7 +110,7 @@ object MockitoScalaSession {
     def report(): Unit = if (nonEmpty) throw new UnnecessaryStubbingException(toString)
   }
 
-  class MockitoScalaSessionListener extends MockCreationListener {
+  class MockitoScalaSessionListener(strictness: Strictness) extends MockCreationListener {
     def reportIssues(): Seq[Reporter] = {
       val mockDetails = mocks.toSet.map(MockitoSugar.mockingDetails)
 
@@ -138,7 +138,7 @@ object MockitoScalaSession {
     private val mocks = mutable.Set.empty[AnyRef]
 
     override def onMockCreated(mock: AnyRef, settings: MockCreationSettings[_]): Unit =
-      if (!settings.isLenient) mocks += mock
+      if (!settings.isLenient && strictness != Strictness.LENIENT) mocks += mock
   }
 }
 

core/src/test/scala/org/mockito/MockitoScalaSessionTest.scala

@@ -3,6 +3,7 @@ package org.mockito
 import org.scalatest
 import org.mockito.exceptions.misusing.{PotentialStubbingProblem, UnexpectedInvocationException, UnnecessaryStubbingException}
 import org.mockito.exceptions.verification.SmartNullPointerException
+import org.mockito.quality.Strictness
 import org.scalatest.{OptionValues, WordSpec}
 
 //noinspection RedundantDefaultArgument
@@ -175,7 +176,7 @@ class MockitoScalaSessionTest extends WordSpec with IdiomaticMockito with scalat
       }
     }
 
-    "don't check unused stubs for lenient mocks" in {
+    "don't check unexpected stubs for lenient mocks" in {
       MockitoScalaSession().run {
         val foo = mock[Foo](withSettings.lenient())
 
@@ -186,7 +187,76 @@ class MockitoScalaSessionTest extends WordSpec with IdiomaticMockito with scalat
         foo.bar("paco")
       }
     }
+    "check unexpected stubs for lenient mocks" in {
+      intercept[UnexpectedInvocationException] {
+        MockitoScalaSession().run {
+          val foo = mock[Foo]
+
+          foo.bar("pepe") shouldReturn "mocked"
+
+          foo.bar("pepe")
+
+          foo.bar("paco")
+        }
+      }
+    }
+
+    "don't check unexpected stubs in lenient setting" in {
+      MockitoScalaSession(strictness = Strictness.LENIENT).run {
+        val foo = mock[Foo]
+
+        foo.bar("pepe") shouldReturn "mocked"
+
+        foo.bar("pepe")
+
+        foo.bar("paco")
+      }
+    }
+    "check unexpected stubs in lenient setting" in {
+      intercept[UnexpectedInvocationException] {
+        MockitoScalaSession().run {
+          val foo = mock[Foo]
+
+          foo.bar("pepe") shouldReturn "mocked"
 
+          foo.bar("pepe")
+
+          foo.bar("paco")
+        }
+      }
+    }
+
+    "don't check unused stubs for lenient mocks" in {
+      MockitoScalaSession().run {
+        val foo = mock[Foo](withSettings.lenient())
+        foo.bar("pepe") shouldReturn "mocked"
+      }
+    }
+
+    "check unused stubs for not lenient mocks" in {
+      intercept[UnnecessaryStubbingException] {
+        MockitoScalaSession().run {
+          val foo = mock[Foo]
+          foo.bar("pepe") shouldReturn "mocked"
+        }
+      }
+    }
+
+    "don't check unused stubs in lenient setting" in {
+      MockitoScalaSession(strictness = Strictness.LENIENT).run {
+        val foo = mock[Foo]
+        foo.bar("pepe") shouldReturn "mocked"
+      }
+    }
+
+    "check unused stubs in not lenient setting" in {
+      intercept[UnnecessaryStubbingException] {
+        MockitoScalaSession(strictness = Strictness.STRICT_STUBS).run {
+          val foo = mock[Foo]
+          foo.bar("pepe") shouldReturn "mocked"
+        }
+      }
+    }
     "work with nested deep stubs" in {
       MockitoScalaSession().run {
         val foo = mock[Foo](ReturnsDeepStubs)