Make ByName arguments an experimental feature

Author: ultrasecreth

README.md

@@ -23,11 +23,6 @@ The library has independent developers, release cycle and versioning from core m
 *   Repositories: [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cmockito-scala_2.12) or [JFrog's Bintray](https://bintray.com/mockito/maven/mockito-scala)
 
 
-**IMPORTANT!** mockito-scala will pull the right version of mockito-core as a transitive dependency, 
-but if for some reason you'd like to have both libraries explicitly declared in your build file, please make sure
-you declare mockito-core first, as we currently rely on a class loader hack to make by-name arguments work.
-
-
 For a more detailed explanation of the features please read [this](https://medium.com/@bbonanno_83496/introduction-to-mockito-scala-ede30769cbda) article series
 
 
@@ -43,7 +38,7 @@ This trait wraps the API available on `org.mockito.Mockito` from the Java versio
 *   Eliminates parenthesis when possible to make the test code more readable
 *   Adds `spyLambda[T]` to allow spying lambdas (they don't work with the standard spy as they are created as final classes by the compiler)
 *   Supports mocking inline mixins like `mock[MyClass with MyTrait]`
-*   Supports by-name arguments in some scenarios
+*   Supports by-name arguments in some scenarios [EXPERIMENTAL](#experimental-features)
     *   Full support when all arguments in a method are by-name
     *   Full support when only some arguments in a method are by-name, but we use the `any[T]` matcher for every argument
     *   Full support when only some arguments in a method are by-name, but we use NO matchers at all
@@ -75,6 +70,25 @@ The matchers for the value classes always require the type to be explicit, apart
    verify(myObj).myMethod(eqToVal[MyValueClass](456))
    ```
 
+## Experimental features
+
+* **by-name** arguments is currently an experimental feature as the implementation is a bit hacky and it gave some people problems
+
+If you want to use it, you have to mix-in an extra trait (`org.mockito.ByNameExperimental`) 
+in your test class, after `org.mockito.MockitoSugar`, so your test file would look like
+
+```
+class MyTest extends WordSpec with MockitoSugar with ByNameExperimental
+```
+
+It is important to notice that this feature relies on the class loader order to work, as we currently have to override a class
+from `mockito-core`, you should not have to do anything special to make it work, `mockito-scala` already pulls the right 
+version of `mockito-core` as a transitive dependency and it should be the only dependency you need, **BUT**, if you start getting 
+weird exceptions while trying to use `org.mockito.ByNameExperimental` you can try to be explicit with the `mockito-core` dependency.
+I can't tell you if you should put it before or after the `mockito-scala` dependency in your build file as it depends a lot
+on which build tool and IDE you use, so try it out.
+
+We are working with the mockito-core developers to add the necessary features in it so we can get rid of this hack as soon as we can, stay tuned!
 
 ## Authors
 

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

@@ -20,6 +20,22 @@ import scala.collection.JavaConverters._
 import scala.reflect.ClassTag
 import scala.reflect.runtime.universe.TypeTag
 
+private[mockito] trait MockCreator {
+  def mock[T <: AnyRef: ClassTag: TypeTag]: T
+  def mock[T <: AnyRef: ClassTag: TypeTag](defaultAnswer: Answer[_]): T
+  def mock[T <: AnyRef: ClassTag: TypeTag](mockSettings: MockSettings): T
+  def mock[T <: AnyRef: ClassTag: TypeTag](name: String): T
+}
+
+trait ByNameExperimental extends MockCreator {
+
+  abstract override def mock[T <: AnyRef: ClassTag: TypeTag](mockSettings: MockSettings): T = {
+    ReflectionUtils.markMethodsWithLazyArgs(clazz)
+    super.mock[T](mockSettings)
+  }
+
+}
+
 private[mockito] trait DoSomething {
 
   /**
@@ -67,7 +83,7 @@ private[mockito] trait DoSomething {
   def doAnswer(answer: Answer[_]): Stubber = Mockito.doAnswer(answer)
 }
 
-private[mockito] trait MockitoEnhancer {
+private[mockito] trait MockitoEnhancer extends MockCreator {
 
   /**
    * Delegates to <code>Mockito.mock(type: Class[T])</code>
@@ -83,7 +99,7 @@ private[mockito] trait MockitoEnhancer {
    * <code>verify(aMock).iHaveSomeDefaultArguments("I'm not gonna pass the second argument", "default value")</code>
    * as the value for the second parameter would have been null...
    */
-  def mock[T <: AnyRef: ClassTag: TypeTag]: T = mock(withSettings)
+  override def mock[T <: AnyRef: ClassTag: TypeTag]: T = mock(withSettings)
 
   /**
    * Delegates to <code>Mockito.mock(type: Class[T], defaultAnswer: Answer[_])</code>
@@ -99,7 +115,7 @@ private[mockito] trait MockitoEnhancer {
    * <code>verify(aMock).iHaveSomeDefaultArguments("I'm not gonna pass the second argument", "default value")</code>
    * as the value for the second parameter would have been null...
    */
-  def mock[T <: AnyRef: ClassTag: TypeTag](defaultAnswer: Answer[_]): T =
+  override def mock[T <: AnyRef: ClassTag: TypeTag](defaultAnswer: Answer[_]): T =
     mock(withSettings.defaultAnswer(defaultAnswer))
 
   /**
@@ -116,11 +132,9 @@ private[mockito] trait MockitoEnhancer {
    * <code>verify(aMock).iHaveSomeDefaultArguments("I'm not gonna pass the second argument", "default value")</code>
    * as the value for the second parameter would have been null...
    */
-  def mock[T <: AnyRef: ClassTag: TypeTag](mockSettings: MockSettings): T = {
+  override def mock[T <: AnyRef: ClassTag: TypeTag](mockSettings: MockSettings): T = {
     val interfaces = ReflectionUtils.interfaces
 
-    ReflectionUtils.markMethodsWithLazyArgs(clazz)
-
     val settings =
       if (interfaces.nonEmpty) mockSettings.extraInterfaces(interfaces: _*)
       else mockSettings
@@ -142,8 +156,7 @@ private[mockito] trait MockitoEnhancer {
    * <code>verify(aMock).iHaveSomeDefaultArguments("I'm not gonna pass the second argument", "default value")</code>
    * as the value for the second parameter would have been null...
    */
-  def mock[T <: AnyRef: ClassTag: TypeTag](name: String): T =
-    mock(withSettings.name(name))
+  override def mock[T <: AnyRef: ClassTag: TypeTag](name: String): T = mock(withSettings.name(name))
 
   /**
    * Delegates to <code>Mockito.reset(T... mocks)</code>, but restores the default stubs that
@@ -157,8 +170,7 @@ private[mockito] trait MockitoEnhancer {
   /**
    * Delegates to <code>Mockito.mockingDetails()</code>, it's only here to expose the full Mockito API
    */
-  def mockingDetails(toInspect: AnyRef): MockingDetails =
-    Mockito.mockingDetails(toInspect)
+  def mockingDetails(toInspect: AnyRef): MockingDetails = Mockito.mockingDetails(toInspect)
 
   /**
    * Delegates to <code>Mockito.withSettings()</code>, it's only here to expose the full Mockito API
@@ -206,26 +218,22 @@ private[mockito] trait Verifications {
   /**
    * Delegates to <code>Mockito.times()</code>, it's only here to expose the full Mockito API
    */
-  def times(wantedNumberOfInvocations: Int): VerificationMode =
-    Mockito.times(wantedNumberOfInvocations)
+  def times(wantedNumberOfInvocations: Int): VerificationMode = Mockito.times(wantedNumberOfInvocations)
 
   /**
    * Delegates to <code>Mockito.calls()</code>, it's only here to expose the full Mockito API
    */
-  def calls(wantedNumberOfInvocations: Int): VerificationMode =
-    Mockito.calls(wantedNumberOfInvocations)
+  def calls(wantedNumberOfInvocations: Int): VerificationMode = Mockito.calls(wantedNumberOfInvocations)
 
   /**
    * Delegates to <code>Mockito.atMost()</code>, it's only here to expose the full Mockito API
    */
-  def atMost(maxNumberOfInvocations: Int): VerificationMode =
-    Mockito.atMost(maxNumberOfInvocations)
+  def atMost(maxNumberOfInvocations: Int): VerificationMode = Mockito.atMost(maxNumberOfInvocations)
 
   /**
    * Delegates to <code>Mockito.atLeast()</code>, it's only here to expose the full Mockito API
    */
-  def atLeast(minNumberOfInvocations: Int): VerificationMode =
-    Mockito.atLeast(minNumberOfInvocations)
+  def atLeast(minNumberOfInvocations: Int): VerificationMode = Mockito.atLeast(minNumberOfInvocations)
 }
 
 /**
@@ -268,8 +276,7 @@ trait MockitoSugar extends MockitoEnhancer with DoSomething with Verifications {
   /**
    * Delegates to <code>Mockito.ignoreStubs()</code>, it's only here to expose the full Mockito API
    */
-  def ignoreStubs(mocks: AnyRef*): Array[AnyRef] =
-    Mockito.ignoreStubs(mocks: _*)
+  def ignoreStubs(mocks: AnyRef*): Array[AnyRef] = Mockito.ignoreStubs(mocks: _*)
 
   /**
    * Delegates to <code>Mockito.validateMockitoUsage()</code>, it's only here to expose the full Mockito API
@@ -279,8 +286,7 @@ trait MockitoSugar extends MockitoEnhancer with DoSomething with Verifications {
   /**
    * Delegates to <code>Mockito.verifyZeroInteractions()</code>, it's only here to expose the full Mockito API
    */
-  def verifyZeroInteractions(mocks: AnyRef*): Unit =
-    Mockito.verifyZeroInteractions(mocks: _*)
+  def verifyZeroInteractions(mocks: AnyRef*): Unit = Mockito.verifyZeroInteractions(mocks: _*)
 
   /**
    * Delegates to <code>Mockito.inOrder()</code>, it's only here to expose the full Mockito API

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

@@ -3,7 +3,12 @@ package org.mockito
 import org.scalatest
 import org.scalatest.WordSpec
 
-class MockitoSugarTest extends WordSpec with MockitoSugar with scalatest.Matchers with ArgumentMatchersSugar {
+class MockitoSugarTest
+    extends WordSpec
+    with MockitoSugar
+    with scalatest.Matchers
+    with ArgumentMatchersSugar
+    with ByNameExperimental {
 
   class Foo {
     def bar = "not mocked"
@@ -17,7 +22,8 @@ class MockitoSugarTest extends WordSpec with MockitoSugar with scalatest.Matcher
 
     def iHaveFunction0Args(normal: String, f0: () => String): String = s"$normal - $f0"
 
-    def iHaveByNameAndFunction0Args(normal: String, f0: () => String, byName: => String): String = s"$normal - $byName - $f0"
+    def iHaveByNameAndFunction0Args(normal: String, f0: () => String, byName: => String): String =
+      s"$normal - $byName - $f0"
   }
 
   class Bar {