I learned about seams after reading Micheal Feathers’s book Working Effectively with Legacy Code. In essence a seam is a way to circumvent code that makes testing hard or even impossible.

For example, lets say we have a class that checks if a given task is valid. For reasons that do not interest us that same class makes a connection to another service and sends some data to it. That connection alone makes the class hard to test since we need to have and maintain a connection to that service during testing:

	class TaskChecker {
	fun check(task: Task): CheckResult {
	if (isNotCreatedInCurrentWeek(task)) return Invalid
	if (isResolved(task)) return Invalid
	if (isNotAssigned(task)) return Invalid
	return Valid
	}
	private fun isNotAssigned(task: Task): Boolean {
	if (task.assignedTo != Nobody) return false
	val connection = Connection()
	val assigner = TaskAssigner(connection)
	assigner.add(task)
	return true
	}
	//…
	}

view raw creating_a_seam_initial.kt hosted with ❤ by GitHub

In this example, isNotAssigned() makes the necessary checks but also sends the task to TaskAssigner so if we want to write some tests for TaskChecker we need to make sure that assigner is up and running.

Object seams

According to Mr Feathers there are three types of seams. The one that fits our case is called object seam and we are going to use it in order to bypass entirely making a connection and talking to the assigner.

Following the book’s example we end up with this:

	class TestingTaskChecker : TaskChecker() {
	override fun sendTaskToAssigner(task: Task) {
	// do nothing
	}
	}
	open class TaskChecker {
	fun check(task: Task): CheckResult {
	if (isNotCreatedInCurrentWeek(task)) return Invalid
	if (isResolved(task)) return Invalid
	if (isNotAssigned(task)) return Invalid
	return Valid
	}
	private fun isNotAssigned(task: Task): Boolean {
	if (task.assignedTo != Nobody) return false
	sendTaskToAssigner(task)
	return true
	}
	protected open fun sendTaskToAssigner(task: Task) {
	val connection = Connection()
	val assigner = TaskAssigner(connection)
	assigner.add(task)
	}
	//…
	}

view raw creating_a_seam_books_approach.kt hosted with ❤ by GitHub

which does exactly what we want since it provides a way to write tests that do not involve the assigner. We just need to use TestingTaskChecker in our tests and we are good to go.

The downside with this approach is that we had to open our class which might not meet the project’s standards.

Function reference

Lets see what we can do without opening the class.

Just like before we need to extract the behavior that we want to override to its own method but this time we are also going to assign this method to a value and use the value in the calling site:

	class TaskChecker {
	private val safeSendTaskToAssigner: (Task) -> Unit = ::sendTaskToAssigner
	fun check(task: Task): CheckResult {
	if (isNotCreatedInCurrentWeek(task)) return Invalid
	if (isResolved(task)) return Invalid
	if (isNotAssigned(task)) return Invalid
	return Valid
	}
	private fun isNotAssigned(task: Task): Boolean {
	if (task.assignedTo != Nobody) return false
	safeSendTaskToAssigner(task)
	return true
	}
	private fun sendTaskToAssigner(task: Task) {
	val connection = Connection()
	val assigner = TaskAssigner(connection)
	assigner.add(task)
	}
	//…
	}

view raw creating_a_seam_function_reference.kt hosted with ❤ by GitHub

isNotAssigned() will keep talking with the assigner only this time it does it through safeSendTaskToAssigner.

Default value

Having this function reference means that we can force isNotAssigned() to change its behavior by simply assigning a new value to safeSendTaskToAssigner! And this is what we are going to do:

	class TaskChecker(
	seamToAssigner: ((Task) -> Unit)? = null
	) {
	private val safeSendTaskToAssigner: (Task) -> Unit = seamToAssigner ?: ::sendTaskToAssigner
	fun check(task: Task): CheckResult {
	if (isNotCreatedInCurrentWeek(task)) return Invalid
	if (isResolved(task)) return Invalid
	if (isNotAssigned(task)) return Invalid
	return Valid
	}
	private fun isNotAssigned(task: Task): Boolean {
	if (task.assignedTo != Nobody) return false
	safeSendTaskToAssigner(task)
	return true
	}
	private fun sendTaskToAssigner(task: Task) {
	val connection = Connection()
	val assigner = TaskAssigner(connection)
	assigner.add(task)
	}
	//…
	}

view raw creating_a_seam_final.kt hosted with ❤ by GitHub

By default the seam is null which leads in having safeSendTaskToAssigner referencing the original behavior allowing the entire project to keep working as before without any additional changes to other files.

If now we pass a non null value then it gets assigned to safeSendTaskToAssigner and ends up being called instead of sendTaskToAssigner. This way we remove the communication from our flow allowing us to finally write some tests.

Testing

All we need to do is to write our tests by simply creating a checker with a do nothing seam:

	@Test fun `a task that is not assigned is invalid`() {
	val task = Task(AssignedTo.Nobody)
	val taskChecker = TaskChecker {} // <– check with seam
	val actual = taskChecker.check(task)
	assertThat(actual, equalTo(Invalid))
	}

view raw creating_a_seam_test.kt hosted with ❤ by GitHub