refactor: migrate all tests to kotest

api/build.gradle.kts

@@ -25,8 +25,8 @@ dependencies {
   implementation(libs.dagger)
   implementation(libs.javax.inject)
   testImplementation(testFixtures(libs.eithernet))
-  testImplementation(kotlin("test-junit"))
+  testImplementation(libs.kotest.assertions.core)
-  testImplementation(libs.kotlinx.coroutines.core)
+  testImplementation(libs.kotest.runner.junit5)
   testImplementation(libs.kotlinx.serialization.json)
   testImplementation(libs.retrofit.kotlinxSerializationConverter)
 }

api/src/test/kotlin/dev/msfjarvis/claw/api/ApiTest.kt

@@ -11,42 +11,40 @@ import com.slack.eithernet.test.newEitherNetController
 import dev.msfjarvis.claw.model.LobstersPost
 import dev.msfjarvis.claw.model.LobstersPostDetails
 import dev.msfjarvis.claw.model.User
-import kotlin.test.Test
+import io.kotest.core.spec.style.FunSpec
-import kotlin.test.assertEquals
+import io.kotest.matchers.collections.shouldHaveSize
-import kotlin.test.assertIs
+import io.kotest.matchers.shouldBe
-import kotlinx.coroutines.runBlocking
+import io.kotest.matchers.types.shouldBeTypeOf
 
-class ApiTest {
+class ApiTest : FunSpec() {
   private val wrapper = ApiWrapper(newEitherNetController())
   private val api
     get() = wrapper.api
 
-  @Test
+  init {
-  fun `api gets correct number of items`() = runBlocking {
+    test("api gets correct number of items") {
       val posts = api.getHottestPosts(1)
-    assertIs<Success<List<LobstersPost>>>(posts)
+      posts.shouldBeTypeOf<Success<List<LobstersPost>>>()
-    assertEquals(25, posts.value.size)
+      posts.value shouldHaveSize 25
     }
 
-  @Test
+    test("posts with no urls") {
-  fun `posts with no urls`() = runBlocking {
       val posts = api.getHottestPosts(1)
-    assertIs<Success<List<LobstersPost>>>(posts)
+      posts.shouldBeTypeOf<Success<List<LobstersPost>>>()
       val commentsOnlyPosts = posts.value.asSequence().filter { it.url.isEmpty() }.toSet()
-    assertEquals(2, commentsOnlyPosts.size)
+      commentsOnlyPosts shouldHaveSize 2
     }
 
-  @Test
+    test("post details with comments") {
-  fun `post details with comments`() = runBlocking {
       val postDetails = api.getPostDetails("tdfoqh")
-    assertIs<Success<LobstersPostDetails>>(postDetails)
+      postDetails.shouldBeTypeOf<Success<LobstersPostDetails>>()
-    assertEquals(7, postDetails.value.comments.size)
+      postDetails.value.comments shouldHaveSize 7
     }
 
-  @Test
+    test("get user details") {
-  fun `get user details`() = runBlocking {
       val user = api.getUser("msfjarvis")
-    assertIs<Success<User>>(user)
+      user.shouldBeTypeOf<Success<User>>()
-    assertEquals("msfjarvis", user.value.username)
+      user.value.username shouldBe "msfjarvis"
+    }
   }
 }

api/src/test/kotlin/dev/msfjarvis/claw/api/ApiWrapper.kt

@@ -27,7 +27,7 @@ class ApiWrapper(controller: EitherNetController<LobstersApi>) {
 
   init {
     controller.enqueue(LobstersApi::getHottestPosts) { success(hottest) }
-    controller.enqueue(LobstersApi::getNewestPosts) { success(hottest) }
+    controller.enqueue(LobstersApi::getHottestPosts) { success(hottest) }
     controller.enqueue(LobstersApi::getPostDetails) { success(postDetails) }
     controller.enqueue(LobstersApi::getUser) { success(user) }
   }

build-logic/kotlin-plugins/src/main/kotlin/dev/msfjarvis/aps/gradle/KotlinCommonPlugin.kt

@@ -37,6 +37,7 @@ class KotlinCommonPlugin : Plugin<Project> {
       withType<Test>().configureEach {
         maxParallelForks = Runtime.getRuntime().availableProcessors() * 2
         testLogging { events(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED) }
+        useJUnitPlatform()
       }
     }
   }

database/build.gradle.kts

@@ -33,7 +33,8 @@ dependencies {
   implementation(projects.core)
   implementation(libs.sqldelight.androidDriver)
   implementation(libs.sqldelight.primitiveAdapters)
-  testImplementation(libs.sqldelight.jvmDriver)
+  testImplementation(libs.kotest.assertions.core)
+  testImplementation(libs.kotest.runner.junit5)
   testImplementation(libs.kotlinx.coroutines.core)
-  testImplementation(kotlin("test-junit"))
+  testImplementation(libs.sqldelight.jvmDriver)
 }

database/src/test/kotlin/dev/msfjarvis/claw/database/local/SqlDelightQueriesTest.kt

@@ -10,17 +10,17 @@ import app.cash.sqldelight.adapter.primitive.IntColumnAdapter
 import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
 import dev.msfjarvis.claw.database.LobstersDatabase
 import dev.msfjarvis.claw.database.model.TagsAdapter
-import kotlin.test.Test
+import io.kotest.core.spec.style.FunSpec
-import kotlin.test.assertEquals
+import io.kotest.matchers.collections.shouldBeEmpty
-import kotlinx.coroutines.runBlocking
+import io.kotest.matchers.collections.shouldHaveSize
-import org.junit.Before
+import io.kotest.matchers.shouldBe
 
-class SqlDelightQueriesTest {
+class SqlDelightQueriesTest : FunSpec() {
 
   private lateinit var postQueries: SavedPostQueries
 
-  @Before
+  init {
-  fun setUp() {
+    beforeEach {
       val driver = JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY)
       LobstersDatabase.Schema.create(driver)
       val database =
@@ -31,31 +31,17 @@ class SqlDelightQueriesTest {
       postQueries = database.savedPostQueries
     }
 
-  @Test
+    test("add and count posts") {
-  fun selectCount() = runBlocking {
       val posts = createTestData(5)
 
       posts.forEach { postQueries.insertOrReplacePost(it) }
 
       val postCount = postQueries.selectCount().executeAsOne()
-    assertEquals(5, postCount)
-  }
-
-  @Test
-  fun insertIntoDatabase() = runBlocking {
-    // Get 5 posts
-    val posts = createTestData(5)
-
-    // Insert posts into DB
-    posts.forEach { postQueries.insertOrReplacePost(it) }
 
-    // Check post count
+      postCount shouldBe 5
-    val postsCount = postQueries.selectCount().executeAsOne()
-    assertEquals(5, postsCount)
     }
 
-  @Test
+    test("update post in database") {
-  fun replaceFromDatabase() = runBlocking {
       // Get 1 post
       val post = createTestData(1)[0]
 
@@ -68,15 +54,15 @@ class SqlDelightQueriesTest {
 
       // Check post count
       val postsCount = postQueries.selectCount().executeAsOne()
-    assertEquals(1, postsCount)
+      postsCount shouldBe 1
 
       // Check if post is updated
       val postFromDb = postQueries.selectPost(post.shortId).executeAsOne()
-    assertEquals("Fake name", postFromDb.submitterName)
+
+      postFromDb.submitterName shouldBe "Fake name"
     }
 
-  @Test
+    test("get post from db") {
-  fun selectPost() = runBlocking {
       // Get 1 post
       val post = createTestData(1)[0]
 
@@ -84,11 +70,10 @@ class SqlDelightQueriesTest {
       postQueries.insertOrReplacePost(post)
 
       val postFromDb = postQueries.selectAllPosts().executeAsOne()
-    assertEquals("test_id_1", postFromDb.shortId)
+      postFromDb.shortId shouldBe "test_id_1"
     }
 
-  @Test
+    test("get multiple posts from db") {
-  fun selectAllPosts() = runBlocking {
       // Get 5 post
       val posts = createTestData(5)
 
@@ -98,13 +83,10 @@ class SqlDelightQueriesTest {
       val postsFromDb = postQueries.selectAllPosts().executeAsList()
 
       // Check if all posts have correct shortId
-    for (i in 1..5) {
+      postsFromDb.forEachIndexed { index, post -> post.shortId shouldBe "test_id_${index.inc()}" }
-      assertEquals("test_id_$i", postsFromDb[i - 1].shortId)
-    }
     }
 
-  @Test
+    test("delete post") {
-  fun deletePost() = runBlocking {
       // Create 3 posts and insert them to DB
       val posts = createTestData(3)
       posts.forEach { postQueries.insertOrReplacePost(it) }
@@ -115,13 +97,12 @@ class SqlDelightQueriesTest {
       val postsFromDB = postQueries.selectAllPosts().executeAsList()
 
       // Check if size is 2, and only the correct post is deleted
-    assertEquals(2, postsFromDB.size)
+      postsFromDB shouldHaveSize 2
-    assertEquals("test_id_1", postsFromDB[0].shortId)
+      postsFromDB[0].shortId shouldBe "test_id_1"
-    assertEquals("test_id_3", postsFromDB[1].shortId)
+      postsFromDB[1].shortId shouldBe "test_id_3"
     }
 
-  @Test
+    test("delete all posts") {
-  fun deleteAllPost() = runBlocking {
       // Create 5 posts and insert them to DB
       val posts = createTestData(5)
       posts.forEach { postQueries.insertOrReplacePost(it) }
@@ -129,10 +110,10 @@ class SqlDelightQueriesTest {
       // Delete all posts
       postQueries.deleteAllPosts()
 
-    val postsCount = postQueries.selectCount().executeAsOne()
+      val dbPosts = postQueries.selectAllPosts().executeAsList()
 
-    // Check if db is empty
+      dbPosts.shouldBeEmpty()
-    assertEquals(0, postsCount)
+    }
   }
 
   private fun createTestData(count: Int): ArrayList<SavedPost> {