feat: adapt tests to new error types

Author: chrispader

example/src/tests/unit/common.ts

@@ -1,10 +1,13 @@
 import { Chance } from 'chance'
-import { enableSimpleNullHandling } from 'react-native-nitro-sqlite'
+import {
+  enableSimpleNullHandling,
+  NitroSQLiteError,
+} from 'react-native-nitro-sqlite'
 import { resetTestDb } from '../db'
 import chai from 'chai'
 
-export function isError(e: unknown): e is Error {
-  return e instanceof Error
+export function isNitroSQLiteError(e: unknown): e is NitroSQLiteError {
+  return e instanceof NitroSQLiteError
 }
 
 export const expect = chai.expect

example/src/tests/unit/specs/execute.spec.ts

@@ -1,4 +1,4 @@
-import { chance, expect, isError } from '../common'
+import { chance, expect, isNitroSQLiteError } from '../common'
 import {
   enableSimpleNullHandling,
   NITRO_SQLITE_NULL,
@@ -94,7 +94,7 @@ export default function registerExecuteUnitTests() {
             [id, name, age, networth],
           )
         } catch (e: unknown) {
-          if (isError(e)) {
+          if (isNitroSQLiteError(e)) {
             expect(e.message).to.include(
               'cannot store TEXT value in REAL column User.age',
             )

example/src/tests/unit/specs/transaction.spec.ts

@@ -1,8 +1,11 @@
-import { chance, expect, isError } from '../common'
+import { chance, expect, isNitroSQLiteError } from '../common'
 import { describe, it } from '../../MochaRNAdapter'
 import type { User } from '../../../model/User'
 import { testDb, testDbQueue } from '../../db'
 
+const DUMMY_ERROR_NAME = 'Transaction Rejection Error'
+const DUMMY_ERROR_MESSAGE = 'Error from callback'
+
 export default function registerTransactionUnitTests() {
   describe('transaction', () => {
     it('Transaction, auto commit', async () => {
@@ -199,17 +202,18 @@ export default function registerTransactionUnitTests() {
 
     it('Transaction, rejects on callback error', async () => {
       const promised = testDb.transaction(() => {
-        throw new Error('Error from callback')
+        throw new Error(DUMMY_ERROR_MESSAGE)
       })
 
       // ASSERT: should return a promise that eventually rejects
       expect(promised).to.have.property('then').that.is.a('function')
       try {
         await promised
-        expect.fail('Should not resolve')
+        expect.fail(DUMMY_ERROR_NAME)
       } catch (e) {
-        if (isError(e)) expect(e.message).to.equal('Error from callback')
-        else expect.fail('Should have thrown a valid NitroSQLiteException')
+        if (isNitroSQLiteError(e))
+          expect(e.message).to.include(DUMMY_ERROR_MESSAGE)
+        else expect.fail('Should have thrown a valid NitroSQLiteError')
       }
     })
 
@@ -221,11 +225,11 @@ export default function registerTransactionUnitTests() {
       expect(promised).to.have.property('then').that.is.a('function')
       try {
         await promised
-        expect.fail('Should not resolve')
+        expect.fail(DUMMY_ERROR_NAME)
       } catch (e) {
-        if (isError(e))
+        if (isNitroSQLiteError(e))
           expect(e.message).to.include('no such table: tableThatDoesNotExist')
-        else expect.fail('Should have thrown a valid NitroSQLiteException')
+        else expect.fail('Should have thrown a valid NitroSQLiteError')
       }
     })
 
@@ -289,15 +293,15 @@ export default function registerTransactionUnitTests() {
           )
         })
       } catch (e) {
-        if (isError(e)) {
+        if (isNitroSQLiteError(e)) {
           expect(e.message)
             .to.include('SqlExecutionError')
             .and.to.include('cannot store TEXT value in REAL column User.id')
 
           const res = testDb.execute('SELECT * FROM User')
           expect(res.rows?._array).to.eql([])
         } else {
-          expect.fail('Should have thrown a valid NitroSQLiteException')
+          expect.fail('Should have thrown a valid NitroSQLiteError')
         }
       }
     })
@@ -401,17 +405,18 @@ export default function registerTransactionUnitTests() {
 
     it('Async transaction, rejects on callback error', async () => {
       const promised = testDb.transaction(() => {
-        throw new Error('Error from callback')
+        throw new Error(DUMMY_ERROR_MESSAGE)
       })
 
       // ASSERT: should return a promise that eventually rejects
       expect(promised).to.have.property('then').that.is.a('function')
       try {
         await promised
-        expect.fail('Should not resolve')
+        expect.fail(DUMMY_ERROR_NAME)
       } catch (e) {
-        if (isError(e)) expect(e.message).to.equal('Error from callback')
-        else expect.fail('Should have thrown a valid NitroSQLiteException')
+        if (isNitroSQLiteError(e))
+          expect(e.message).to.include(DUMMY_ERROR_MESSAGE)
+        else expect.fail('Should have thrown a valid NitroSQLiteError')
       }
     })
 
@@ -424,11 +429,11 @@ export default function registerTransactionUnitTests() {
       expect(promised).to.have.property('then').that.is.a('function')
       try {
         await promised
-        expect.fail('Should not resolve')
+        expect.fail(DUMMY_ERROR_NAME)
       } catch (e) {
-        if (isError(e))
+        if (isNitroSQLiteError(e))
           expect(e.message).to.include('no such table: tableThatDoesNotExist')
-        else expect.fail('Should have thrown a valid NitroSQLiteException')
+        else expect.fail('Should have thrown a valid NitroSQLiteError')
       }
     })