how to write a test for this class: ```class Task(...

# getting-started

[Dron Bhattacharya]

how to write a test for this class:

class Task(var title: String, bodyText: String = "") {
    var body: String = bodyText
        get() {
            return if (this.body.isEmpty()) "NO BODY FOUND"
            else this.body
        }
    fun printTask() {
        println("Task: $title\n")
        println("Body:")
        println(body)
    }
}

The current TaskTest.kt file:

import org.junit.jupiter.api.Test

import org.junit.jupiter.api.Assertions.*

class TaskTest {
    val testSample1: Task = Task("Learn Encapsulation")
    val testSample2: Task = Task("Learn Encapsulation", "Encapsulation is good for reducing change")
    @Test
    fun printTask() {

    }
}

[Sam]

It’s hard to test this because println is an example of a function that operates via side effects — i.e. it does something, instead of returning something.

[mkrussel]

You could replace System.out with your own object that builds a string.

[Dron Bhattacharya]

@mkrussel I cannot understand your suggestion. Can you elaborate a little bit?

[mkrussel]

I've not done this in Kotlin, but Java has https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#setOut-java.io.PrintStream-

You can use that to redirect System.out which the println function uses.

You then create a PrintStream that takes an ByteArrayOutputStream, you can then convert those bytes to a String to validate the printing.

[mkrussel]

Then revert System.out back to the original print stream.

[Sam]

Possibly a simpler version of the same thing might be something like this:

class Task(var title: String, bodyText: String = "") {
    var body: String = bodyText
        get() {
            return if (this.body.isEmpty()) "NO BODY FOUND"
            else this.body
        }
    fun printTask() {
        printer("Task: $title\n")
        printer("Body:")
        printer(body)
    }

    companion object {
        var printer: (String) -> Unit = ::println
    }
}

class TaskTest {
    val testSample1: Task = Task("Learn Encapsulation")
    val testSample2: Task = Task("Learn Encapsulation", "Encapsulation is good for reducing change")
    @Test
    fun printTask() {
        val output = mutableListOf<String>()
        Task.printer = { output.add(it) }
        testSample1.printTask()
        assertTrue(output.contains("Learn Encapsulation"))
    }
}

[Sam]

Easier to replace a (String) -> Unit function than the whole system output stream.

[Sam]

Not the sort of thing I would want to do in real code, but good enough for learning

[mkrussel]

I would probably go with making the printer a constructor argument versus changing global state.

[Sam]

Yep, would definitely do that if I was going to use something like this for real

[Adam S]

generally what applications do is use a Logger rather than printing directly to console.

There are libraries that provide loggers, but you don't need a library as @Sam & @mkrussel demoed - the most basic logger I can think of is just a type alias

typealias Logger = (String) -> Unit

So anywhere you want to print, pass in a Logger

typealias Logger = (String) -> Unit

class Task(
  private val logger: Logger
) { 

  fun printTask() {
      logger("Task: ...")
      logger("Body: ...")
  }
}

[Adam S]

and it's perfectly fine to print to stdout - so you can set that up as the default behaviour

class Task(
  private val logger: Logger = ::println
)

that uses a function reference to println(), so for every message it will just print to stdout

[Adam S]

and then in tests you override the default logger to capture the log messages by, for example, collecting them into a list

fun main() {
    // collect the log messages into this list
    val logMessages = mutableListOf<String>()
    
    // override the default logger
    val task = Task(logger = logMessages::add)
    
    task.printTask()
    
    // now we can access all captured messages
    println("captured messages $logMessages")
}

So that ^ will collect all your log messages into a list. Now each test can be run independently, and the logs won't be muddled up.

[Adam S]

Here's a runnable example that I updated to use a more object-oriented approach, which I think is more readable.

run in Kotlin Playground

logger_demo.kt.cpp

[Klitos Kyriacou]

By the way, if you are trying to access the backing field, you should use field. Otherwise this will cause an endless recursion and eventually a stack overflow:

var body: String = bodyText
        get() {
            return if (this.body.isEmpty()) "NO BODY FOUND"
            else this.body
        }

More details: https://kotlinlang.org/docs/properties.html#backing-fields

[Ties]

I just offered to explain things like side-effects and how it impacts testability in a call 😛 might be more effective than slack messages

[Dron Bhattacharya]

I have ended up writing this. Is it OK?

Task.kt:

class Task(var title: String, private val bodyText: String = "") {
    var body: String = bodyText
        get() = field.ifEmpty { "NO BODY FOUND" }
    fun printTask(): String {
        val text: String = """
                Task: $title
                
                Body:
                $body
            """.trimIndent().also {
            println(it)
        }
        return text
    }
}

TaskTest.kt:

class TaskTest {
    val titles = listOf<String>("Learn Encapsulation", "Learn interface")
    val bodys = listOf<String>("NO BODY FOUND", "Interface is good for reducing change")

    val testSample1: Task = Task(titles[0])
    val testSample2: Task = Task(titles[1], bodys[1])

    @Test
    fun printTask_NoBody() {
        val expected =
            """
                Task: ${titles[0]}

                Body:
                ${bodys[0]}
            """.trimIndent()
        assertEquals(expected, testSample1.printTask())
    }

    @Test
    fun printTask() {
        val expected =
            """
                Task: ${titles[1]}

                Body:
                ${bodys[1]}
            """.trimIndent()
        assertEquals(expected, testSample2.printTask())
    }
}

[Dron Bhattacharya]

Is there anything more to test for this class, like instance creation of the class? I am new to this

[Dron Bhattacharya]

I am using a String template in the printTask() function. But when I change the template, I have to change it manually in the test class too.
I have to change the template in 3 places. I know it can be better, but what to apply here is not clear to me (abstract class, interface, or something else).
Can I do anything here?

[Dron Bhattacharya]

I have tried to solve the "manually modifying String template" issue in this way:
Now if I have to modify the String that gets printed, I can change it in 1 place and it reflects in other places.

Task.kt:

import java.util.UUID

class Task(var title: String, bodyText: String = "") {

    val id = UUID.randomUUID().hashCode()
    var body: String = bodyText
        get() = field.ifEmpty { "NO BODY FOUND" }

    init {
        println("Task created with ID=$id")
    }

    fun printTask() =
        TaskPrintString(title, body).formattedString.also {
            println(it)
        }
}

data class TaskPrintString(private val title: String, private val body: String) {
    val formattedString: String =
        """
            
            --------------------               
            Task: $title
            --------------------
            Body:
            $body
            
        """.trimIndent()
}

TaskTest.kt:

class TaskTest {
    val titles = listOf<String>("Learn Encapsulation", "Learn interface")
    val bodys = listOf<String>("NO BODY FOUND", "Interface is good for reducing change")


    @Test
    fun printTask_NoBody() {
        val testSample1: Task = Task(titles[0])
        val expected = TaskPrintString(titles[0], bodys[0]).formattedString
        assertEquals(expected, testSample1.printTask())
    }

    @Test
    fun printTask_withBody() {
        val testSample2: Task = Task(titles[1], bodys[1])
        val expected = TaskPrintString(titles[1], bodys[1]).formattedString
        assertEquals(expected, testSample2.printTask())
    }
}