Testing extension functions inside classes

问题

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