/** * Determine if the given buffer is utf8. * @param {Buffer} buffer */ export default function isBufferUtf8Representable(buffer) { const utfEncodedBuffer = buffer.toString('utf8'); const reconstructedBuffer = Buffer.from(utfEncodedBuffer, 'utf8'); return reconstructedBuffer.equals(buffer); }
transporterReceive(next) { return (cmd, data, s) => { const decrypter = iv ? crypto.createDecipheriv(algorithm, password, iv) : crypto.createDecipher(algorithm, password); const res = Buffer.concat([decrypter.update(data), decrypter.final()]); return next(cmd, res, s); }; }
it("should decompress with 'deflateRaw'", () => { const mw = Middleware({ method: "deflateRaw", threshold: 0 }); mw.created(broker); const meta = {}; const next = jest.fn(); const receive = mw.transporterReceive.call(broker, next); const compressedData = Buffer.concat([COMPRESSED_FLAG, zlib.deflateRawSync(Buffer.from("compressed data"))]); return receive("topic", compressedData, meta).catch(protectReject).then(() => { expect(next).toHaveBeenCalledTimes(1); expect(next).toHaveBeenCalledWith("topic", Buffer.from("compressed data"), meta); }); });
beforeEach(() => { msgHandler = jest.fn(); transporter = new Amqp10Transporter({ url: "amqp10://localhost" }); transporter.init(new Transit(new ServiceBroker({ logger: false, namespace: "TEST" })), msgHandler); transporter.serialize = jest.fn(() => Buffer.from("json data")); return transporter.connect(); });
// Promisify readFile async function readFile(file) { const promise = await new Promise((resolve, reject) => { fs.readFile(file, (err, data) => { if (err) reject(err); else resolve(data.toString()); }); }); return promise; }
writeInt16(value) { this.ensureAvailable(INT16_SIZE) this.buf.writeInt16BE(value, this.offset) this.offset += INT16_SIZE return this }
writeString(value) { if (value == null) { this.writeInt16(-1) return this } const byteLength = Buffer.byteLength(value, 'utf8') this.ensureAvailable(INT16_SIZE + byteLength) this.writeInt16(byteLength) this.buf.write(value, this.offset, byteLength, 'utf8') this.offset += byteLength return this }
// Returns a new random hex string of the given even size. function randomHexString(size) { if (size === 0) { throw new Error('Zero-length randomHexString is useless.'); } if (size % 2 !== 0) { throw new Error('randomHexString size must be divisible by 2.'); } return (0, _crypto.randomBytes)(size / 2).toString('hex'); }
it("should serialize the heartbeat packet", () => { const obj = { ver: "4", sender: "test-1", cpu: 12.5 }; const s = serializer.serialize(obj, P.PACKET_HEARTBEAT); expect(s.length).toBe(33); const res = serializer.deserialize(s, P.PACKET_HEARTBEAT); expect(res).not.toBe(obj); expect(res).toEqual(obj); });
const hmacSHA1 = (key: string, data: string) => { // hmac.digest([encoding]) // If encoding is provided a string is returned; otherwise a Buffer is returned; return crypto.createHmac('sha1', key).update(data).digest().toString('base64'); }
app.get( '/notes/:socketId', function( req, res ) { fs.readFile( opts.baseDir + 'plugin/notes-server/notes.html', function( err, data ) { res.send( Mustache.to_html( data.toString(), { socketId : req.params.socketId })); }); });
it("should store chunk in buffer if length is smaller than 6 bytes", () => { let cb = jest.fn(); let buf = Buffer.alloc(5, "0"); parser._write(buf, null, cb); expect(cb).toHaveBeenCalledTimes(1); expect(cb).toHaveBeenCalledWith(); expect(parser.buf).toBeInstanceOf(Buffer); expect(parser.buf.toString()).toBe("00000"); });
/** * Encodes the JSON representation of the profile in base64. * * @returns {string} The encoded profile. */ encode() { return Buffer.from(JSON.stringify(this)).toString('base64'); }
writeInt32(value) { this.ensureAvailable(INT32_SIZE) this.buf.writeInt32BE(value, this.offset) this.offset += INT32_SIZE return this }