ObjectMother with customization in Kotlin

This repository explores many solutions in Kotlin to create test data dynamically based on ObjectMother pattern. In Java, this can be addressed with Test Data Builders, but implies a lot of verbosity.

factory_bot, written un ruby, was a great source of inspiration, which achieves to be very concise, readable and flexible.

The problem to resolve

When writing tests, we many objects have to be created in given (given/when/then) or arrange (arrange/act/assert) phase. The creation of these objects usually requires to provide much information, but some of them are not relevant depending on the test, which leads to noise. More over, this may hide the test intent. For example, does Rectangle(center, 20, 20) mean we need a rectangle with 20 as width, a square or a rectangle precisely centered?

ObjectMother can resolve these issues (ex: Rectangle.buildSquare()), but we usually also need to:

combine factories. Ex: rectangle which is squared and centered on the origin
arbitrary customize created instances, which may be tricky when classes are immutables. Ex: a square with a particular side length

Here is the functional solution we try to implement in this repository:

the ability to create a valid (default) instance of a class where provided data are fixed or generated on the fly
… which can be (manually) customized through constructor parameters
… which can be (manually) customized instance once created (if class is mutable)
… which can also be customized through many registered set of customizations (on constructor parameters or on created instances), called traits (like in factory_bot)
traits can be based on each others
and all of these can be combined in following order (each one takes precedence to the previous one):
- default instance
- traits
- constructor parameters
- mutable state

Additionally, the searched solutions should imply minimal noises in tests (with sufficient ). For example, Rectangle.squared() would be preferable compared to RenctangleFactory.build(SQUARED).

POC v0 - data classes

Prerequisites

target class is a data class
target class must have declared a companion object (no longer necessary after Kotlin 2.0 thanks to static extension

Usage

val rectangle = Rectangle.build(SQUARED, BIG)
    .copy(y = 10)
    .apply { emptyLabel() }

feature	implemented?
default instance	✅
customize with many traits	✅
traits can customize constructor parameters	✅ with `copy()`
traits can customize mutable state	❌ (*)
traits based on each others	???
manually customize constructor parameters	✅ with `copy()`
manually customize mutable state	✅ with `apply()`
combine all of this	✅

(*) This is possible, but may lead to unexpected behavior when using multiple traits or mutable state is customized.

Implementation

fun build(i: Int): Rectangle {
    val width = 100
    return Rectangle(i, arrayOf(1, 2, 3).random(), width, 120, "width = $width")
}

val SQUARED: Trait<Rectangle> = { copy(height = width) }
val CENTERED: Trait<Rectangle> = { copy(x = height / 2, y = width / 2) }
val BIG: Trait<Rectangle> = { copy(width = width + 1000, height = height + 1000) }
val CENTERED_AND_SQUARED: Trait<Rectangle> = { SQUARED(CENTERED(this)) }

Generic code

typealias Trait<T> = T.() -> T

And follow code should be duplicated for each target class:

private var i = 0
fun Rectangle.Companion.build(
    vararg traits: Trait<Rectangle> = emptyArray()
) = traits.fold(build(i++)) { rectangle, trait -> trait.invoke(rectangle) }

POC v1

Prerequisites

target class must have declared a companion object (no longer necessary after Kotlin 2.0 thanks to static extension

Usage

val rectangle = Rectangle.build(SQUARED, BIG, y = 10) {
    emptyLabel()
    label = "my rectangle"
}

feature	implemented?
default instance	✅
customize with many traits	✅
traits can customize constructor parameters	❌
traits can customize mutable state	✅ with `apply()`
traits based on each others	✅
manually customize constructor parameters	✅
manually customize mutable state	✅
combine all of this	✅

Note: implementation is a bit complex

Implementation

var i = 0

fun Rectangle.Companion.build(
    vararg traits: Trait<Rectangle> = emptyArray<Trait<Rectangle>>(),
    x: Int = i++,
    y: Int = arrayOf(1, 2, 3).random(),
    width: Int = 100,
    height: Int = 100,
    label: String = "width = $width",
    override: Rectangle.() -> Unit = {}
) = traits.fold(Rectangle(x, y, width, height, label)) { rectangle, trait -> trait.invoke(rectangle) }
    .apply(override)

val SQUARED: Trait<Rectangle> = { it.apply { height = width } }
val CENTERED: Trait<Rectangle> = {
    it.apply {
        x = height / 2
        y = width / 2
    }
}
val BIG: Trait<Rectangle> = {
    it.apply {
        width = width + 1000
        height = height + 1000
    }
}
val CENTERED_AND_SQUARED: Trait<Rectangle> = { SQUARED(CENTERED(it)) }

Generic code

typealias Trait<T> = (T) -> T

POC v2

Prerequisites

target class is a data class
target class must have declared a companion object (no longer necessary after Kotlin 2.0 thanks to static extension

Usage

val rectangle = Rectangle.build(SQUARED, BIG) {
    emptyLabel()
    label = "my rectangle"
}.copy(y = 10)

feature	implemented?
default instance	✅
customize with many traits	✅
traits can customize constructor parameters	❌
traits can customize mutable state	✅ with `copy()`
traits based on each others	✅
manually customize constructor parameters	❌
manually customize mutable state	✅
combine all of this	✅

Implementation

private fun rectangle(i: Int): Rectangle {
    val width = 100
    return Rectangle(
        x = i, // Dynamic attribute based on a sequence
        y = arrayOf(1, 2, 3).random(), // Dynamic attribute
        width = width,
        height = 100,
        label = "width = $width", // Dynamic attribute based on other attribute
    )
}

val SQUARED: Trait<Rectangle> = { it.copy(height = it.width) }
val BIG: Trait<Rectangle> = { it.copy(height = it.height + 1000, width = it.width + 1000) }
val CENTERED: Trait<Rectangle> = {
    it.copy(
        x = it.height / 2,
        y = it.width / 2
    )
}
val CENTERED_AND_SQUARED: Trait<Rectangle> = { SQUARED(CENTERED(it)) }

Generic code

typealias Trait<T> = (T) -> T

And follow code should be duplicated for each target class:

var i = 0
fun Rectangle.Companion.build(
    vararg traits: Trait<Rectangle> = emptyArray(),
    override: Rectangle.() -> Unit = {}
): Rectangle {
    return traits.fold(rectangle(i++)) { args, trait -> trait.invoke(args) }.apply(override)
}

POC v3

Prerequisites

target class is a data class
target class must have declared a companion object (no longer necessary after Kotlin 2.0 thanks to static extension

Usage

val rectangle = Rectangle.build(SQUARED, BIG) {
    y = 10
}.apply {
    emptyLabel()
    label = "my rectangle"
}

feature	implemented?
default instance	✅
customize with many traits	✅
traits can customize constructor parameters	✅
traits can customize mutable state	❌
traits based on each others	✅
manually customize constructor parameters	✅
manually customize mutable state	✅ with `apply()`
combine all of this	✅

Implementation

class RectangleParams(i: Int) {
    var x: Int = i
    var y: Int = arrayOf(1, 2, 3).random()
    var width: Int = 100
    var height: Int = width
    var label: String? = "width = $width"

    fun build() = Rectangle(x, y, width, height, label)
}

val SQUARED: Trait<RectangleParams> = { height = width }
val CENTERED: Trait<RectangleParams> = {
    x = height / 2
    y = width / 2
}
val BIG: Trait<RectangleParams> = {
    width += 1000
    height += 1000
}
val CENTERED_AND_SQUARED: Trait<Rectangle> = { ??? }

Generic code

typealias Trait<T> = T.() -> Unit

And follow code should be duplicated for each target class:

private var i = 0
fun Rectangle.Companion.build(
    vararg traits: Trait<RectangleParams> = emptyArray(),
    override: RectangleParams.() -> Unit = {}
) = RectangleParams(i++).apply {
    traits.forEach { apply(it) }
    apply(override)
}.build()

POC v4

Prerequisites

target class is a data class

Usage

val rectangle = create(Rectangle, SQUARED, BIG)
    .copy(y = 10)
    .apply { emptyLabel() }

feature	implemented?
default instance	✅
customize with many traits	✅
traits can customize constructor parameters	✅ with `copy()`
traits can customize mutable state	❌ (*)
traits based on each others	✅
manually customize constructor parameters	✅ with `copy()`
manually customize mutable state	✅ with `apply()`
combine all of this	✅

(*) This is possible, but may lead to unexpected behavior when using multiple traits or mutable state is customized.

Advantages:

no generic code to replicate for each target class
no need for target class to declare a companion object

Implementation

object Rectangle : Factory<Rectangle> {
  override fun one(i: Int) = Rectangle(
    x = i,
    y = arrayOf(1, 2, 3).random(),
    width = 50,
    height = 100,
    label = "width = 50",
  )

  val SQUARED: Trait<Rectangle> = { copy(width = height) }
  val BIG: Trait<Rectangle> = {
    copy(
      width = width + 1000,
      height = height + 1000
    )
  }
}

Generic code

interface Factory<T> {
    fun one(i: Int): T
}
typealias Trait<T> = T.() -> T

var i = 0;
fun <T> create(factory: Factory<T>, vararg traits: Trait<T>) =
    traits.fold(factory.one(i++)) { model, trait -> trait.invoke(model) }

Alternative approaches

Kotlin FactoryBot Library : cannot handle immutable objets, trait usage is verified at compile time and object construction cannot be customized by traits
faktory-bot: code generation, cannot handle immutable objects and object construction cannot be customized by traits

Further explorations

https://github.com/yujinyan/faktory with its usage of KProperty in Factory.make()

sogilis/objectmother-builder-kotlin

ObjectMother with customization in Kotlin

The problem to resolve

POC v0 - data classes

Prerequisites

Usage

Implementation

Generic code

POC v1

Prerequisites

Usage

Implementation

Generic code

POC v2

Prerequisites

Usage

Implementation

Generic code

POC v3

Prerequisites

Usage

Implementation

Generic code

POC v4

Prerequisites

Usage

Implementation

Generic code

Alternative approaches

Further explorations