Mockito Syntactic Sugar for Scala

Mocks.scala

package misc

import org.mockito.MockSettings
import org.mockito.Mockito.{mock => mockitoMock}
import org.mockito.invocation.InvocationOnMock
import org.mockito.stubbing.Answer
import org.mockito.verification.VerificationMode

import scala.reflect.{Manifest, ClassTag}

trait Mocks {

  def mock[T <: AnyRef](implicit manifest: Manifest[T]): T =
    mockitoMock(manifest.erasure.asInstanceOf[Class[T]])

  def mock[T <: AnyRef](defaultAnswer: Answer[_])(implicit manifest: Manifest[T]): T =
    mockitoMock(manifest.erasure.asInstanceOf[Class[T]], defaultAnswer)

  def mock[T <: AnyRef](mockSettings: MockSettings)(implicit manifest: Manifest[T]): T =
    mockitoMock(manifest.erasure.asInstanceOf[Class[T]], mockSettings)

  def mock[T <: AnyRef](name: String)(implicit manifest: Manifest[T]): T =
    mockitoMock(manifest.erasure.asInstanceOf[Class[T]], name)

  def timeout(millis: Int) =
    org.mockito.Mockito.timeout(millis)

  def mockingDetails(toInspect: scala.Any) =
    org.mockito.Mockito.mockingDetails(toInspect)

  def doThrow(toBeThrown: Throwable) =
    org.mockito.Mockito.doThrow(toBeThrown)

  def verifyZeroInteractions(mocks: AnyRef*) =
    org.mockito.Mockito.verifyZeroInteractions(mocks: _*)

  def calls(wantedNumberOfInvocations: Int) =
    org.mockito.Mockito.calls(wantedNumberOfInvocations)

  def doThrow(toBeThrown: Class[_ <: Throwable]) =
    org.mockito.Mockito.doThrow(toBeThrown)

  def times(wantedNumberOfInvocations: Int) =
    org.mockito.Mockito.times(wantedNumberOfInvocations)

  def inOrder(mocks: AnyRef*) =
    org.mockito.Mockito.inOrder(mocks: _*)

  def atLeast(minNumberOfInvocations: Int) =
    org.mockito.Mockito.atLeast(minNumberOfInvocations)

  def stub[T](methodCall: T) =
    org.mockito.Mockito.stub(methodCall)

  def only() =
    org.mockito.Mockito.only()

  def doReturn(toBeReturned: scala.Any) =
    org.mockito.Mockito.doReturn(toBeReturned)

  def atMost(maxNumberOfInvocations: Int) =
    org.mockito.Mockito.atMost(maxNumberOfInvocations)

  def ignoreStubs(mocks: AnyRef*) =
    org.mockito.Mockito.ignoreStubs(mocks: _*)

  def reset[T](mocks: T*) =
    org.mockito.Mockito.reset(mocks: _*)

  def doCallRealMethod() =
    org.mockito.Mockito.doCallRealMethod()

  def spy[T](`object`: T) =
    org.mockito.Mockito.spy(`object`)

  def when[T](methodCall: T) =
    org.mockito.Mockito.when(methodCall)

  def verify[T](mock: T) =
    org.mockito.Mockito.verify(mock)

  def never() =
    org.mockito.Mockito.never()

  def doAnswer(answer: Answer[_]) =
    org.mockito.Mockito.doAnswer(answer)

  def verify[T](mock: T, mode: VerificationMode) =
    org.mockito.Mockito.verify(mock, mode)

  def validateMockitoUsage() =
    org.mockito.Mockito.validateMockitoUsage()

  def atLeastOnce() =
    org.mockito.Mockito.atLeastOnce()

  def verifyNoMoreInteractions(mocks: AnyRef*) =
    org.mockito.Mockito.verifyNoMoreInteractions(mocks: _*)

  def doNothing() =
    org.mockito.Mockito.doNothing()

  def withSettings() =
    org.mockito.Mockito.withSettings()

  def isA[T: ClassTag] =
    org.mockito.Matchers.isA(implicitly[ClassTag[T]].runtimeClass.asInstanceOf[Class[T]])
    
  // Scala 2.12 Single Abstract Method types (https://github.com/scala/scala/pull/4971) will make this unnecessary.
  implicit def toAnswer[T](thunk: InvocationOnMock ⇒ T): Answer[T] =
    new Answer[T] {
    def answer(invocation: InvocationOnMock) =
      thunk(invocation)
  }

}