Solution: ApplicationScope
class ApplicationScope(
private val scope: CoroutineScope,
private val applicationScope: ApplicationControlScope,
private val loggingScope: LoggingScope,
) : CoroutineScope by scope,
ApplicationControlScope by applicationScope,
LoggingScope by loggingScope
Example solution in playground
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.SupervisorJob
import org.junit.Test
import kotlin.coroutines.EmptyCoroutineContext
class ApplicationScope(
private val scope: CoroutineScope,
private val applicationScope: ApplicationControlScope,
private val loggingScope: LoggingScope,
) : CoroutineScope by scope,
ApplicationControlScope by applicationScope,
LoggingScope by loggingScope
interface ApplicationControlScope {
val application: Application
fun start()
fun stop()
fun isRunning(): Boolean
}
data class Application(val name: String)
interface LoggingScope {
fun logInfo(message: String)
fun logWarning(message: String)
fun logError(message: String)
}
class ApplicationScopeTest {
private val fakeApplicationScope = FakeApplicationControlScope(
application = Application("Test"),
)
private val fakeLoggingScope = FakeLoggingScope()
private val coroutineScope = CoroutineScope(SupervisorJob())
private val applicationScope = ApplicationScope(
scope = coroutineScope,
applicationScope = fakeApplicationScope,
loggingScope = fakeLoggingScope,
)
@Test
fun `should use coroutine scope`() {
assert(applicationScope.coroutineContext == coroutineScope.coroutineContext)
}
@Test
fun `should use application scope`() {
assert(applicationScope.application.name == "Test")
applicationScope.start()
assert(fakeApplicationScope.isRunning())
applicationScope.stop()
assert(!fakeApplicationScope.isRunning())
}
@Test
fun `should use logging scope`() {
applicationScope.logInfo("Info")
applicationScope.logWarning("Warning")
applicationScope.logError("Error")
assert(fakeLoggingScope.messages == listOf(
"INFO: Info",
"WARNING: Warning",
"ERROR: Error",
))
}
}
class FakeApplicationControlScope(
override val application: Application,
) : ApplicationControlScope {
private var started = false
override fun start() {
started = true
}
override fun stop() {
started = false
}
override fun isRunning(): Boolean = started
}
class FakeLoggingScope : LoggingScope {
val messages = mutableListOf<String>()
override fun logInfo(message: String) {
messages += "INFO: $message"
}
override fun logWarning(message: String) {
messages += "WARNING: $message"
}
override fun logError(message: String) {
messages += "ERROR: $message"
}
}
