refactor: migrate all tests to kotest

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,129 +10,110 @@ 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 kotlin.test.assertEquals
-import kotlinx.coroutines.runBlocking
-import org.junit.Before
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldBeEmpty
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.shouldBe
 
-class SqlDelightQueriesTest {
+class SqlDelightQueriesTest : FunSpec() {
 
   private lateinit var postQueries: SavedPostQueries
 
-  @Before
-  fun setUp() {
-    val driver = JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY)
-    LobstersDatabase.Schema.create(driver)
-    val database =
-      LobstersDatabase(
-        driver,
-        SavedPost.Adapter(IntColumnAdapter, TagsAdapter()),
-      )
-    postQueries = database.savedPostQueries
-  }
-
-  @Test
-  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
-    val postsCount = postQueries.selectCount().executeAsOne()
-    assertEquals(5, postsCount)
-  }
-
-  @Test
-  fun replaceFromDatabase() = runBlocking {
-    // Get 1 post
-    val post = createTestData(1)[0]
-
-    // Insert post into DB
-    postQueries.insertOrReplacePost(post)
-
-    // Create a new post and try replacing it
-    val newPost = post.copy(submitterName = "Fake name")
-    postQueries.insertOrReplacePost(newPost)
-
-    // Check post count
-    val postsCount = postQueries.selectCount().executeAsOne()
-    assertEquals(1, postsCount)
-
-    // Check if post is updated
-    val postFromDb = postQueries.selectPost(post.shortId).executeAsOne()
-    assertEquals("Fake name", postFromDb.submitterName)
-  }
-
-  @Test
-  fun selectPost() = runBlocking {
-    // Get 1 post
-    val post = createTestData(1)[0]
-
-    // Insert post into DB
-    postQueries.insertOrReplacePost(post)
-
-    val postFromDb = postQueries.selectAllPosts().executeAsOne()
-    assertEquals("test_id_1", postFromDb.shortId)
-  }
-
-  @Test
-  fun selectAllPosts() = runBlocking {
-    // Get 5 post
-    val posts = createTestData(5)
-
-    // Insert posts into DB
-    posts.forEach { postQueries.insertOrReplacePost(it) }
-
-    val postsFromDb = postQueries.selectAllPosts().executeAsList()
-
-    // Check if all posts have correct shortId
-    for (i in 1..5) {
-      assertEquals("test_id_$i", postsFromDb[i - 1].shortId)
+  init {
+    beforeEach {
+      val driver = JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY)
+      LobstersDatabase.Schema.create(driver)
+      val database =
+        LobstersDatabase(
+          driver,
+          SavedPost.Adapter(IntColumnAdapter, TagsAdapter()),
+        )
+      postQueries = database.savedPostQueries
     }
-  }
 
-  @Test
-  fun deletePost() = runBlocking {
-    // Create 3 posts and insert them to DB
-    val posts = createTestData(3)
-    posts.forEach { postQueries.insertOrReplacePost(it) }
+    test("add and count posts") {
+      val posts = createTestData(5)
 
-    // Delete 2nd post
-    postQueries.deletePost("test_id_2")
+      posts.forEach { postQueries.insertOrReplacePost(it) }
 
-    val postsFromDB = postQueries.selectAllPosts().executeAsList()
+      val postCount = postQueries.selectCount().executeAsOne()
 
-    // Check if size is 2, and only the correct post is deleted
-    assertEquals(2, postsFromDB.size)
-    assertEquals("test_id_1", postsFromDB[0].shortId)
-    assertEquals("test_id_3", postsFromDB[1].shortId)
-  }
+      postCount shouldBe 5
+    }
+
+    test("update post in database") {
+      // Get 1 post
+      val post = createTestData(1)[0]
+
+      // Insert post into DB
+      postQueries.insertOrReplacePost(post)
+
+      // Create a new post and try replacing it
+      val newPost = post.copy(submitterName = "Fake name")
+      postQueries.insertOrReplacePost(newPost)
+
+      // Check post count
+      val postsCount = postQueries.selectCount().executeAsOne()
+      postsCount shouldBe 1
+
+      // Check if post is updated
+      val postFromDb = postQueries.selectPost(post.shortId).executeAsOne()
+
+      postFromDb.submitterName shouldBe "Fake name"
+    }
+
+    test("get post from db") {
+      // Get 1 post
+      val post = createTestData(1)[0]
+
+      // Insert post into DB
+      postQueries.insertOrReplacePost(post)
+
+      val postFromDb = postQueries.selectAllPosts().executeAsOne()
+      postFromDb.shortId shouldBe "test_id_1"
+    }
 
-  @Test
-  fun deleteAllPost() = runBlocking {
-    // Create 5 posts and insert them to DB
-    val posts = createTestData(5)
-    posts.forEach { postQueries.insertOrReplacePost(it) }
+    test("get multiple posts from db") {
+      // Get 5 post
+      val posts = createTestData(5)
 
-    // Delete all posts
-    postQueries.deleteAllPosts()
+      // Insert posts into DB
+      posts.forEach { postQueries.insertOrReplacePost(it) }
 
-    val postsCount = postQueries.selectCount().executeAsOne()
+      val postsFromDb = postQueries.selectAllPosts().executeAsList()
 
-    // Check if db is empty
-    assertEquals(0, postsCount)
+      // Check if all posts have correct shortId
+      postsFromDb.forEachIndexed { index, post -> post.shortId shouldBe "test_id_${index.inc()}" }
+    }
+
+    test("delete post") {
+      // Create 3 posts and insert them to DB
+      val posts = createTestData(3)
+      posts.forEach { postQueries.insertOrReplacePost(it) }
+
+      // Delete 2nd post
+      postQueries.deletePost("test_id_2")
+
+      val postsFromDB = postQueries.selectAllPosts().executeAsList()
+
+      // Check if size is 2, and only the correct post is deleted
+      postsFromDB shouldHaveSize 2
+      postsFromDB[0].shortId shouldBe "test_id_1"
+      postsFromDB[1].shortId shouldBe "test_id_3"
+    }
+
+    test("delete all posts") {
+      // Create 5 posts and insert them to DB
+      val posts = createTestData(5)
+      posts.forEach { postQueries.insertOrReplacePost(it) }
+
+      // Delete all posts
+      postQueries.deleteAllPosts()
+
+      val dbPosts = postQueries.selectAllPosts().executeAsList()
+
+      dbPosts.shouldBeEmpty()
+    }
   }
 
   private fun createTestData(count: Int): ArrayList<SavedPost> {