Create tests for DbType class

[zaleslaw]

Now, a lot of logic was transferred there, it requires proper mocking testing for

• fallbacks
• raised SQLExceptions
• clear JUnit testing of functionality )now it's covered through integration tests)

[zaleslaw]

package org.jetbrains.kotlinx.dataframe.io.db

import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import org.junit.Test
import java.sql.Connection
import java.sql.DatabaseMetaData
import java.sql.ResultSet
import java.sql.ResultSetMetaData
import java.sql.SQLFeatureNotSupportedException
import java.sql.Statement
import java.sql.Types

class DbTypeMetadataFallbackTest {

    private object TestDbType : DbType("test") {
        override val driverClassName = "org.test.Driver"
        override fun convertSqlTypeToColumnSchemaValue(tableColumnMetadata: TableColumnMetadata) = null
        override fun isSystemTable(tableMetadata: TableMetadata) = false
        override fun buildTableMetadata(tables: ResultSet) = TableMetadata("test", null, null)
        override fun convertSqlTypeToKType(tableColumnMetadata: TableColumnMetadata) = null
    }

    private val notSupported: Nothing get() = throw SQLFeatureNotSupportedException("Not supported")

    private fun mockResultSet(
        columns: List<MockColumn>,
        catalog: () -> String? = { "test_catalog" },
        schema: () -> String? = { "test_schema" },
    ): ResultSet {
        val rsMetaData = mockk<ResultSetMetaData> {
            every { columnCount } returns columns.size
            columns.forEachIndexed { i, col ->
                val idx = i + 1
                every { getColumnName(idx) } answers { col.name() }
                every { getColumnLabel(idx) } answers { col.label() }
                every { getTableName(idx) } answers { col.tableName() }
                every { isNullable(idx) } answers { col.nullable() }
                every { getColumnTypeName(idx) } answers { col.typeName() }
                every { getColumnType(idx) } answers { col.jdbcType() }
                every { getColumnDisplaySize(idx) } answers { col.displaySize() }
                every { getColumnClassName(idx) } answers { col.className() }
            }
        }

        val dbMetaData = mockk<DatabaseMetaData> {
            every { getColumns(any(), any(), any(), any()) } returns mockk {
                every { next() } returns false
                every { close() } returns Unit
            }
        }

        val connection = mockk<Connection> {
            every { this@mockk.catalog } answers { catalog() }
            every { this@mockk.schema } answers { schema() }
            every { metaData } returns dbMetaData
        }

        val statement = mockk<Statement> {
            every { this@mockk.connection } returns connection
        }

        return mockk {
            every { metaData } returns rsMetaData
            every { this@mockk.statement } returns statement
        }
    }

    private data class MockColumn(
        val name: () -> String = { "column" },
        val label: () -> String = { "label" },
        val tableName: () -> String = { "table" },
        val nullable: () -> Int = { ResultSetMetaData.columnNullable },
        val typeName: () -> String = { "VARCHAR" },
        val jdbcType: () -> Int = { Types.VARCHAR },
        val displaySize: () -> Int = { 255 },
        val className: () -> String = { "java.lang.String" },
    )

    @Test
    fun `normal case`() {
        val rs = mockResultSet(
            listOf(
                MockColumn(name = { "id" }, jdbcType = { Types.INTEGER }, nullable = { ResultSetMetaData.columnNoNulls }),
                MockColumn(name = { "name" }),
            ),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].name shouldBe "id"
        columns[0].jdbcType shouldBe Types.INTEGER
        columns[0].isNullable shouldBe false

        columns[1].name shouldBe "name"
        columns[1].isNullable shouldBe true
    }

    @Test
    fun `fallback to getColumnLabel when getColumnName throws`() {
        val rs = mockResultSet(
            listOf(
                MockColumn(name = { notSupported }, label = { "id_label" }),
                MockColumn(name = { notSupported }, label = { "name_label" }),
            ),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].name shouldBe "id_label"
        columns[1].name shouldBe "name_label"
    }

    @Test
    fun `fallback to generated name when both throw`() {
        val rs = mockResultSet(
            listOf(
                MockColumn(name = { notSupported }, label = { notSupported }),
                MockColumn(name = { notSupported }, label = { notSupported }),
            ),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].name shouldBe "column_1"
        columns[1].name shouldBe "column_2"
    }

    @Test
    fun `fallback when getTableName throws (Hive-like)`() {
        val rs = mockResultSet(
            listOf(MockColumn(name = { "id" }, tableName = { notSupported })),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns.size shouldBe 1
    }

    @Test
    fun `fallback to nullable when isNullable throws`() {
        val rs = mockResultSet(
            listOf(MockColumn(name = { "id" }, nullable = { notSupported })),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].isNullable shouldBe true
    }

    @Test
    fun `fallback to OTHER when type methods throw`() {
        val rs = mockResultSet(
            listOf(MockColumn(name = { "id" }, typeName = { notSupported }, jdbcType = { notSupported })),
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].sqlTypeName shouldBe "OTHER"
        columns[0].jdbcType shouldBe Types.OTHER
    }

    @Test
    fun `fallback when catalog and schema throw`() {
        val rs = mockResultSet(
            columns = listOf(MockColumn(name = { "id" })),
            catalog = { notSupported },
            schema = { notSupported },
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns.size shouldBe 1
    }

    @Test
    fun `worst case - everything throws`() {
        val rs = mockResultSet(
            columns = listOf(
                MockColumn(
                    name = { notSupported },
                    label = { notSupported },
                    tableName = { notSupported },
                    nullable = { notSupported },
                    typeName = { notSupported },
                    jdbcType = { notSupported },
                    displaySize = { notSupported },
                    className = { notSupported },
                ),
            ),
            catalog = { notSupported },
            schema = { notSupported },
        )

        val columns = TestDbType.getTableColumnsMetadata(rs)

        columns[0].run {
            name shouldBe "column_1"
            sqlTypeName shouldBe "OTHER"
            jdbcType shouldBe Types.OTHER
            size shouldBe 0
            javaClassName shouldBe "java.lang.Object"
            isNullable shouldBe true
        }
    }
}