@qvac/ocr-ggml 0.0.1 → 0.1.1

package/test/integration/param-validation.test.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const { OcrGgml } = require('../..')
+const { QvacErrorAddonOcrGgml, ERR_CODES } = require('../..')
+const test = require('brittle')
+const { isMobile } = require('./utils')
+
+const MOBILE_TIMEOUT = 600 * 1000
+const DESKTOP_TIMEOUT = 30 * 1000
+const TEST_TIMEOUT = isMobile ? MOBILE_TIMEOUT : DESKTOP_TIMEOUT
+
+test('load() rejects when langList is missing', { timeout: TEST_TIMEOUT }, async function (t) {
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathDetector: 'models/craft_mlt_25k.gguf',
+      pathRecognizer: 'models/latin_g2.gguf'
+    }
+  })
+
+  try {
+    await ocrGgml.load()
+    t.fail('Should have thrown for missing langList')
+  } catch (err) {
+    t.ok(err instanceof QvacErrorAddonOcrGgml, 'Should throw QvacErrorAddonOcrGgml')
+    t.is(err.code, ERR_CODES.MISSING_REQUIRED_PARAMETER, 'Error code should be MISSING_REQUIRED_PARAMETER')
+    t.ok(err.message.includes('langList'), 'Error message should mention langList')
+    t.pass('Correctly rejected missing langList')
+  }
+})
+
+test('load() rejects when langList is empty array after filtering', { timeout: TEST_TIMEOUT }, async function (t) {
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathDetector: 'models/craft_mlt_25k.gguf',
+      pathRecognizer: 'models/latin_g2.gguf',
+      langList: ['klingon', 'elvish', 'dothraki']
+    }
+  })
+
+  try {
+    await ocrGgml.load()
+    t.fail('Should have thrown for all-unsupported languages')
+  } catch (err) {
+    t.ok(err instanceof QvacErrorAddonOcrGgml, 'Should throw QvacErrorAddonOcrGgml')
+    t.is(err.code, ERR_CODES.UNSUPPORTED_LANGUAGE, 'Error code should be UNSUPPORTED_LANGUAGE')
+    t.pass('Correctly rejected all-unsupported language list')
+  }
+})
+
+test('load() rejects when pathDetector is missing', { timeout: TEST_TIMEOUT }, async function (t) {
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathRecognizer: 'models/latin_g2.gguf',
+      langList: ['en']
+    }
+  })
+
+  try {
+    await ocrGgml.load()
+    t.fail('Should have thrown for missing pathDetector')
+  } catch (err) {
+    t.ok(err instanceof QvacErrorAddonOcrGgml, 'Should throw QvacErrorAddonOcrGgml')
+    t.is(err.code, ERR_CODES.MISSING_REQUIRED_PARAMETER, 'Error code should be MISSING_REQUIRED_PARAMETER')
+    t.ok(err.message.includes('pathDetector'), 'Error message should mention pathDetector')
+    t.pass('Correctly rejected missing pathDetector')
+  }
+})
+
+test('load() rejects when pathRecognizer is missing', { timeout: TEST_TIMEOUT }, async function (t) {
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathDetector: 'models/craft_mlt_25k.gguf',
+      langList: ['en']
+    }
+  })
+
+  try {
+    await ocrGgml.load()
+    t.fail('Should have thrown for missing pathRecognizer')
+  } catch (err) {
+    t.ok(err instanceof QvacErrorAddonOcrGgml, 'Should throw QvacErrorAddonOcrGgml')
+    t.is(err.code, ERR_CODES.MISSING_REQUIRED_PARAMETER, 'Error code should be MISSING_REQUIRED_PARAMETER')
+    t.ok(err.message.includes('pathRecognizer'), 'Error message should mention pathRecognizer')
+    t.pass('Correctly rejected missing recognizer path')
+  }
+})

package/test/integration/pipeline.test.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { OcrGgml } = require('../..')
+const test = require('brittle')
+const { isMobile, getImagePath, ensureModelPath } = require('./utils')
+
+const MOBILE_TIMEOUT = 600 * 1000 // 10 minutes for mobile
+const DESKTOP_TIMEOUT = 60 * 1000 // 1 minute for desktop
+const TEST_TIMEOUT = isMobile ? MOBILE_TIMEOUT : DESKTOP_TIMEOUT
+
+test('Test for a fix of missing end of job event', { timeout: TEST_TIMEOUT }, async function (t) {
+  const detectorPath = await ensureModelPath('detector_craft')
+  const recognizerPath = await ensureModelPath('recognizer_latin')
+  const imagePath = getImagePath('/test/images/unrecognizable_text.bmp')
+
+  t.comment('Testing with image: ' + imagePath)
+
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathDetector: detectorPath,
+      pathRecognizer: recognizerPath,
+      langList: ['en']
+    },
+    opts: { stats: true }
+  })
+
+  await ocrGgml.load()
+
+  try {
+    let errorReceived = false
+    let responseCompleted = false
+
+    const response = await ocrGgml.run({
+      path: imagePath,
+      options: { paragraph: false }
+    })
+
+    await response
+      .onUpdate(output => {
+        t.ok(Array.isArray(output), 'output should be an array')
+      })
+      .onError(error => {
+        errorReceived = true
+        t.fail('Unexpected error received: ' + JSON.stringify(error))
+      })
+      .await()
+      .then(() => {
+        responseCompleted = true
+        t.pass('Response completed successfully - JobEnded event was received')
+      })
+
+    t.ok(!errorReceived, 'No error should be received')
+    t.ok(responseCompleted, 'Response should complete - JobEnded event was received')
+    t.pass('Pipeline completed successfully without hanging')
+  } catch (err) {
+    t.fail(`Error in test: ${err}`)
+  } finally {
+    await ocrGgml.unload()
+    await new Promise(resolve => setTimeout(resolve, 1000))
+  }
+})

package/test/integration/run-internal-ordering.test.js

@@ -0,0 +1,75 @@
+'use strict'
+
+// Regression test for #1756.
+//
+// The native OCR binding fires output/stats/error callbacks synchronously
+// from inside `binding.runJob(...)`. If `_runInternal` awaits `runJob` before
+// calling `_job.start()`, those callbacks land while the job handler has no
+// active QvacResponse and are silently dropped. This test pins the ordering
+// by stubbing `this.addon` with a `runJob` that mirrors the native semantics
+// (callbacks fired synchronously inside the call) and asserts the response
+// receives them.
+
+const test = require('brittle')
+const { OcrGgml } = require('../..')
+
+function createOcr () {
+  const ocr = new OcrGgml({
+    params: {
+      pathDetector: 'unused',
+      pathRecognizer: 'unused',
+      langList: ['en']
+    },
+    opts: { stats: true }
+  })
+
+  ocr._readImage = () => ({ data: Buffer.from('stub'), isEncoded: true })
+
+  return ocr
+}
+
+test('output callbacks fired synchronously inside runJob are not dropped', async t => {
+  const ocr = createOcr()
+  const expectedOutput = [[[[0, 0], [10, 0], [10, 10], [0, 10]], 'hello', 0.99]]
+
+  ocr.addon = {
+    runJob: async () => {
+      ocr._addonOutputCallback(ocr.addon, 'Output', expectedOutput)
+      ocr._addonOutputCallback(ocr.addon, 'JobEnded', { totalTime: 1 })
+    },
+    cancel: () => {}
+  }
+
+  const response = await ocr.run({ path: 'stub' })
+  const result = await response.await()
+
+  t.alike(result, [expectedOutput], 'output emitted before runJob await must reach the response')
+  t.alike(response.stats, { totalTime: 1 }, 'stats emitted before runJob await must reach the response')
+})
+
+test('error callbacks fired synchronously inside runJob are not dropped', async t => {
+  const ocr = createOcr()
+
+  ocr.addon = {
+    runJob: async () => {
+      ocr._addonOutputCallback(ocr.addon, 'Error', null, 'native failure')
+    },
+    cancel: () => {}
+  }
+
+  const response = await ocr.run({ path: 'stub' })
+  await t.exception(response.await(), /native failure/, 'error emitted before runJob await must reach the response')
+})
+
+test('runJob rejection is routed through _job.fail and clears the active response', async t => {
+  const ocr = createOcr()
+  const failure = new Error('runJob rejected')
+
+  ocr.addon = {
+    runJob: async () => { throw failure },
+    cancel: () => {}
+  }
+
+  await t.exception(ocr.run({ path: 'stub' }), /runJob rejected/, 'runJob rejection must propagate to the caller')
+  t.is(ocr._job.active, null, 'failed run must clear the active response so the next start() does not see a stale job')
+})

package/test/integration/run-tests.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Shell wrapper for bare integration tests.
+# Bare.exit() hangs when native addon handles keep the event loop alive,
+# so run-with-exit.js writes an .exit-code file when tests finish.
+# This script monitors for that file and terminates bare cleanly.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+EXIT_CODE_FILE="$SCRIPT_DIR/.exit-code"
+TIMEOUT=${INTEGRATION_TEST_TIMEOUT:-600}
+
+rm -f "$EXIT_CODE_FILE"
+
+bare "$SCRIPT_DIR/run-with-exit.js" &
+BARE_PID=$!
+
+ELAPSED=0
+while [ ! -f "$EXIT_CODE_FILE" ]; do
+  sleep 1
+  ELAPSED=$((ELAPSED + 1))
+  if ! kill -0 "$BARE_PID" 2>/dev/null; then
+    wait "$BARE_PID" 2>/dev/null
+    BARE_EC=$?
+    if [ -f "$EXIT_CODE_FILE" ]; then
+      break
+    fi
+    exit "$BARE_EC"
+  fi
+  if [ "$ELAPSED" -ge "$TIMEOUT" ]; then
+    echo "# integration-test timeout (${TIMEOUT}s) — forcing exit"
+    kill "$BARE_PID" 2>/dev/null
+    sleep 1
+    kill -9 "$BARE_PID" 2>/dev/null
+    exit 1
+  fi
+done
+
+EC=$(cat "$EXIT_CODE_FILE")
+rm -f "$EXIT_CODE_FILE"
+kill "$BARE_PID" 2>/dev/null
+sleep 1
+kill -9 "$BARE_PID" 2>/dev/null
+wait "$BARE_PID" 2>/dev/null
+exit "$EC"

package/test/integration/run-with-exit.js

@@ -0,0 +1,71 @@
+'use strict'
+
+// Native addon keeps the event loop alive, so brittle's beforeExit never fires
+// and the process hangs after all tests pass. This wrapper detects completion
+// via two mechanisms: (1) intercepting brittle's TAP summary via console.log,
+// and (2) polling test count stability. When done it writes the exit code to
+// .exit-code so the shell wrapper (run-tests.sh) can kill bare and propagate
+// the correct status.
+
+const fs = require('bare-fs')
+const path = require('bare-path')
+
+const origLog = console.log
+
+// Patch console.log BEFORE loading tests so brittle's _log captures our version.
+console.log = function () {
+  origLog.apply(console, arguments)
+  if (arguments.length === 1) {
+    const arg = arguments[0]
+    if (arg === '# ok' || arg === '# not ok') {
+      flushAndWriteExitCode()
+    }
+  }
+}
+
+require('./all.js')
+
+const RUNNER = Symbol.for('brittle-runner')
+
+let utils = null
+try { utils = require('./utils.js') } catch (_) {}
+
+function flushAndWriteExitCode () {
+  if (utils && typeof utils.flushPerfReport === 'function') {
+    try { utils.flushPerfReport() } catch (_) {}
+  }
+  writeExitCode()
+}
+
+function writeExitCode () {
+  let code = 0
+  if (global.Bare && global.Bare.exitCode !== undefined) code = global.Bare.exitCode
+  try {
+    fs.writeFileSync(path.join(__dirname, '.exit-code'), String(code))
+  } catch (e) {}
+}
+
+// Backup: poll test count stability in case console.log interception fails.
+let lastCount = 0
+let stableTicks = 0
+let done = false
+const stabilityPoll = setInterval(function () {
+  if (done) { clearInterval(stabilityPoll); return }
+  const runner = global[RUNNER]
+  if (!runner || !runner.started) return
+
+  const count = runner.tests.count
+  if (count > 0 && count === lastCount && runner.next === null) {
+    stableTicks++
+  } else {
+    stableTicks = 0
+  }
+  lastCount = count
+
+  if (stableTicks >= 3) {
+    done = true
+    clearInterval(stabilityPoll)
+    flushAndWriteExitCode()
+    try { runner.end() } catch (e) {}
+  }
+}, 5000)