Solution: BestStudentUseCase
class BestStudentUseCase(
private val repo: StudentsRepository
) {
suspend fun getBestStudent(
semester: String
): Student = coroutineScope {
repo.getStudentIds(semester)
.map { id -> async { repo.getStudent(id) } }
.awaitAll()
.maxByOrNull { it.result }
?: error("No students in semester $semester")
}
}
It is a common mistake to wrap getStudentIds with an async call, and await it. The effective behavior of getBestStudent would be the same as without this async call, but this unnecessary wrapping would make the code less readable and less performant.
Another common mistake is to use map { it.await() } instead of awaitAll(). In both cases, the effective behavior of getBestStudent will be the same. Still, it is best practice to use awaitAll() because it is more readable and more performant, and it behaves more appropriately in some other functions if there is an exception in an async call.
Example solution in playground
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.test.currentTime
import kotlinx.coroutines.test.runTest
import org.junit.Test
import kotlin.system.measureTimeMillis
import kotlin.test.assertEquals
class BestStudentUseCase(
private val repo: StudentsRepository
) {
suspend fun getBestStudent(
semester: String
): Student = coroutineScope {
repo.getStudentIds(semester)
.map { id -> async { repo.getStudent(id) } }
.awaitAll()
.maxByOrNull { it.result }
?: error("No students in semester $semester")
}
}
data class Student(val id: Int, val result: Double, val semester: String)
interface StudentsRepository {
suspend fun getStudentIds(semester: String): List<Int>
suspend fun getStudent(id: Int): Student
}
class RequestTest {
@Test
fun `Function does return the best student in the semester`() = runTest {
// given
val semester = "19L"
val best = Student(2, 95.0, semester)
val repo = ImmediateFakeStudentRepo(
listOf(
Student(1, 90.0, semester),
best,
Student(3, 50.0, semester)
)
)
val useCase = BestStudentUseCase(repo)
// when
val chosen = useCase.getBestStudent(semester)
// then
assertEquals(best, chosen)
}
@Test
fun `When no students, correct error is thrown`() = runTest {
// given
val semester = "19L"
val repo = ImmediateFakeStudentRepo(listOf())
val useCase = BestStudentUseCase(repo)
// when and then
assertThrowsError<IllegalStateException> {
useCase.getBestStudent(semester)
}
}
@Test
fun `Requests do not wait for each other`() = runTest {
// given
val repo = WaitingFakeStudentRepo()
val useCase = BestStudentUseCase(repo)
// when
useCase.getBestStudent("AAA")
// then
assertEquals(1200, currentTime)
}
@Test
fun `Cancellation works fine`() = runTest {
// given
val repo = WaitingFakeStudentRepo()
val useCase = BestStudentUseCase(repo)
// when
val job = launch {
useCase.getBestStudent("AAA")
}
delay(300)
job.cancel()
// then
assertEquals(0, repo.returnedStudents)
}
@Test
fun `When one request has error, all are stopped and error is thrown`() = runTest {
// given
val repo = FirstFailingFakeStudentRepo()
val useCase = BestStudentUseCase(repo)
// when and then
assertThrowsError<FirstFailingFakeStudentRepo.FirstFailingError> {
useCase.getBestStudent("AAA")
}
// then
assertEquals(
0,
repo.studentsReturned,
"Looks like some requests were still running after the first one had an error"
)
}
}
class ImmediateFakeStudentRepo(
private val students: List<Student>
) : StudentsRepository {
override suspend fun getStudentIds(semester: String): List<Int> =
students.filter { it.semester == semester }
.map { it.id }
override suspend fun getStudent(id: Int): Student =
students.first { it.id == id }
}
inline fun assertTimeAround(expectedTime: Int, upperMargin: Int = 100, body: () -> Unit) {
val actualTime = measureTimeMillis(body)
assert(actualTime in expectedTime..(expectedTime + upperMargin)) {
"Operation should take around $expectedTime, but it took $actualTime"
}
}
inline fun <reified T : Throwable> assertThrowsError(body: () -> Unit) {
try {
body()
assert(false) { "There should be an error of type ${T::class.simpleName}" }
} catch (throwable: Throwable) {
if (throwable !is T) {
throw throwable
}
}
}
class WaitingFakeStudentRepo : StudentsRepository {
var returnedStudents = 0
override suspend fun getStudentIds(semester: String): List<Int> {
delay(200)
return (1..5).toList()
}
override suspend fun getStudent(id: Int): Student {
delay(1000)
returnedStudents++
return Student(12, 12.0, "AAA")
}
}
class FirstFailingFakeStudentRepo : StudentsRepository {
var first = true
var studentsReturned = 0
val mutex = Mutex()
override suspend fun getStudentIds(semester: String): List<Int> {
delay(200)
return (1..5).toList()
}
override suspend fun getStudent(id: Int): Student {
delay(100)
mutex.withLock {
if (first) {
first = false
throw FirstFailingError()
}
}
delay(100)
studentsReturned++
return Student(12, 12.0, "AAA")
}
class FirstFailingError() : Error()
}
