test/pro.respawn.flowmvi.test/StoreTestScope

StoreTestScope

class StoreTestScope<S : MVIState, I : MVIIntent, A : MVIAction> : Store<S, I, A> , Provider<S, I, A>

A class which implements a dsl for testing Store.

Properties

actions

open override val actions: Flow<A>

isActive

open override val isActive: Boolean

isStarted

open override val isStarted: Boolean

name

open override val name: String?

provider

val provider: Provider<S, I, A>

states

open override val states: StateFlow<S>

store

val store: Store<S, I, A>

timeoutMs

val timeoutMs: Long = 3000

Functions

awaitStartup

open suspend override fun awaitStartup()

awaitUntilClosed

open suspend override fun awaitUntilClosed()

expect open override fun close()

closeAndWait

open suspend override fun closeAndWait()

emit

open suspend override fun emit(intent: I)

ensureStarted

fun StoreLifecycle.ensureStarted()

equals

open operator override fun equals(other: Any?): Boolean

hashCode

open override fun hashCode(): Int

intent

open override fun intent(intent: I)

resultsIn

inline suspend fun <S> I.resultsIn()

Assert that Provider.state's state is of type S

infix inline suspend fun I.resultsIn(action: A)

Assert that intent this results in action

infix inline suspend fun I.resultsIn(state: S)

Assert that Provider.state is equal to state

infix inline suspend fun I.resultsIn(assertion: () -> Unit)

Assert that intent this passes checks defined in assertion

start

open override fun start(scope: CoroutineScope): StoreLifecycle

open override fun CoroutineScope.subscribe(block: suspend Provider<S, I, A>.() -> Unit): Job

subscribeAndTest

inline suspend fun <S : MVIState, I : MVIIntent, A : MVIAction> Store<S, I, A>.subscribeAndTest(crossinline block: suspend StoreTestScope<S, I, A>.() -> Unit)

Call Store.start, then call Store.subscribe and execute block inside that scope. Unsubscribe and stop the store afterwards

test

inline suspend fun <S : MVIState, I : MVIIntent, A : MVIAction> Store<S, I, A>.test(crossinline block: suspend Store<S, I, A>.() -> Unit)

Call Store.start and then execute block, cancelling the store afterwards