Model View Presenter Writing Spek Specification - gists for blog post

build.gradle

dependencies {
    (...)
    testImplementation unitTestDependencies.values()
    testImplementation spekDependencies.values()
    testImplementation kotlinTestDependencies.values()
}

PeopleListContract.kt

interface PeopleListContract {
    interface View {
        fun addPeople(people: List<Person>)
        fun showError(throwable: Throwable = Throwable())
        fun showLoading()
        fun hideLoading()
    }

    interface Presenter {
        fun attach(view: View)
        fun detach()
    }
}

PeopleListPresenter#impl.kt

class PeopleListPresenter(private val repository: Repository<Person>) : PeopleListContract.Presenter {

    var view: PeopleListContract.View? = null

    override fun attach(view: PeopleListContract.View) {
        this.view = view
        loadPeople()
    }

    private fun loadPeople() {
            repository.getAll()
                    .doOnSubscribe { view?.showLoading() }
                    .doOnError {
                        view?.apply {
                            showError(it)
                            hideLoading()
                        }
                    }
                    .doOnSuccess {
                        view?.apply {
                            addPeople(it)
                            hideLoading()
                        }
                    }
                    .subscribe()
        }
}

PeopleListPresenter.kt

class PeopleListPresenter(val repository: Repository<Person>) : PeopleListContract.Presenter {

    var view: PeopleListContract.View? = null

    override fun attach(view: PeopleListContract.View) {
        this.view = view
    }

    override fun detach() {
        this.view = null
    }
}

PeopleListTest#assertions.kt

val presenter = PeopleListPresenter(repository)

on("presenter attach"){
    presenter.attach(view)
    it("should attach view"){
        assertNotNull(presenter.view)
    }
    it("should start loading") {
        verify(view).showLoading()
    }
    it("should load list into view"){
        verify(view).addPeople(peopleList)
    }
    it("should stop loading") {
        verify(view).hideLoading()
    }
    it("should never show any error"){
        verify(view, never()).showError(anyOrNull())
    }
}
on("presenter detach"){
    it("should detach view"){
    presenter.detach()
        assertNull(presenter.view)
    }
}

PeopleListTest#bothextensions.kt

given("no people in repository"){
    val view: PeopleListContract.View = mock()
    val repository : Repository<Person> = mock {
        on { getAll() } doReturn Single.error(Error("no data"))
    }
    val presenter = PeopleListPresenter(repository)
    on("presenter attach"){
        presenter.attach(view)
        presenterAttachStandardFlow(view, presenter){
            it("should not add anything to view"){
                verify(view, never()).addPeople(any())
            }
            it("should display error in view"){
                verify(view).showError(any())
            }
        }
    }
    presenterDetachAction(presenter)
}

PeopleListTest#mockito.kt

val peopleList : List<Person> = listOf(
                    Person(id = "1", firstName = "Mark", surname = "Train"),
                    Person(id = "2", firstName = "George", secondName = "Edward", surname = "Bicycle")
            )

val repository : Repository<Person> = mock{
    on { getAll() } doReturn Single.just(peopleList)
}

PeopleListTest#nopeople.kt

given("no people in repository"){
    val view: PeopleListContract.View = mock()
    val repository : Repository<Person> = mock {
        on { getAll() } doReturn Single.error(Error("no data"))
    }
    val presenter = PeopleListPresenter(repository)
    on("presenter attach"){
        presenter.attach(view)
        presenterAttachStandardFlow(view, presenter){
            it("should not add anything to view"){
                verify(view, never()).addPeople(any())
            }
            it("should display error in view"){
                verify(view).showError(any())
            }
        }
    }
}

PeopleListTest#presenterattach.kt

on("presenter attach") {
    presenter.attach(view)
    it("should attach view") {
        assertNotNull(presenter.view)
    }
    it("should start loading") {
        verify(view).showLoading()
    }
    it("should load list into view") {
        verify(view).addPeople(peopleList)
    }
    it("should stop loading") {
        verify(view).hideLoading()
    }
    it("should never show any error") {
        verify(view, never()).showError(anyOrNull())
    }
}

PeopleListTest#start.kt

import org.jetbrains.spek.api.Spek
import org.jetbrains.spek.api.dsl.*
import org.junit.platform.runner.JUnitPlatform
import com.nhaarman.mockito_kotlin.*
import org.junit.runner.RunWith

@RunWith(JUnitPlatform::class)
object PeopleListTest : Spek({
    given("people exists in repository"){
        val view: PeopleListContract.View = mock()    
    }
})

PeopleListTest#withactionextension.kt

on("presenter attach") {
    presenter.attach(view)
    presenterAttachStandardFlow(view, presenter) {
        it("should add people to view") {
            verify(view).addPeople(peopleList)
        }
        it("should never show error") {
            verify(view, never()).showError(anyOrNull())
        }
    }
}

PoepleListTestExtensions#actionbody.kt

fun ActionBody.presenterAttachStandardFlow(
        view: PeopleListContract.View,
        presenter: PeopleListPresenter,
        additionalTestBlock: () -> Unit) {
    it("should attach view") {
        Assert.assertNotNull(presenter.view)
    }
    it("should start loading") {
        verify(view).showLoading()
    }
    
    additionalTestBlock.invoke()

    it("should stop loading") {
        verify(view).hideLoading()
    }
}

PoepleListTestExtensions#testbody.kt

fun SpecBody.detachPresenterAction(presenter: PeopleListPresenter) {
    on("presenter detach") {
        presenter.detach()
        it("should detach view") {
            Assert.assertNull(presenter.view)
        }
    }
}

Repository.kt

interface Repository<in T>{
    fun getAll() : Single<List<T>>
    fun getOne(id : String) : Single<T>
    fun create(t : T)
}

spek-test-example.kt

on("presenter detach"){
    presenter.detach()
    it("should dispose observables"){
        //
    }
}

testDependencies.gradle

ext {

    def JunitVersion = '4.12'
    def KotlinMockitoVersion = '1.5.0'
    def SpekVersion = "1.1.5"

    unitTestDependencies = [
            junit      : "junit:junit:${JunitVersion}",
    ]

    kotlinTestDependencies = [
            kotlinMockito: "com.nhaarman:mockito-kotlin:${KotlinMockitoVersion}",
    ]

    spekDependencies = [
            spekApi: "org.jetbrains.spek:spek-api:${SpekVersion}",
            platformEngine: "org.jetbrains.spek:spek-junit-platform-engine:${SpekVersion}",
            junitPlatformRunner: "org.junit.platform:junit-platform-runner:1.0.0"
    ]
}