@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/thread-stream/test/context.test.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const ThreadStream = require('..')
+const { version } = require('../package.json')
+
+test('get context', (t, done) => {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'get-context.js'),
+    workerData: {},
+    sync: true
+  })
+  t.after(() => stream.end())
+  stream.on('context', (ctx) => {
+    assert.deepStrictEqual(ctx.threadStreamVersion, version)
+    done()
+  })
+  stream.write('hello')
+})

package/node_modules/thread-stream/test/create-and-exit.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { join } = require('path')
+const ThreadStream = require('..')
+
+const stream = new ThreadStream({
+  filename: join(__dirname, 'to-file.js'),
+  workerData: { dest: process.argv[2] },
+  sync: true
+})
+
+stream.write('hello')
+stream.write(' ')
+stream.write('world\n')
+stream.flushSync()
+stream.unref()

package/node_modules/thread-stream/test/custom-worker.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { parentPort } = require('worker_threads')
+
+parentPort.postMessage({
+  code: 'CUSTOM-WORKER-CALLED'
+})
+
+require('../lib/worker')

package/node_modules/thread-stream/test/emit-event.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { Writable } = require('stream')
+const parentPort = require('worker_threads').parentPort
+
+async function run () {
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      if (parentPort) {
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'socketError',
+          args: ['list', 'of', 'args', 123, new Error('unable to write data to the TCP socket')]
+        })
+      }
+      cb()
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/end.test.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { readFile } = require('fs')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+
+test('destroy support', function (t, done) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file-on-destroy.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.on('close', () => {
+    assert.ok(!stream.writable)
+    readFile(dest, 'utf8', (err, data) => {
+      assert.ifError(err)
+      assert.strictEqual(data, 'hello world\nsomething else\n')
+      done()
+    })
+  })
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+  assert.ok(stream.writable)
+
+  stream.end()
+})
+
+test('synchronous _final support', function (t, done) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file-on-final.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.on('close', () => {
+    assert.ok(!stream.writable)
+    readFile(dest, 'utf8', (err, data) => {
+      assert.ifError(err)
+      assert.strictEqual(data, 'hello world\nsomething else\n')
+      done()
+    })
+  })
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+  assert.ok(stream.writable)
+
+  stream.end()
+})

package/node_modules/thread-stream/test/error.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+async function run (opts) {
+  const stream = new Writable({
+    write (chunk, enc, cb) {
+      cb(new Error('kaboom'))
+    }
+  })
+  return stream
+}
+
+module.exports = run

package/node_modules/thread-stream/test/esm.test.mjs

@@ -0,0 +1,46 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'fs'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { pathToFileURL } from 'url'
+import { file } from './helper.js'
+
+function basic (text, filename) {
+  test(text, function (t, done) {
+    const dest = file()
+    const stream = new ThreadStream({
+      filename,
+      workerData: { dest },
+      sync: true
+    })
+
+    stream.on('finish', () => {
+      readFile(dest, 'utf8', (err, data) => {
+        assert.ifError(err)
+        assert.strictEqual(data, 'hello world\nsomething else\n')
+      })
+    })
+
+    stream.on('close', () => {
+      done()
+    })
+
+    assert.ok(stream.write('hello world\n'))
+    assert.ok(stream.write('something else\n'))
+
+    stream.end()
+  })
+}
+
+basic('esm with path', join(import.meta.url, 'to-file.mjs'))
+basic('esm with file URL', pathToFileURL(join(import.meta.url, 'to-file.mjs')).href)
+
+basic('(ts -> es6) esm with path', join(import.meta.url, 'ts', 'to-file.es6.mjs'))
+basic('(ts -> es6) esm with file URL', pathToFileURL(join(import.meta.url, 'ts', 'to-file.es6.mjs')).href)
+
+basic('(ts -> es2017) esm with path', join(import.meta.url, 'ts', 'to-file.es2017.mjs'))
+basic('(ts -> es2017) esm with file URL', pathToFileURL(join(import.meta.url, 'ts', 'to-file.es2017.mjs')).href)
+
+basic('(ts -> esnext) esm with path', join(import.meta.url, 'ts', 'to-file.esnext.mjs'))
+basic('(ts -> esnext) esm with file URL', pathToFileURL(join(import.meta.url, 'ts', 'to-file.esnext.mjs')).href)

package/node_modules/thread-stream/test/event.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const ThreadStream = require('..')
+
+test('event propagate', (t, done) => {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'emit-event.js'),
+    workerData: {},
+    sync: true
+  })
+  t.after(() => stream.end())
+  stream.on('socketError', function (a, b, c, n, error) {
+    assert.deepStrictEqual(a, 'list')
+    assert.deepStrictEqual(b, 'of')
+    assert.deepStrictEqual(c, 'args')
+    assert.deepStrictEqual(n, 123)
+    assert.deepStrictEqual(error, new Error('unable to write data to the TCP socket'))
+    done()
+  })
+  stream.write('hello')
+})

package/node_modules/thread-stream/test/exit.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+async function run (opts) {
+  const stream = new Writable({
+    write (chunk, enc, cb) {
+      process.exit(1)
+    }
+  })
+  return stream
+}
+
+module.exports = run

package/node_modules/thread-stream/test/get-context.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { Writable } = require('stream')
+const parentPort = require('worker_threads').parentPort
+
+async function run (opts) {
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      if (parentPort) {
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'context',
+          args: opts.$context
+        })
+      }
+      cb()
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/helper.d.ts

@@ -0,0 +1 @@
+export declare function file(): string

package/node_modules/thread-stream/test/helper.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { join } = require('path')
+const { tmpdir } = require('os')
+const { unlinkSync } = require('fs')
+
+const files = []
+let count = 0
+
+function file () {
+  const file = join(tmpdir(), `thread-stream-${process.pid}-${count++}`)
+  files.push(file)
+  return file
+}
+
+process.on('beforeExit', () => {
+  for (const file of files) {
+    try {
+      unlinkSync(file)
+    } catch (e) {
+      // ignore cleanup errors
+    }
+  }
+})
+
+module.exports.file = file

package/node_modules/thread-stream/test/indexes.test.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const indexes = require('../lib/indexes')
+
+for (const index of Object.keys(indexes)) {
+  test(`${index} is lock free`, function () {
+    assert.strictEqual(Atomics.isLockFree(indexes[index]), true)
+  })
+}

package/node_modules/thread-stream/test/multibyte-chars.test.mjs

@@ -0,0 +1,75 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'fs'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { file } from './helper.js'
+
+test('break up utf8 multibyte (sync)', (t, done) => {
+  const longString = '\u03A3'.repeat(16)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 15, // this must be odd
+    filename: join(import.meta.url, 'to-file.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
+    })
+  })
+
+  stream.write(longString)
+  stream.end()
+})
+
+test('break up utf8 multibyte (async)', (t, done) => {
+  const longString = '\u03A3'.repeat(16)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 15, // this must be odd
+    filename: join(import.meta.url, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
+    })
+  })
+
+  stream.write(longString)
+  stream.end()
+})
+
+test('break up utf8 multibyte several times bigger than write buffer', (t, done) => {
+  const longString = '\u03A3'.repeat(32)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 15, // this must be odd
+    filename: join(import.meta.url, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
+    })
+  })
+
+  stream.write(longString)
+  stream.end()
+})

package/node_modules/thread-stream/test/on-message.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { parentPort } = require('worker_threads')
+const { Writable } = require('stream')
+
+function run () {
+  parentPort.once('message', function ({ text, takeThisPortPlease }) {
+    takeThisPortPlease.postMessage(`received: ${text}`)
+  })
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      cb()
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/pkg/index.js

@@ -0,0 +1,37 @@
+'use strict'
+
+/**
+ * This file is packaged using pkg in order to test if worker.js works in that context.
+ * Note: We can't use node:test here because it crashes inside pkg bundles due to V8 internals.
+ */
+
+const assert = require('node:assert')
+const { join } = require('path')
+const { file } = require('../helper')
+const ThreadStream = require('../..')
+
+globalThis.__bundlerPathsOverrides = {
+  'thread-stream-worker': join(__dirname, '..', 'custom-worker.js')
+}
+
+const dest = file()
+
+process.on('uncaughtException', (error) => {
+  console.error(error)
+  process.exit(1)
+})
+
+const stream = new ThreadStream({
+  filename: join(__dirname, '..', 'to-file.js'),
+  workerData: { dest },
+  sync: true
+})
+
+stream.worker.removeAllListeners('message')
+stream.worker.once('message', (message) => {
+  assert.strictEqual(message.code, 'CUSTOM-WORKER-CALLED')
+  console.log('pkg test passed')
+  process.exit(0)
+})
+
+stream.end()

package/node_modules/thread-stream/test/pkg/pkg.config.json

@@ -0,0 +1,14 @@
+{
+    "pkg": {
+        "assets": [
+            "../custom-worker.js",
+            "../to-file.js"
+        ],
+        "targets": [
+            "node20",
+            "node22",
+            "node24"
+        ],
+        "outputPath": "test/pkg"
+    }
+}

package/node_modules/thread-stream/test/pkg/pkg.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const config = require('./pkg.config.json')
+const { promisify } = require('util')
+const { unlink } = require('fs/promises')
+const { join } = require('path')
+const { platform } = require('process')
+const exec = promisify(require('child_process').exec)
+
+test('worker test when packaged into executable using pkg', async () => {
+  const packageName = 'index'
+
+  // package the app into several node versions, check config for more info
+  const filePath = `${join(__dirname, packageName)}.js`
+  const configPath = join(__dirname, 'pkg.config.json')
+  process.env.NODE_OPTIONS ||= ''
+  process.env.NODE_OPTIONS = '--no-warnings'
+  const { stderr } = await exec(`npx pkg ${filePath} --config ${configPath}`)
+
+  // there should be no error when packaging
+  assert.strictEqual(stderr, '')
+
+  // pkg outputs files in the following format by default: {filename}-{node version}
+  for (const target of config.pkg.targets) {
+    // execute the packaged test
+    let executablePath = `${join(config.pkg.outputPath, packageName)}-${target}`
+
+    // when on windows, we need the .exe extension
+    if (platform === 'win32') {
+      executablePath = `${executablePath}.exe`
+    } else {
+      executablePath = `./${executablePath}`
+    }
+
+    const { stderr } = await exec(executablePath)
+
+    // check if there were no errors
+    assert.strictEqual(stderr, '')
+
+    // clean up afterwards
+    await unlink(executablePath)
+  }
+})

package/node_modules/thread-stream/test/port.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+function run (opts) {
+  const { port } = opts
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      port.postMessage(chunk.toString())
+      cb()
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/post-message.test.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { once } = require('events')
+const { MessageChannel } = require('worker_threads')
+const ThreadStream = require('..')
+
+test('message events emitted on the stream are posted to the worker', async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'on-message.js'),
+    sync: false
+  })
+  t.after(() => {
+    stream.end()
+  })
+
+  stream.emit('message', { text: 'hello', takeThisPortPlease: port1 }, [port1])
+  const [confirmation] = await once(port2, 'message')
+  assert.strictEqual(confirmation, 'received: hello')
+})

package/node_modules/thread-stream/test/string-limit-2.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { file } = require('./helper')
+const { createReadStream } = require('fs')
+const ThreadStream = require('..')
+const buffer = require('buffer')
+
+const MAX_STRING = buffer.constants.MAX_STRING_LENGTH
+
+test('string limit 2', { skip: process.env.CI }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('close', async () => {
+    let buf
+    for await (const chunk of createReadStream(dest)) {
+      buf = chunk
+    }
+    assert.strictEqual('asd', buf.toString().slice(-3))
+    done()
+  })
+
+  stream.on('ready', () => {
+    stream.write('a'.repeat(MAX_STRING - 2))
+    stream.write('asd')
+    stream.end()
+  })
+})

package/node_modules/thread-stream/test/string-limit.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { file } = require('./helper')
+const { stat } = require('fs')
+const ThreadStream = require('..')
+
+test('string limit', { skip: process.env.CI, timeout: 30000 }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  let length = 0
+
+  stream.on('close', () => {
+    stat(dest, (err, f) => {
+      assert.ifError(err)
+      assert.strictEqual(f.size, length)
+      done()
+    })
+  })
+
+  const buf = Buffer.alloc(1024).fill('x').toString() // 1 KB
+
+  // This writes 1 GB of data
+  for (let i = 0; i < 1024 * 1024; i++) {
+    length += buf.length
+    stream.write(buf)
+  }
+
+  stream.end()
+})

package/node_modules/thread-stream/test/syntax-error.mjs

@@ -0,0 +1,2 @@
+// this is a syntax error
+import