Lanzar excepciones marcadas de simulacros con Mockito

Estoy tratando de que uno de mis objetos burlados arroje una excepción marcada cuando se llama a un método en particular. Estoy intentando lo siguiente.

@Test(expectedExceptions = SomeException.class)
public void throwCheckedException() {
    List<String> list = mock(List.class);
    when(list.get(0)).thenThrow(new SomeException());
    String test = list.get(0);
}

public class SomeException extends Exception {
}

Sin embargo, eso produce el siguiente error.

org.testng.TestException: 
Expected exception com.testing.MockitoCheckedExceptions$SomeException but got org.mockito.exceptions.base.MockitoException: 
Checked exception is invalid for this method!
Invalid: com.testing.MockitoCheckedExceptions$SomeException

Mirando la documentación de Mockito , solo usan RuntimeException, ¿no es posible lanzar Excepciones marcadas de un objeto simulado con Mockito?

Verifique la API de Java para la Lista .
Se get(int index)declara que el método arroja solo el IndexOutOfBoundExceptionque se extiende RuntimeException.
Estás tratando de decirle a Mockito que arroje una excepción SomeException()que no es válida para ser lanzada por esa llamada de método en particular .

Para aclarar más.
La interfaz de Lista no permite get(int index)que se arroje una Excepción marcada del método y es por eso que Mockito falla.
Cuando cree la Lista simulada, Mockito usará la definición de Lista .class para crear su simulación.

El comportamiento que está especificando con el when(list.get(0)).thenThrow(new SomeException()) no coincide con la firma del método en List API , porque el get(int index)método no arroja,SomeException() por lo que Mockito falla.

Si realmente quieres hacer esto, entonces haz que Mockito arroje un new RuntimeException() o incluso mejor, new ArrayIndexOutOfBoundsException()ya que la API especifica que esa es la única excepción válida que se lanzará.

Una solución alternativa es utilizar un willAnswer()método.

Por ejemplo, lo siguiente funciona (y no arroja un, MockitoExceptionpero en realidad arroja un marcado Exceptioncomo se requiere aquí) usando BDDMockito:

given(someObj.someMethod(stringArg1)).willAnswer( invocation -> { throw new Exception("abc msg"); });

El equivalente para Mockito simple sería usar el doAnswermétodo

Tenga en cuenta que, en general, Mockito no permite lanzar excepciones controladas, siempre y cuando la excepción se declara en la firma del mensaje. Por ejemplo, dado

class BarException extends Exception {
  // this is a checked exception
}

interface Foo {
  Bar frob() throws BarException
}

es legal escribir:

Foo foo = mock(Foo.class);
when(foo.frob()).thenThrow(BarException.class)

Sin embargo, si arroja una excepción marcada no declarada en la firma del método, por ejemplo

class QuxException extends Exception {
  // a different checked exception
}

Foo foo = mock(Foo.class);
when(foo.frob()).thenThrow(QuxException.class)

Mockito fallará en tiempo de ejecución con el mensaje genérico algo engañoso:

Checked exception is invalid for this method!
Invalid: QuxException

Esto puede llevarlo a creer que las excepciones marcadas en general no son compatibles, pero de hecho Mockito solo está tratando de decirle que esta excepción marcada no es válida para este método .

Existe la solución con Kotlin:

given(myObject.myCall()).willAnswer {
    throw IOException("Ooops")
}

De donde viene dado

import org.mockito.BDDMockito.given

Esto funciona para mí en Kotlin:

when(list.get(0)).thenThrow(new ArrayIndexOutOfBoundsException());

Nota: Lanza cualquier excepción definida que no sea Exception ()