Add support to mock object methods (#297)

* Update Dependencies

* Add support to mock object methods

Author: ultrasecreth

.scalafmt.conf

@@ -7,5 +7,5 @@ spaces.inImportCurlyBraces = true
 indentOperator = spray
 unindentTopLevelOperators = true
 
-version=2.6.4
+version=2.7.2
 

README.md

@@ -748,6 +748,35 @@ val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) raises Error("er
 val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) returns Left(Error("error"))
 ```
 
+## Mocking Scala `object`
+
+Since version 1.16.0 it is possible to mock `object` methods, given that such definitions are global, the way to mock them is sligtly different in order to ensure we restore the real implementation of the object after we are done
+Example:
+
+```scala
+object FooObject {
+  def simpleMethod: String = "not mocked!"
+}
+
+"mock" should {
+    "stub an object method" in {
+      FooObject.simpleMethod shouldBe "not mocked!"
+
+      withObjectMocked[FooObject.type] {
+        FooObject.simpleMethod returns "mocked!"
+        //or
+        when(FooObject.simpleMethod) thenReturn "mocked!"
+
+        FooObject.simpleMethod shouldBe "mocked!"
+      }
+
+      FooObject.simpleMethod shouldBe "not mocked!"
+    }
+}
+```
+
+As you can see, the effect of the mocking is only available inside the code block passed to `withObjectMocked`, when such block ends the behavior of the object is restored to its original implementation
+
 
 ## Notes
 

common/src/main/scala/org/mockito/MockitoAPI.scala

@@ -68,8 +68,8 @@ private[mockito] trait DoSomething {
    * match argument types (`Type`)}}}
    */
   def doReturn[T: ValueClassExtractor](toBeReturned: T, toBeReturnedNext: T*): Stubber =
-    toBeReturnedNext.foldLeft(Mockito.doAnswer(ScalaReturns(toBeReturned))) {
-      case (s, v) => s.doAnswer(ScalaReturns(v))
+    toBeReturnedNext.foldLeft(Mockito.doAnswer(ScalaReturns(toBeReturned))) { case (s, v) =>
+      s.doAnswer(ScalaReturns(v))
     }
 
   /**
@@ -616,6 +616,17 @@ private[mockito] trait MockitoEnhancer extends MockCreator {
    * they are created as final classes by the compiler
    */
   def spyLambda[T <: AnyRef: ClassTag](realObj: T): T = Mockito.mock(clazz, AdditionalAnswers.delegatesTo(realObj))
+
+  /**
+   * Mocks the specified object only for the context of the block
+   */
+  def withObjectMocked[O <: AnyRef: ClassTag](block: => Any): Unit = {
+    val moduleField = clazz[O].getDeclaredField("MODULE$")
+    val realImpl    = moduleField.get(null)
+    ReflectionUtils.setFinalStatic(moduleField, mock[O])
+    try block
+    finally ReflectionUtils.setFinalStatic(moduleField, realImpl)
+  }
 }
 
 private[mockito] trait Verifications {

common/src/main/scala/org/mockito/ReflectionUtils.scala

@@ -1,6 +1,6 @@
 package org.mockito
 
-import java.lang.reflect.Method
+import java.lang.reflect.{ Field, Method, Modifier }
 
 import org.mockito.internal.ValueClassWrapper
 import org.mockito.invocation.InvocationOnMock
@@ -122,4 +122,12 @@ object ReflectionUtils {
         .toOption
         .getOrElse(Seq.empty)
     }
+
+  def setFinalStatic(field: Field, newValue: Any) = {
+    field.setAccessible(true)
+    val modifiersField = classOf[Field].getDeclaredField("modifiers")
+    modifiersField.setAccessible(true)
+    modifiersField.setInt(field, field.getModifiers & ~Modifier.FINAL)
+    field.set(null, newValue)
+  }
 }

common/src/main/scala/org/mockito/internal/invocation/ScalaInvocation.scala

@@ -53,9 +53,9 @@ class ScalaInvocation(
     other match {
       case that: ScalaInvocation =>
         super.equals(that) &&
-        getMock == that.getMock &&
-        mockitoMethod == that.mockitoMethod &&
-        (arguments sameElements that.arguments)
+          getMock == that.getMock &&
+          mockitoMethod == that.mockitoMethod &&
+          (arguments sameElements that.arguments)
       case _ => false
     }
   override def hashCode(): Int = {

common/src/main/scala/org/mockito/stubbing/ScalaBaseStubbing.scala

@@ -12,17 +12,17 @@ abstract class ScalaBaseStubbing[T: ValueClassExtractor] {
   protected def delegate: OngoingStubbing[T]
 
   protected def _thenReturn(value: T, values: Seq[T]): ScalaOngoingStubbing[T] =
-    values.foldLeft(delegate.thenAnswer(ScalaReturns(value))) {
-      case (s, v) => s.thenAnswer(ScalaReturns(v))
+    values.foldLeft(delegate.thenAnswer(ScalaReturns(value))) { case (s, v) =>
+      s.thenAnswer(ScalaReturns(v))
     }
 
   private def thenThrow(t: Throwable): ScalaOngoingStubbing[T] = delegate thenAnswer new ScalaThrowsException(t)
 
   protected def _thenThrow(throwables: Seq[Throwable]): ScalaOngoingStubbing[T] =
     if (throwables == null || throwables.isEmpty) thenThrow(null)
     else
-      throwables.tail.foldLeft(thenThrow(throwables.head)) {
-        case (os, t) => os andThenThrow t
+      throwables.tail.foldLeft(thenThrow(throwables.head)) { case (os, t) =>
+        os andThenThrow t
       }
 
   protected def _thenThrow[E <: Throwable: ClassTag]: ScalaOngoingStubbing[T] = thenThrow((new ObjenesisStd).newInstance(clazz))

common/src/test/scala/org/mockito/matchers/MatcherProps.scala

@@ -14,20 +14,19 @@ class MatcherProps extends Properties("matchers") {
   import Generators._
 
   property("AllOf") = forAll(chooseNum(0, 8))(length =>
-    forAll(listOfN(length, arbitrary[ArgumentMatcher[MiniInt]]), arbitrary[MiniInt]) {
-      case (matchers, value) =>
-        val allOf     = AllOf(matchers: _*)
-        val stringRep = allOf.toString
-
-        classify(allOf.matches(value), "matches", "doesn't match") {
-          (allOf.matches(value) ?= matchers.forall(_.matches(value))) :| "matches all underlying" &&
-          matchers.iff {
-            case Nil            => stringRep ?= "<any>"
-            case matcher :: Nil => stringRep ?= matcher.toString()
-            case _              => stringRep ?= s"allOf(${matchers.mkString(", ")})"
-          } :| "renders to string correctly"
-
-        }
+    forAll(listOfN(length, arbitrary[ArgumentMatcher[MiniInt]]), arbitrary[MiniInt]) { case (matchers, value) =>
+      val allOf     = AllOf(matchers: _*)
+      val stringRep = allOf.toString
+
+      classify(allOf.matches(value), "matches", "doesn't match") {
+        (allOf.matches(value) ?= matchers.forall(_.matches(value))) :| "matches all underlying" &&
+        matchers.iff {
+          case Nil            => stringRep ?= "<any>"
+          case matcher :: Nil => stringRep ?= matcher.toString()
+          case _              => stringRep ?= s"allOf(${matchers.mkString(", ")})"
+        } :| "renders to string correctly"
+
+      }
     }
   )
 

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

@@ -36,8 +36,11 @@ class MockitoScalaSession(name: String, strictness: Strictness, logger: MockitoS
         mockitoSession.finishMocking(e)
         listener.reportIssues().foreach {
           case unStubbedCalls: UnexpectedInvocations if unStubbedCalls.nonEmpty =>
-            throw new UnexpectedInvocationException(s"""A NullPointerException was thrown, check if maybe related to
-                   |$unStubbedCalls""".stripMargin, e)
+            throw new UnexpectedInvocationException(
+              s"""A NullPointerException was thrown, check if maybe related to
+                   |$unStubbedCalls""".stripMargin,
+              e
+            )
           case _ => throw e
         }
       case other =>
@@ -72,8 +75,8 @@ object MockitoScalaSession {
     override def toString: String =
       if (nonEmpty) {
         val locations = invocations.zipWithIndex
-          .map {
-            case (invocation, idx) => s"${idx + 1}. $invocation ${invocation.getLocation}"
+          .map { case (invocation, idx) =>
+            s"${idx + 1}. $invocation ${invocation.getLocation}"
           }
           .mkString("\n")
         s"""Unexpected invocations found
@@ -92,8 +95,8 @@ object MockitoScalaSession {
     override def toString: String =
       if (nonEmpty) {
         val locations = stubbings.zipWithIndex
-          .map {
-            case (stubbing, idx) => s"${idx + 1}. $stubbing ${stubbing.getLocation}"
+          .map { case (stubbing, idx) =>
+            s"${idx + 1}. $stubbing ${stubbing.getLocation}"
           }
           .mkString("\n")
         s"""Unnecessary stubbings detected.
@@ -113,8 +116,8 @@ object MockitoScalaSession {
     lazy val stubbings: Set[StubbedInvocationMatcher] =
       mockDetails
         .flatMap(_.getStubbings.asScala)
-        .collect {
-          case s: StubbedInvocationMatcher => s
+        .collect { case s: StubbedInvocationMatcher =>
+          s
         }
 
     lazy val invocations: Set[Invocation] = mockDetails.flatMap(_.getInvocations.asScala)
@@ -140,11 +143,10 @@ object MockitoScalaSession {
       stubbings
         .filterNot(_.wasUsed())
         .flatMap(s => lenientStubbings.find(_.getMethod === s.getMethod).map(s -> _))
-        .foreach {
-          case (stubbing, lenient) =>
-            stubbing.markStubUsed(new DescribedInvocation {
-              override def getLocation: Location = lenient.getLocation
-            })
+        .foreach { case (stubbing, lenient) =>
+          stubbing.markStubUsed(new DescribedInvocation {
+            override def getLocation: Location = lenient.getLocation
+          })
         }
     }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

macro/src/main/scala/org/mockito/DoSomethingMacro.scala

@@ -189,8 +189,8 @@ object DoSomethingMacro {
     else if (pf.isDefinedAt(invocation.children.last)) {
       val values = invocation.children
         .dropRight(1)
-        .collect {
-          case q"$_ val $name:$_ = $value" => name.toString -> value.asInstanceOf[c.Tree]
+        .collect { case q"$_ val $name:$_ = $value" =>
+          name.toString -> value.asInstanceOf[c.Tree]
         }
         .toMap
 

macro/src/main/scala/org/mockito/VerifyMacro.scala

@@ -64,8 +64,8 @@ private[mockito] trait VerificationMacroTransformer {
     else if (invocation.children.nonEmpty && pf.isDefinedAt(invocation.children.last)) {
       val values = invocation.children
         .dropRight(1)
-        .collect {
-          case q"$_ val $name:$_ = $value" => name.toString -> value.asInstanceOf[c.Tree]
+        .collect { case q"$_ val $name:$_ = $value" =>
+          name.toString -> value.asInstanceOf[c.Tree]
         }
         .toMap
 

macro/src/main/scala/org/mockito/WhenMacro.scala

@@ -24,8 +24,8 @@ object WhenMacro {
     else if (pf.isDefinedAt(invocation.children.last)) {
       val values = invocation.children
         .dropRight(1)
-        .collect {
-          case q"$_ val $name:$_ = $value" => name.toString -> value.asInstanceOf[c.Tree]
+        .collect { case q"$_ val $name:$_ = $value" =>
+          name.toString -> value.asInstanceOf[c.Tree]
         }
         .toMap
 

macro/src/main/scala/org/mockito/captor/Captor.scala

@@ -18,8 +18,8 @@ trait Captor[T] {
   def values: List[T]
 
   def hasCaptured(expectations: T*)(implicit $eq: Equality[T]): Unit =
-    expectations.zip(values).foreach {
-      case (e, v) => if (e !== v) throw new ArgumentsAreDifferent(s"Got [$v] instead of [$e]")
+    expectations.zip(values).foreach { case (e, v) =>
+      if (e !== v) throw new ArgumentsAreDifferent(s"Got [$v] instead of [$e]")
     }
 }
 

project/Dependencies.scala

@@ -2,7 +2,7 @@ import sbt._
 
 object Dependencies {
 
-  val scalatestVersion = "3.2.1"
+  val scalatestVersion = "3.2.2"
 
   val commonLibraries = Seq(
     "org.mockito"   % "mockito-core"      % "3.5.13",
@@ -25,5 +25,5 @@ object Dependencies {
   val scalaz = "org.scalaz"    %% "scalaz-core" % "7.3.2"   % "provided"
 
   val catsLaws = "org.typelevel" %% "cats-laws" % "2.0.0"
-  val disciplineScalatest = "org.typelevel" %% "discipline-scalatest" % "2.0.0"
+  val disciplineScalatest = "org.typelevel" %% "discipline-scalatest" % "2.0.1"
 }

scalatest/src/test/scala/user/org/mockito/IdiomaticStubbingTest.scala

@@ -1,15 +1,15 @@
 package user.org.mockito
 
+import java.lang.reflect.{ Field, Modifier }
 import java.util.concurrent.atomic.AtomicInteger
 
-import org.mockito.ArgumentMatchersSugar
-import org.mockito.IdiomaticStubbing
 import org.mockito.invocation.InvocationOnMock
+import org.mockito.{ clazz, ArgumentMatchersSugar, IdiomaticStubbing }
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
-import user.org.mockito.matchers.ValueCaseClassInt
-import user.org.mockito.matchers.ValueCaseClassString
-import user.org.mockito.matchers.ValueClass
+import user.org.mockito.matchers.{ ValueCaseClassInt, ValueCaseClassString, ValueClass }
+
+import scala.reflect.ClassTag
 
 class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatchersSugar with IdiomaticMockitoTestSetup with IdiomaticStubbing {
 
@@ -302,5 +302,16 @@ class IdiomaticStubbingTest extends AnyWordSpec with Matchers with ArgumentMatch
       mocked(*) returns "123"
       mocked("key") shouldBe "123"
     }
+
+    "stub an object method" in {
+      FooObject.simpleMethod shouldBe "not mocked!"
+
+      withObjectMocked[FooObject.type] {
+        FooObject.simpleMethod returns "mocked!"
+        FooObject.simpleMethod shouldBe "mocked!"
+      }
+
+      FooObject.simpleMethod shouldBe "not mocked!"
+    }
   }
 }

scalatest/src/test/scala/user/org/mockito/MockitoSugarTest.scala

@@ -432,6 +432,17 @@ class MockitoSugarTest extends AnyWordSpec with MockitoSugar with Matchers with
 
       verify(aMock).varargMethod("hola", 1, 2, 3)
     }
+
+    "stub an object method" in {
+      FooObject.simpleMethod shouldBe "not mocked!"
+
+      withObjectMocked[FooObject.type] {
+        when(FooObject.simpleMethod) thenReturn "mocked!"
+        FooObject.simpleMethod shouldBe "mocked!"
+      }
+
+      FooObject.simpleMethod shouldBe "not mocked!"
+    }
   }
 
   "spyLambda[T]" should {

scalatest/src/test/scala/user/org/mockito/PostfixVerificationsTest.scala

@@ -683,11 +683,11 @@ class PostfixVerificationsTest extends AnyWordSpec with IdiomaticMockitoTestSetu
       "answersPF" in {
         val org = orgDouble()
 
-        org.doSomethingWithThisInt(*) answersPF {
-          case i: Int => i * 10 + 2
+        org.doSomethingWithThisInt(*) answersPF { case i: Int =>
+          i * 10 + 2
         }
-        org.doSomethingWithThisIntAndString(*, *) answersPF {
-          case (i: Int, s: String) => (i * 10 + s.toInt).toString
+        org.doSomethingWithThisIntAndString(*, *) answersPF { case (i: Int, s: String) =>
+          (i * 10 + s.toInt).toString
         }
         org.doSomethingWithThisIntAndStringAndBoolean(*, *, *) answersPF {
           case (i: Int, s: String, true)  => (i * 10 + s.toInt).toString + " verdadero"

scalatest/src/test/scala/user/org/mockito/PrefixExpectationsTest.scala

@@ -707,11 +707,11 @@ class PrefixExpectationsTest extends AnyWordSpec with Matchers with ArgumentMatc
       "answersPF" in {
         val org = orgDouble()
 
-        org.doSomethingWithThisInt(*) answersPF {
-          case i: Int => i * 10 + 2
+        org.doSomethingWithThisInt(*) answersPF { case i: Int =>
+          i * 10 + 2
         }
-        org.doSomethingWithThisIntAndString(*, *) answersPF {
-          case (i: Int, s: String) => (i * 10 + s.toInt).toString
+        org.doSomethingWithThisIntAndString(*, *) answersPF { case (i: Int, s: String) =>
+          (i * 10 + s.toInt).toString
         }
         org.doSomethingWithThisIntAndStringAndBoolean(*, *, *) answersPF {
           case (i: Int, s: String, true)  => (i * 10 + s.toInt).toString + " verdadero"

scalatest/src/test/scala/user/org/mockito/TestModel.scala

@@ -126,3 +126,7 @@ class TestController(org: Org) {
   def async(f: => Int): Int = f
   def test(id: Int)         = async(org.doSomethingWithThisInt(id))
 }
+
+object FooObject {
+  def simpleMethod: String = "not mocked!"
+}

version.properties

@@ -1,4 +1,4 @@
 #Version of the produced binaries. This file is intended to be checked-in.
 #It will be automatically bumped by release automation.
-version=1.15.2
+version=1.16.0
 previousVersion=1.15.1