added tests with SQLDelight library

Author: wojta

build.gradle.kts

@@ -10,6 +10,7 @@ plugins {
     alias(libs.plugins.detekt)
     alias(libs.plugins.dokka)
     alias(libs.plugins.kover)
+    alias(libs.plugins.sqldelight)
     id("maven-publish")
     id("signing")
 }
@@ -87,7 +88,15 @@ kotlin {
             }
         }
         val jsTest by getting {
+            sqldelight {
+                databases {
+                    create("Database") {
+                        packageName.set("com.example")
+                        generateAsync.set(true)
 
+                    }
+                }
+            }
         }
 
         val publicationsFromMainHost =
@@ -178,6 +187,7 @@ kotlin {
                         password = System.getenv("SONATYPE_PASSWORD") ?: localProperties["sonatype.password"] as String?
                     }
                 }
+                mavenLocal()
             }
         }
 

gradle/libs.versions.toml

@@ -19,4 +19,5 @@ detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 kotlin-js = { id = "org.jetbrains.kotlin.js", version.ref = "kotlin" }
-kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
+kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
+sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" }

src/commonMain/sqldelight/com/example/Player.sq

@@ -0,0 +1,32 @@
+CREATE TABLE hockeyPlayer (
+  player_number INTEGER PRIMARY KEY NOT NULL,
+  full_name TEXT NOT NULL
+);
+
+CREATE INDEX hockeyPlayer_full_name ON hockeyPlayer(full_name);
+
+INSERT INTO hockeyPlayer (player_number, full_name)
+VALUES (15, 'Ryan Getzlaf');
+
+
+selectAll:
+SELECT *
+FROM hockeyPlayer;
+
+selectWithLimit:
+SELECT *
+FROM hockeyPlayer LIMIT ?,?;
+
+insert:
+INSERT INTO hockeyPlayer(player_number, full_name)
+VALUES (?, ?);
+
+insertFullPlayerObject:
+INSERT INTO hockeyPlayer(player_number, full_name)
+VALUES ?;
+
+updateName:
+UPDATE hockeyPlayer SET full_name = ? WHERE player_number = ?;
+
+deletePlayer:
+DELETE FROM hockeyPlayer WHERE player_number = ?;

src/jsTest/kotlin/cz/sazel/sqldelight/node/sqlite3/DriverWithLibraryTest.kt

@@ -0,0 +1,124 @@
+package cz.sazel.sqldelight.node.sqlite3
+
+import com.example.Database
+import com.example.HockeyPlayer
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toCollection
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertContains
+import kotlin.test.assertEquals
+
+class DriverWithLibraryTest {
+
+    private lateinit var driver: SQLite3Driver
+    private val dbName = "driver_test.db"
+
+    private fun withDatabase(fn: suspend Database.() -> Unit) = runTest {
+        val dbName = this@DriverWithLibraryTest.dbName
+        js("var fs=require('fs'); if(fs.existsSync(dbName)) fs.unlinkSync(dbName)")
+        try {
+            driver = initSqlite3SqlDriver(filename = "driver_test.db", schema = Database.Schema)
+            val database = Database(driver)
+            database.fn()
+        } finally {
+            js("require('fs').unlinkSync(dbName)")
+        }
+    }
+
+    @Test
+    fun testInitialContents() = withDatabase {
+        playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf()).let {
+            assertEquals(initialPlayer, it.first())
+            assertEquals(1, it.size)
+        }
+    }
+
+    @Test
+    fun testInsert() = withDatabase {
+        val insertedPlayer = HockeyPlayer(player_number = 8, full_name = "Teemu Selanne")
+        transaction {
+            playerQueries.insertFullPlayerObject(insertedPlayer)
+        }
+        playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf()).let {
+            assertContains(it, initialPlayer)
+            assertContains(it, insertedPlayer)
+            assertEquals(2, it.size)
+        }
+    }
+
+    @Test
+    fun testInsertWithCancelledTransaction() = withDatabase {
+        val insertedPlayer = HockeyPlayer(player_number = 18, full_name = "Saku Koivu")
+        try {
+            transaction {
+                playerQueries.insertFullPlayerObject(insertedPlayer)
+                throw RuntimeException("Rollback")
+            }
+        } catch (e: Exception) {
+
+        } finally {
+            playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf()).let {
+                assertContains(it, initialPlayer)
+                assertEquals(1, it.size)
+            }
+        }
+    }
+
+    @Test
+    fun testMultipleInsertsAndPartialCursorRead() = withDatabase {
+        val insertedPlayers = (0..10).map { HockeyPlayer(player_number = 100L + it, full_name = "Player $it") }
+        transaction {
+            insertedPlayers.forEach {
+                playerQueries.insertFullPlayerObject(it)
+            }
+        }
+        playerQueries.selectAll().executeAsFlow().take(4).toCollection(mutableListOf()).let {
+            println(it)
+            assertContains(it, initialPlayer)
+            assertEquals(4, it.size)
+        }
+    }
+
+    @Test
+    fun testUpdate() = withDatabase {
+        val updatedPlayer = initialPlayer.copy(full_name = "Petr Sykora")
+        transaction {
+            playerQueries.updateName(updatedPlayer.full_name, initialPlayer.player_number)
+        }
+        playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf()).let {
+            assertContains(it, updatedPlayer)
+            assertEquals(1, it.size)
+        }
+    }
+
+    @Test
+    fun testDelete() = withDatabase {
+        transaction {
+            playerQueries.deletePlayer(initialPlayer.player_number)
+        }
+        playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf()).let {
+            assertEquals(0, it.size)
+        }
+    }
+
+    @Test
+    fun testSelectWithLimit() = withDatabase {
+        val insertedPlayers = (0..100).map { HockeyPlayer(player_number = 100L + it, full_name = "Player $it") }
+        transaction {
+            insertedPlayers.forEach {
+                playerQueries.insertFullPlayerObject(it)
+            }
+        }
+        val list1 = playerQueries.selectWithLimit(0, 50).executeAsFlow().toCollection(mutableListOf())
+        println(list1.size)
+        val list2 = playerQueries.selectWithLimit(50, 99).executeAsFlow().toCollection(mutableListOf())
+        println(list2.size)
+        val list3 = playerQueries.selectAll().executeAsFlow().toCollection(mutableListOf())
+        println(list3.size)
+    }
+
+    private companion object {
+        val initialPlayer = HockeyPlayer(player_number = 15, full_name = "Ryan Getzlaf")
+    }
+}