Prueba de unidad Kotlin para parámetro de function y object

En Kotlin ,, podríamos tener object de function y pasar como parámetro de function.

  1. ¿Cómo crear una testing unitaria para probar la lógica del object de function? (por ejemplo, funcParam continuación)
  2. ¿Cómo probar la unidad de la function que tiene el parámetro de function? (por ejemplo, functionWithFuncParam continuación) – es decir, ¿puedo crear un simulacro para funcParam ?

     class MyClass1(val myObject: MyObject) { val funcParam = fun (num: Int): Int { return num * num } fun myFunctionOne() { myObject.functionWithFuncParam(funcParam) } } class MyObject () { fun functionWithFuncParam(funcParam: (Int) -> Int) { println(funcParam(32)) } } 

Asumiendo que funcParam es public intencionalmente, puedes probarlo como cualquier otro método:

 class MyClass1Tests { val sut = MyClass1(MyObject()) @Test fun `funcParam multiplies input`() { assertThat(sut.funcParam(4), equalTo(16)) assertThat(sut.funcParam(1), equalTo(1)) assertThat(sut.funcParam(0), equalTo(0)) assertThat(sut.funcParam(-10), equalTo(100)) } } 

Si funcParam es privado, no debe probar su comportamiento directamente, sino solo a través de la interfaz pública de su class.

Al probar functionWithFuncParam puede proporcionar fácilmente una implementación de stub de (Int) -> Int :

 class MyObjectTests { val outContent = ByteArrayOutputStream().apply { System.setOut(PrintStream(this)) } val sut = MyObject() @Test fun `functionWithFuncParam prints function output `() { sut.functionWithFuncParam { 12345678 } assertThat(outContent.toString(), containsString("12345678")) } } 

Si desea probar la interacción de MyObject con MyObject una forma es utilizar la interfaz implementada por MyClass1 en MyClass1 . Por lo general, la mejor opción si 2 classs son queueboradores distintos en el sentido de que tienen un comportamiento separado, en gran parte no relacionado:

 interface FunctionalObj { fun functionWithFuncParam(funcParam: (Int) -> Int) } class MyClass1(val myObject: FunctionalObj) { //omitted for brevity } class MyClass1Tests { var params = mutableListOf<(Int)->Int>() val sut = MyClass1(object: FunctionalObj { override fun functionWithFuncParam(funcParam: (Int) -> Int) { params.add(funcParam) } }) @Test fun `myFunctionOne calls delegate`() { sut.myFunctionOne() assertThat(params.size, equalTo(1)) assertThat(params[0], equalTo(sut.funcParam))//only if `funcParam` is public } } 

Si la MyClass1 entre MyClass1 y MyObject es más compleja (es decir, implica más llamadas, tanto consultas como commands ), implicaría que son compañeros que trabajan en estrecha queueboración. En tal caso, el uso de simulaciones puede llevar a testings frágiles y difíciles de escribir.