Fix unit tests

Author: ashtanko

README.md

@@ -22,23 +22,23 @@
 
 ### Metrics
 ```text
-14991 number of properties
-10385 number of functions
-8856 number of classes
+14993 number of properties
+10384 number of functions
+8855 number of classes
 229 number of packages
 3486 number of kt files
 ```
 
 
 ### Complexity Report
 ```text
-259507 lines of code (loc)
-158943 source lines of code (sloc)
-115975 logical lines of code (lloc)
-72503 comment lines of code (cloc)
-24705 cyclomatic complexity (mcc)
-20233 cognitive complexity
+259493 lines of code (loc)
+158946 source lines of code (sloc)
+115976 logical lines of code (lloc)
+72487 comment lines of code (cloc)
+24701 cyclomatic complexity (mcc)
+20232 cognitive complexity
 0 number of total code smells
 45 comment source ratio
-213 mcc per 1,000 lloc
+212 mcc per 1,000 lloc
 ```

build.gradle.kts

@@ -35,7 +35,7 @@ plugins {
     application
     jacoco
     id("com.github.johnrengelman.shadow") version "8.1.1"
-    // id ("org.sonarqube") version "4.4.1.3373"
+    id("org.jetbrains.kotlinx.binary-compatibility-validator") version "0.17.0"
     idea
     alias(libs.plugins.kt.jvm)
     alias(libs.plugins.detekt)

gradle/libs.versions.toml

@@ -34,6 +34,7 @@ truth = "1.4.4"             # https://central.sonatype.com/artifact/com.google.t
 sandwich = "2.1.0"          # https://github.com/skydoves/sandwich
 protobuf = "0.9.2"
 protoc = "4.30.2"
+binaryCompatibility = "0.17.0"
 
 [libraries]
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "coroutines" }
@@ -96,3 +97,4 @@ kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
 diktat = { id = "com.saveourtool.diktat", version.ref = "diktat" }
 ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }
 protobuf = { id = "com.google.protobuf", version.ref = "protobuf" }
+kotlin-binary-compatibility = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binaryCompatibility" }

src/test/kotlin/dev/shtanko/retry/RetryTest.kt

@@ -8,6 +8,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.test.runTest
 import okhttp3.ExperimentalOkHttpApi
 import okhttp3.ResponseBody
@@ -16,6 +18,7 @@ import okhttp3.mockwebserver.MockWebServer
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.RepeatedTest
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import retrofit2.HttpException
@@ -76,36 +79,38 @@ class RetryTest {
         assertEquals(3, counter, "Should retry 3 times before failing")
     }
 
-    @Test
+    @RepeatedTest(10)
     fun `should handle concurrency and correctly update attempt`() = runTest {
-        // Set up a CountDownLatch to wait for all coroutines to finish
         val latch = CountDownLatch(5)
         val retryAttempts = mutableListOf<Int>()
         val expectedAttempts = 5
+        val mutex = Mutex()
 
+        // Launch multiple coroutines to simulate concurrent retries
         val job = CoroutineScope(Dispatchers.Default).launch {
             repeat(expectedAttempts) {
                 launch {
+                    var attempt = 0
                     try {
-                        retry(policy = DefaultRetryPolicy(maxAttempts = 3)) {
+                        retry(policy = DefaultRetryPolicy(maxAttempts = 3)) { currentAttempt ->
+                            attempt = currentAttempt
                             throw IOException("Simulated failure")
                         }
-                    } catch (e: IOException) {
-                        // Capture the attempt number from AtomicInteger (using attempt.get())
-                        retryAttempts.add(e.message?.let { "Failed on attempt: $it" }?.length ?: -1)
+                    } catch (_: IOException) {
+                        mutex.withLock {
+                            retryAttempts.add(attempt)
+                        }
                     } finally {
                         latch.countDown()
                     }
                 }
             }
         }
 
-        latch.await() // Wait for all coroutines to finish
-
-        // Verify that all attempts are captured correctly
-        assertTrue(retryAttempts.size == expectedAttempts)
-        retryAttempts.forEach {
-            assertTrue(it > 0) // Ensure retry attempts were recorded
+        latch.await()
+        assertEquals(expectedAttempts, retryAttempts.size)
+        retryAttempts.forEach { attempt ->
+            assertTrue(attempt in 1..3, "Retry attempt should be between 1 and 3")
         }
 
         job.cancelAndJoin()