tape('deterministic signatures', function (t) {
t.plan(10)
var key = bufferFrom('9718a1ff1c4ca79feac551c0c7212a65e4091278ec886b88be01ee4039682238', 'hex')
var secretKey = bufferFrom(
'53729c0311846cca9cc0eded07aaf9e6689705b6a0b1bb8c3a2a839b72fda383' +
'9718a1ff1c4ca79feac551c0c7212a65e4091278ec886b88be01ee4039682238',
'hex'
)
var expectedSignatures = bufferFrom(
'050257010000400745643235353139000000000000000000000000000000000084684e8dd76c339' +
'd6f5754e813204906ee818e6c6cdc6a816a2ac785a3e0d926ac08641a904013194fe6121847b7da' +
'd4e361965d47715428eb0a0ededbdd5909d037ff3c3614fa0100ed9264a712d3b77cbe7a4f6eadd' +
'8f342809be99dfb9154a19e278d7a5de7d2b4d890f7701a38b006469f6bab1aff66ac6125d48baf' +
'dc0711057675ed57d445ce7ed4613881be37ebc56bb40556b822e431bb4dc3517421f9a5e3ed124' +
'eb5c4db8367386d9ce12b2408613b9fec2837022772a635ffd807',
'hex'
)
for (var i = 0; i < 5; i++) run()
function run () {
var st = storage()
var feed = hypercore(st, key, {
secretKey: secretKey
})
feed.append(['a', 'b', 'c'], function () {
t.same(st.data.toBuffer().toString(), 'abc')
t.same(st.signatures.toBuffer().slice(-64), expectedSignatures.slice(-64), 'only needs last sig')
})
}
})
b.once('handshake', function () {
t.same(b.remoteSupports('a'), false)
t.same(b.remoteSupports('b'), true)
t.same(b.remoteSupports('c'), false)
ch2.extension('a', bufferFrom('nooo'))
ch2.extension('b', bufferFrom('hello ch1'))
ch2.extension('c', bufferFrom('nooo'))
})
b.once('handshake', function () {
t.same(b.id, bufferFrom('b'))
t.same(b.live, false)
t.same(b.ack, true)
t.same(b.userData, null)
t.same(b.remoteId, bufferFrom('a'))
t.same(b.remoteLive, true)
t.same(b.remoteUserData, bufferFrom(data))
t.same(b.remoteAck, false)
})
function bufferConcat (parts) {
var bufs = []
for (var i = 0; i < parts.length; i++) {
var p = parts[i]
if (Buffer.isBuffer(p)) {
bufs.push(p)
} else if (isBufferish(p)) {
bufs.push(bufferFrom(p))
} else {
bufs.push(bufferFrom(String(p)))
}
}
return Buffer.concat(bufs)
}
function compareStackTrace(sourceMap, source, expected) {
// Check once with a separate source map
fs.writeFileSync('.generated.js.map', sourceMap);
fs.writeFileSync('.generated.js', 'exports.test = function() {' +
source.join('\n') + '};//@ sourceMappingURL=.generated.js.map');
try {
delete require.cache[require.resolve('./.generated')];
require('./.generated').test();
} catch (e) {
compareLines(e.stack.split(/\r\n|\n/), expected);
}
fs.unlinkSync('.generated.js');
fs.unlinkSync('.generated.js.map');
// Check again with an inline source map (in a data URL)
fs.writeFileSync('.generated.js', 'exports.test = function() {' +
source.join('\n') + '};//@ sourceMappingURL=data:application/json;base64,' +
bufferFrom(sourceMap.toString()).toString('base64'));
try {
delete require.cache[require.resolve('./.generated')];
require('./.generated').test();
} catch (e) {
compareLines(e.stack.split(/\r\n|\n/), expected);
}
fs.unlinkSync('.generated.js');
}
retrieveMapHandlers.push(function(source) {
var sourceMappingURL = retrieveSourceMapURL(source);
if (!sourceMappingURL) return null;
// Read the contents of the source map
var sourceMapData;
if (reSourceMap.test(sourceMappingURL)) {
// Support source map URL as a data url
var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
sourceMapData = bufferFrom(rawData, "base64").toString();
sourceMappingURL = source;
} else {
// Support source map URLs relative to the source URL
sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
sourceMapData = retrieveFile(sourceMappingURL);
}
if (!sourceMapData) {
return null;
}
return {
url: sourceMappingURL,
map: sourceMapData
};
});
tape('deterministic data and tree', function (t) {
t.plan(10)
var expectedTree = bufferFrom(
'0502570200002807424c414b4532620000000000000000000000000000000000ab27d45f509274' +
'ce0d08f4f09ba2d0e0d8df61a0c2a78932e81b5ef26ef398df0000000000000001064321a8413b' +
'e8c604599689e2c7a59367b031b598bceeeb16556a8f3252e0de000000000000000294c1705400' +
'5942a002c7c39fbb9c6183518691fb401436f1a2f329b380230af800000000000000018dfe81d5' +
'76464773f848b9aba1c886fde57a49c283ab57f4a297d976d986651e00000000000000041d2fad' +
'c9ce604c7e592949edc964e45aaa10990d7ee53328439ef9b2cf8aa6ff00000000000000013a8d' +
'cc74e80b8314e8e13e1e462358cf58cf5fc4413a9b18a891ffacc551c395000000000000000228' +
'28647a654a712738e35f49d1c05c676010be0b33882affc1d1e7e9fee59d400000000000000001' +
'000000000000000000000000000000000000000000000000000000000000000000000000000000' +
'00baac70b6d38243efa028ee977c462e4bec73d21d09ceb8cc16f4d4b1ee228a45000000000000' +
'0001d1b021632c7fab84544053379112ca7b165bb21283821816c5b6c89ff7f78e2d0000000000' +
'000002d2ab421cece792033058787a5ba72f3a701fddc25540d5924e9819d7c12e02f200000000' +
'00000001',
'hex'
)
for (var i = 0; i < 5; i++) run()
function run () {
var st = storage()
var feed = hypercore(st)
feed.append(['a', 'b', 'c', 'd', 'e', 'f'], function () {
t.same(st.data.toBuffer().toString(), 'abcdef')
t.same(st.tree.toBuffer(), expectedTree)
})
}
})
BaseService.prototype.initCredentials = function(options) {
if (options.token) {
options.headers = options.headers || {};
options.headers['X-Watson-Authorization-Token'] = options.token;
return options;
}
options.jar = request.jar();
// Get credentials from environment properties or Bluemix
// but prefer credentials provided pragmatically!
options = extend({}, this.getCredentialsFromBluemix(this.name), this.getCredentialsFromEnvironment(this.name), options);
if (!options.use_unauthenticated) {
if (!options.username || !options.password) {
throw new Error('Argument error: username and password are required unless use_unauthenticated is set');
}
// Calculate and add Authorization header to base options
const authHeader = {
Authorization: 'Basic ' + bufferFrom(options.username + ':' + options.password).toString('base64')
};
options.headers = extend(authHeader, options.headers);
}
return options;
};
client.sign(key, data, function (err, sig) {
if (err) return cb(err)
if (enc === 'base64') return cb(null, sig.signature)
var buf = bufferFrom(sig.signature, 'base64')
if (enc) buf = buf.toString(enc)
cb(null, buf)
})
d.on('end', function () {
d = lpstream.decode({allowEmpty: true})
d.on('data', function (data) {
t.same(data, bufferAlloc(0), 'empty buffer')
t.end()
})
d.write(bufferFrom([0]))
d.end()
})
tape('message limit', function (t) {
var d = lpstream.decode({limit: 10})
d.on('error', function (err) {
t.ok(err, 'should error')
t.end()
})
d.write(bufferFrom('zzzzzzzzzzzzzz'))
})
test('typed array from strings, buffers, and arrays', function (t) {
t.plan(2)
var arrays = concat({ encoding: 'Uint8Array' }, function(out) {
t.equal(typeof out.subarray, 'function')
t.deepEqual(bufferFrom(out).toString('utf8'), 'abcde fg xyz')
})
arrays.write('abcde')
arrays.write(bufferFrom(' fg '))
arrays.end([ 120, 121, 122 ])
})
it('stream as an attachment', () => {
attachments = [{
filename: 'text2.txt',
content: bufferFrom('hello new world', 'utf-8')
}];
attachment = parser.parse(attachments).attached[0];
expect(attachment.contentType).eql('text/plain');
expect(attachment.contentDisposition).eql('attachment');
expect(attachment.filename).be.equal('text2.txt');
expect(attachment.content.toString()).be.equal('hello new world');
});
tape('basic with handshake options', function (t) {
t.plan(16)
var data = [
'eeaa62fbb11ba521cce58cf3fae42deb15d94a0436fc7fa0cbba8f130e7c0499',
'8c797667bf307d82c51a8308fe477b781a13708e0ec1f2cc7f497392574e2464'
]
var a = protocol({id: bufferFrom('a'), live: true, userData: bufferFrom(data)})
var b = protocol({id: bufferFrom('b'), live: false, ack: true})
a.feed(KEY)
b.feed(KEY)
a.once('handshake', function () {
t.same(a.id, bufferFrom('a'))
t.same(a.live, true)
t.same(a.ack, false)
t.same(a.userData, bufferFrom(data))
t.same(a.remoteId, bufferFrom('b'))
t.same(a.remoteLive, false)
t.same(a.remoteUserData, null)
t.same(a.remoteAck, true)
})
b.once('handshake', function () {
t.same(b.id, bufferFrom('b'))
t.same(b.live, false)
t.same(b.ack, true)
t.same(b.userData, null)
t.same(b.remoteId, bufferFrom('a'))
t.same(b.remoteLive, true)
t.same(b.remoteUserData, bufferFrom(data))
t.same(b.remoteAck, false)
})
a.pipe(b).pipe(a)
})
var server = http.createServer(function (req, res) {
var au = req.headers.authorization;
if (!au) return res.end('ACCESS DENIED');
var buf = bufferFrom(au.replace(/^Basic\s+/, ''), 'base64');
var s = buf.toString().split(':');
if (s[0] === 'moo' && s[1] === 'hax') {
res.end('WELCOME TO ZOMBO COM');
}
else {
res.end('ACCESS DENIED!!!');
}
});
function stringConcat (parts) {
var strings = []
var needsToString = false
for (var i = 0; i < parts.length; i++) {
var p = parts[i]
if (typeof p === 'string') {
strings.push(p)
} else if (Buffer.isBuffer(p)) {
strings.push(p)
} else if (isBufferish(p)) {
strings.push(bufferFrom(p))
} else {
strings.push(bufferFrom(String(p)))
}
}
if (Buffer.isBuffer(parts[0])) {
strings = Buffer.concat(strings)
strings = strings.toString('utf8')
} else {
strings = strings.join('')
}
return strings
}
var Parser = function (opts) {
if (!opts) opts = {}
if (Array.isArray(opts)) opts = {headers: opts}
stream.Transform.call(this, {objectMode: true, highWaterMark: 16})
this.separator = opts.separator ? bufferFrom(opts.separator)[0] : comma
this.quote = opts.quote ? bufferFrom(opts.quote)[0] : quote
this.escape = opts.escape ? bufferFrom(opts.escape)[0] : this.quote
if (opts.newline) {
this.newline = bufferFrom(opts.newline)[0]
this.customNewline = true
} else {
this.newline = nl
this.customNewline = false
}
this.headers = opts.headers || null
this.strict = opts.strict || null
this.mapHeaders = opts.mapHeaders || identity
this.mapValues = opts.mapValues || identity
this._raw = !!opts.raw
this._prev = null
this._prevEnd = 0
this._first = true
this._quoted = false
this._escaped = false
this._empty = this._raw ? bufferAlloc(0) : ''
this._Row = null
if (this.headers) {
this._first = false
this._compile(this.headers)
}
}
function u8Concat (parts) {
var len = 0
for (var i = 0; i < parts.length; i++) {
if (typeof parts[i] === 'string') {
parts[i] = bufferFrom(parts[i])
}
len += parts[i].length
}
var u8 = new U8(len)
for (var i = 0, offset = 0; i < parts.length; i++) {
var part = parts[i]
for (var j = 0; j < part.length; j++) {
u8[offset++] = part[j]
}
}
return u8
}
export function build(worksheets, options = {}) {
const defaults = {
bookType: 'xlsx',
bookSST: false,
type: 'binary'
};
const workBook = new Workbook();
worksheets.forEach((worksheet) => {
const sheetName = worksheet.name || 'Sheet';
const sheetOptions = worksheet.options || {};
const sheetData = buildSheetFromMatrix(worksheet.data || [], {...options, ...sheetOptions});
workBook.SheetNames.push(sheetName);
workBook.Sheets[sheetName] = sheetData;
});
const excelData = XLSX.write(workBook, Object.assign({}, defaults, options));
return excelData instanceof Buffer ? excelData : bufferFrom(excelData, 'binary');
}
it('finds source maps with charset specified', function() {
var sourceMap = createMultiLineSourceMap()
var source = [ 'throw new Error("test");' ];
var expected = [
'Error: test',
/^ at Object\.exports\.test \((?:.*[/\\])?line1\.js:1001:101\)$/
];
fs.writeFileSync('.generated.js', 'exports.test = function() {' +
source.join('\n') + '};//@ sourceMappingURL=data:application/json;charset=utf8;base64,' +
bufferFrom(sourceMap.toString()).toString('base64'));
try {
delete require.cache[require.resolve('./.generated')];
require('./.generated').test();
} catch (e) {
compareLines(e.stack.split(/\r\n|\n/), expected);
}
fs.unlinkSync('.generated.js');
});
tape('allow empty', function (t) {
var d = lpstream.decode()
d.on('data', function () {
t.fail('should not emit empty buffers')
})
d.on('end', function () {
d = lpstream.decode({allowEmpty: true})
d.on('data', function (data) {
t.same(data, bufferAlloc(0), 'empty buffer')
t.end()
})
d.write(bufferFrom([0]))
d.end()
})
d.write(bufferFrom([0]))
d.end()
})
it('Put a file in the db, then destroy it', function (done) {
var db = new PouchDB('veryimportantfiles');
fs.writeFile('./tmp/_pouch_veryimportantfiles/something',
bufferFrom('lalala'), function () {
db.destroy(function (err) {
if (err) {
return done(err);
}
fs.readFile('./tmp/_pouch_veryimportantfiles/something',
{encoding: 'utf8'}, function (err, resp) {
if (err) {
return done(err);
}
resp.should.equal('lalala',
'./tmp/veryimportantfiles/something was not removed');
done();
});
});
});
});
tape('stream is encrypted', function (t) {
var a = protocol()
var b = protocol()
var ch1 = a.feed(KEY)
var ch2 = b.feed(KEY)
ch2.on('data', function (data) {
t.same(data.value, bufferFrom('i am secret'))
t.end()
})
a.on('data', function (data) {
t.ok(data.toString().indexOf('secret') === -1)
})
a.pipe(b).pipe(a)
ch1.data({index: 42, value: bufferFrom('i am secret')})
})
function validateArgument (key, val) {
switch (key) {
case 'path':
if (typeof val === 'string') return val
throw new TypeError('`path` must be a string')
case 'attr':
if (typeof val === 'string') return val
throw new TypeError('`attr` must be a string')
case 'value':
if (typeof val === 'string') return bufferFrom(val)
if (Buffer.isBuffer(val)) return val
throw new TypeError('`value` must be a string or buffer')
case 'cb':
if (typeof val === 'function') return val
if (val == null) return defaultCallback
throw new TypeError('`cb` must be a function')
default:
throw new Error(`Unknown argument: ${key}`)
}
}
it('allows code/comments after sourceMappingURL', function() {
var sourceMap = createMultiLineSourceMap()
var source = [ 'throw new Error("test");' ];
var expected = [
'Error: test',
/^ at Object\.exports\.test \((?:.*[/\\])?line1\.js:1001:101\)$/
];
fs.writeFileSync('.generated.js', 'exports.test = function() {' +
source.join('\n') + '};//# sourceMappingURL=data:application/json;base64,' +
bufferFrom(sourceMap.toString()).toString('base64') +
'\n// Some comment below the sourceMappingURL\nvar foo = 0;');
try {
delete require.cache[require.resolve('./.generated')];
require('./.generated').test();
} catch (e) {
compareLines(e.stack.split(/\r\n|\n/), expected);
}
fs.unlinkSync('.generated.js');
});
saveAttachmentRefs(id, rev, digest, function (err, isNewAttachment) {
/* istanbul ignore if */
if (err) {
return callback(err);
}
// do not try to store empty attachments
if (data.length === 0) {
return callback(err);
}
if (!isNewAttachment) {
// small optimization - don't bother writing it again
return callback(err);
}
txn.batch([{
type: 'put',
prefix: stores.binaryStore,
key: digest,
value: bufferFrom(data, 'binary')
}]);
callback();
});
Req.prototype._send = function () {
this._sent = true;
var headers = this.headers || {};
var u = url.parse(this.uri);
var au = u.auth || this.auth;
if (au) {
headers.authorization = 'Basic ' + bufferFrom(au).toString('base64');
}
var protocol = u.protocol || '';
var iface = protocol === 'https:' ? https : http;
var opts = {
scheme: protocol.replace(/:$/, ''),
method: this.method,
host: u.hostname,
port: Number(u.port) || (protocol === 'https:' ? 443 : 80),
path: u.path,
agent: this.options.agent || false,
headers: headers,
withCredentials: this.options.withCredentials,
localAddress: this.options.localAddress
};
if (protocol === 'https:') {
opts.pfx = this.options.pfx;
opts.key = this.options.key;
opts.cert = this.options.cert;
opts.ca = this.options.ca;
opts.ciphers = this.options.ciphers;
opts.rejectUnauthorized = this.options.rejectUnauthorized;
opts.secureProtocol = this.options.secureProtocol;
}
var req = iface.request(opts);
var timeout = this.options.timeout || 2147483647;
if (req.setTimeout) req.setTimeout(timeout);
return req;
};
return function sign (data, enc, cb) {
if (typeof enc === 'function') return sign(data, null, enc)
if (typeof data === 'string') data = bufferFrom(data)
if (cachedSign) return cachedSign(data, enc, cb)
detectPublicKey(function (err, key) {
if (err) return cb(err)
if (key === null) {
cachedSign = signer(username)
return sign(data, enc, cb)
}
debug('selected public key', key.ssh_key)
client.sign(key, data, function (err, sig) {
if (err) return cb(err)
if (enc === 'base64') return cb(null, sig.signature)
var buf = bufferFrom(sig.signature, 'base64')
if (enc) buf = buf.toString(enc)
cb(null, buf)
})
})
}
tape('stream can be unencrypted', function (t) {
var a = protocol({encrypt: false})
var b = protocol({encrypt: false})
var ch1 = a.feed(KEY)
var ch2 = b.feed(KEY)
var sawSecret = false
ch2.on('data', function (data) {
t.ok(sawSecret, 'saw secret')
t.same(data.value, bufferFrom('i am secret'))
t.end()
})
a.on('data', function (data) {
if (data.toString().indexOf('secret') > -1) {
sawSecret = true
}
})
a.pipe(b).pipe(a)
ch1.data({index: 42, value: bufferFrom('i am secret')})
})
it('should allow for runtime inline source maps', function(done) {
var sourceMap = createMultiLineSourceMapWithSourcesContent();
fs.writeFileSync('.generated.jss', 'foo');
compareStdout(function(err) {
fs.unlinkSync('.generated.jss');
done(err);
}, createSingleLineSourceMap(), [
'require("./source-map-support").install({',
' hookRequire: true',
'});',
'require.extensions[".jss"] = function(module, filename) {',
' module._compile(',
JSON.stringify([
'',
'var count = 0;',
'function foo() {',
' console.log(new Error("this is the error").stack.split("\\n").slice(0, 2).join("\\n"));',
'}',
'process.nextTick(foo);',
'process.nextTick(foo);',
'process.nextTick(function() { console.log(count); });',
'//@ sourceMappingURL=data:application/json;charset=utf8;base64,' + bufferFrom(sourceMap.toString()).toString('base64')
].join('\n')),
', filename);',
'};',
'require("./.generated.jss");',
], [
'Error: this is the error',
/^ at foo \(.*[/\\]original\.js:1004:5\)$/,
'Error: this is the error',
/^ at foo \(.*[/\\]original\.js:1004:5\)$/,
'0', // The retrieval should only be attempted once
]);
});