amqplib 2.2.0 → 2.2.1

package/test/data.test.js

@@ -1,33 +0,0 @@
-const { forAll } = require('claire');
-const { Octet, ShortStr, LongStr, UShort, ULong, ULongLong, Short, Long, LongLong, Bit, Double, Float, Decimal, Timestamp, FieldTable, FieldArray } = require('./lib/data');
-
-const domainProps = [
-  [Octet, (n) => n >= 0 && n < 256],
-  [ShortStr, (s) => typeof s === 'string' && s.length < 256],
-  [LongStr, (s) => Buffer.isBuffer(s)],
-  [UShort, (n) => n >= 0 && n <= 0xffff],
-  [ULong, (n) => n >= 0 && n <= 0xffffffff],
-  [ULongLong, (n) => n >= 0 && n <= 0xffffffffffffffff],
-  [Short, (n) => n >= -0x8000 && n <= 0x8000],
-  [Long, (n) => n >= -0x80000000 && n < 0x80000000],
-  [LongLong, (n) => n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER],
-  [Bit, (b) => typeof b === 'boolean'],
-  [Double, (f) => !Number.isNaN(f) && Number.isFinite(f)],
-  [Float, (f) => !Number.isNaN(f) && Number.isFinite(f) && Math.log(Math.abs(f)) * Math.LOG10E < 309],
-  [Decimal, (d) => d['!'] === 'decimal' && d.value['places'] <= 255 && d.value['digits'] <= 0xffffffff],
-  [Timestamp, (t) => t['!'] === 'timestamp'],
-  [FieldTable, (t) => typeof t === 'object'],
-  [FieldArray, (a) => Array.isArray(a)],
-];
-
-if (global.describe) {
-  describe('Domains', () => {
-    domainProps.forEach((p) => {
-      console.log(p[0].toString())
-      it(`${p[0]} domain`, forAll(p[0]).satisfy((v) => {
-        console.log({ v });
-        return p[1](v)
-      }).asTest({ times: 1 }));
-    });
-  });
-}

package/test/frame.test.js

@@ -1,180 +0,0 @@
-const { describe, it } = require('node:test');
-const assert = require('node:assert');
-const connection = require('../lib/connection');
-const Frames = connection.Connection;
-const HEARTBEAT = require('../lib/frame').HEARTBEAT;
-const Stream = require('node:stream');
-const PassThrough = Stream.PassThrough;
-const { choice, forAll, repeat, label, sequence, transform, sized } = require('claire');
-const amqp = require('./lib/data');
-const assertEqualModuloDefaults = require('./lib/util').assertEqualModuloDefaults;
-const defs = require('../lib/defs');
-
-// We'll need to supply a stream which we manipulate ourselves
-function inputs() {
-  // don't coalesce buffers, since that could mess up properties (e.g., encoded frame size)
-  return new PassThrough({ objectMode: true });
-}
-
-const HB = Buffer.from([
-  defs.constants.FRAME_HEARTBEAT,
-  0,
-  0, // channel 0
-  0,
-  0,
-  0,
-  0, // zero size
-  defs.constants.FRAME_END,
-]);
-
-describe('Frame', () => {
-
-  describe('Explicit parsing', () => {
-    it('Parse heartbeat', () => {
-      const input = inputs();
-      const frames = new Frames(input);
-      input.write(HB);
-      assert.ok(frames.recvFrame() === HEARTBEAT);
-      assert.ok(!frames.recvFrame());
-    });
-
-    it('Parse partitioned', () => {
-      const input = inputs();
-      const frames = new Frames(input);
-      input.write(HB.subarray(0, 3));
-      assert.ok(!frames.recvFrame());
-      input.write(HB.subarray(3));
-      assert.ok(frames.recvFrame() === HEARTBEAT);
-      assert.ok(!frames.recvFrame());
-    });
-
-    function testBogusFrame(name, bytes) {
-      it(name, (_t, done) => {
-        const input = inputs();
-        const frames = new Frames(input);
-        frames.frameMax = 5; //for the max frame test
-        input.write(Buffer.from(bytes));
-        frames.step((err, _frame) => {
-          if (err != null) done();
-          else assert.fail('Was a bogus frame!');
-        });
-      });
-    }
-
-    testBogusFrame('Wrong sized frame', [
-      defs.constants.FRAME_BODY,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0, // zero length
-      65, // but a byte!
-      defs.constants.FRAME_END,
-    ]);
-
-    testBogusFrame('Unknown method frame', [
-      defs.constants.FRAME_METHOD,
-      0,
-      0,
-      0,
-      0,
-      0,
-      4,
-      0,
-      0,
-      0,
-      0, // garbage ID
-      defs.constants.FRAME_END,
-    ]);
-  });
-
-  const Trace = label('frame trace', repeat(choice.apply(choice, amqp.methods)));
-
-  describe('Parsing', () => {
-    function testPartitioning(partition) {
-      return forAll(Trace)
-        .satisfy((t) => {
-          const bufs = [];
-          const input = inputs();
-          const frames = new Frames(input);
-          let i = 0;
-          let ex;
-          frames.accept = (f) => {
-            // A minor hack to make sure we get the assertion exception;
-            // otherwise, it's just a test that we reached the line
-            // incrementing `i` for each frame.
-            try {
-              assertEqualModuloDefaults(t[i], f.fields);
-            } catch (e) {
-              ex = e;
-            }
-            i++;
-          };
-
-          t.forEach((f) => {
-            f.channel = 0;
-            bufs.push(defs.encodeMethod(f.id, 0, f.fields));
-          });
-
-          partition(bufs).forEach((chunk) => input.write(chunk));
-          frames.acceptLoop();
-          if (ex) throw ex;
-          return i === t.length;
-        })
-        .asTest({ times: 20 });
-    }
-
-    it('Parse trace of methods', testPartitioning((bufs) => bufs));
-
-    it("Parse concat'd methods", testPartitioning((bufs) => [Buffer.concat(bufs)]));
-
-    it('Parse partitioned methods', testPartitioning((bufs) => {
-      const full = Buffer.concat(bufs);
-      const onethird = Math.floor(full.length / 3);
-      const twothirds = 2 * onethird;
-      return [full.subarray(0, onethird), full.subarray(onethird, twothirds), full.subarray(twothirds)];
-    }));
-  });
-
-  const FRAME_MAX_MAX = 4096 * 4;
-  const FRAME_MAX_MIN = 4096;
-  const FrameMax = amqp.rangeInt('frame max', FRAME_MAX_MIN, FRAME_MAX_MAX);
-  const Body = sized((_n) => Math.floor(Math.random() * FRAME_MAX_MAX), repeat(amqp.Octet));
-
-  const Content = transform(
-    (args) => ({
-      method: args[0].fields,
-      header: args[1].fields,
-      body: Buffer.from(args[2]),
-    }),
-    sequence(amqp.methods['BasicDeliver'], amqp.properties['BasicProperties'], Body),
-  );
-
-  describe('Content framing', () => {
-    it('Adhere to frame max', forAll(Content, FrameMax)
-      .satisfy((content, max) => {
-        const input = inputs();
-        const frames = new Frames(input);
-        frames.frameMax = max;
-        frames.sendMessage(0, defs.BasicDeliver, content.method, defs.BasicProperties, content.header, content.body);
-        let _i = 0;
-        let largest = 0;
-        let frame = input.read();
-        while (frame) {
-          _i++;
-          if (frame.length > largest) largest = frame.length;
-          if (frame.length > max) {
-            return false;
-          }
-          frame = input.read();
-        }
-        // The ratio of frames to 'contents' should always be >= 2
-        // (one properties frame and at least one content frame); > 2
-        // indicates fragmentation. The largest is always, of course <= frame max
-        //console.log('Frames: %d; frames per message: %d; largest frame %d', _i, _i / t.length, largest);
-        return true;
-      })
-      .asTest());
-  });
-});

package/test/lib/data.js

@@ -1,249 +0,0 @@
-const { data: arb, transform, repeat, label, sequence, asGenerator, sized, recursive, choice, Undefined } = require('claire');
-const defs = require('../../lib/defs');
-
-// These aren't exported in claire/index. so I could have to reproduce them I guess.
-function choose(a, b) {
-  return Math.random() * (b - a) + a;
-}
-
-function chooseInt(a, b) {
-  return Math.floor(choose(a, b));
-}
-
-function rangeInt(name, a, b) {
-  return label(name, asGenerator((_) => chooseInt(a, b)));
-}
-
-function toFloat32(i) {
-  const b = Buffer.alloc(4);
-  b.writeFloatBE(i, 0);
-  return b.readFloatBE(0);
-}
-
-function floatChooser(maxExp) {
-  return () => {
-    let n = Number.NaN;
-    while (Number.isNaN(n)) {
-      const mantissa = Math.random() * 2 - 1;
-      const exponent = chooseInt(0, maxExp);
-      n = mantissa ** exponent;
-    }
-    return n;
-  };
-}
-
-function explicitType(t, underlying) {
-  return label(
-    t,
-    transform((n) => ({ '!': t, value: n }), underlying),
-  );
-}
-
-// FIXME null, byte array, others?
-
-const Octet = rangeInt('octet', 0, 255);
-const ShortStr = label('shortstr', transform((s) => s.substr(0, 255), arb.Str));
-const LongStr = label('longstr', transform((bytes) => Buffer.from(bytes), repeat(Octet)));
-const UShort = rangeInt('short-uint', 0, 0xffff);
-const ULong = rangeInt('long-uint', 0, 0xffffffff);
-const ULongLong = rangeInt('longlong-uint', 0, Number.MAX_SAFE_INTEGER);
-const Short = rangeInt('short-int', -0x8000, 0x7fff);
-const Long = rangeInt('long-int', -0x80000000, 0x7fffffff);
-const LongLong = rangeInt('longlong-int', Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-const Bit = label('bit', arb.Bool);
-const Double = label('double', asGenerator(floatChooser(308)));
-const Float = label('float', transform(toFloat32, floatChooser(38)));
-const Timestamp = label('timestamp', transform((n) => ({ '!': 'timestamp', value: n }), ULongLong));
-const Decimal = label('decimal', transform((args) => ({ '!': 'decimal', value: { places: args[1], digits: args[0] } }), sequence(arb.UInt, Octet)));
-const UnsignedByte = label('unsignedbyte', transform((n) => ({ '!': 'unsignedbyte', value: n }), Octet));
-const UnsignedShort = label('unsignedshort', transform((n) => ({ '!': 'unsignedshort', value: n }), UShort));
-const UnsignedInt = label('unsignedint', transform((n) => ({ '!': 'unsignedint', value: n }), ULong));
-const Byte = rangeInt('byte', -128, 127);
-
-// Explicitly typed values
-const ExByte = explicitType('byte', Byte);
-const ExInt8 = explicitType('int8', Byte);
-const ExShort = explicitType('short', Short);
-const ExInt16 = explicitType('int16', Short);
-const ExInt = explicitType('int', Long);
-const ExInt32 = explicitType('int32', Long);
-const ExLong = explicitType('long', LongLong);
-const ExInt64 = explicitType('int64', LongLong);
-
-const FieldArray = label('field-array',
-  recursive(() =>
-    arb.Array(
-      arb.Null,
-      LongStr,
-      ShortStr,
-      Octet,
-      UShort,
-      ULong,
-      ULongLong,
-      Byte,
-      Short,
-      Long,
-      LongLong,
-      ExByte,
-      ExInt8,
-      ExShort,
-      ExInt16,
-      ExInt,
-      ExInt32,
-      ExLong,
-      ExInt64,
-      Bit,
-      Float,
-      Double,
-      FieldTable,
-      FieldArray,
-    ),
-  ),
-);
-
-const FieldTable = label('field-table',
-  recursive(() =>
-    sized(
-      () => 5,
-      arb.Object(
-        arb.Null,
-        LongStr,
-        ShortStr,
-        Octet,
-        UShort,
-        ULong,
-        ULongLong,
-        Byte,
-        Short,
-        Long,
-        LongLong,
-        ExByte,
-        ExInt8,
-        ExShort,
-        ExInt16,
-        ExInt,
-        ExInt32,
-        ExLong,
-        ExInt64,
-        Bit,
-        Float,
-        Double,
-        FieldArray,
-        FieldTable,
-      ),
-    ),
-  ),
-);
-
-// For methods and properties (as opposed to field table values) it's
-// easier just to accept and produce numbers for timestamps.
-const ArgTimestamp = label('timestamp', ULongLong);
-
-// These are the domains used in method arguments
-const ARG_TYPES = {
-  octet: Octet,
-  shortstr: ShortStr,
-  longstr: LongStr,
-  short: UShort,
-  long: ULong,
-  longlong: ULongLong,
-  bit: Bit,
-  table: FieldTable,
-  timestamp: ArgTimestamp,
-};
-
-function argtype(thing) {
-  if (thing.default === undefined) {
-    return ARG_TYPES[thing.type];
-  } else {
-    return choice(ARG_TYPES[thing.type], Undefined);
-  }
-}
-
-function zipObject(vals, names) {
-  const obj = {};
-  vals.forEach((v, i) => {
-    obj[names[i]] = v;
-  });
-  return obj;
-}
-
-function name(arg) {
-  return arg.name;
-}
-
-function method(info) {
-  const domain = sequence.apply(null, info.args.map(argtype));
-  const names = info.args.map(name);
-  return label(
-    info.name,
-    transform((fieldVals) => ({ id: info.id, fields: zipObject(fieldVals, names) }), domain),
-  );
-}
-
-function properties(info) {
-  const types = info.args.map(argtype);
-  types.unshift(ULongLong); // size
-  const domain = sequence.apply(null, types);
-  const names = info.args.map(name);
-  return label(info.name,
-    transform((fieldVals) => ({ id: info.id, size: fieldVals[0], fields: zipObject(fieldVals.slice(1), names) }), domain),
-  );
-}
-
-const methods = [];
-const propertieses = [];
-
-for (const k in defs) {
-  if (k.substr(0, 10) === 'methodInfo') {
-    methods.push(method(defs[k]));
-    methods[defs[k].name] = method(defs[k]);
-  } else if (k.substr(0, 14) === 'propertiesInfo') {
-    propertieses.push(properties(defs[k]));
-    propertieses[defs[k].name] = properties(defs[k]);
-  }
-}
-
-const OPEN_OPTS = {
-  // start-ok
-  clientProperties: {},
-  mechanism: 'PLAIN',
-  response: Buffer.from(['', 'guest', 'guest'].join(String.fromCharCode(0))),
-  locale: 'en_US',
-
-  // tune-ok
-  channelMax: 0,
-  frameMax: 0,
-  heartbeat: null,
-
-  // open
-  virtualHost: '/',
-  capabilities: '',
-  insist: 0,
-};
-
-module.exports = {
-  Octet,
-  ShortStr,
-  LongStr,
-  UShort,
-  ULong,
-  ULongLong,
-  Short,
-  Long,
-  LongLong,
-  Bit,
-  Double,
-  Float,
-  Timestamp,
-  Decimal,
-  UnsignedByte,
-  UnsignedShort,
-  UnsignedInt,
-  FieldArray,
-  FieldTable,
-  methods,
-  properties: propertieses,
-  rangeInt,
-  OPEN_OPTS,
-};

package/test/lib/util.js

@@ -1,223 +0,0 @@
-const crypto = require('node:crypto');
-const PassThrough = require('node:stream').PassThrough;
-const Connection = require('../../lib/connection').Connection;
-const defs = require('../../lib/defs');
-const assert = require('node:assert');
-
-const schedule = typeof setImmediate === 'function' ? setImmediate : process.nextTick;
-
-function randomString() {
-  const hash = crypto.createHash('sha1');
-  hash.update(crypto.randomBytes(64));
-  return hash.digest('base64');
-}
-
-// Set up a socket pair {client, server}, such that writes to the
-// client are readable from the server, and writes to the server are
-// readable at the client.
-//
-//          +---+      +---+
-//          | C |      | S |
-// --write->| l |----->| e |--read-->
-//          | i |      | r |
-// <--read--| e |<-----| v |<-write--
-//          | n |      | e |
-//          | t |      | r |
-//          +---+      +---+
-//
-// I also need to make sure that end called on either socket affects
-// the other.
-
-function socketPair() {
-  const server = new PassThrough();
-  const client = new PassThrough();
-  server.write = client.push.bind(client);
-  client.write = server.push.bind(server);
-  function end(chunk, encoding) {
-    if (chunk) this.push(chunk, encoding);
-    this.push(null);
-  }
-  server.end = end.bind(client);
-  client.end = end.bind(server);
-
-  return { client: client, server: server };
-}
-
-function runServer(socket, run) {
-  const frames = new Connection(socket);
-  // We will be closing the socket without doing a closing handshake,
-  // so cheat
-  frames.expectSocketClose = true;
-  // We also need to create some channel buffers, again a cheat
-  frames.freshChannel(null);
-  frames.freshChannel(null);
-  frames.freshChannel(null);
-
-  function send(id, fields, channel, content) {
-    channel = channel || 0;
-    if (content) {
-      schedule(() => {
-        frames.sendMessage(channel, id, fields, defs.BasicProperties, fields, content);
-      });
-    } else {
-      schedule(() => {
-        frames.sendMethod(channel, id, fields);
-      });
-    }
-  }
-
-  function wait(method) {
-    return () =>
-      new Promise((resolve, reject) => {
-        if (method) {
-          frames.step((e, f) => {
-            if (e !== null) return reject(e);
-            if (f.id === method) resolve(f);
-            else reject(new Error(`Expected method: ${method}, got ${f.id}`));
-          });
-        } else {
-          frames.step((e, f) => {
-            if (e !== null) return reject(e);
-            else resolve(f);
-          });
-        }
-      });
-  }
-  run(send, wait);
-  return frames;
-}
-
-// Create a function that will call done once it's been called itself
-// `count` times. If it's called with an error value, it will
-// immediately call done with that error value.
-function latch(count, done) {
-  let awaiting = count;
-  let alive = true;
-  return (err) => {
-    if (err instanceof Error && alive) {
-      alive = false;
-      done(err);
-    } else {
-      awaiting--;
-      if (awaiting === 0 && alive) {
-        alive = false;
-        done();
-      }
-    }
-  };
-}
-
-// Call a thunk with a continuation that will be called with an error
-// if the thunk throws one, or nothing if it runs to completion.
-function completes(thunk, done) {
-  try {
-    thunk();
-    done();
-  } catch (e) {
-    done(e);
-  }
-}
-
-
-// When encoding, you can supply explicitly-typed fields like `{'!':
-// int32, 50}`. Most of these do not appear in the decoded values, so
-// to compare like-to-like we have to remove them from the input.
-function removeExplicitTypes(input) {
-  switch (typeof input) {
-    case 'object':
-      if (input == null) {
-        return null;
-      }
-      if (Array.isArray(input)) {
-        const newArr = [];
-        for (let i = 0; i < input.length; i++) {
-          newArr[i] = removeExplicitTypes(input[i]);
-        }
-        return newArr;
-      }
-      if (Buffer.isBuffer(input)) {
-        return input;
-      }
-      switch (input['!']) {
-        case 'timestamp':
-        case 'decimal':
-        case 'float':
-          return input;
-        case undefined: {
-          const newObj = {};
-          for (const k in input) {
-            newObj[k] = removeExplicitTypes(input[k]);
-          }
-          return newObj;
-        }
-        default:
-          return input.value;
-      }
-
-    default:
-      return input;
-  }
-}
-
-// Asserts that the decoded fields are equal to the original fields,
-// or equal to a default where absent in the original. The defaults
-// depend on the type of method or properties.
-//
-// This works slightly different for methods and properties: for
-// methods, each field must have a value, so the default is
-// substituted for undefined values when encoding; for properties,
-// fields may be absent in the encoded value, so a default is
-// substituted for missing fields when decoding. The effect is the
-// same so far as these tests are concerned.
-function assertEqualModuloDefaults(original, decodedFields) {
-  const args = defs.info(original.id).args;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const originalValue = original.fields[arg.name];
-    const decodedValue = decodedFields[arg.name];
-    try {
-      if (originalValue === undefined) {
-        // longstr gets special treatment here, since the defaults are
-        // given as strings rather than buffers, but the decoded values
-        // will be buffers.
-        assert.deepEqual(arg.type === 'longstr' ? Buffer.from(arg.default) : arg.default, decodedValue);
-      } else {
-        assert.deepEqual(removeExplicitTypes(originalValue), decodedValue);
-      }
-    } catch (assertionErr) {
-      const methodOrProps = defs.info(original.id).name;
-      assertionErr.message += ` (frame ${methodOrProps} field ${arg.name})`;
-      throw assertionErr;
-    }
-  }
-  // %%% TODO make sure there's no surplus fields
-  return true;
-}
-
-function handshake(send, wait) {
-  // kick it off
-  send(defs.ConnectionStart, {
-    versionMajor: 0,
-    versionMinor: 9,
-    serverProperties: {},
-    mechanisms: Buffer.from('PLAIN'),
-    locales: Buffer.from('en_US'),
-  });
-  return wait(defs.ConnectionStartOk)()
-    .then(() => send(defs.ConnectionTune, { channelMax: 0, heartbeat: 0, frameMax: 0 }))
-    .then(wait(defs.ConnectionTuneOk))
-    .then(wait(defs.ConnectionOpen))
-    .then(() => send(defs.ConnectionOpenOk, { knownHosts: '' }));
-}
-
-module.exports = {
-  socketPair,
-  runServer,
-  latch,
-  completes,
-  schedule,
-  randomString,
-  removeExplicitTypes,
-  assertEqualModuloDefaults,
-  handshake,
-};