Exercise: CompanyDetailsRepository
The CompanyDetailsRepository class is used to fetch company details from an API. The problem is that the current implementation is not thread-safe and exposes internal collection. Fix those problems using the following techniques:
- Use
synchronizedblock to protect the shared state and keep using a mutable map to store company details. - Use
synchronizedblock to protect the shared state and use a read-only map to store company details. - Use a dispatcher limited to a single thread and keep using a mutable map to store company details.
- Use a dispatcher limited to a single thread and use a read-only map to store company details.
- Use
AtomicReferenceand read-only map to store company details (that should work, but that is certainly not a good solution). - Use a concurrent collection to store company details.
- Use a mutex and keep using a mutable map to store company details.
None of those solutions can guarantee that one element is fetched only once. To achieve this, implement solutions using the following techniques:
- Use a concurrent collection with suspending lazy objects to store company details (before doing this one, first finish Suspended lazy exercise).
- Use caching library to cache company details (Aedile is a good choice).
Starting code:
class CompanyDetailsRepository(
private val client: CompanyDetailsClient,
dispatcher: CoroutineDispatcher
) {
private val details = mutableMapOf<Company, CompanyDetails>()
suspend fun getDetails(company: Company): CompanyDetails {
val current = getDetailsOrNull(company)
if (current == null) {
val companyDetails = client.fetchDetails(company)
details[company] = companyDetails
return companyDetails
}
return current
}
fun getDetailsOrNull(company: Company): CompanyDetails? =
details[company]
fun getReadyDetails(): Map<Company, CompanyDetails> =
details
fun clear() {
details.clear()
}
}
This problem can either be solved in the below playground or you can clone kotlin-exercises project and solve it locally. In the project, you can find code template for this exercise in effective/safe/CompanyDetailsRepository.kt. You can find there starting code and unit tests.
On the project, you can also find performance tests that can help you test the performance of each solution. Use them, and note down the results.
Once you are done with the exercise, you can check your solution here.
Playground
import kotlinx.coroutines.*
import kotlinx.coroutines.test.currentTime
import kotlinx.coroutines.test.runTest
import java.math.BigDecimal
import org.junit.Ignore
import org.junit.Test
import kotlin.test.assertEquals
import kotlin.time.measureTime
class CompanyDetailsRepository(
private val client: CompanyDetailsClient,
dispatcher: CoroutineDispatcher
) {
private val details = mutableMapOf<Company, CompanyDetails>()
suspend fun getDetails(company: Company): CompanyDetails {
val current = getDetailsOrNull(company)
if (current == null) {
val companyDetails = client.fetchDetails(company)
details[company] = companyDetails
return companyDetails
}
return current
}
fun getDetailsOrNull(company: Company): CompanyDetails? =
details[company]
fun getReadyDetails(): Map<Company, CompanyDetails> =
details
fun clear() {
details.clear()
}
}
// Run in main
suspend fun performanceTest(): Unit = coroutineScope {
val companies = (0 until 100_000).map { Company(it.toString()) }
val client = FakeCompanyDetailsClient(
details = buildMap {
companies.forEach { put(it, CompanyDetails("Company${it.id}", "Address${it.id}", BigDecimal.TEN)) }
}
)
val repository = CompanyDetailsRepository(client, Dispatchers.IO)
val dispatcher = newFixedThreadPoolContext(100, "test")
// The time of getting and storing details
measureTime {
companies.map { async(dispatcher) { repository.getDetails(it) } }.awaitAll()
}.also {
val averageTime = it.inWholeNanoseconds / companies.size
println("Average time of getting details: $averageTime ns")
}
// The time of getting details from cache
measureTime {
companies.map { async(dispatcher) { repository.getDetailsOrNull(it) } }.awaitAll()
}.also {
val averageTime = it.inWholeNanoseconds / companies.size
println("Average time of getting details from cache: $averageTime ns")
}
// The time of getting all details
val repeats = 1000
measureTime {
coroutineScope {
repeat(repeats) {
launch(dispatcher) {
repository.getReadyDetails()
}
}
}
}.also {
val averageTime = it.inWholeNanoseconds / repeats
println("Time of getting all details: $averageTime ns")
}
}
interface CompanyDetailsClient {
suspend fun fetchDetails(company: Company): CompanyDetails
}
data class CompanyDetails(val name: String, val address: String, val revenue: BigDecimal)
data class Company(val id: String)
@OptIn(ExperimentalStdlibApi::class)
class CompanyDetailsRepositoryTest {
@Test
fun `detailsFor should fetch details from client`() = runTest {
// given
val company = Company("1")
val details = CompanyDetails("Company", "Address", BigDecimal.TEN)
val client = FakeCompanyDetailsClient()
client.setDetails(company, details)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
// when
val result = repository.getDetails(company)
// then
assertEquals(details, result)
}
@Test
fun `detailsFor should cache details`() = runTest {
// given
val company = Company("1")
val details = CompanyDetails("Company", "Address", BigDecimal.TEN)
val client = FakeCompanyDetailsClient(
details = mapOf(company to details),
delay = 1000
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
// when
val result1 = repository.getDetails(company)
// then
assertEquals(details, result1)
assertEquals(1000, currentTime)
// when
client.clear()
// then
val result = repository.getDetails(company)
assertEquals(details, result)
}
@Test
fun `getReadyDetails should return all details`() = runTest {
// given
val company1 = Company("1")
val company2 = Company("2")
val details1 = CompanyDetails("Company1", "Address1", BigDecimal.TEN)
val details2 = CompanyDetails("Company2", "Address2", BigDecimal.ONE)
val client = FakeCompanyDetailsClient(
details = mapOf(company1 to details1, company2 to details2)
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
// when
repository.getDetails(company1)
repository.getDetails(company2)
val result = repository.getReadyDetails()
// then
assertEquals(mapOf(company1 to details1, company2 to details2), result)
}
@Test
fun `getReadyDetails should fetch details asynchronously`() = runTest {
// given
val company1 = Company("1")
val company2 = Company("2")
val details1 = CompanyDetails("Company1", "Address1", BigDecimal.TEN)
val details2 = CompanyDetails("Company2", "Address2", BigDecimal.ONE)
val client = FakeCompanyDetailsClient(
details = mapOf(company1 to details1, company2 to details2),
delay = 1000,
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
// when
coroutineScope {
launch {
repository.getDetails(company1)
assertEquals(1000, currentTime)
}
launch {
repository.getDetails(company2)
assertEquals(1000, currentTime)
}
}
val result = repository.getReadyDetails()
// then
assertEquals(mapOf(company1 to details1, company2 to details2), result)
assertEquals(1000, currentTime)
}
@Test
fun `should not expose internal collection`() = runTest {
// given
val company = Company("1")
val details = CompanyDetails("Company", "Address", BigDecimal.TEN)
val client = FakeCompanyDetailsClient(
details = mapOf(company to details)
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
val detailsMap = repository.getReadyDetails()
// when
repository.getDetails(company)
// then
assertEquals(mapOf(), detailsMap)
}
@Test
fun `getDetailsOrNull should return details if exists`() = runTest {
// given
val company = Company("1")
val company2 = Company("2")
val details = CompanyDetails("Company", "Address", BigDecimal.TEN)
val client = FakeCompanyDetailsClient(
details = mapOf(company to details)
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
// then
assertEquals(null, repository.getDetailsOrNull(company))
assertEquals(null, repository.getDetailsOrNull(company2))
// when
repository.getDetails(company)
// then
assertEquals(details, repository.getDetailsOrNull(company))
assertEquals(null, repository.getDetailsOrNull(company2))
}
Synchronization tests
@Test
fun `should cache all details`() = runBlocking(Dispatchers.IO) {
val parallelCalls = 10_000
val companies = (0 until parallelCalls).map { Company(it.toString()) }
val client = FakeCompanyDetailsClient(
details = buildMap {
companies.forEach { put(it, CompanyDetails("Company${it.id}", "Address${it.id}", BigDecimal.TEN)) }
}
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
coroutineScope {
for (company in companies) {
launch {
val details = repository.getDetails(company)
assertEquals(
CompanyDetails("Company${company.id}", "Address${company.id}", BigDecimal.TEN),
details
)
}
}
}
assertEquals(parallelCalls, repository.getReadyDetails().size)
}
@Test
fun `should not have conflict when changing details and getting all`() = runBlocking(Dispatchers.IO) {
val parallelCalls = 10_000
val companies = (0 until parallelCalls).map { Company(it.toString()) }
val client = FakeCompanyDetailsClient(
details = buildMap {
companies.forEach { put(it, CompanyDetails("Company${it.id}", "Address${it.id}", BigDecimal.TEN)) }
}
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
for (company in companies) {
launch { repository.getDetails(company) }
}
repeat(1000) {
launch { repository.getReadyDetails() }
}
}
@Test
@Ignore
fun `should not fetch the same details twice`() = runTest {
val company = Company("1")
val details = CompanyDetails("Company", "Address", BigDecimal.TEN)
val client = FakeCompanyDetailsClient(
details = mapOf(company to details),
delay = 1000
)
val repository = CompanyDetailsRepository(client, coroutineContext[CoroutineDispatcher]!!)
coroutineScope {
launch { repository.getDetails(company) }
launch { repository.getDetails(company) }
}
assertEquals(1, client.calls)
}
}
class FakeCompanyDetailsClient(
details: Map<Company, CompanyDetails> = emptyMap(),
var delay: Long = 0,
) : CompanyDetailsClient {
private val details: MutableMap<Company, CompanyDetails> = details.toMutableMap()
var calls = 0
private set
override suspend fun fetchDetails(company: Company): CompanyDetails {
calls++
delay(delay)
return details[company] ?: error("Company not found")
}
fun setDetails(company: Company, details: CompanyDetails) {
this.details[company] = details
}
fun clear() {
details.clear()
delay = 0
}
}
