[Junie] IO overloads tests

AndreiKingsley · AndreiKingsley · commit 6331f917d985 · 2025-11-12T15:29:43.000+04:00
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/GuessOverloadsTest.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/GuessOverloadsTest.kt
@@ -0,0 +1,41 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+import java.nio.file.Files
+import java.nio.file.Path
+import kotlin.io.path.createTempDirectory
+import kotlin.io.path.writeText
+
+class GuessOverloadsTest {
+
+    private fun sampleJson(): String = """
+        [
+          {"name":"Alice","age":15},
+          {"name":"Bob","age":20}
+        ]
+    """.trimIndent()
+
+    @Test
+    fun read_guess_overloads_String_Path_File_produce_same_df() {
+        val tmp: Path = createTempDirectory("guess_overloads_")
+        try {
+            val p = tmp.resolve("people.json")
+            p.writeText(sampleJson())
+
+            val d1 = DataFrame.read(p.toString())
+            val d2 = DataFrame.read(p)
+            val d3 = DataFrame.read(p.toFile())
+
+            d2.rowsCount() shouldBe d1.rowsCount()
+            d3.rowsCount() shouldBe d1.rowsCount()
+            d2.columnNames() shouldBe d1.columnNames()
+            d3.columnNames() shouldBe d1.columnNames()
+            d2.toJson() shouldBe d1.toJson()
+            d3.toJson() shouldBe d1.toJson()
+        } finally {
+            Files.walk(tmp).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/HtmlOverloadsTest.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/HtmlOverloadsTest.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.junit.Test
+import org.junit.Assert.assertEquals
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.nio.file.Path
+import kotlin.io.path.createTempDirectory
+
+class HtmlOverloadsTest {
+
+    @Test
+    fun writeHtml_overloads_String_Path_File_produce_same_content() {
+        val html = DataFrameHtmlData(style = "body{color:black;}", body = "<div>hello</div>", script = "console.log('x')")
+        val expected = html.toString()
+
+        val tmpDir: Path = createTempDirectory("html_overloads_")
+        try {
+            val pathOut = tmpDir.resolve("out_path.html")
+            val fileOut = tmpDir.resolve("out_file.html").toFile()
+            val strOut = tmpDir.resolve("out_str.html").toString()
+
+            html.writeHtml(pathOut)
+            html.writeHtml(fileOut)
+            html.writeHtml(strOut)
+
+            fun readText(p: Path): String = String(Files.readAllBytes(p), Charsets.UTF_8)
+            assertEquals(expected, readText(pathOut))
+            assertEquals(expected, readText(fileOut.toPath()))
+            assertEquals(expected, readText(Paths.get(strOut)))
+        } finally {
+            Files.walk(tmpDir).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ImportDataSchemaOverloadsTest.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/jupyter/ImportDataSchemaOverloadsTest.kt
@@ -0,0 +1,39 @@
+package org.jetbrains.kotlinx.dataframe.jupyter
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.createTempDirectory
+
+class ImportDataSchemaOverloadsTest {
+
+    @Test
+    fun importDataSchema_constructors_and_functions_produce_same_url() {
+        val tmp: Path = createTempDirectory("ids_overloads_")
+        try {
+            val file = tmp.resolve("schema.json").toFile().also { it.writeText("{}") }
+            val path = file.toPath()
+            val str = path.toUri().toString() // String-оверлоад ожидает URL/URI-строку
+
+            // constructors
+            val c1 = ImportDataSchema(str).url
+            val c2 = ImportDataSchema(path).url
+            val c3 = ImportDataSchema(file).url
+
+            assertEquals(c1, c2)
+            assertEquals(c1, c3)
+
+            // top-level functions
+            val f1 = importDataSchema(str).url
+            val f2 = importDataSchema(path).url
+            val f3 = importDataSchema(file).url
+
+            assertEquals(f1, f2)
+            assertEquals(f1, f3)
+        } finally {
+            Files.walk(tmp).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/dataframe-arrow/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ArrowOverloadsSmokeTest.kt b/dataframe-arrow/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ArrowOverloadsSmokeTest.kt
@@ -0,0 +1,71 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.createTempDirectory
+
+class ArrowOverloadsSmokeTest {
+
+    @Test
+    fun feather_overloads_roundtrip() {
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        )
+        val tmp: Path = createTempDirectory("arrow_overloads_")
+        try {
+            val p = tmp.resolve("people_path.feather")
+            val f = tmp.resolve("people_file.feather").toFile()
+            val s = tmp.resolve("people_str.feather").toString()
+
+            // write with three overloads
+            df.writeArrowFeather(p)
+            df.writeArrowFeather(f)
+            // no String overload for write; only File/Path are supported
+
+            // read back the SAME file using different overloads
+            val r1 = DataFrame.readArrowFeather(p)
+            val r2 = DataFrame.readArrowFeather(p.toFile())
+            val r3 = DataFrame.readArrowFeather(p.toString())
+
+            r1.rowsCount() shouldBe df.rowsCount()
+            r2.rowsCount() shouldBe df.rowsCount()
+            r3.rowsCount() shouldBe df.rowsCount()
+            r1.columnNames() shouldBe df.columnNames()
+            r2.columnNames() shouldBe df.columnNames()
+            r3.columnNames() shouldBe df.columnNames()
+        } finally {
+            Files.walk(tmp).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+
+    @Test
+    fun ipc_overloads_write_and_read() {
+        val df = dataFrameOf("x")(
+            1,
+            2,
+        )
+        val tmp: Path = createTempDirectory("arrow_overloads_ipc_")
+        try {
+            val p = tmp.resolve("data_path.arrow")
+            val f = tmp.resolve("data_file.arrow").toFile()
+            val s = tmp.resolve("data_str.arrow").toString()
+
+            df.writeArrowIPC(p)
+            df.writeArrowIPC(f)
+            // no String overload for write; only File/Path are supported
+
+            // read back the SAME file using a different overload (String)
+            val r = DataFrame.readArrowIPC(p.toString())
+            r.rowsCount() shouldBe df.rowsCount()
+            r.columnNames() shouldBe df.columnNames()
+        } finally {
+            Files.walk(tmp).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvOverloadsTest.kt b/dataframe-csv/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/CsvOverloadsTest.kt
@@ -0,0 +1,80 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.junit.Test
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import kotlin.io.path.createTempDirectory
+import kotlin.io.path.createTempFile
+import kotlin.io.path.deleteExisting
+import kotlin.io.path.writeText
+
+class CsvOverloadsTest {
+
+    private fun sampleCsv(): String = buildString {
+        appendLine("name,age")
+        appendLine("Alice,15")
+        appendLine("Bob,20")
+    }
+
+    @Test
+    fun readCsv_overloads_String_Path_File_produce_same_df() {
+        val tmpDir: Path = createTempDirectory("csv_overloads_read_")
+        try {
+            val csvPath = tmpDir.resolve("people.csv")
+            csvPath.writeText(sampleCsv())
+
+            val dfFromString = DataFrame.readCsv(csvPath.toString())
+            val dfFromPath = DataFrame.readCsv(csvPath)
+            val dfFromFile = DataFrame.readCsv(csvPath.toFile())
+
+            dfFromPath.rowsCount() shouldBe dfFromString.rowsCount()
+            dfFromFile.rowsCount() shouldBe dfFromString.rowsCount()
+            dfFromPath.columnNames() shouldBe dfFromString.columnNames()
+            dfFromFile.columnNames() shouldBe dfFromString.columnNames()
+            // compare serialized CSV text to avoid dependency on row order formatters
+            dfFromPath.toCsvStr() shouldBe dfFromString.toCsvStr()
+            dfFromFile.toCsvStr() shouldBe dfFromString.toCsvStr()
+        } finally {
+            Files.walk(tmpDir)
+                .sorted(Comparator.reverseOrder())
+                .forEach { it.toFile().delete() }
+        }
+    }
+
+    @Test
+    fun writeDelim_overloads_String_Path_File_roundtrip() {
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        )
+
+        val tmpDir: Path = createTempDirectory("csv_overloads_write_")
+        try {
+            val pathOut = tmpDir.resolve("out_path.csv")
+            val fileOut = tmpDir.resolve("out_file.csv").toFile()
+            val strOut = tmpDir.resolve("out_str.csv").toString()
+
+            // write using three overloads
+            df.writeDelim(pathOut)
+            df.writeDelim(fileOut)
+            df.writeDelim(strOut)
+
+            // read back with any overload (use Path for uniformity)
+            val readPath = DataFrame.readCsv(pathOut)
+            val readFile = DataFrame.readCsv(fileOut)
+            val readStr = DataFrame.readCsv(strOut)
+
+            readPath.toCsvStr() shouldBe df.toCsvStr()
+            readFile.toCsvStr() shouldBe df.toCsvStr()
+            readStr.toCsvStr() shouldBe df.toCsvStr()
+        } finally {
+            Files.walk(tmpDir)
+                .sorted(Comparator.reverseOrder())
+                .forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/dataframe-excel/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ExcelOverloadsTest.kt b/dataframe-excel/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/ExcelOverloadsTest.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.junit.Test
+import org.junit.Assert.assertTrue
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.createTempDirectory
+
+class ExcelOverloadsTest {
+
+    @Test
+    fun writeExcel_overloads_String_Path_File_create_nonempty_files() {
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        )
+
+        val tmpDir: Path = createTempDirectory("excel_overloads_write_")
+        try {
+            val pathOut = tmpDir.resolve("out_path.xlsx")
+            val fileOut = tmpDir.resolve("out_file.xlsx").toFile()
+            val strOut = tmpDir.resolve("out_str.xlsx").toString()
+
+            df.writeExcel(pathOut)
+            df.writeExcel(fileOut)
+            df.writeExcel(strOut)
+
+            assertTrue(Files.exists(pathOut) && Files.size(pathOut) > 0L)
+            assertTrue(Files.exists(fileOut.toPath()) && Files.size(fileOut.toPath()) > 0L)
+            val strOutPath = Paths.get(strOut)
+            assertTrue(Files.exists(strOutPath) && Files.size(strOutPath) > 0L)
+        } finally {
+            Files.walk(tmpDir).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/dataframe-json/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/JsonOverloadsTest.kt b/dataframe-json/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/JsonOverloadsTest.kt
@@ -0,0 +1,87 @@
+package org.jetbrains.kotlinx.dataframe.io
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyRow
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import kotlin.test.Test
+import kotlin.test.assertTrue
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import kotlin.io.path.createTempDirectory
+import kotlin.io.path.writeText
+
+class JsonOverloadsTest {
+
+    private fun sampleJson(): String = """
+        [
+          {"name":"Alice","age":15},
+          {"name":"Bob","age":20}
+        ]
+    """.trimIndent()
+
+    @Test
+    fun readJson_overloads_String_Path_File_produce_same_df() {
+        val tmpDir: Path = createTempDirectory("json_overloads_read_")
+        try {
+            val jsonPath = tmpDir.resolve("people.json")
+            jsonPath.writeText(sampleJson())
+
+            val dfFromString = DataFrame.readJson(jsonPath.toString())
+            val dfFromPath = DataFrame.readJson(jsonPath)
+            val dfFromFile = DataFrame.readJson(jsonPath.toFile())
+
+            dfFromPath.rowsCount() shouldBe dfFromString.rowsCount()
+            dfFromFile.rowsCount() shouldBe dfFromString.rowsCount()
+            dfFromPath.columnNames() shouldBe dfFromString.columnNames()
+            dfFromFile.columnNames() shouldBe dfFromString.columnNames()
+
+            // serialize back to JSON (order-insensitive enough for this sample) and compare sizes
+            dfFromPath.toJson() shouldBe dfFromString.toJson()
+            dfFromFile.toJson() shouldBe dfFromString.toJson()
+        } finally {
+            Files.walk(tmpDir).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+
+    @Test
+    fun writeJson_overloads_String_Path_File_roundtrip_df_and_row() {
+        val df = dataFrameOf("name", "age")(
+            "Alice", 15,
+            "Bob", 20,
+        )
+        val row: AnyRow = df[0]
+
+        val tmpDir: Path = createTempDirectory("json_overloads_write_")
+        try {
+            val pathOut = tmpDir.resolve("out_path.json")
+            val fileOut = tmpDir.resolve("out_file.json").toFile()
+            val strOut = tmpDir.resolve("out_str.json").toString()
+
+            df.writeJson(pathOut, prettyPrint = true)
+            df.writeJson(fileOut, prettyPrint = true)
+            df.writeJson(strOut, prettyPrint = true)
+
+            // read back using three overloads
+            val readP = DataFrame.readJson(pathOut)
+            val readF = DataFrame.readJson(fileOut)
+            val readS = DataFrame.readJson(strOut)
+
+            readP.toJson() shouldBe df.toJson()
+            readF.toJson() shouldBe df.toJson()
+            readS.toJson() shouldBe df.toJson()
+
+            // AnyRow writeJson overloads do not read back; verify they produce files
+            row.writeJson(tmpDir.resolve("row_path.json"))
+            row.writeJson(tmpDir.resolve("row_file.json").toFile())
+            row.writeJson(tmpDir.resolve("row_str.json").toString())
+
+            assertTrue(Files.size(tmpDir.resolve("row_path.json")) > 0L)
+            assertTrue(Files.size(tmpDir.resolve("row_file.json")) > 0L)
+            assertTrue(Files.size(tmpDir.resolve("row_str.json")) > 0L)
+        } finally {
+            Files.walk(tmpDir).sorted(Comparator.reverseOrder()).forEach { it.toFile().delete() }
+        }
+    }
+}
diff --git a/dataframe-openapi-generator/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/IsOpenApiOverloadsTest.kt b/dataframe-openapi-generator/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/IsOpenApiOverloadsTest.kt
