test(javascript/driver-manager): add test suite

Author: kentkwu

javascript/__test__/bind.spec.ts

@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import { test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { createSqliteDatabase, createTestTable } from './test_utils'
+import { AdbcDatabase, AdbcConnection, AdbcStatement } from '../lib/index.js'
+import { tableFromArrays, Table } from 'apache-arrow'
+
+let db: AdbcDatabase
+let conn: AdbcConnection
+let stmt: AdbcStatement
+
+before(async () => {
+  db = await createSqliteDatabase()
+  conn = await db.connect()
+  stmt = await conn.createStatement()
+  await createTestTable(stmt, 'bind_test')
+})
+
+after(async () => {
+  try {
+    await stmt?.close()
+    await conn?.close()
+    await db?.close()
+  } catch {
+    // ignore
+  }
+})
+
+test('statement: bind and query data', async () => {
+  const recordBatchToBind = tableFromArrays({
+    id: [null],
+    name: ['test_name'],
+  })
+
+  assert.strictEqual(recordBatchToBind.numRows, 1)
+  await stmt.bind(recordBatchToBind)
+
+  await stmt.setSqlQuery('INSERT INTO bind_test (id, name) VALUES (?, ?)')
+  const insertResult = await stmt.executeUpdate()
+  assert.strictEqual(insertResult, 1)
+
+  await stmt.setSqlQuery('SELECT id, name FROM bind_test')
+  const reader = await stmt.executeQuery()
+
+  let rowCount = 0
+  for await (const batch of reader) {
+    rowCount += batch.numRows
+    const idVector = batch.getChild('id')
+    const nameVector = batch.getChild('name')
+    assert.strictEqual(idVector?.get(0), null)
+    assert.strictEqual(nameVector?.get(0), 'test_name')
+  }
+
+  assert.strictEqual(rowCount, 1)
+})
+
+test('statement: bind multi-batch table throws descriptive error', async () => {
+  // Both batches must share the same schema instance for Table to accept them
+  const base = tableFromArrays({ id: [10], name: ['first'] })
+  const batch1 = base.batches[0]
+  const batch2 = base.batches[0] // same schema, reused to construct a multi-batch Table
+  const multiTable = new Table([batch1, batch2])
+  assert.strictEqual(multiTable.batches.length, 2)
+
+  const stmt2 = await conn.createStatement()
+  const error = await stmt2.bind(multiTable).catch((e) => e)
+  assert.ok(error instanceof Error)
+  assert.match(error.message, /bind\(\).*batches|batches.*bind\(\)/i)
+  await stmt2.close()
+})

javascript/__test__/error_handling.spec.ts

@@ -0,0 +1,107 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import { test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { createSqliteDatabase } from './test_utils'
+import { AdbcDatabase, AdbcConnection, AdbcStatement, AdbcError } from '../lib/index.js'
+
+let db: AdbcDatabase
+let conn: AdbcConnection
+let stmt: AdbcStatement
+
+before(async () => {
+  db = await createSqliteDatabase()
+  conn = await db.connect()
+  stmt = await conn.createStatement()
+})
+
+after(async () => {
+  try {
+    await stmt?.close()
+    await conn?.close()
+    await db?.close()
+  } catch {
+    // ignore
+  }
+})
+
+test('error: invalid sql syntax', async () => {
+  await stmt.setSqlQuery('SELECT * FROM') // Syntax error
+
+  let error: unknown
+  try {
+    const reader = await stmt.executeQuery()
+    for await (const _ of reader) {
+    }
+  } catch (e) {
+    error = e
+  }
+
+  assert.ok(error instanceof AdbcError)
+  assert.match(error.message, /syntax error|incomplete input/i)
+  assert.ok(error.sqlState)
+})
+
+test('error: table not found', async () => {
+  await stmt.setSqlQuery('SELECT * FROM non_existent_table')
+
+  let error: unknown
+  try {
+    const reader = await stmt.executeQuery()
+    for await (const _ of reader) {
+    }
+  } catch (e) {
+    error = e
+  }
+
+  assert.ok(error instanceof AdbcError)
+  assert.match(error.message, /no such table/i)
+})
+
+test('error: constraint violation', async () => {
+  const setupStmt = await conn.createStatement()
+  await setupStmt.setSqlQuery('CREATE TABLE IF NOT EXISTS err_test (id INTEGER PRIMARY KEY)')
+  await setupStmt.executeUpdate()
+  await setupStmt.setSqlQuery('INSERT INTO err_test (id) VALUES (1)')
+  await setupStmt.executeUpdate()
+  await setupStmt.close()
+
+  await stmt.setSqlQuery('INSERT INTO err_test (id) VALUES (1)')
+  let error: unknown
+  try {
+    await stmt.executeUpdate()
+  } catch (e) {
+    error = e
+  }
+
+  assert.ok(error instanceof AdbcError)
+  assert.match(error.code, /AlreadyExists|Integrity|IO/)
+})
+
+test('error: unsupported option', () => {
+  // SQLite does not support the read_only connection option at runtime
+  let error: unknown
+  try {
+    conn.setOption('adbc.connection.read_only', 'true')
+  } catch (e) {
+    error = e
+  }
+
+  assert.ok(error instanceof AdbcError)
+  assert.strictEqual(error.code, 'NotImplemented')
+})

javascript/__test__/metadata.spec.ts

@@ -0,0 +1,82 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import { test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { createSqliteDatabase, createTestTable, dumpReader } from './test_utils'
+import { AdbcDatabase, AdbcConnection, AdbcStatement } from '../lib/index.js'
+
+let db: AdbcDatabase
+let conn: AdbcConnection
+let stmt: AdbcStatement
+
+before(async () => {
+  db = await createSqliteDatabase()
+  conn = await db.connect()
+  stmt = await conn.createStatement()
+  await createTestTable(stmt, 'metadata_test')
+})
+
+after(async () => {
+  try {
+    await stmt?.close()
+    await conn?.close()
+    await db?.close()
+  } catch (e) {
+    console.error('Error cleaning up test resources:', e)
+  }
+})
+
+test('metadata: getTableTypes', async () => {
+  const tableTypes = await dumpReader(await conn.getTableTypes())
+
+  // Sort actual results for consistent comparison
+  tableTypes.sort((a, b) => (a.table_type || '').localeCompare(b.table_type || ''))
+
+  assert.strictEqual(tableTypes[0].table_type, 'table')
+  assert.strictEqual(tableTypes[1].table_type, 'view')
+})
+
+test('metadata: getTableSchema', async () => {
+  const schema = await conn.getTableSchema({ tableName: 'metadata_test' })
+
+  assert.strictEqual(schema.fields[0].name, 'id')
+  assert.strictEqual(schema.fields[0].nullable, true)
+  assert.strictEqual(schema.fields[1].name, 'name')
+  assert.strictEqual(schema.fields[1].nullable, true)
+})
+
+test('metadata: getObjects', async () => {
+  // SQLite structure: Catalog (null/main) -> Schemas (null/main) -> Tables
+  const objects = await dumpReader(
+    await conn.getObjects({
+      depth: 3,
+      tableName: 'metadata_test',
+      tableType: ['table', 'view'],
+    }),
+  )
+
+  const tables = objects[0].catalog_db_schemas[0].db_schema_tables
+  assert.ok(tables.some((t: { table_name: string }) => t.table_name === 'metadata_test'))
+})
+
+test('metadata: getInfo', async () => {
+  const info = await dumpReader(await conn.getInfo())
+
+  assert.strictEqual(info[0].info_name, 0)
+  assert.strictEqual(info[0].info_value, 'SQLite')
+})

javascript/__test__/options.spec.ts

@@ -0,0 +1,82 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import { test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { createSqliteDatabase } from './test_utils'
+import { AdbcDatabase, AdbcConnection, AdbcStatement, AdbcError } from '../lib/index.js'
+
+let db: AdbcDatabase
+let conn: AdbcConnection
+let stmt: AdbcStatement
+
+before(async () => {
+  db = await createSqliteDatabase()
+  conn = await db.connect()
+  stmt = await conn.createStatement()
+})
+
+after(async () => {
+  try {
+    await stmt?.close()
+    await conn?.close()
+    await db?.close()
+  } catch {
+    // ignore
+  }
+})
+
+test('options: connection setOption', () => {
+  // Test setting autocommit via canonical ADBC key (supported by SQLite)
+  assert.doesNotThrow(() => {
+    conn.setOption('adbc.connection.autocommit', 'true')
+  })
+
+  // Test setting read_only via canonical ADBC key (not supported by SQLite at runtime)
+  let errorReadOnly: unknown
+  try {
+    conn.setOption('adbc.connection.read_only', 'false')
+  } catch (e) {
+    errorReadOnly = e
+  }
+  assert.ok(errorReadOnly instanceof AdbcError)
+  assert.strictEqual(errorReadOnly.code, 'NotImplemented')
+  assert.match(errorReadOnly.message, /Unknown connection option/i)
+
+  // Test setting generic option (SQLite driver is strict and rejects unknown options)
+  let errorCustom: unknown
+  try {
+    conn.setOption('custom_option', 'custom_value')
+  } catch (e) {
+    errorCustom = e
+  }
+  assert.ok(errorCustom instanceof AdbcError)
+  assert.strictEqual(errorCustom.code, 'NotImplemented')
+})
+
+test('options: statement setOption', () => {
+  // Test setting an unknown statement option (SQLite driver is strict)
+  let error: unknown
+  try {
+    stmt.setOption('adbc.stmt.some_option', 'value')
+  } catch (e) {
+    error = e
+  }
+  assert.ok(error instanceof AdbcError)
+  assert.strictEqual(error.code, 'NotImplemented')
+  assert.match(error.message, /Unknown statement option/i)
+})