El parámetro especificado como no nulo es nulo cuando se usa Mokito anyObject () en la function Kotlin

Mi código de la siguiente manera se refiere a la solución en https://stackoverflow.com/a/30308199/3286489

import org.mockito.Mock import org.mockito.Mockito import org.mockito.MockitoAnnotations import org.mockito.Mockito.* class SimpleClassTest { private fun <T> anyObject(): T { Mockito.anyObject<T>() return uninitialized() } private fun <T> uninitialized(): T = null as T lateinit var simpleObject: SimpleClass @Mock lateinit var injectedObject: InjectedClass @Before fun setUp() { MockitoAnnotations.initMocks(this) } @Test fun testSimpleFunction() { simpleObject = SimpleClass(injectedObject) verify(injectedObject).settingDependentObject(anyObject()) } } 

Todavía tengo el siguiente error

 java.lang.IllegalArgumentException: Parameter specified as non-null is null: method my.package.InjectedClass.settingDependentObject, parameter dependentObject 

¿Yo me perdí algo?

ACTUALIZADO A continuación se muestra el código probado (forma y funcionamiento más sencillos)

 class SimpleClass(val injectedClass: InjectedClass) { fun simpleFunction() { injectedClass.settingDependentObject(DependentClass(Response.Builder().build())) } } open class DependentClass(response: Response) { } open class InjectedClass() { lateinit var dependentObject: DependentClass fun settingDependentObject(dependentObject: DependentClass) { this.dependentObject = dependentObject } } 

Por defecto, las classs y los miembros de Kotlin son finales . Mockito no puede burlarse de las classs o methods finales . Por lo tanto, cuando escribes:

 verify(injectedObject).settingDependentObject(anyObject()) 

se llama a la implementación real que requiere un argumento no nulo.

Para solucionarlo, abra su class y su método o, mejor aún, cambie SimpleClass para aceptar una interfaz como su argumento constructor y simular la interfaz.

Hay un proyecto específicamente para ayudar a lidiar con Kotlin "cerrado por defecto" en testings unitarias con Mockito. Para JUNIT, puede usar el kotlin-testrunner, que es una manera fácil de hacer que cualquier testing de Kotlin abra automáticamente las classs para probarlas a medida que las carga el cargador de classs. El uso es simple, solo agrega una anotación de @RunWith(KotlinTestRunner::class) , por ejemplo:

 @RunWith(KotlinTestRunner::class) class MyKotlinTestclass { @Test fun test() { ... } } 

Esto está completamente cubierto en el artículo Nunca diga final: burlarse de las classs de Kotlin en testings unitarias

Esto cubre su caso de uso de forma automática al permitir burlarse de todas las classs que de otro modo no se permitirían.

  • ¿Es posible usar doReturn () y CALLS_REAL_METHODS con mockito-kotlin?
  • burlarse de la respuesta anidada del server
  • Mockito querido pero no invocado
  • Error con los methods simulados
  • ¿Proporcionando object burlado a otro constructor de object falso?
  • java.lang.AbstractMethodError: método abstracto al ejecutar espresso en Kotlin con Mockito
  • Mocking methods de Kotlin con Java + Mockito
  • Mockito con Kotlin probando la falla asincrónica
  • nullPointerException en shanetworkingpreferences class auxiliar Al ejecutar una testing
  • Mockito ArgumentCaptor para la function de Kotlin
  • java.lang.reflect.InvocationTargetException al usar la biblioteca Kotlin-Mokito