Testing extension functions inside classes

倾然丶 夕夏残阳落幕 提交于 2019-12-08 19:55:35

问题


If we want to test an extension function on a type, we can create an instance of this type, call the function and check the returned value. But what about testing extension functions defined inside classes?

abstract class AbstractClass<T> {
    fun doStuff(): T = "Hello".foo()

    abstract fun String.foo(): T
}

class SubClass1: AbstractClass<Int>() {
    override fun String.foo(): Int = 1
}

class SubClass2: AbstractClass<Boolean>() {
    override fun String.foo(): Boolean = true
}

How do we test the logic of the methods foo() in classes SubClass1 and SubClass2? Is it even possible?

I know I can change the design to test it. Two possibilities have occurred to me:

  1. Don't use extension functions. ¯\_(ツ)_/¯

    abstract class AbstractClass<T> {
        fun doStuff(): T = foo("Hello")
    
        abstract fun foo(string: String): T
    }
    
    class SubClass1: AbstractClass<Int>() {
        override fun foo(string: String): Int = 1
    }
    

    Then we can create an object SubClass1, call foo() and check the returned value.

  2. Create additional extension functions with internal visibility just to test the logic.

    class SubClass1: AbstractClass<Int>() {
        override fun String.foo(): Int = internalFoo()
    }
    
    internal fun String.internalFoo(): Int = 1
    

    Then we can create an object String, call internalFoo() and check the returned value. However, I don't like this solution because we could change the body of override fun String.foo(): Int and our test would pass.

So, is it possible to test extension functions inside classes? If not, how would you change your design in order to test their logic?


回答1:


Since tests should be written from the client's perspective, I'm not sure it would be a valid test. But I did come up with one way to test it.

@Test
fun `test extension function`() {
    var int = 0

    SubClass1().apply {
        int = "blah".foo()
    }

    assertThat(int, `is`(1))
}



回答2:


Extension methods are great and they enable beautiful fluent syntax like that in LINQ, Android KTX.

However, extension methods do not work well with subclassing. This is because extension are essentially non-object-oriented. They resemble the static methods in Java that can be hidden but not overridden in subclasses.

If you have some code you expect to change in a subclass, don't write an extension method as you will face the barriers to testing you have experienced yourself in your question and all of the disadvantages that static methods brings to testability.

There is absolutely nothing wrong with your first example and no good reason to insist on extension methods there:

abstract class AbstractClass<T> {
    fun doStuff(): T = foo("Hello")

    abstract fun foo(string: String): T
}

class SubClass1: AbstractClass<Int>() {
    override fun foo(string: String): Int = 1
}


来源:https://stackoverflow.com/questions/50702478/testing-extension-functions-inside-classes

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!