msgpackr 1.5.1 → 1.5.2

package/tests/test-compatibility.cjs

@@ -1,64 +0,0 @@
-const data = require('./example4.json');
-const { pack, unpack, Packr } = require('msgpackr/pack');
-const chai = require('chai');
-
-function tryRequire(module) {
-	try {
-		return require(module)
-	} catch(error) {
-		console.log(error)
-	}
-}
-//if (typeof chai === 'undefined') { chai = require('chai') }
-const assert = chai.assert
-//if (typeof msgpackr === 'undefined') { msgpackr = require('..') }
-var msgpack_msgpack = tryRequire('@msgpack/msgpack');
-var msgpack_lite = tryRequire('msgpack-lite');
-var msgpack = tryRequire('msgpack');
-
-const addCompatibilitySuite = (data) => () => {
-	if (msgpack_msgpack) {
-		test('from @msgpack/msgpack', function(){
-			var serialized = msgpack_msgpack.encode(data)
-			var deserialized = unpack(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-
-		test('to @msgpack/msgpack', function(){
-			var serialized = pack(data)
-			var deserialized = msgpack_msgpack.decode(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-	}
-	if (msgpack_lite) {
-		test('from msgpack-lite', function(){
-			var serialized = msgpack_lite.encode(data)
-			var deserialized = unpack(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-
-		test('to msgpack-lite', function(){
-			var serialized = pack(data)
-			var deserialized = msgpack_lite.decode(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-	}
-	if (msgpack) {
-		test.skip('from msgpack', function(){
-			var serialized = msgpack.pack(data)
-			var deserialized = unpack(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-
-		test('to msgpack', function(){
-			var serialized = pack(data)
-			var deserialized = msgpack.unpack(serialized)
-			assert.deepEqual(deserialized, data)
-		})
-	}
-}
-
-suite('msgpackr compatibility tests (example)', addCompatibilitySuite(require('./example.json')))
-suite('msgpackr compatibility tests (example4)', addCompatibilitySuite(require('./example4.json')))
-suite('msgpackr compatibility tests (example5)', addCompatibilitySuite(require('./example5.json')))
-suite.skip('msgpackr compatibility tests with dates', addCompatibilitySuite({ date: new Date() }))

package/tests/test-incomplete.js

@@ -1,41 +0,0 @@
-import { encode } from '../index.js'
-import { assert } from 'chai'
-import { Encoder } from '../pack.js'
-
-const tests = {
-  string: 'interesting string',
-  number: 12345,
-  buffer: Buffer.from('hello world'),
-  bigint: 12345678910n,
-  array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
-  'many-strings': [],
-  set: new Set('abcdefghijklmnopqrstuvwxyz'.split('')),
-  object: { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }
-}
-for (let i = 0; i < 100; i++) {
-  tests['many-strings'].push('test-data-' + i)
-}
-
-suite('encode and decode tests with partial values', function () {
-  const encoder = new Encoder({ objectMode: true, structures: [], structuredClone: true })
-
-  for (const [label, testData] of Object.entries(tests)) {
-    test(label, () => {
-      const encoded = encoder.encode(testData)
-      assert.isTrue(Buffer.isBuffer(encoded), 'encode returns a Buffer')
-      assert.deepStrictEqual(encoder.decode(encoded, encoded.length, true), testData, 'full buffer decodes well')
-      const firstHalf = encoded.slice(0, Math.floor(encoded.length / 2))
-      let value
-      try {
-        value = encoder.decode(firstHalf, firstHalf.length, true)
-      } catch (err) {
-        if (err.incomplete !== true) {
-          assert.fail(`Should throw an error with .incomplete set to true, instead threw error <${err}>`)
-        } else {
-          return; // victory! correct outcome!
-        }
-      }
-      assert.fail(`Should throw an error with .incomplete set to true, instead returned value ${JSON.stringify(value)}`)
-    })
-  }
-})

package/tests/test-node-iterators.js

@@ -1,72 +0,0 @@
-import { encodeIter, decodeIter } from '../index.js'
-import { decode } from '../index.js'
-import { assert } from 'chai'
-
-const tests = [
-  null,
-  false,
-  true,
-  'interesting string',
-  12345,
-  123456789n,
-  123.456,
-  Buffer.from('Hello World'),
-  'abcdefghijklmnopqrstuvwxyz'.split('')
-]
-
-suite('msgpackr iterators interface tests', function () {
-  test('sync encode iterator', () => {
-    const encodings = [...encodeIter(tests)]
-    const decodings = encodings.map(x => decode(x))
-    assert.deepStrictEqual(decodings, tests)
-  })
-
-  test('async encode iterator', async () => {
-    async function * generate () {
-      for (const test of tests) {
-        await new Promise((resolve, reject) => setImmediate(resolve))
-        yield test
-      }
-    }
-
-    const chunks = []
-    for await (const chunk of encodeIter(generate())) {
-      chunks.push(chunk)
-    }
-
-    const decodings = chunks.map(x => decode(x))
-    assert.deepStrictEqual(decodings, tests)
-  })
-
-  test('sync encode and decode iterator', () => {
-    const encodings = [...encodeIter(tests)]
-    assert.isTrue(encodings.every(v => Buffer.isBuffer(v)))
-    const decodings = [...decodeIter(encodings)]
-    assert.deepStrictEqual(decodings, tests)
-
-    // also test decodings work with buffers multiple values in a buffer
-    const concatEncoding = Buffer.concat([...encodings])
-    const decodings2 = [...decodeIter([concatEncoding])]
-    assert.deepStrictEqual(decodings2, tests)
-
-    // also test decodings work with partial buffers that don't align to values perfectly
-    const half1 = concatEncoding.slice(0, Math.floor(concatEncoding.length / 2))
-    const half2 = concatEncoding.slice(Math.floor(concatEncoding.length / 2))
-    const decodings3 = [...decodeIter([half1, half2])]
-    assert.deepStrictEqual(decodings3, tests)
-  })
-
-  test('async encode and decode iterator', async () => {
-    async function * generator () {
-      for (const obj of tests) {
-        await new Promise((resolve, reject) => setImmediate(resolve))
-        yield obj
-      }
-    }
-    const yields = []
-    for await (const value of decodeIter(encodeIter(generator()))) {
-      yields.push(value)
-    }
-    assert.deepStrictEqual(yields, tests)
-  })
-})

package/tests/test-node-stream.js

@@ -1,76 +0,0 @@
-import { PackrStream, UnpackrStream } from '../node-index.js'
-import stream from 'stream'
-import chai from 'chai'
-import util from 'util'
-import fs from 'fs'
-const finished = util.promisify(stream.finished)
-var assert = chai.assert
-
-suite('msgpackr node stream tests', function(){
-	test('serialize/parse stream', () => {
-		const serializeStream = new PackrStream({
-		})
-		const parseStream = new UnpackrStream()
-		serializeStream.pipe(parseStream)
-		const received = []
-		parseStream.on('data', data => {
-			received.push(data)
-		})
-		const messages = [{
-			name: 'first'
-		}, {
-			name: 'second'
-		}, {
-			name: 'third'
-		}, {
-			name: 'third',
-			extra: [1, 3, { foo: 'hi'}, 'bye']
-		}]
-		for (const message of messages)
-			serializeStream.write(message)
-		return new Promise((resolve, reject) => {
-			setTimeout(() => {
-				assert.deepEqual(received, messages)
-				resolve()
-			}, 10)
-		})
-	})
-	test('stream from buffer', () => new Promise(async resolve => {
-		const parseStream = new UnpackrStream()
-		let values = []
-		parseStream.on('data', (value) => {
-			values.push(value)
-		})
-		parseStream.on('end', () => {
-			assert.deepEqual(values, [1, 2])
-			resolve()
-		})
-		let bufferStream = new stream.Duplex()
-		bufferStream.pipe(parseStream)
-		bufferStream.push(new Uint8Array([1, 2]))
-		bufferStream.push(null)
-	}))
-	test('serialize stream to file', async function() {
-		const serializeStream = new PackrStream({
-		})
-		const fileStream = fs.createWriteStream('test-output.msgpack');
-		serializeStream.pipe(fileStream);
-		const messages = [{
-			name: 'first'
-		}, {
-			name: 'second',
-			extra: [1, 3, { foo: 'hi'}, 'bye']
-		}]
-		for (const message of messages)
-			serializeStream.write(message)
-		setTimeout(() => serializeStream.end(), 10)
-		
-		await finished(serializeStream)
-	})
-	teardown(function() {
-		try {
-			fs.unlinkSync('test-output.msgpack')
-		}catch(error){}
-	})
-})
-