ff4k-contract-test/com.yonatankarp.ff4k.test.contract.store/FeatureStoreContractTest

FeatureStoreContractTest

abstract class FeatureStoreContractTest(body: FunSpec.() -> Unit = {}) : FunSpec(source)

Abstract contract test for FeatureStore implementations.

This abstract class defines a comprehensive test suite that all FeatureStore implementations must pass. It implements all specific contract test interfaces:

featureStoreCrudTests
featureStoreGroupTests
featureStorePermissionTests
featureStoreConcurrencyTests

To use this contract test, extend this class and implement the createStore method:

class InMemoryFeatureStoreTest : FeatureStoreContractTest() {
    override suspend fun createStore(): FeatureStore = InMemoryFeatureStore()
}

Constructors

FeatureStoreContractTest

constructor(body: FunSpec.() -> Unit = {})

Properties

assertions

var assertions: AssertionMode?

assertSoftly

var assertSoftly: Boolean?

blockingTest

@ExperimentalKotest

var blockingTest: Boolean?

concurrency

@ExperimentalKotest

var concurrency: Int?

coroutineDebugProbes

var coroutineDebugProbes: Boolean?

coroutineDispatcherFactory

@ExperimentalKotest

var coroutineDispatcherFactory: CoroutineDispatcherFactory?

coroutineTestScope

var coroutineTestScope: Boolean?

defaultTestConfig

var ~~defaultTestConfig~~: TestCaseConfig?

dispatcherAffinity

@ExperimentalKotest

var dispatcherAffinity: Boolean?

duplicateTestNameMode

var duplicateTestNameMode: DuplicateTestNameMode?

failfast

var failfast: Boolean?

invocationTimeout

var invocationTimeout: Long?

isolationMode

var isolationMode: IsolationMode?

severity

var severity: TestCaseSeverityLevel?

testCoroutineDispatcher

@ExperimentalKotest

var ~~testCoroutineDispatcher~~: Boolean?

testOrder

var testOrder: TestCaseOrder?

threads

var threads: Int?

timeout

var timeout: Long?

Functions

add

open override fun add(test: RootTest)

afterAny

fun afterAny(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open suspend fun afterAny(testCase: TestCase, result: TestResult)

afterContainer

fun afterContainer(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open suspend fun afterContainer(testCase: TestCase, result: TestResult)

afterEach

fun afterEach(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open suspend fun afterEach(testCase: TestCase, result: TestResult)

afterInvocation

fun afterInvocation(f: suspend (TestCase, Int) -> Unit)

afterProject

fun afterProject(f: AfterProject)

afterSpec

open suspend fun afterSpec(spec: Spec)

open override fun afterSpec(f: suspend (Spec) -> Unit)

afterTest

open override fun afterTest(f: suspend (Tuple2<TestCase, TestResult>) -> Unit)

open suspend fun afterTest(testCase: TestCase, result: TestResult)

appliedTags

fun appliedTags(): Set<Tag>

aroundSpec

fun ~~aroundSpec~~(aroundSpecFn: suspend (Tuple2<KClass<out Spec>, suspend () -> Unit>) -> Unit)

aroundTest

fun aroundTest(aroundTestFn: suspend (Tuple2<TestCase, suspend (TestCase) -> TestResult>) -> TestResult)

assertionMode

open fun assertionMode(): AssertionMode?

autoClose

fun <T : AutoCloseable> autoClose(closeable: T): T

fun <T : AutoCloseable> autoClose(closeable: Lazy<T>): Lazy<T>

beforeAny

fun beforeAny(f: suspend (TestCase) -> Unit)

open suspend fun beforeAny(testCase: TestCase)

beforeContainer

fun beforeContainer(f: suspend (TestCase) -> Unit)

open suspend fun beforeContainer(testCase: TestCase)

beforeEach

fun beforeEach(f: suspend (TestCase) -> Unit)

open suspend fun beforeEach(testCase: TestCase)

beforeInvocation

fun beforeInvocation(f: suspend (TestCase, Int) -> Unit)

beforeSpec

fun beforeSpec(f: suspend (Spec) -> Unit)

open suspend fun beforeSpec(spec: Spec)

beforeTest

open suspend fun beforeTest(testCase: TestCase)

open override fun beforeTest(f: suspend (TestCase) -> Unit)

concurrency

@ExperimentalKotest

open fun concurrency(): Int?

context

@ExperimentalKotest

open fun context(name: String): RootContainerWithConfigBuilder<FunSpecContainerScope>

open fun context(name: String, test: suspend FunSpecContainerScope.() -> Unit)

coroutineDispatcherFactory

open fun coroutineDispatcherFactory(): CoroutineDispatcherFactory?

createStore

abstract suspend fun createStore(): FeatureStore

defaultTestCaseConfig

open fun ~~defaultTestCaseConfig~~(): TestCaseConfig?

dispatcherAffinity

@ExperimentalKotest

open fun dispatcherAffinity(): Boolean?

extension

fun <T : Extension> extension(extension: T): T

fun extension(f: suspend (Tuple2<TestCase, suspend (TestCase) -> TestResult>) -> TestResult)

extensions

fun extensions(vararg extensions: Extension)

fun extensions(extensions: List<Extension>)

open fun extensions(): List<Extension>

finalizeSpec

fun finalizeSpec(f: suspend (Tuple2<KClass<out Spec>, Map<TestCase, TestResult>>) -> Unit)

globalExtensions

open override fun globalExtensions(): List<Extension>

include

fun include(factory: TestFactory)

fun include(prefix: String, factory: TestFactory)

invocationTimeout

open fun invocationTimeout(): Long?

isolationMode

open fun isolationMode(): IsolationMode?

listener

fun <T : TestListener> listener(listener: T): T

listeners

fun listeners(vararg listeners: TestListener)

fun listeners(listeners: List<TestListener>)

open fun listeners(): List<TestListener>

prependExtension

fun prependExtension(extension: Extension)

prependExtensions

fun prependExtensions(extensions: List<Extension>)

fun <T : TestListener> register(extension: T): T

fun register(vararg extensions: Extension)

fun register(extensions: List<Extension>)

registeredAutoCloseables

fun registeredAutoCloseables(): List<Lazy<AutoCloseable>>

registeredExtensions

fun registeredExtensions(): List<Extension>

rootTests

open override fun rootTests(): List<RootTest>

seal

fun seal()

setParentConfiguration

fun setParentConfiguration(configuration: TestConfiguration)