Adding heavier tests

Author: gionatamettifogo

src/drivers/connection-tls.ts

@@ -102,6 +102,7 @@ export class SQLiteCloudTlsConnection extends SQLiteCloudConnection {
     this.buffer = Buffer.alloc(0)
     this.startedOn = new Date()
     this.processCallback = callback
+    this.executingCommands = commands
 
     // compose commands following SCPC protocol
     const formattedCommands = formatCommand(commands)
@@ -134,6 +135,7 @@ export class SQLiteCloudTlsConnection extends SQLiteCloudConnection {
   // buffer to accumulate incoming data until an whole command is received and can be parsed
   private buffer: Buffer = Buffer.alloc(0)
   private startedOn: Date = new Date()
+  private executingCommands?: string
 
   // callback to be called when a command is finished processing
   private processCallback?: ResultsCallback

test/benchmark.test.ts

@@ -0,0 +1,100 @@
+/**
+ * benchmark.test.ts - test low level communication protocol with tls sockets and raw commands
+ */
+
+import { SQLiteCloudConnection } from '../src/drivers/connection'
+import { EXTRA_LONG_TIMEOUT, getChinookTlsConnection, getTestingDatabaseName, sendCommandsAsync } from './shared'
+
+const fs = require('fs')
+const path = require('path')
+
+async function createDatabaseAsync(): Promise<{ connection: SQLiteCloudConnection; database: string }> {
+  const connection = getChinookTlsConnection()
+  const database = getTestingDatabaseName('benchmark')
+  const createSql = `UNUSE DATABASE; CREATE DATABASE ${database}; USE DATABASE ${database};`
+  const createResults = await sendCommandsAsync(connection, createSql)
+  expect(createResults).toBe('OK')
+  return { database, connection }
+}
+
+async function destroyDatabaseAsync(connection: SQLiteCloudConnection, database: string) {
+  const cleanupResults = await sendCommandsAsync(connection, `UNUSE DATABASE; REMOVE DATABASE ${database}`)
+  expect(cleanupResults).toBe('OK')
+  connection.close()
+}
+
+async function runScript(connection: SQLiteCloudConnection, database: string, relativePathname: string) {
+  // convert to absolute path, read contents of .sql script
+  const absolutePathname = path.resolve(__dirname, 'benchmark/test', relativePathname)
+  const sql = fs.readFileSync(absolutePathname, 'utf8')
+  const results = await sendCommandsAsync(connection, sql)
+  if (results !== 'OK') {
+    const error = `runScript - database: ${database}, script: ${relativePathname}, returned: ${results?.toString()}`
+    debugger
+    throw new Error(error)
+  }
+
+  if (results !== 'OK') {
+    console.error(`runScript - ${relativePathname} returned: ${results}`)
+  }
+  expect(results).toBe('OK')
+}
+
+describe('benchmark', () => {
+  describe('benchmark tests', () => {
+    it('should run setup', async () => {
+      const { connection, database } = await createDatabaseAsync()
+      await destroyDatabaseAsync(connection, database)
+    })
+
+    it(
+      'should run script 120.sql',
+      async () => {
+        const { connection, database } = await createDatabaseAsync()
+        await runScript(connection, database, '120.sql')
+        await destroyDatabaseAsync(connection, database)
+      },
+      EXTRA_LONG_TIMEOUT
+    )
+
+    it(
+      'should run scripts with new connection for each script',
+      async () => {
+        // setup database used for testing
+        const { connection, database } = await createDatabaseAsync()
+
+        // list contents of test folder
+        const testFolder = path.resolve(__dirname, './benchmark/test')
+        const files = fs.readdirSync(testFolder).sort()
+
+        for (const testFile of files) {
+          const scriptConnection = getChinookTlsConnection()
+          console.debug(`Benchmark tests, run ${testFile}`)
+          await runScript(scriptConnection, database, testFile)
+        }
+
+        await destroyDatabaseAsync(connection, database)
+      },
+      EXTRA_LONG_TIMEOUT
+    )
+
+    it(
+      'should run benchmark scripts with same connection',
+      async () => {
+        // setup database used for testing
+        const { connection, database } = await createDatabaseAsync()
+        // list contents of test folder
+        const testFolder = path.resolve(__dirname, './benchmark/test')
+        const files = fs.readdirSync(testFolder).sort()
+
+        for (const testFile of files) {
+          console.debug(`Benchmark tests, run ${testFile}`)
+          await runScript(connection, database, testFile)
+        }
+
+        await destroyDatabaseAsync(connection, database)
+      },
+      EXTRA_LONG_TIMEOUT
+    )
+  })
+})

test/benchmark.testOFF.ts

@@ -1,12 +1,12 @@
 -- 8 INSERTs into table with no index
 BEGIN;
-CREATE TABLE z99(a INTEGER , b INTEGER , c VARCHAR(200) );
-INSERT INTO z99 VALUES(32768,1,'thirty two thousand seven hundred sixty eight');
-INSERT INTO z99 VALUES(16384,2,'sixteen thousand three hundred eighty four');
-INSERT INTO z99 VALUES(49152,3,'forty nine thousand one hundred fifty two');
-INSERT INTO z99 VALUES(8192,4,'eight thousand one hundred ninety two');
-INSERT INTO z99 VALUES(40960,5,'forty thousand nine hundred sixty');
-INSERT INTO z99 VALUES(24576,6,'twenty four thousand five hundred seventy six');
-INSERT INTO z99 VALUES(57344,7,'fifty seven thousand three hundred forty four');
-INSERT INTO z99 VALUES(4096,8,'four thousand ninety six');
+CREATE TABLE zPollo(a INTEGER , b INTEGER , c VARCHAR(200) );
+INSERT INTO zPollo VALUES(32768,1,'thirty two thousand seven hundred sixty eight');
+INSERT INTO zPollo VALUES(16384,2,'sixteen thousand three hundred eighty four');
+INSERT INTO zPollo VALUES(49152,3,'forty nine thousand one hundred fifty two');
+INSERT INTO zPollo VALUES(8192,4,'eight thousand one hundred ninety two');
+INSERT INTO zPollo VALUES(40960,5,'forty thousand nine hundred sixty');
+INSERT INTO zPollo VALUES(24576,6,'twenty four thousand five hundred seventy six');
+INSERT INTO zPollo VALUES(57344,7,'fifty seven thousand three hundred forty four');
+INSERT INTO zPollo VALUES(4096,8,'four thousand ninety six');
 COMMIT;

test/benchmark/test/090.sql

@@ -2,7 +2,7 @@
  * connection-tls.test.ts - test low level communication protocol with tls sockets and raw commands
  */
 
-import { SQLiteCloudError } from '../src/index'
+import { SQLiteCloudError, SQLiteCloudRowset } from '../src/index'
 import { SQLiteCloudConnection } from '../src/drivers/connection'
 import { SQLiteCloudTlsConnection } from '../src/drivers/connection-tls'
 import { anonimizeCommand } from '../src/drivers/utilities'
@@ -13,6 +13,7 @@ import {
   getTestingConfig,
   getChinookConfig,
   getChinookTlsConnection,
+  sendCommandsAsync,
   // clearTestingDatabasesAsync,
   WARN_SPEED_MS,
   EXPECT_SPEED_MS,
@@ -453,6 +454,36 @@ describe('connection-tls', () => {
   })
 
   describe('send select commands', () => {
+    it(
+      'should send xxl query',
+      async () => {
+        const XXL_QUERY = 1 * 1_000_000
+        let longSql = ''
+
+        const connection = getConnection()
+        while (longSql.length < XXL_QUERY) {
+          for (let i = 0; i < 5_000; i++) longSql += `SELECT ${longSql.length} 'HowLargeIsTooMuch'; `
+
+          try {
+            const longResults = await sendCommandsAsync(connection, longSql)
+            expect(longResults).toBeInstanceOf(SQLiteCloudRowset)
+            if (longResults instanceof SQLiteCloudRowset) {
+              expect(longResults.numberOfColumns).toBe(1)
+              expect(longResults.numberOfRows).toBe(1)
+              expect(longResults[0]['HowLargeIsTooMuch']).toBeGreaterThanOrEqual(longSql.length - 50)
+            }
+          } catch (error) {
+            console.error(`An error occoured while sending an xxl query of ${longSql.length} bytes, error: ${error}`)
+            debugger
+            throw error
+          }
+        }
+
+        connection.close()
+      },
+      EXTRA_LONG_TIMEOUT
+    )
+
     it('should LIST METADATA', done => {
       const chinook = getConnection()
       chinook.sendCommands('LIST METADATA;', (error, results) => {

test/connection-tls.test.ts

@@ -127,15 +127,7 @@ export function getChinookDatabase(callback?: ResultsCallback, extraConfig?: Par
 /** SQL used to setup testing database with some data */
 export const TESTING_SQL = readFileSync(join(__dirname, 'assets/testing.sql'), 'utf8')
 
-export function getTestingConfig(url = CHINOOK_DATABASE_URL): SQLiteCloudConfig {
-  const testingConfig = parseConnectionString(url)
-
-  if (testingConfig.host === 'localhost' && testingConfig.tlsOptions === undefined) {
-    testingConfig.tlsOptions = {
-      ca: SELF_SIGNED_CERTIFICATE
-    }
-  }
-
+export function getTestingDatabaseName(prefix: string) {
   // create a unique id for this test run based on current time with
   // enough precision to avoid duplicate ids and be human readable
   function generateRandomId(length: number): string {
@@ -155,13 +147,25 @@ export function getTestingConfig(url = CHINOOK_DATABASE_URL): SQLiteCloudConfig
     '-' +
     generateRandomId(4)
 
+  return `${prefix}-${id}.sqlite`
+}
+
+export function getTestingConfig(url = CHINOOK_DATABASE_URL): SQLiteCloudConfig {
+  const testingConfig = parseConnectionString(url)
+
+  if (testingConfig.host === 'localhost' && testingConfig.tlsOptions === undefined) {
+    testingConfig.tlsOptions = {
+      ca: SELF_SIGNED_CERTIFICATE
+    }
+  }
+
   testingConfig.createDatabase = true
 
   if (!(testingConfig.database === 'chinook.sqlite')) {
     throw Error('testingConfig.database is not equal to chinook.sqlite')
   }
 
-  testingConfig.database = testingConfig.database?.replace('chinook.sqlite', `testing-${id}.db`)
+  testingConfig.database = testingConfig.database?.replace('chinook.sqlite', getTestingDatabaseName('testing'))
   return testingConfig
 }
 
@@ -260,3 +264,15 @@ export async function removeDatabaseAsync(database?: Database) {
     database.close()
   }
 }
+
+export async function sendCommandsAsync<T>(connection: SQLiteCloudConnection, sql: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    connection.sendCommands(sql, (error, results) => {
+      if (error) {
+        console.error(`sendCommandsAsync - error running ${sql}, error: ${error}`, sql, error)
+        reject(error)
+      }
+      resolve(results)
+    })
+  })
+}