From 29343491840c971df62aefdcdb7455aeaacc7be1 Mon Sep 17 00:00:00 2001 From: Christoph Pader Date: Thu, 19 Mar 2026 16:00:27 +0100 Subject: [PATCH] refactor: update test imports and assertions to use react-native-harness --- .github/workflows/test-harness-android.yml | 56 ++++++++ .github/workflows/test-harness-ios.yml | 66 +++++++++ example/__tests__/typeorm.harness.ts | 3 + example/__tests__/unit.harness.ts | 3 + example/jest.config.js | 12 ++ example/package.json | 10 +- example/rn-harness.config.mjs | 35 +++++ example/src/tests/unit/common.ts | 4 +- example/src/tests/unit/index.ts | 2 +- .../tests/unit/specs/DatabaseQueue.spec.ts | 110 +++++++-------- .../unit/specs/operations/execute.spec.ts | 72 +++++----- .../specs/operations/executeBatch.spec.ts | 6 +- .../unit/specs/operations/transaction.spec.ts | 127 +++++++++--------- example/src/tests/unit/specs/typeorm.spec.ts | 28 ++-- example/tsconfig.json | 2 +- tsconfig.json | 1 + 16 files changed, 362 insertions(+), 175 deletions(-) create mode 100644 .github/workflows/test-harness-android.yml create mode 100644 .github/workflows/test-harness-ios.yml create mode 100644 example/__tests__/typeorm.harness.ts create mode 100644 example/__tests__/unit.harness.ts create mode 100644 example/jest.config.js create mode 100644 example/rn-harness.config.mjs diff --git a/.github/workflows/test-harness-android.yml b/.github/workflows/test-harness-android.yml new file mode 100644 index 00000000..d51fd47b --- /dev/null +++ b/.github/workflows/test-harness-android.yml @@ -0,0 +1,56 @@ +name: Test Harness Android + +on: + pull_request: + paths: + - ".github/workflows/test-harness-android.yml" + - "example/android/**" + - "example/src/tests/**" + - "example/__tests__/**" + - "example/rn-harness.config.mjs" + - "example/jest.config.js" + - "package/cpp/**" + - "package/android/**" + - "**/bun.lock" + - "**/react-native.config.js" + - "**/nitro.json" + +env: + TARGET_ANDROID_ARCH: x86_64 + +jobs: + test: + name: Harness Tests (Android) + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v6 + - uses: oven-sh/setup-bun@v2 + + - name: Setup JDK 17 + uses: actions/setup-java@v5 + with: + distribution: "zulu" + java-version: 17 + + - name: Enable KVM group perms + run: | + echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules + sudo udevadm control --reload-rules + sudo udevadm trigger --name-match=kvm + + - name: Install dependencies (bun) + run: bun install + + - name: Run react-native-harness on Android + uses: reactivecircus/android-emulator-runner@v2 + with: + api-level: 35 + arch: x86_64 + avd-name: Pixel_8_API_35 + working-directory: example/android + script: >- + ./gradlew :app:installDebug --no-daemon + -PreactNativeArchitectures=${{ env.TARGET_ANDROID_ARCH }} + && bun --cwd .. run test:harness:android + diff --git a/.github/workflows/test-harness-ios.yml b/.github/workflows/test-harness-ios.yml new file mode 100644 index 00000000..2dd0f5f1 --- /dev/null +++ b/.github/workflows/test-harness-ios.yml @@ -0,0 +1,66 @@ +name: Test Harness iOS + +on: + pull_request: + paths: + - ".github/workflows/test-harness-ios.yml" + - "example/ios/**" + - "example/src/tests/**" + - "example/__tests__/**" + - "example/rn-harness.config.mjs" + - "example/jest.config.js" + - "package/cpp/**" + - "package/ios/**" + - "**/Podfile.lock" + - "**/*.podspec" + - "**/react-native.config.js" + - "**/nitro.json" + - "**/bun.lock" + +jobs: + test: + name: Harness Tests (iOS) + runs-on: macOS-26 + + steps: + - uses: actions/checkout@v6 + - uses: oven-sh/setup-bun@v2 + + - name: Setup Ruby (bundle) + uses: ruby/setup-ruby@v1 + with: + ruby-version: 3.3.0 + bundler-cache: true + working-directory: example + + - name: Select Xcode 26.2 + run: sudo xcode-select -s "/Applications/Xcode_26.2.app/Contents/Developer" + + - name: Install Pods + working-directory: example + run: bun pods + + - name: Boot iOS Simulator + run: | + xcrun simctl boot "iPhone 17 Pro (26.2)" || true + xcrun simctl bootstatus booted -b + + - name: Build and install debug app + working-directory: example/ios + run: | + set -o pipefail + xcodebuild \ + CC=clang CPLUSPLUS=clang++ LD=clang LDPLUSPLUS=clang++ \ + -derivedDataPath build -UseModernBuildSystem=YES \ + -workspace NitroSQLiteExample.xcworkspace \ + -scheme NitroSQLiteExample \ + -sdk iphonesimulator \ + -configuration Debug \ + -destination 'platform=iOS Simulator,name=iPhone 17 Pro,OS=26.2' \ + ONLY_ACTIVE_ARCH=YES \ + install \ + CODE_SIGNING_ALLOWED=NO + + - name: Run react-native-harness on iOS + run: bun --cwd example run test:harness:ios + diff --git a/example/__tests__/typeorm.harness.ts b/example/__tests__/typeorm.harness.ts new file mode 100644 index 00000000..e9014087 --- /dev/null +++ b/example/__tests__/typeorm.harness.ts @@ -0,0 +1,3 @@ +import { registerTypeORMUnitTests } from '../src/tests/unit' + +registerTypeORMUnitTests() diff --git a/example/__tests__/unit.harness.ts b/example/__tests__/unit.harness.ts new file mode 100644 index 00000000..00517503 --- /dev/null +++ b/example/__tests__/unit.harness.ts @@ -0,0 +1,3 @@ +import { registerUnitTests } from '../src/tests/unit' + +registerUnitTests() diff --git a/example/jest.config.js b/example/jest.config.js new file mode 100644 index 00000000..634fb9c6 --- /dev/null +++ b/example/jest.config.js @@ -0,0 +1,12 @@ +module.exports = { + projects: [ + { + displayName: "react-native-harness", + preset: "react-native-harness", + testMatch: [ + "**/__tests__/**/*.(test|spec|harness).(js|jsx|ts|tsx)", + ], + }, + ], +}; + diff --git a/example/package.json b/example/package.json index 031410ef..96b9069d 100644 --- a/example/package.json +++ b/example/package.json @@ -10,7 +10,10 @@ "pods": "cd ios && bundle exec pod install", "typecheck": "tsc --noEmit", "lint": "eslint \"**/*.{js,ts,tsx}\" --fix", - "codegen": "bun react-native codegen" + "codegen": "bun react-native codegen", + "test:harness": "react-native-harness", + "test:harness:android": "react-native-harness --harnessRunner android", + "test:harness:ios": "react-native-harness --harnessRunner ios" }, "dependencies": { "@craftzdog/react-native-buffer": "^6.0.5", @@ -49,6 +52,11 @@ "@types/node": "^22.7.4", "@types/react": "^19.1.1", "@types/react-test-renderer": "^19.1.0", + "@react-native-harness/cli": "1.0.0-alpha.21", + "@react-native-harness/jest": "1.0.0-alpha.21", + "@react-native-harness/platform-android": "1.0.0-alpha.21", + "@react-native-harness/platform-apple": "1.0.0-alpha.21", + "react-native-harness": "1.0.0-alpha.21", "mocha": "^10.1.0", "postinstall-postinstall": "^2.1.0", "react-test-renderer": "19.1.1" diff --git a/example/rn-harness.config.mjs b/example/rn-harness.config.mjs new file mode 100644 index 00000000..d0e24b1d --- /dev/null +++ b/example/rn-harness.config.mjs @@ -0,0 +1,35 @@ +import { + androidPlatform, + androidEmulator, +} from "@react-native-harness/platform-android"; +import { + applePlatform, + appleSimulator, +} from "@react-native-harness/platform-apple"; + +const config = { + entryPoint: "./index.js", + appRegistryComponentName: "NitroSQLiteExample", + + runners: [ + androidPlatform({ + name: "android", + device: androidEmulator("Pixel_8_API_35"), + bundleId: "com.margelo.rnnitrosqlite.example", + }), + applePlatform({ + name: "ios", + device: appleSimulator("iPhone 17 Pro", "26.2"), + bundleId: "com.margelo.rnnitrosqlite.example", + }), + ], + + defaultRunner: "android", + bridgeTimeout: 120000, + + resetEnvironmentBetweenTestFiles: true, + unstable__skipAlreadyIncludedModules: false, +}; + +export default config; + diff --git a/example/src/tests/unit/common.ts b/example/src/tests/unit/common.ts index 5f6213eb..a71b3c82 100644 --- a/example/src/tests/unit/common.ts +++ b/example/src/tests/unit/common.ts @@ -1,7 +1,7 @@ import { Chance } from 'chance' import { NitroSQLiteError } from 'react-native-nitro-sqlite' import { resetTestDb } from '../db' -import chai from 'chai' +import { expect as harnessExpect } from 'react-native-harness' export const TEST_ERROR_CODES = { EXPECT_NITRO_SQLITE_ERROR: 'Should have thrown a valid NitroSQLiteError', @@ -15,7 +15,7 @@ export function isNitroSQLiteError(e: unknown): e is NitroSQLiteError { return e instanceof NitroSQLiteError } -export const expect = chai.expect +export const expect = harnessExpect export const chance = new Chance() export function setupTestDb() { diff --git a/example/src/tests/unit/index.ts b/example/src/tests/unit/index.ts index bb4c1070..0c994800 100644 --- a/example/src/tests/unit/index.ts +++ b/example/src/tests/unit/index.ts @@ -1,4 +1,4 @@ -import { beforeEach, describe } from '../MochaRNAdapter' +import { beforeEach, describe } from 'react-native-harness' import { setupTestDb } from './common' import registerExecuteUnitTests from './specs/operations/execute.spec' import registerTransactionUnitTests from './specs/operations/transaction.spec' diff --git a/example/src/tests/unit/specs/DatabaseQueue.spec.ts b/example/src/tests/unit/specs/DatabaseQueue.spec.ts index 1d36a8f2..1389cdfb 100644 --- a/example/src/tests/unit/specs/DatabaseQueue.spec.ts +++ b/example/src/tests/unit/specs/DatabaseQueue.spec.ts @@ -5,7 +5,7 @@ import { TEST_ERROR_CODES, TEST_ERROR_MESSAGE, } from '../common' -import { describe, it } from '../../MochaRNAdapter' +import { describe, it } from 'react-native-harness' import { testDb, testDbQueue } from '../../db' import type { BatchQueryCommand } from 'react-native-nitro-sqlite' @@ -19,26 +19,26 @@ export default function registerDatabaseQueueUnitTests() { const transaction1Promise = testDb.transaction(async (tx) => { tx.execute(TEST_QUERY) - expect(testDbQueue.queue.length).to.equal(2) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(2) + expect(testDbQueue.inProgress).toBe(true) await new Promise((resolve) => setTimeout(resolve, 100)) tx.execute(TEST_QUERY) - expect(testDbQueue.queue.length).to.equal(2) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(2) + expect(testDbQueue.inProgress).toBe(true) }) - expect(testDbQueue.inProgress).to.equal(true) - expect(testDbQueue.queue.length).to.equal(0) + expect(testDbQueue.inProgress).toBe(true) + expect(testDbQueue.queue.length).toBe(0) const transaction2Promise = testDb.transaction(async (tx) => { tx.execute(TEST_QUERY) }) - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) const transaction3Promise = testDb.transaction(async (tx) => { tx.execute(TEST_QUERY) @@ -46,50 +46,50 @@ export default function registerDatabaseQueueUnitTests() { await transaction1Promise - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) await transaction2Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) await transaction3Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(false) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(false) }) it('multiple executeBatchAsync operations are queued', async () => { const executeBatch1Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) const executeBatch2Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) const executeBatch3Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(2) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(2) + expect(testDbQueue.inProgress).toBe(true) await executeBatch1Promise - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) await executeBatch2Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) await executeBatch3Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(false) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(false) }) it('mixed transactions and executeBatchAsync operations are queued', async () => { @@ -97,45 +97,45 @@ export default function registerDatabaseQueueUnitTests() { tx.execute('SELECT * FROM [User];') }) - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) const executeBatch1Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) const transaction2Promise = testDb.transaction(async (tx) => { tx.execute(TEST_QUERY) }) - expect(testDbQueue.queue.length).to.equal(2) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(2) + expect(testDbQueue.inProgress).toBe(true) const executeBatch2Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(3) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(3) + expect(testDbQueue.inProgress).toBe(true) await transaction1Promise - expect(testDbQueue.queue.length).to.equal(2) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(2) + expect(testDbQueue.inProgress).toBe(true) await executeBatch1Promise - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) await transaction2Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) await executeBatch2Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(false) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(false) }) it('errors are thrown through DatabaseQueue', async () => { @@ -144,37 +144,37 @@ export default function registerDatabaseQueueUnitTests() { throw TEST_ERROR }) - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) const executeBatch1Promise = testDb.executeBatchAsync(TEST_BATCH_COMMANDS) - expect(testDbQueue.queue.length).to.equal(1) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(1) + expect(testDbQueue.inProgress).toBe(true) try { await transaction1Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(true) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(true) } catch (e) { if (isNitroSQLiteError(e)) { - expect(e.message).to.include(TEST_ERROR_MESSAGE) + expect(e.message).toContain(TEST_ERROR_MESSAGE) } else { - expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } } try { await executeBatch1Promise - expect(testDbQueue.queue.length).to.equal(0) - expect(testDbQueue.inProgress).to.equal(false) + expect(testDbQueue.queue.length).toBe(0) + expect(testDbQueue.inProgress).toBe(false) } catch (e) { if (isNitroSQLiteError(e)) { - expect(e.message).to.include(TEST_ERROR_MESSAGE) + expect(e.message).toContain(TEST_ERROR_MESSAGE) } else { - expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } } }) diff --git a/example/src/tests/unit/specs/operations/execute.spec.ts b/example/src/tests/unit/specs/operations/execute.spec.ts index d8d113b4..d6e32b9e 100644 --- a/example/src/tests/unit/specs/operations/execute.spec.ts +++ b/example/src/tests/unit/specs/operations/execute.spec.ts @@ -1,5 +1,5 @@ import { chance, expect, isNitroSQLiteError } from '../../common' -import { describe, it } from '../../../MochaRNAdapter' +import { describe, it } from 'react-native-harness' import { createArrayBufferTestDb, testDb } from '../../../db' export default function registerExecuteUnitTests() { @@ -15,11 +15,11 @@ export default function registerExecuteUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') }) it('Insert with null', () => { @@ -32,14 +32,14 @@ export default function registerExecuteUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') const selectRes = testDb.execute('SELECT * FROM User') - expect(selectRes.rows?._array).to.eql([ + expect(selectRes.rows?._array).toEqual([ { id, name, @@ -62,11 +62,11 @@ export default function registerExecuteUnitTests() { ) } catch (e: unknown) { if (isNitroSQLiteError(e)) { - expect(e.message).to.include( + expect(e.message).toContain( 'cannot store TEXT value in REAL column User.age', ) } else { - expect.fail('Should have thrown a valid NitroSQLiteException') + throw new Error('Should have thrown a valid NitroSQLiteException') } } }) @@ -82,7 +82,7 @@ export default function registerExecuteUnitTests() { [id, name, age, networth], ) } catch (e: unknown) { - expect(e).to.not.equal(null) + expect(e).not.toBe(null) } }) }) @@ -100,9 +100,9 @@ export default function registerExecuteUnitTests() { const res = testDb.execute('SELECT * FROM User') - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([ + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([ { id, name, @@ -124,9 +124,9 @@ export default function registerExecuteUnitTests() { const res = testDb.execute('SELECT * FROM User WHERE id = ?', [id]) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([ + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([ { id, name, @@ -157,18 +157,18 @@ export default function registerExecuteUnitTests() { [1], ) - expect(result.rowsAffected).to.equal(1) - expect(result.rows?.length).to.equal(1) + expect(result.rowsAffected).toBe(1) + expect(result.rows?.length).toBe(1) const row = result.results[0] // const row = result.rows?.item(0) - expect(row).to.not.equal(undefined) + expect(row).not.toBe(undefined) const value = row?.data - expect(value).to.be.instanceOf(ArrayBuffer) + expect(value).toBeInstanceOf(ArrayBuffer) const returnedBytes = new Uint8Array(value as ArrayBuffer) - expect(Array.from(returnedBytes)).to.eql(Array.from(originalBytes)) + expect(Array.from(returnedBytes)).toEqual(Array.from(originalBytes)) } finally { db.close() db.delete() @@ -195,18 +195,18 @@ export default function registerExecuteUnitTests() { [1], ) - expect(result.rowsAffected).to.equal(1) - expect(result.rows?.length).to.equal(1) + expect(result.rowsAffected).toBe(1) + expect(result.rows?.length).toBe(1) const row = result.results[0] // const row = result.rows?.item(0) - expect(row).to.not.equal(undefined) + expect(row).not.toBe(undefined) const value = row?.data - expect(value).to.be.instanceOf(ArrayBuffer) + expect(value).toBeInstanceOf(ArrayBuffer) const returnedBytes = new Uint8Array(value as ArrayBuffer) - expect(Array.from(returnedBytes)).to.eql(Array.from(originalBytes)) + expect(Array.from(returnedBytes)).toEqual(Array.from(originalBytes)) } finally { db.close() db.delete() @@ -235,17 +235,17 @@ export default function registerExecuteUnitTests() { [1], ) - expect(result.rowsAffected).to.equal(1) - expect(result.rows?.length).to.equal(1) + expect(result.rowsAffected).toBe(1) + expect(result.rows?.length).toBe(1) const row = result.results[0] - expect(row).to.not.equal(undefined) + expect(row).not.toBe(undefined) const value = row?.data - expect(value).to.be.instanceOf(ArrayBuffer) + expect(value).toBeInstanceOf(ArrayBuffer) const returnedBytes = new Uint8Array(value as ArrayBuffer) - expect(Array.from(returnedBytes)).to.eql(Array.from(originalBytes)) + expect(Array.from(returnedBytes)).toEqual(Array.from(originalBytes)) } finally { db.close() db.delete() diff --git a/example/src/tests/unit/specs/operations/executeBatch.spec.ts b/example/src/tests/unit/specs/operations/executeBatch.spec.ts index 901f019f..423cb42c 100644 --- a/example/src/tests/unit/specs/operations/executeBatch.spec.ts +++ b/example/src/tests/unit/specs/operations/executeBatch.spec.ts @@ -1,6 +1,6 @@ import { chance, expect } from '../../common' import type { BatchQueryCommand } from 'react-native-nitro-sqlite' -import { describe, it } from '../../../MochaRNAdapter' +import { describe, it } from 'react-native-harness' import { testDb } from '../../../db' export default function registerExecuteBatchUnitTests() { @@ -31,7 +31,7 @@ export default function registerExecuteBatchUnitTests() { testDb.executeBatch(commands) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id: id1, name: name1, age: age1, networth: networth1 }, { id: id2, @@ -67,7 +67,7 @@ export default function registerExecuteBatchUnitTests() { await testDb.executeBatchAsync(commands) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id: id1, name: name1, age: age1, networth: networth1 }, { id: id2, diff --git a/example/src/tests/unit/specs/operations/transaction.spec.ts b/example/src/tests/unit/specs/operations/transaction.spec.ts index fd194aa8..fb48e899 100644 --- a/example/src/tests/unit/specs/operations/transaction.spec.ts +++ b/example/src/tests/unit/specs/operations/transaction.spec.ts @@ -6,7 +6,7 @@ import { TEST_ERROR_MESSAGE, TEST_ERROR_CODES, } from '../../common' -import { describe, it } from '../../../MochaRNAdapter' +import { describe, it } from 'react-native-harness' import type { User } from '../../../../model/User' import { testDb } from '../../../db' @@ -24,15 +24,15 @@ export default function registerTransactionUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id, name, @@ -54,17 +54,17 @@ export default function registerTransactionUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') tx.commit() }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id, name, @@ -122,10 +122,7 @@ export default function registerTransactionUnitTests() { const expected = Array(iterations) .fill(0) .map((_, index) => index * 1000) - expect(actual).to.eql( - expected, - 'Each transaction should read a different value', - ) + expect(actual).toEqual(expected) }) it('Transaction, cannot execute after commit', async () => { @@ -140,23 +137,23 @@ export default function registerTransactionUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') tx.commit() try { tx.execute('SELECT * FROM "User"') } catch (e) { - expect(e).to.not.equal(undefined) + expect(e).not.toBe(undefined) } }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id, name, @@ -184,7 +181,7 @@ export default function registerTransactionUnitTests() { }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([]) + expect(res.rows?._array).toEqual([]) }) it('Rollback', async () => { @@ -200,7 +197,7 @@ export default function registerTransactionUnitTests() { ) tx.rollback() const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([]) + expect(res.rows?._array).toEqual([]) }) }) @@ -210,14 +207,16 @@ export default function registerTransactionUnitTests() { }) // ASSERT: should return a promise that eventually rejects - expect(promised).to.have.property('then').that.is.a('function') + expect(typeof (promised as unknown as PromiseLike).then).toBe( + 'function', + ) try { await promised - expect.fail(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) + throw new Error(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) } catch (e) { if (isNitroSQLiteError(e)) - expect(e.message).to.include(TEST_ERROR_MESSAGE) - else expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + expect(e.message).toContain(TEST_ERROR_MESSAGE) + else throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } }) @@ -226,14 +225,16 @@ export default function registerTransactionUnitTests() { tx.execute('SELECT * FROM [tableThatDoesNotExist];') }) // ASSERT: should return a promise that eventually rejects - expect(promised).to.have.property('then').that.is.a('function') + expect(typeof (promised as unknown as PromiseLike).then).toBe( + 'function', + ) try { await promised - expect.fail(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) + throw new Error(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) } catch (e) { if (isNitroSQLiteError(e)) - expect(e.message).to.include('no such table: tableThatDoesNotExist') - else expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + expect(e.message).toContain('no such table: tableThatDoesNotExist') + else throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } }) @@ -248,9 +249,11 @@ export default function registerTransactionUnitTests() { }) // ASSERT: should return a promise that eventually rejects - expect(promised).to.have.property('then').that.is.a('function') + expect(typeof (promised as unknown as PromiseLike).then).toBe( + 'function', + ) await promised - expect(ranCallback).to.equal(true, 'Should handle async callback') + expect(ranCallback).toBe(true) }) it('Async transaction, auto commit', async () => { @@ -265,15 +268,15 @@ export default function registerTransactionUnitTests() { [id, name, age, networth], ) - expect(res.rowsAffected).to.equal(1) - expect(res.insertId).to.equal(1) - expect(res.rows?._array).to.eql([]) - expect(res.rows?.length).to.equal(0) - expect(res.rows?.item).to.be.a('function') + expect(res.rowsAffected).toBe(1) + expect(res.insertId).toBe(1) + expect(res.rows?._array).toEqual([]) + expect(res.rows?.length).toBe(0) + expect(res.rows?.item).toBeTypeOf('function') }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id, name, @@ -298,14 +301,15 @@ export default function registerTransactionUnitTests() { }) } catch (e) { if (isNitroSQLiteError(e)) { - expect(e.message) - .to.include('SqlExecutionError') - .and.to.include('cannot store TEXT value in REAL column User.id') + expect(e.message).toContain('SqlExecutionError') + expect(e.message).toContain( + 'cannot store TEXT value in REAL column User.id', + ) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([]) + expect(res.rows?._array).toEqual([]) } else { - expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } } }) @@ -325,7 +329,7 @@ export default function registerTransactionUnitTests() { }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([ + expect(res.rows?._array).toEqual([ { id, name, @@ -350,7 +354,7 @@ export default function registerTransactionUnitTests() { }) const res = testDb.execute('SELECT * FROM User') - expect(res.rows?._array).to.eql([]) + expect(res.rows?._array).toEqual([]) }) it('Async transaction, executed in order', async () => { @@ -401,10 +405,7 @@ export default function registerTransactionUnitTests() { const expected = Array(iterations) .fill(0) .map((_, index) => index * 1000) - expect(actual).to.eql( - expected, - 'Each transaction should read a different value', - ) + expect(actual).toEqual(expected) }) it('Async transaction, rejects on callback error', async () => { @@ -413,14 +414,16 @@ export default function registerTransactionUnitTests() { }) // ASSERT: should return a promise that eventually rejects - expect(promised).to.have.property('then').that.is.a('function') + expect(typeof (promised as unknown as PromiseLike).then).toBe( + 'function', + ) try { await promised - expect.fail(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) + throw new Error(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) } catch (e) { if (isNitroSQLiteError(e)) - expect(e.message).to.include(TEST_ERROR_MESSAGE) - else expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + expect(e.message).toContain(TEST_ERROR_MESSAGE) + else throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } }) @@ -430,14 +433,16 @@ export default function registerTransactionUnitTests() { }) // ASSERT: should return a promise that eventually rejects - expect(promised).to.have.property('then').that.is.a('function') + expect(typeof (promised as unknown as PromiseLike).then).toBe( + 'function', + ) try { await promised - expect.fail(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) + throw new Error(TEST_ERROR_CODES.EXPECT_PROMISE_REJECTION) } catch (e) { if (isNitroSQLiteError(e)) - expect(e.message).to.include('no such table: tableThatDoesNotExist') - else expect.fail(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) + expect(e.message).toContain('no such table: tableThatDoesNotExist') + else throw new Error(TEST_ERROR_CODES.EXPECT_NITRO_SQLITE_ERROR) } }) }) diff --git a/example/src/tests/unit/specs/typeorm.spec.ts b/example/src/tests/unit/specs/typeorm.spec.ts index 3ee5f724..2151cc90 100644 --- a/example/src/tests/unit/specs/typeorm.spec.ts +++ b/example/src/tests/unit/specs/typeorm.spec.ts @@ -1,5 +1,5 @@ import { expect } from '../common' -import { beforeAll, beforeEachAsync, describe, it } from '../../MochaRNAdapter' +import { beforeAll, beforeEach, describe, it } from 'react-native-harness' import type { Repository } from 'typeorm' import { DataSource } from 'typeorm' import { typeORMDriver } from 'react-native-nitro-sqlite' @@ -12,7 +12,7 @@ let bookRepository: Repository export default function registerTypeORMUnitTests() { describe('Typeorm tests', () => { - beforeAll((done) => { + beforeAll(async () => { dataSource = new DataSource({ type: 'react-native', database: 'typeormDb.sqlite', @@ -22,26 +22,24 @@ export default function registerTypeORMUnitTests() { synchronize: true, }) - dataSource - .initialize() - .then(() => { - userRepository = dataSource.getRepository(User) - bookRepository = dataSource.getRepository(Book) - done() - }) - .catch((e) => { - console.error('error initializing typeORM datasource', e) - throw e - }) + try { + await dataSource.initialize() + } catch (e) { + console.error('error initializing typeORM datasource', e) + throw e + } + + userRepository = dataSource.getRepository(User) + bookRepository = dataSource.getRepository(Book) }) - beforeEachAsync(async () => { + beforeEach(async () => { await userRepository.clear() await bookRepository.clear() }) it('basic test', () => { - expect(1).to.equal(2) + expect(1).toBe(1) }) }) } diff --git a/example/tsconfig.json b/example/tsconfig.json index 6dabcad8..2c625c34 100644 --- a/example/tsconfig.json +++ b/example/tsconfig.json @@ -1,6 +1,6 @@ { "extends": "../config/tsconfig.json", - "include": ["src", "index.js", "../package"], + "include": ["src", "index.js", "../package", "__tests__/**/*"], "compilerOptions": { "baseUrl": ".", "paths": { diff --git a/tsconfig.json b/tsconfig.json index 118e7b29..47e68be0 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,5 +1,6 @@ { "files": [], + "include": ["example/__tests__/**/*"], "references": [ { "path": "./package/tsconfig.json" }, { "path": "./example/tsconfig.json" }