Eslintify all of libtextsecure
This commit is contained in:
Scott Nonnenberg
parent
4b3f9e969a
commit
0774ba2903
36 changed files with 1960 additions and 2128 deletions
|
|
@ -3,19 +3,19 @@ window.assert = chai.assert;
|
|||
window.PROTO_ROOT = '../../protos';
|
||||
|
||||
(function() {
|
||||
var OriginalReporter = mocha._reporter;
|
||||
const OriginalReporter = mocha._reporter;
|
||||
|
||||
var SauceReporter = function(runner) {
|
||||
var failedTests = [];
|
||||
const SauceReporter = function(runner) {
|
||||
const failedTests = [];
|
||||
|
||||
runner.on('end', function() {
|
||||
runner.on('end', () => {
|
||||
window.mochaResults = runner.stats;
|
||||
window.mochaResults.reports = failedTests;
|
||||
});
|
||||
|
||||
runner.on('fail', function(test, err) {
|
||||
var flattenTitles = function(test) {
|
||||
var titles = [];
|
||||
runner.on('fail', (test, err) => {
|
||||
const flattenTitles = function(test) {
|
||||
const titles = [];
|
||||
while (test.parent.title) {
|
||||
titles.push(test.parent.title);
|
||||
test = test.parent;
|
||||
|
|
@ -47,9 +47,9 @@ function assertEqualArrayBuffers(ab1, ab2) {
|
|||
}
|
||||
|
||||
function hexToArrayBuffer(str) {
|
||||
var ret = new ArrayBuffer(str.length / 2);
|
||||
var array = new Uint8Array(ret);
|
||||
for (var i = 0; i < str.length / 2; i++)
|
||||
const ret = new ArrayBuffer(str.length / 2);
|
||||
const array = new Uint8Array(ret);
|
||||
for (let i = 0; i < str.length / 2; i++)
|
||||
array[i] = parseInt(str.substr(i * 2, 2), 16);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,30 +1,28 @@
|
|||
'use strict';
|
||||
|
||||
describe('AccountManager', function() {
|
||||
describe('AccountManager', () => {
|
||||
let accountManager;
|
||||
|
||||
beforeEach(function() {
|
||||
beforeEach(() => {
|
||||
accountManager = new window.textsecure.AccountManager();
|
||||
});
|
||||
|
||||
describe('#cleanSignedPreKeys', function() {
|
||||
describe('#cleanSignedPreKeys', () => {
|
||||
let originalProtocolStorage;
|
||||
let signedPreKeys;
|
||||
const DAY = 1000 * 60 * 60 * 24;
|
||||
|
||||
beforeEach(function() {
|
||||
beforeEach(() => {
|
||||
originalProtocolStorage = window.textsecure.storage.protocol;
|
||||
window.textsecure.storage.protocol = {
|
||||
loadSignedPreKeys: function() {
|
||||
loadSignedPreKeys() {
|
||||
return Promise.resolve(signedPreKeys);
|
||||
},
|
||||
};
|
||||
});
|
||||
afterEach(function() {
|
||||
afterEach(() => {
|
||||
window.textsecure.storage.protocol = originalProtocolStorage;
|
||||
});
|
||||
|
||||
it('keeps three confirmed keys even if over a week old', function() {
|
||||
it('keeps three confirmed keys even if over a week old', () => {
|
||||
const now = Date.now();
|
||||
signedPreKeys = [
|
||||
{
|
||||
|
|
@ -48,7 +46,7 @@ describe('AccountManager', function() {
|
|||
return accountManager.cleanSignedPreKeys();
|
||||
});
|
||||
|
||||
it('eliminates confirmed keys over a week old, if more than three', function() {
|
||||
it('eliminates confirmed keys over a week old, if more than three', () => {
|
||||
const now = Date.now();
|
||||
signedPreKeys = [
|
||||
{
|
||||
|
|
@ -81,18 +79,18 @@ describe('AccountManager', function() {
|
|||
let count = 0;
|
||||
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {
|
||||
if (keyId !== 1 && keyId !== 4) {
|
||||
throw new Error('Wrong keys were eliminated! ' + keyId);
|
||||
throw new Error(`Wrong keys were eliminated! ${keyId}`);
|
||||
}
|
||||
|
||||
count++;
|
||||
};
|
||||
|
||||
return accountManager.cleanSignedPreKeys().then(function() {
|
||||
return accountManager.cleanSignedPreKeys().then(() => {
|
||||
assert.strictEqual(count, 2);
|
||||
});
|
||||
});
|
||||
|
||||
it('keeps at least three unconfirmed keys if no confirmed', function() {
|
||||
it('keeps at least three unconfirmed keys if no confirmed', () => {
|
||||
const now = Date.now();
|
||||
signedPreKeys = [
|
||||
{
|
||||
|
|
@ -116,18 +114,18 @@ describe('AccountManager', function() {
|
|||
let count = 0;
|
||||
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {
|
||||
if (keyId !== 2) {
|
||||
throw new Error('Wrong keys were eliminated! ' + keyId);
|
||||
throw new Error(`Wrong keys were eliminated! ${keyId}`);
|
||||
}
|
||||
|
||||
count++;
|
||||
};
|
||||
|
||||
return accountManager.cleanSignedPreKeys().then(function() {
|
||||
return accountManager.cleanSignedPreKeys().then(() => {
|
||||
assert.strictEqual(count, 1);
|
||||
});
|
||||
});
|
||||
|
||||
it('if some confirmed keys, keeps unconfirmed to addd up to three total', function() {
|
||||
it('if some confirmed keys, keeps unconfirmed to addd up to three total', () => {
|
||||
const now = Date.now();
|
||||
signedPreKeys = [
|
||||
{
|
||||
|
|
@ -153,13 +151,13 @@ describe('AccountManager', function() {
|
|||
let count = 0;
|
||||
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {
|
||||
if (keyId !== 3) {
|
||||
throw new Error('Wrong keys were eliminated! ' + keyId);
|
||||
throw new Error(`Wrong keys were eliminated! ${keyId}`);
|
||||
}
|
||||
|
||||
count++;
|
||||
};
|
||||
|
||||
return accountManager.cleanSignedPreKeys().then(function() {
|
||||
return accountManager.cleanSignedPreKeys().then(() => {
|
||||
assert.strictEqual(count, 1);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,21 +1,19 @@
|
|||
'use strict';
|
||||
|
||||
describe('ContactBuffer', function() {
|
||||
describe('ContactBuffer', () => {
|
||||
function getTestBuffer() {
|
||||
var buffer = new dcodeIO.ByteBuffer();
|
||||
var avatarBuffer = new dcodeIO.ByteBuffer();
|
||||
var avatarLen = 255;
|
||||
const buffer = new dcodeIO.ByteBuffer();
|
||||
const avatarBuffer = new dcodeIO.ByteBuffer();
|
||||
const avatarLen = 255;
|
||||
for (var i = 0; i < avatarLen; ++i) {
|
||||
avatarBuffer.writeUint8(i);
|
||||
}
|
||||
avatarBuffer.limit = avatarBuffer.offset;
|
||||
avatarBuffer.offset = 0;
|
||||
var contactInfo = new textsecure.protobuf.ContactDetails({
|
||||
const contactInfo = new textsecure.protobuf.ContactDetails({
|
||||
name: 'Zero Cool',
|
||||
number: '+10000000000',
|
||||
avatar: { contentType: 'image/jpeg', length: avatarLen },
|
||||
});
|
||||
var contactInfoBuffer = contactInfo.encode().toArrayBuffer();
|
||||
const contactInfoBuffer = contactInfo.encode().toArrayBuffer();
|
||||
|
||||
for (var i = 0; i < 3; ++i) {
|
||||
buffer.writeVarint32(contactInfoBuffer.byteLength);
|
||||
|
|
@ -28,11 +26,11 @@ describe('ContactBuffer', function() {
|
|||
return buffer.toArrayBuffer();
|
||||
}
|
||||
|
||||
it('parses an array buffer of contacts', function() {
|
||||
var arrayBuffer = getTestBuffer();
|
||||
var contactBuffer = new ContactBuffer(arrayBuffer);
|
||||
var contact = contactBuffer.next();
|
||||
var count = 0;
|
||||
it('parses an array buffer of contacts', () => {
|
||||
const arrayBuffer = getTestBuffer();
|
||||
const contactBuffer = new ContactBuffer(arrayBuffer);
|
||||
let contact = contactBuffer.next();
|
||||
let count = 0;
|
||||
while (contact !== undefined) {
|
||||
count++;
|
||||
assert.strictEqual(contact.name, 'Zero Cool');
|
||||
|
|
@ -40,8 +38,8 @@ describe('ContactBuffer', function() {
|
|||
assert.strictEqual(contact.avatar.contentType, 'image/jpeg');
|
||||
assert.strictEqual(contact.avatar.length, 255);
|
||||
assert.strictEqual(contact.avatar.data.byteLength, 255);
|
||||
var avatarBytes = new Uint8Array(contact.avatar.data);
|
||||
for (var j = 0; j < 255; ++j) {
|
||||
const avatarBytes = new Uint8Array(contact.avatar.data);
|
||||
for (let j = 0; j < 255; ++j) {
|
||||
assert.strictEqual(avatarBytes[j], j);
|
||||
}
|
||||
contact = contactBuffer.next();
|
||||
|
|
@ -50,23 +48,23 @@ describe('ContactBuffer', function() {
|
|||
});
|
||||
});
|
||||
|
||||
describe('GroupBuffer', function() {
|
||||
describe('GroupBuffer', () => {
|
||||
function getTestBuffer() {
|
||||
var buffer = new dcodeIO.ByteBuffer();
|
||||
var avatarBuffer = new dcodeIO.ByteBuffer();
|
||||
var avatarLen = 255;
|
||||
const buffer = new dcodeIO.ByteBuffer();
|
||||
const avatarBuffer = new dcodeIO.ByteBuffer();
|
||||
const avatarLen = 255;
|
||||
for (var i = 0; i < avatarLen; ++i) {
|
||||
avatarBuffer.writeUint8(i);
|
||||
}
|
||||
avatarBuffer.limit = avatarBuffer.offset;
|
||||
avatarBuffer.offset = 0;
|
||||
var groupInfo = new textsecure.protobuf.GroupDetails({
|
||||
const groupInfo = new textsecure.protobuf.GroupDetails({
|
||||
id: new Uint8Array([1, 3, 3, 7]).buffer,
|
||||
name: 'Hackers',
|
||||
members: ['cereal', 'burn', 'phreak', 'joey'],
|
||||
avatar: { contentType: 'image/jpeg', length: avatarLen },
|
||||
});
|
||||
var groupInfoBuffer = groupInfo.encode().toArrayBuffer();
|
||||
const groupInfoBuffer = groupInfo.encode().toArrayBuffer();
|
||||
|
||||
for (var i = 0; i < 3; ++i) {
|
||||
buffer.writeVarint32(groupInfoBuffer.byteLength);
|
||||
|
|
@ -79,11 +77,11 @@ describe('GroupBuffer', function() {
|
|||
return buffer.toArrayBuffer();
|
||||
}
|
||||
|
||||
it('parses an array buffer of groups', function() {
|
||||
var arrayBuffer = getTestBuffer();
|
||||
var groupBuffer = new GroupBuffer(arrayBuffer);
|
||||
var group = groupBuffer.next();
|
||||
var count = 0;
|
||||
it('parses an array buffer of groups', () => {
|
||||
const arrayBuffer = getTestBuffer();
|
||||
const groupBuffer = new GroupBuffer(arrayBuffer);
|
||||
let group = groupBuffer.next();
|
||||
let count = 0;
|
||||
while (group !== undefined) {
|
||||
count++;
|
||||
assert.strictEqual(group.name, 'Hackers');
|
||||
|
|
@ -95,8 +93,8 @@ describe('GroupBuffer', function() {
|
|||
assert.strictEqual(group.avatar.contentType, 'image/jpeg');
|
||||
assert.strictEqual(group.avatar.length, 255);
|
||||
assert.strictEqual(group.avatar.data.byteLength, 255);
|
||||
var avatarBytes = new Uint8Array(group.avatar.data);
|
||||
for (var j = 0; j < 255; ++j) {
|
||||
const avatarBytes = new Uint8Array(group.avatar.data);
|
||||
for (let j = 0; j < 255; ++j) {
|
||||
assert.strictEqual(avatarBytes[j], j);
|
||||
}
|
||||
group = groupBuffer.next();
|
||||
|
|
|
|||
|
|
@ -1,18 +1,18 @@
|
|||
describe('encrypting and decrypting profile data', function() {
|
||||
var NAME_PADDED_LENGTH = 26;
|
||||
describe('encrypting and decrypting profile names', function() {
|
||||
it('pads, encrypts, decrypts, and unpads a short string', function() {
|
||||
var name = 'Alice';
|
||||
var buffer = dcodeIO.ByteBuffer.wrap(name).toArrayBuffer();
|
||||
var key = libsignal.crypto.getRandomBytes(32);
|
||||
describe('encrypting and decrypting profile data', () => {
|
||||
const NAME_PADDED_LENGTH = 26;
|
||||
describe('encrypting and decrypting profile names', () => {
|
||||
it('pads, encrypts, decrypts, and unpads a short string', () => {
|
||||
const name = 'Alice';
|
||||
const buffer = dcodeIO.ByteBuffer.wrap(name).toArrayBuffer();
|
||||
const key = libsignal.crypto.getRandomBytes(32);
|
||||
|
||||
return textsecure.crypto
|
||||
.encryptProfileName(buffer, key)
|
||||
.then(function(encrypted) {
|
||||
.then(encrypted => {
|
||||
assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfileName(encrypted, key)
|
||||
.then(function(decrypted) {
|
||||
.then(decrypted => {
|
||||
assert.strictEqual(
|
||||
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
|
||||
'Alice'
|
||||
|
|
@ -20,17 +20,17 @@ describe('encrypting and decrypting profile data', function() {
|
|||
});
|
||||
});
|
||||
});
|
||||
it('works for empty string', function() {
|
||||
var name = dcodeIO.ByteBuffer.wrap('').toArrayBuffer();
|
||||
var key = libsignal.crypto.getRandomBytes(32);
|
||||
it('works for empty string', () => {
|
||||
const name = dcodeIO.ByteBuffer.wrap('').toArrayBuffer();
|
||||
const key = libsignal.crypto.getRandomBytes(32);
|
||||
|
||||
return textsecure.crypto
|
||||
.encryptProfileName(name.buffer, key)
|
||||
.then(function(encrypted) {
|
||||
.then(encrypted => {
|
||||
assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfileName(encrypted, key)
|
||||
.then(function(decrypted) {
|
||||
.then(decrypted => {
|
||||
assert.strictEqual(decrypted.byteLength, 0);
|
||||
assert.strictEqual(
|
||||
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
|
||||
|
|
@ -40,37 +40,37 @@ describe('encrypting and decrypting profile data', function() {
|
|||
});
|
||||
});
|
||||
});
|
||||
describe('encrypting and decrypting profile avatars', function() {
|
||||
it('encrypts and decrypts', function() {
|
||||
var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer();
|
||||
var key = libsignal.crypto.getRandomBytes(32);
|
||||
describe('encrypting and decrypting profile avatars', () => {
|
||||
it('encrypts and decrypts', () => {
|
||||
const buffer = dcodeIO.ByteBuffer.wrap(
|
||||
'This is an avatar'
|
||||
).toArrayBuffer();
|
||||
const key = libsignal.crypto.getRandomBytes(32);
|
||||
|
||||
return textsecure.crypto
|
||||
.encryptProfile(buffer, key)
|
||||
.then(function(encrypted) {
|
||||
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfile(encrypted, key)
|
||||
.then(function(decrypted) {
|
||||
assertEqualArrayBuffers(buffer, decrypted);
|
||||
});
|
||||
});
|
||||
return textsecure.crypto.encryptProfile(buffer, key).then(encrypted => {
|
||||
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfile(encrypted, key)
|
||||
.then(decrypted => {
|
||||
assertEqualArrayBuffers(buffer, decrypted);
|
||||
});
|
||||
});
|
||||
});
|
||||
it('throws when decrypting with the wrong key', function() {
|
||||
var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer();
|
||||
var key = libsignal.crypto.getRandomBytes(32);
|
||||
var bad_key = libsignal.crypto.getRandomBytes(32);
|
||||
it('throws when decrypting with the wrong key', () => {
|
||||
const buffer = dcodeIO.ByteBuffer.wrap(
|
||||
'This is an avatar'
|
||||
).toArrayBuffer();
|
||||
const key = libsignal.crypto.getRandomBytes(32);
|
||||
const bad_key = libsignal.crypto.getRandomBytes(32);
|
||||
|
||||
return textsecure.crypto
|
||||
.encryptProfile(buffer, key)
|
||||
.then(function(encrypted) {
|
||||
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfile(encrypted, bad_key)
|
||||
.catch(function(error) {
|
||||
assert.strictEqual(error.name, 'ProfileDecryptError');
|
||||
});
|
||||
});
|
||||
return textsecure.crypto.encryptProfile(buffer, key).then(encrypted => {
|
||||
assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
|
||||
return textsecure.crypto
|
||||
.decryptProfile(encrypted, bad_key)
|
||||
.catch(error => {
|
||||
assert.strictEqual(error.name, 'ProfileDecryptError');
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -22,17 +22,18 @@ const fakeAPI = {
|
|||
// sendMessages: fakeCall,
|
||||
setSignedPreKey: fakeCall,
|
||||
|
||||
getKeysForNumber: function(number, deviceId) {
|
||||
var res = getKeysForNumberMap[number];
|
||||
getKeysForNumber(number, deviceId) {
|
||||
const res = getKeysForNumberMap[number];
|
||||
if (res !== undefined) {
|
||||
delete getKeysForNumberMap[number];
|
||||
return Promise.resolve(res);
|
||||
} else throw new Error('getKeysForNumber of unknown/used number');
|
||||
}
|
||||
throw new Error('getKeysForNumber of unknown/used number');
|
||||
},
|
||||
|
||||
sendMessages: function(destination, messageArray) {
|
||||
sendMessages(destination, messageArray) {
|
||||
for (i in messageArray) {
|
||||
var msg = messageArray[i];
|
||||
const msg = messageArray[i];
|
||||
if (
|
||||
(msg.type != 1 && msg.type != 3) ||
|
||||
msg.destinationDeviceId === undefined ||
|
||||
|
|
@ -45,7 +46,7 @@ const fakeAPI = {
|
|||
throw new Error('Invalid message');
|
||||
|
||||
messagesSentMap[
|
||||
destination + '.' + messageArray[i].destinationDeviceId
|
||||
`${destination}.${messageArray[i].destinationDeviceId}`
|
||||
] = msg;
|
||||
}
|
||||
},
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
describe('Key generation', function() {
|
||||
var count = 10;
|
||||
const count = 10;
|
||||
this.timeout(count * 2000);
|
||||
|
||||
function validateStoredKeyPair(keyPair) {
|
||||
|
|
@ -14,49 +12,41 @@ describe('Key generation', function() {
|
|||
assert.strictEqual(keyPair.privKey.byteLength, 32);
|
||||
}
|
||||
function itStoresPreKey(keyId) {
|
||||
it('prekey ' + keyId + ' is valid', function() {
|
||||
return textsecure.storage.protocol
|
||||
.loadPreKey(keyId)
|
||||
.then(function(keyPair) {
|
||||
validateStoredKeyPair(keyPair);
|
||||
});
|
||||
});
|
||||
it(`prekey ${keyId} is valid`, () =>
|
||||
textsecure.storage.protocol.loadPreKey(keyId).then(keyPair => {
|
||||
validateStoredKeyPair(keyPair);
|
||||
}));
|
||||
}
|
||||
function itStoresSignedPreKey(keyId) {
|
||||
it('signed prekey ' + keyId + ' is valid', function() {
|
||||
return textsecure.storage.protocol
|
||||
.loadSignedPreKey(keyId)
|
||||
.then(function(keyPair) {
|
||||
validateStoredKeyPair(keyPair);
|
||||
});
|
||||
});
|
||||
it(`signed prekey ${keyId} is valid`, () =>
|
||||
textsecure.storage.protocol.loadSignedPreKey(keyId).then(keyPair => {
|
||||
validateStoredKeyPair(keyPair);
|
||||
}));
|
||||
}
|
||||
function validateResultKey(resultKey) {
|
||||
return textsecure.storage.protocol
|
||||
.loadPreKey(resultKey.keyId)
|
||||
.then(function(keyPair) {
|
||||
.then(keyPair => {
|
||||
assertEqualArrayBuffers(resultKey.publicKey, keyPair.pubKey);
|
||||
});
|
||||
}
|
||||
function validateResultSignedKey(resultSignedKey) {
|
||||
return textsecure.storage.protocol
|
||||
.loadSignedPreKey(resultSignedKey.keyId)
|
||||
.then(function(keyPair) {
|
||||
.then(keyPair => {
|
||||
assertEqualArrayBuffers(resultSignedKey.publicKey, keyPair.pubKey);
|
||||
});
|
||||
}
|
||||
|
||||
before(function() {
|
||||
before(() => {
|
||||
localStorage.clear();
|
||||
return libsignal.KeyHelper.generateIdentityKeyPair().then(function(
|
||||
keyPair
|
||||
) {
|
||||
return textsecure.storage.protocol.put('identityKey', keyPair);
|
||||
});
|
||||
return libsignal.KeyHelper.generateIdentityKeyPair().then(keyPair =>
|
||||
textsecure.storage.protocol.put('identityKey', keyPair)
|
||||
);
|
||||
});
|
||||
|
||||
describe('the first time', function() {
|
||||
var result;
|
||||
describe('the first time', () => {
|
||||
let result;
|
||||
/* result should have this format
|
||||
* {
|
||||
* preKeys: [ { keyId, publicKey }, ... ],
|
||||
|
|
@ -64,101 +54,98 @@ describe('Key generation', function() {
|
|||
* identityKey: <ArrayBuffer>
|
||||
* }
|
||||
*/
|
||||
before(function() {
|
||||
var accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(function(res) {
|
||||
before(() => {
|
||||
const accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(res => {
|
||||
result = res;
|
||||
});
|
||||
});
|
||||
for (var i = 1; i <= count; i++) {
|
||||
for (let i = 1; i <= count; i++) {
|
||||
itStoresPreKey(i);
|
||||
}
|
||||
itStoresSignedPreKey(1);
|
||||
|
||||
it('result contains ' + count + ' preKeys', function() {
|
||||
it(`result contains ${count} preKeys`, () => {
|
||||
assert.isArray(result.preKeys);
|
||||
assert.lengthOf(result.preKeys, count);
|
||||
for (var i = 0; i < count; i++) {
|
||||
for (let i = 0; i < count; i++) {
|
||||
assert.isObject(result.preKeys[i]);
|
||||
}
|
||||
});
|
||||
it('result contains the correct keyIds', function() {
|
||||
for (var i = 0; i < count; i++) {
|
||||
it('result contains the correct keyIds', () => {
|
||||
for (let i = 0; i < count; i++) {
|
||||
assert.strictEqual(result.preKeys[i].keyId, i + 1);
|
||||
}
|
||||
});
|
||||
it('result contains the correct public keys', function() {
|
||||
return Promise.all(result.preKeys.map(validateResultKey));
|
||||
});
|
||||
it('returns a signed prekey', function() {
|
||||
it('result contains the correct public keys', () =>
|
||||
Promise.all(result.preKeys.map(validateResultKey)));
|
||||
it('returns a signed prekey', () => {
|
||||
assert.strictEqual(result.signedPreKey.keyId, 1);
|
||||
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
|
||||
return validateResultSignedKey(result.signedPreKey);
|
||||
});
|
||||
});
|
||||
describe('the second time', function() {
|
||||
var result;
|
||||
before(function() {
|
||||
var accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(function(res) {
|
||||
describe('the second time', () => {
|
||||
let result;
|
||||
before(() => {
|
||||
const accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(res => {
|
||||
result = res;
|
||||
});
|
||||
});
|
||||
for (var i = 1; i <= 2 * count; i++) {
|
||||
for (let i = 1; i <= 2 * count; i++) {
|
||||
itStoresPreKey(i);
|
||||
}
|
||||
itStoresSignedPreKey(1);
|
||||
itStoresSignedPreKey(2);
|
||||
it('result contains ' + count + ' preKeys', function() {
|
||||
it(`result contains ${count} preKeys`, () => {
|
||||
assert.isArray(result.preKeys);
|
||||
assert.lengthOf(result.preKeys, count);
|
||||
for (var i = 0; i < count; i++) {
|
||||
for (let i = 0; i < count; i++) {
|
||||
assert.isObject(result.preKeys[i]);
|
||||
}
|
||||
});
|
||||
it('result contains the correct keyIds', function() {
|
||||
for (var i = 1; i <= count; i++) {
|
||||
it('result contains the correct keyIds', () => {
|
||||
for (let i = 1; i <= count; i++) {
|
||||
assert.strictEqual(result.preKeys[i - 1].keyId, i + count);
|
||||
}
|
||||
});
|
||||
it('result contains the correct public keys', function() {
|
||||
return Promise.all(result.preKeys.map(validateResultKey));
|
||||
});
|
||||
it('returns a signed prekey', function() {
|
||||
it('result contains the correct public keys', () =>
|
||||
Promise.all(result.preKeys.map(validateResultKey)));
|
||||
it('returns a signed prekey', () => {
|
||||
assert.strictEqual(result.signedPreKey.keyId, 2);
|
||||
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
|
||||
return validateResultSignedKey(result.signedPreKey);
|
||||
});
|
||||
});
|
||||
describe('the third time', function() {
|
||||
var result;
|
||||
before(function() {
|
||||
var accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(function(res) {
|
||||
describe('the third time', () => {
|
||||
let result;
|
||||
before(() => {
|
||||
const accountManager = new textsecure.AccountManager('');
|
||||
return accountManager.generateKeys(count).then(res => {
|
||||
result = res;
|
||||
});
|
||||
});
|
||||
for (var i = 1; i <= 3 * count; i++) {
|
||||
for (let i = 1; i <= 3 * count; i++) {
|
||||
itStoresPreKey(i);
|
||||
}
|
||||
itStoresSignedPreKey(2);
|
||||
itStoresSignedPreKey(3);
|
||||
it('result contains ' + count + ' preKeys', function() {
|
||||
it(`result contains ${count} preKeys`, () => {
|
||||
assert.isArray(result.preKeys);
|
||||
assert.lengthOf(result.preKeys, count);
|
||||
for (var i = 0; i < count; i++) {
|
||||
for (let i = 0; i < count; i++) {
|
||||
assert.isObject(result.preKeys[i]);
|
||||
}
|
||||
});
|
||||
it('result contains the correct keyIds', function() {
|
||||
for (var i = 1; i <= count; i++) {
|
||||
it('result contains the correct keyIds', () => {
|
||||
for (let i = 1; i <= count; i++) {
|
||||
assert.strictEqual(result.preKeys[i - 1].keyId, i + 2 * count);
|
||||
}
|
||||
});
|
||||
it('result contains the correct public keys', function() {
|
||||
return Promise.all(result.preKeys.map(validateResultKey));
|
||||
});
|
||||
it('result contains a signed prekey', function() {
|
||||
it('result contains the correct public keys', () =>
|
||||
Promise.all(result.preKeys.map(validateResultKey)));
|
||||
it('result contains a signed prekey', () => {
|
||||
assert.strictEqual(result.signedPreKey.keyId, 3);
|
||||
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
|
||||
return validateResultSignedKey(result.signedPreKey);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
'use strict';
|
||||
|
||||
describe('Helpers', function() {
|
||||
describe('ArrayBuffer->String conversion', function() {
|
||||
it('works', function() {
|
||||
var b = new ArrayBuffer(3);
|
||||
var a = new Uint8Array(b);
|
||||
describe('Helpers', () => {
|
||||
describe('ArrayBuffer->String conversion', () => {
|
||||
it('works', () => {
|
||||
const b = new ArrayBuffer(3);
|
||||
const a = new Uint8Array(b);
|
||||
a[0] = 0;
|
||||
a[1] = 255;
|
||||
a[2] = 128;
|
||||
|
|
@ -12,18 +10,18 @@ describe('Helpers', function() {
|
|||
});
|
||||
});
|
||||
|
||||
describe('stringToArrayBuffer', function() {
|
||||
it('returns ArrayBuffer when passed string', function() {
|
||||
var StaticArrayBufferProto = new ArrayBuffer().__proto__;
|
||||
var anArrayBuffer = new ArrayBuffer(1);
|
||||
var typedArray = new Uint8Array(anArrayBuffer);
|
||||
describe('stringToArrayBuffer', () => {
|
||||
it('returns ArrayBuffer when passed string', () => {
|
||||
const StaticArrayBufferProto = new ArrayBuffer().__proto__;
|
||||
const anArrayBuffer = new ArrayBuffer(1);
|
||||
const typedArray = new Uint8Array(anArrayBuffer);
|
||||
typedArray[0] = 'a'.charCodeAt(0);
|
||||
assertEqualArrayBuffers(stringToArrayBuffer('a'), anArrayBuffer);
|
||||
});
|
||||
it('throws an error when passed a non string', function() {
|
||||
var notStringable = [{}, undefined, null, new ArrayBuffer()];
|
||||
notStringable.forEach(function(notString) {
|
||||
assert.throw(function() {
|
||||
it('throws an error when passed a non string', () => {
|
||||
const notStringable = [{}, undefined, null, new ArrayBuffer()];
|
||||
notStringable.forEach(notString => {
|
||||
assert.throw(() => {
|
||||
stringToArrayBuffer(notString);
|
||||
}, Error);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -4,13 +4,13 @@ function SignalProtocolStore() {
|
|||
|
||||
SignalProtocolStore.prototype = {
|
||||
Direction: { SENDING: 1, RECEIVING: 2 },
|
||||
getIdentityKeyPair: function() {
|
||||
getIdentityKeyPair() {
|
||||
return Promise.resolve(this.get('identityKey'));
|
||||
},
|
||||
getLocalRegistrationId: function() {
|
||||
getLocalRegistrationId() {
|
||||
return Promise.resolve(this.get('registrationId'));
|
||||
},
|
||||
put: function(key, value) {
|
||||
put(key, value) {
|
||||
if (
|
||||
key === undefined ||
|
||||
value === undefined ||
|
||||
|
|
@ -20,165 +20,130 @@ SignalProtocolStore.prototype = {
|
|||
throw new Error('Tried to store undefined/null');
|
||||
this.store[key] = value;
|
||||
},
|
||||
get: function(key, defaultValue) {
|
||||
get(key, defaultValue) {
|
||||
if (key === null || key === undefined)
|
||||
throw new Error('Tried to get value for undefined/null key');
|
||||
if (key in this.store) {
|
||||
return this.store[key];
|
||||
} else {
|
||||
return defaultValue;
|
||||
}
|
||||
return defaultValue;
|
||||
},
|
||||
remove: function(key) {
|
||||
remove(key) {
|
||||
if (key === null || key === undefined)
|
||||
throw new Error('Tried to remove value for undefined/null key');
|
||||
delete this.store[key];
|
||||
},
|
||||
|
||||
isTrustedIdentity: function(identifier, identityKey) {
|
||||
isTrustedIdentity(identifier, identityKey) {
|
||||
if (identifier === null || identifier === undefined) {
|
||||
throw new error('tried to check identity key for undefined/null key');
|
||||
}
|
||||
if (!(identityKey instanceof ArrayBuffer)) {
|
||||
throw new error('Expected identityKey to be an ArrayBuffer');
|
||||
}
|
||||
var trusted = this.get('identityKey' + identifier);
|
||||
const trusted = this.get(`identityKey${identifier}`);
|
||||
if (trusted === undefined) {
|
||||
return Promise.resolve(true);
|
||||
}
|
||||
return Promise.resolve(identityKey === trusted);
|
||||
},
|
||||
loadIdentityKey: function(identifier) {
|
||||
loadIdentityKey(identifier) {
|
||||
if (identifier === null || identifier === undefined)
|
||||
throw new Error('Tried to get identity key for undefined/null key');
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.get('identityKey' + identifier));
|
||||
}.bind(this)
|
||||
);
|
||||
return new Promise(resolve => {
|
||||
resolve(this.get(`identityKey${identifier}`));
|
||||
});
|
||||
},
|
||||
saveIdentity: function(identifier, identityKey) {
|
||||
saveIdentity(identifier, identityKey) {
|
||||
if (identifier === null || identifier === undefined)
|
||||
throw new Error('Tried to put identity key for undefined/null key');
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
var existing = this.get('identityKey' + identifier);
|
||||
this.put('identityKey' + identifier, identityKey);
|
||||
if (existing && existing !== identityKey) {
|
||||
resolve(true);
|
||||
} else {
|
||||
resolve(false);
|
||||
}
|
||||
}.bind(this)
|
||||
);
|
||||
return new Promise(resolve => {
|
||||
const existing = this.get(`identityKey${identifier}`);
|
||||
this.put(`identityKey${identifier}`, identityKey);
|
||||
if (existing && existing !== identityKey) {
|
||||
resolve(true);
|
||||
} else {
|
||||
resolve(false);
|
||||
}
|
||||
});
|
||||
},
|
||||
|
||||
/* Returns a prekeypair object or undefined */
|
||||
loadPreKey: function(keyId) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
var res = this.get('25519KeypreKey' + keyId);
|
||||
resolve(res);
|
||||
}.bind(this)
|
||||
);
|
||||
loadPreKey(keyId) {
|
||||
return new Promise(resolve => {
|
||||
const res = this.get(`25519KeypreKey${keyId}`);
|
||||
resolve(res);
|
||||
});
|
||||
},
|
||||
storePreKey: function(keyId, keyPair) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.put('25519KeypreKey' + keyId, keyPair));
|
||||
}.bind(this)
|
||||
);
|
||||
storePreKey(keyId, keyPair) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.put(`25519KeypreKey${keyId}`, keyPair));
|
||||
});
|
||||
},
|
||||
removePreKey: function(keyId) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.remove('25519KeypreKey' + keyId));
|
||||
}.bind(this)
|
||||
);
|
||||
removePreKey(keyId) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.remove(`25519KeypreKey${keyId}`));
|
||||
});
|
||||
},
|
||||
|
||||
/* Returns a signed keypair object or undefined */
|
||||
loadSignedPreKey: function(keyId) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
var res = this.get('25519KeysignedKey' + keyId);
|
||||
resolve(res);
|
||||
}.bind(this)
|
||||
);
|
||||
loadSignedPreKey(keyId) {
|
||||
return new Promise(resolve => {
|
||||
const res = this.get(`25519KeysignedKey${keyId}`);
|
||||
resolve(res);
|
||||
});
|
||||
},
|
||||
loadSignedPreKeys: function() {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
var res = [];
|
||||
for (var i in this.store) {
|
||||
if (i.startsWith('25519KeysignedKey')) {
|
||||
res.push(this.store[i]);
|
||||
}
|
||||
loadSignedPreKeys() {
|
||||
return new Promise(resolve => {
|
||||
const res = [];
|
||||
for (const i in this.store) {
|
||||
if (i.startsWith('25519KeysignedKey')) {
|
||||
res.push(this.store[i]);
|
||||
}
|
||||
resolve(res);
|
||||
}.bind(this)
|
||||
);
|
||||
}
|
||||
resolve(res);
|
||||
});
|
||||
},
|
||||
storeSignedPreKey: function(keyId, keyPair) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.put('25519KeysignedKey' + keyId, keyPair));
|
||||
}.bind(this)
|
||||
);
|
||||
storeSignedPreKey(keyId, keyPair) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.put(`25519KeysignedKey${keyId}`, keyPair));
|
||||
});
|
||||
},
|
||||
removeSignedPreKey: function(keyId) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.remove('25519KeysignedKey' + keyId));
|
||||
}.bind(this)
|
||||
);
|
||||
removeSignedPreKey(keyId) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.remove(`25519KeysignedKey${keyId}`));
|
||||
});
|
||||
},
|
||||
|
||||
loadSession: function(identifier) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.get('session' + identifier));
|
||||
}.bind(this)
|
||||
);
|
||||
loadSession(identifier) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.get(`session${identifier}`));
|
||||
});
|
||||
},
|
||||
storeSession: function(identifier, record) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
resolve(this.put('session' + identifier, record));
|
||||
}.bind(this)
|
||||
);
|
||||
storeSession(identifier, record) {
|
||||
return new Promise(resolve => {
|
||||
resolve(this.put(`session${identifier}`, record));
|
||||
});
|
||||
},
|
||||
removeAllSessions: function(identifier) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
for (key in this.store) {
|
||||
if (
|
||||
key.match(
|
||||
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
|
||||
)
|
||||
) {
|
||||
delete this.store[key];
|
||||
}
|
||||
removeAllSessions(identifier) {
|
||||
return new Promise(resolve => {
|
||||
for (key in this.store) {
|
||||
if (key.match(RegExp(`^session${identifier.replace('+', '\\+')}.+`))) {
|
||||
delete this.store[key];
|
||||
}
|
||||
resolve();
|
||||
}.bind(this)
|
||||
);
|
||||
}
|
||||
resolve();
|
||||
});
|
||||
},
|
||||
getDeviceIds: function(identifier) {
|
||||
return new Promise(
|
||||
function(resolve) {
|
||||
var deviceIds = [];
|
||||
for (key in this.store) {
|
||||
if (
|
||||
key.match(
|
||||
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
|
||||
)
|
||||
) {
|
||||
deviceIds.push(parseInt(key.split('.')[1]));
|
||||
}
|
||||
getDeviceIds(identifier) {
|
||||
return new Promise(resolve => {
|
||||
const deviceIds = [];
|
||||
for (key in this.store) {
|
||||
if (key.match(RegExp(`^session${identifier.replace('+', '\\+')}.+`))) {
|
||||
deviceIds.push(parseInt(key.split('.')[1]));
|
||||
}
|
||||
resolve(deviceIds);
|
||||
}.bind(this)
|
||||
);
|
||||
}
|
||||
resolve(deviceIds);
|
||||
});
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,47 +1,47 @@
|
|||
describe('MessageReceiver', function() {
|
||||
describe('MessageReceiver', () => {
|
||||
textsecure.storage.impl = new SignalProtocolStore();
|
||||
var WebSocket = window.WebSocket;
|
||||
var number = '+19999999999';
|
||||
var deviceId = 1;
|
||||
var signalingKey = libsignal.crypto.getRandomBytes(32 + 20);
|
||||
before(function() {
|
||||
const WebSocket = window.WebSocket;
|
||||
const number = '+19999999999';
|
||||
const deviceId = 1;
|
||||
const signalingKey = libsignal.crypto.getRandomBytes(32 + 20);
|
||||
before(() => {
|
||||
window.WebSocket = MockSocket;
|
||||
textsecure.storage.user.setNumberAndDeviceId(number, deviceId, 'name');
|
||||
textsecure.storage.put('password', 'password');
|
||||
textsecure.storage.put('signaling_key', signalingKey);
|
||||
});
|
||||
after(function() {
|
||||
after(() => {
|
||||
window.WebSocket = WebSocket;
|
||||
});
|
||||
|
||||
describe('connecting', function() {
|
||||
var blob = null;
|
||||
var attrs = {
|
||||
describe('connecting', () => {
|
||||
const blob = null;
|
||||
const attrs = {
|
||||
type: textsecure.protobuf.Envelope.Type.CIPHERTEXT,
|
||||
source: number,
|
||||
sourceDevice: deviceId,
|
||||
timestamp: Date.now(),
|
||||
};
|
||||
var websocketmessage = new textsecure.protobuf.WebSocketMessage({
|
||||
const websocketmessage = new textsecure.protobuf.WebSocketMessage({
|
||||
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
|
||||
request: { verb: 'PUT', path: '/messages' },
|
||||
});
|
||||
|
||||
before(function(done) {
|
||||
var signal = new textsecure.protobuf.Envelope(attrs).toArrayBuffer();
|
||||
var data = new textsecure.protobuf.DataMessage({ body: 'hello' });
|
||||
before(done => {
|
||||
const signal = new textsecure.protobuf.Envelope(attrs).toArrayBuffer();
|
||||
const data = new textsecure.protobuf.DataMessage({ body: 'hello' });
|
||||
|
||||
var signaling_key = signalingKey;
|
||||
var aes_key = signaling_key.slice(0, 32);
|
||||
var mac_key = signaling_key.slice(32, 32 + 20);
|
||||
const signaling_key = signalingKey;
|
||||
const aes_key = signaling_key.slice(0, 32);
|
||||
const mac_key = signaling_key.slice(32, 32 + 20);
|
||||
|
||||
window.crypto.subtle
|
||||
.importKey('raw', aes_key, { name: 'AES-CBC' }, false, ['encrypt'])
|
||||
.then(function(key) {
|
||||
var iv = libsignal.crypto.getRandomBytes(16);
|
||||
.then(key => {
|
||||
const iv = libsignal.crypto.getRandomBytes(16);
|
||||
window.crypto.subtle
|
||||
.encrypt({ name: 'AES-CBC', iv: new Uint8Array(iv) }, key, signal)
|
||||
.then(function(ciphertext) {
|
||||
.then(ciphertext => {
|
||||
window.crypto.subtle
|
||||
.importKey(
|
||||
'raw',
|
||||
|
|
@ -50,12 +50,12 @@ describe('MessageReceiver', function() {
|
|||
false,
|
||||
['sign']
|
||||
)
|
||||
.then(function(key) {
|
||||
.then(key => {
|
||||
window.crypto.subtle
|
||||
.sign({ name: 'HMAC', hash: 'SHA-256' }, key, signal)
|
||||
.then(function(mac) {
|
||||
var version = new Uint8Array([1]);
|
||||
var message = dcodeIO.ByteBuffer.concat([
|
||||
.then(mac => {
|
||||
const version = new Uint8Array([1]);
|
||||
const message = dcodeIO.ByteBuffer.concat([
|
||||
version,
|
||||
iv,
|
||||
ciphertext,
|
||||
|
|
@ -69,27 +69,27 @@ describe('MessageReceiver', function() {
|
|||
});
|
||||
});
|
||||
|
||||
it('connects', function(done) {
|
||||
var mockServer = new MockServer(
|
||||
'ws://localhost:8080/v1/websocket/?login=' +
|
||||
encodeURIComponent(number) +
|
||||
'.1&password=password'
|
||||
it('connects', done => {
|
||||
const mockServer = new MockServer(
|
||||
`ws://localhost:8080/v1/websocket/?login=${encodeURIComponent(
|
||||
number
|
||||
)}.1&password=password`
|
||||
);
|
||||
|
||||
mockServer.on('connection', function(server) {
|
||||
mockServer.on('connection', server => {
|
||||
server.send(new Blob([websocketmessage.toArrayBuffer()]));
|
||||
});
|
||||
|
||||
window.addEventListener('textsecure:message', function(ev) {
|
||||
var signal = ev.proto;
|
||||
for (var key in attrs) {
|
||||
window.addEventListener('textsecure:message', ev => {
|
||||
const signal = ev.proto;
|
||||
for (const key in attrs) {
|
||||
assert.strictEqual(attrs[key], signal[key]);
|
||||
}
|
||||
assert.strictEqual(signal.message.body, 'hello');
|
||||
server.close();
|
||||
done();
|
||||
});
|
||||
var messageReceiver = new textsecure.MessageReceiver(
|
||||
const messageReceiver = new textsecure.MessageReceiver(
|
||||
'ws://localhost:8080',
|
||||
window
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,13 +1,12 @@
|
|||
'use strict';
|
||||
describe('Protocol', function() {
|
||||
describe('Unencrypted PushMessageProto "decrypt"', function() {
|
||||
//exclusive
|
||||
it('works', function(done) {
|
||||
describe('Protocol', () => {
|
||||
describe('Unencrypted PushMessageProto "decrypt"', () => {
|
||||
// exclusive
|
||||
it('works', done => {
|
||||
localStorage.clear();
|
||||
|
||||
var text_message = new textsecure.protobuf.DataMessage();
|
||||
const text_message = new textsecure.protobuf.DataMessage();
|
||||
text_message.body = 'Hi Mom';
|
||||
var server_message = {
|
||||
const server_message = {
|
||||
type: 4, // unencrypted
|
||||
source: '+19999999999',
|
||||
timestamp: 42,
|
||||
|
|
@ -21,7 +20,7 @@ describe('Protocol', function() {
|
|||
server_message.type,
|
||||
server_message.message
|
||||
)
|
||||
.then(function(message) {
|
||||
.then(message => {
|
||||
assert.equal(message.body, text_message.body);
|
||||
assert.equal(
|
||||
message.attachments.length,
|
||||
|
|
|
|||
|
|
@ -1,37 +1,32 @@
|
|||
'use strict';
|
||||
|
||||
describe('Protocol Wrapper', function() {
|
||||
var store = textsecure.storage.protocol;
|
||||
var identifier = '+5558675309';
|
||||
var another_identifier = '+5555590210';
|
||||
var prekeys, identityKey, testKey;
|
||||
const store = textsecure.storage.protocol;
|
||||
const identifier = '+5558675309';
|
||||
const another_identifier = '+5555590210';
|
||||
let prekeys, identityKey, testKey;
|
||||
this.timeout(5000);
|
||||
before(function(done) {
|
||||
before(done => {
|
||||
localStorage.clear();
|
||||
libsignal.KeyHelper.generateIdentityKeyPair()
|
||||
.then(function(identityKey) {
|
||||
return textsecure.storage.protocol.saveIdentity(
|
||||
identifier,
|
||||
identityKey
|
||||
);
|
||||
})
|
||||
.then(function() {
|
||||
.then(identityKey =>
|
||||
textsecure.storage.protocol.saveIdentity(identifier, identityKey)
|
||||
)
|
||||
.then(() => {
|
||||
done();
|
||||
});
|
||||
});
|
||||
describe('processPreKey', function() {
|
||||
it('rejects if the identity key changes', function() {
|
||||
var address = new libsignal.SignalProtocolAddress(identifier, 1);
|
||||
var builder = new libsignal.SessionBuilder(store, address);
|
||||
describe('processPreKey', () => {
|
||||
it('rejects if the identity key changes', () => {
|
||||
const address = new libsignal.SignalProtocolAddress(identifier, 1);
|
||||
const builder = new libsignal.SessionBuilder(store, address);
|
||||
return builder
|
||||
.processPreKey({
|
||||
identityKey: textsecure.crypto.getRandomBytes(33),
|
||||
encodedNumber: address.toString(),
|
||||
})
|
||||
.then(function() {
|
||||
.then(() => {
|
||||
throw new Error('Allowed to overwrite identity key');
|
||||
})
|
||||
.catch(function(e) {
|
||||
.catch(e => {
|
||||
assert.strictEqual(e.message, 'Identity key changed');
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,55 +1,53 @@
|
|||
'use strict';
|
||||
|
||||
describe('SignalProtocolStore', function() {
|
||||
before(function() {
|
||||
describe('SignalProtocolStore', () => {
|
||||
before(() => {
|
||||
localStorage.clear();
|
||||
});
|
||||
var store = textsecure.storage.protocol;
|
||||
var identifier = '+5558675309';
|
||||
var another_identifier = '+5555590210';
|
||||
var identityKey = {
|
||||
const store = textsecure.storage.protocol;
|
||||
const identifier = '+5558675309';
|
||||
const another_identifier = '+5555590210';
|
||||
const identityKey = {
|
||||
pubKey: libsignal.crypto.getRandomBytes(33),
|
||||
privKey: libsignal.crypto.getRandomBytes(32),
|
||||
};
|
||||
var testKey = {
|
||||
const testKey = {
|
||||
pubKey: libsignal.crypto.getRandomBytes(33),
|
||||
privKey: libsignal.crypto.getRandomBytes(32),
|
||||
};
|
||||
it('retrieves my registration id', function(done) {
|
||||
it('retrieves my registration id', done => {
|
||||
store.put('registrationId', 1337);
|
||||
store
|
||||
.getLocalRegistrationId()
|
||||
.then(function(reg) {
|
||||
.then(reg => {
|
||||
assert.strictEqual(reg, 1337);
|
||||
})
|
||||
.then(done, done);
|
||||
});
|
||||
it('retrieves my identity key', function(done) {
|
||||
it('retrieves my identity key', done => {
|
||||
store.put('identityKey', identityKey);
|
||||
store
|
||||
.getIdentityKeyPair()
|
||||
.then(function(key) {
|
||||
.then(key => {
|
||||
assertEqualArrayBuffers(key.pubKey, identityKey.pubKey);
|
||||
assertEqualArrayBuffers(key.privKey, identityKey.privKey);
|
||||
})
|
||||
.then(done, done);
|
||||
});
|
||||
it('stores identity keys', function(done) {
|
||||
it('stores identity keys', done => {
|
||||
store
|
||||
.saveIdentity(identifier, testKey.pubKey)
|
||||
.then(function() {
|
||||
return store.loadIdentityKey(identifier).then(function(key) {
|
||||
.then(() =>
|
||||
store.loadIdentityKey(identifier).then(key => {
|
||||
assertEqualArrayBuffers(key, testKey.pubKey);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('returns whether a key is trusted', function(done) {
|
||||
var newIdentity = libsignal.crypto.getRandomBytes(33);
|
||||
store.saveIdentity(identifier, testKey.pubKey).then(function() {
|
||||
it('returns whether a key is trusted', done => {
|
||||
const newIdentity = libsignal.crypto.getRandomBytes(33);
|
||||
store.saveIdentity(identifier, testKey.pubKey).then(() => {
|
||||
store
|
||||
.isTrustedIdentity(identifier, newIdentity)
|
||||
.then(function(trusted) {
|
||||
.then(trusted => {
|
||||
if (trusted) {
|
||||
done(new Error('Allowed to overwrite identity key'));
|
||||
} else {
|
||||
|
|
@ -59,12 +57,12 @@ describe('SignalProtocolStore', function() {
|
|||
.catch(done);
|
||||
});
|
||||
});
|
||||
it('returns whether a key is untrusted', function(done) {
|
||||
var newIdentity = libsignal.crypto.getRandomBytes(33);
|
||||
store.saveIdentity(identifier, testKey.pubKey).then(function() {
|
||||
it('returns whether a key is untrusted', done => {
|
||||
const newIdentity = libsignal.crypto.getRandomBytes(33);
|
||||
store.saveIdentity(identifier, testKey.pubKey).then(() => {
|
||||
store
|
||||
.isTrustedIdentity(identifier, testKey.pubKey)
|
||||
.then(function(trusted) {
|
||||
.then(trusted => {
|
||||
if (trusted) {
|
||||
done();
|
||||
} else {
|
||||
|
|
@ -74,124 +72,117 @@ describe('SignalProtocolStore', function() {
|
|||
.catch(done);
|
||||
});
|
||||
});
|
||||
it('stores prekeys', function(done) {
|
||||
it('stores prekeys', done => {
|
||||
store
|
||||
.storePreKey(1, testKey)
|
||||
.then(function() {
|
||||
return store.loadPreKey(1).then(function(key) {
|
||||
.then(() =>
|
||||
store.loadPreKey(1).then(key => {
|
||||
assertEqualArrayBuffers(key.pubKey, testKey.pubKey);
|
||||
assertEqualArrayBuffers(key.privKey, testKey.privKey);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('deletes prekeys', function(done) {
|
||||
before(function(done) {
|
||||
it('deletes prekeys', done => {
|
||||
before(done => {
|
||||
store.storePreKey(2, testKey).then(done);
|
||||
});
|
||||
store
|
||||
.removePreKey(2, testKey)
|
||||
.then(function() {
|
||||
return store.loadPreKey(2).then(function(key) {
|
||||
.then(() =>
|
||||
store.loadPreKey(2).then(key => {
|
||||
assert.isUndefined(key);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('stores signed prekeys', function(done) {
|
||||
it('stores signed prekeys', done => {
|
||||
store
|
||||
.storeSignedPreKey(3, testKey)
|
||||
.then(function() {
|
||||
return store.loadSignedPreKey(3).then(function(key) {
|
||||
.then(() =>
|
||||
store.loadSignedPreKey(3).then(key => {
|
||||
assertEqualArrayBuffers(key.pubKey, testKey.pubKey);
|
||||
assertEqualArrayBuffers(key.privKey, testKey.privKey);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('deletes signed prekeys', function(done) {
|
||||
before(function(done) {
|
||||
it('deletes signed prekeys', done => {
|
||||
before(done => {
|
||||
store.storeSignedPreKey(4, testKey).then(done);
|
||||
});
|
||||
store
|
||||
.removeSignedPreKey(4, testKey)
|
||||
.then(function() {
|
||||
return store.loadSignedPreKey(4).then(function(key) {
|
||||
.then(() =>
|
||||
store.loadSignedPreKey(4).then(key => {
|
||||
assert.isUndefined(key);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('stores sessions', function(done) {
|
||||
var testRecord = 'an opaque string';
|
||||
var devices = [1, 2, 3].map(function(deviceId) {
|
||||
return [identifier, deviceId].join('.');
|
||||
});
|
||||
var promise = Promise.resolve();
|
||||
devices.forEach(function(encodedNumber) {
|
||||
promise = promise.then(function() {
|
||||
return store.storeSession(encodedNumber, testRecord + encodedNumber);
|
||||
});
|
||||
it('stores sessions', done => {
|
||||
const testRecord = 'an opaque string';
|
||||
const devices = [1, 2, 3].map(deviceId => [identifier, deviceId].join('.'));
|
||||
let promise = Promise.resolve();
|
||||
devices.forEach(encodedNumber => {
|
||||
promise = promise.then(() =>
|
||||
store.storeSession(encodedNumber, testRecord + encodedNumber)
|
||||
);
|
||||
});
|
||||
promise
|
||||
.then(function() {
|
||||
return Promise.all(devices.map(store.loadSession.bind(store))).then(
|
||||
function(records) {
|
||||
for (var i in records) {
|
||||
.then(() =>
|
||||
Promise.all(devices.map(store.loadSession.bind(store))).then(
|
||||
records => {
|
||||
for (const i in records) {
|
||||
assert.strictEqual(records[i], testRecord + devices[i]);
|
||||
}
|
||||
}
|
||||
);
|
||||
})
|
||||
)
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('removes all sessions for a number', function(done) {
|
||||
var testRecord = 'an opaque string';
|
||||
var devices = [1, 2, 3].map(function(deviceId) {
|
||||
return [identifier, deviceId].join('.');
|
||||
});
|
||||
var promise = Promise.resolve();
|
||||
devices.forEach(function(encodedNumber) {
|
||||
promise = promise.then(function() {
|
||||
return store.storeSession(encodedNumber, testRecord + encodedNumber);
|
||||
});
|
||||
it('removes all sessions for a number', done => {
|
||||
const testRecord = 'an opaque string';
|
||||
const devices = [1, 2, 3].map(deviceId => [identifier, deviceId].join('.'));
|
||||
let promise = Promise.resolve();
|
||||
devices.forEach(encodedNumber => {
|
||||
promise = promise.then(() =>
|
||||
store.storeSession(encodedNumber, testRecord + encodedNumber)
|
||||
);
|
||||
});
|
||||
promise
|
||||
.then(function() {
|
||||
return store.removeAllSessions(identifier).then(function(record) {
|
||||
return Promise.all(devices.map(store.loadSession.bind(store))).then(
|
||||
function(records) {
|
||||
for (var i in records) {
|
||||
.then(() =>
|
||||
store.removeAllSessions(identifier).then(record =>
|
||||
Promise.all(devices.map(store.loadSession.bind(store))).then(
|
||||
records => {
|
||||
for (const i in records) {
|
||||
assert.isUndefined(records[i]);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
})
|
||||
)
|
||||
)
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('returns deviceIds for a number', function(done) {
|
||||
var testRecord = 'an opaque string';
|
||||
var devices = [1, 2, 3].map(function(deviceId) {
|
||||
return [identifier, deviceId].join('.');
|
||||
});
|
||||
var promise = Promise.resolve();
|
||||
devices.forEach(function(encodedNumber) {
|
||||
promise = promise.then(function() {
|
||||
return store.storeSession(encodedNumber, testRecord + encodedNumber);
|
||||
});
|
||||
it('returns deviceIds for a number', done => {
|
||||
const testRecord = 'an opaque string';
|
||||
const devices = [1, 2, 3].map(deviceId => [identifier, deviceId].join('.'));
|
||||
let promise = Promise.resolve();
|
||||
devices.forEach(encodedNumber => {
|
||||
promise = promise.then(() =>
|
||||
store.storeSession(encodedNumber, testRecord + encodedNumber)
|
||||
);
|
||||
});
|
||||
promise
|
||||
.then(function() {
|
||||
return store.getDeviceIds(identifier).then(function(deviceIds) {
|
||||
.then(() =>
|
||||
store.getDeviceIds(identifier).then(deviceIds => {
|
||||
assert.sameMembers(deviceIds, [1, 2, 3]);
|
||||
});
|
||||
})
|
||||
})
|
||||
)
|
||||
.then(done, done);
|
||||
});
|
||||
it('returns empty array for a number with no device ids', function() {
|
||||
return store.getDeviceIds('foo').then(function(deviceIds) {
|
||||
it('returns empty array for a number with no device ids', () =>
|
||||
store.getDeviceIds('foo').then(deviceIds => {
|
||||
assert.sameMembers(deviceIds, []);
|
||||
});
|
||||
});
|
||||
}));
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,78 +1,76 @@
|
|||
'use strict';
|
||||
|
||||
describe('createTaskWithTimeout', function() {
|
||||
it('resolves when promise resolves', function() {
|
||||
var task = function() {
|
||||
describe('createTaskWithTimeout', () => {
|
||||
it('resolves when promise resolves', () => {
|
||||
const task = function() {
|
||||
return Promise.resolve('hi!');
|
||||
};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
|
||||
return taskWithTimeout().then(function(result) {
|
||||
return taskWithTimeout().then(result => {
|
||||
assert.strictEqual(result, 'hi!');
|
||||
});
|
||||
});
|
||||
it('flows error from promise back', function() {
|
||||
var error = new Error('original');
|
||||
var task = function() {
|
||||
it('flows error from promise back', () => {
|
||||
const error = new Error('original');
|
||||
const task = function() {
|
||||
return Promise.reject(error);
|
||||
};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
|
||||
return taskWithTimeout().catch(function(flowedError) {
|
||||
return taskWithTimeout().catch(flowedError => {
|
||||
assert.strictEqual(error, flowedError);
|
||||
});
|
||||
});
|
||||
it('rejects if promise takes too long (this one logs error to console)', function() {
|
||||
var error = new Error('original');
|
||||
var complete = false;
|
||||
var task = function() {
|
||||
return new Promise(function(resolve) {
|
||||
setTimeout(function() {
|
||||
const error = new Error('original');
|
||||
let complete = false;
|
||||
const task = function() {
|
||||
return new Promise(resolve => {
|
||||
setTimeout(() => {
|
||||
complete = true;
|
||||
resolve();
|
||||
}, 3000);
|
||||
});
|
||||
};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
|
||||
timeout: 10,
|
||||
});
|
||||
|
||||
return taskWithTimeout().then(
|
||||
function() {
|
||||
() => {
|
||||
throw new Error('it was not supposed to resolve!');
|
||||
},
|
||||
function() {
|
||||
() => {
|
||||
assert.strictEqual(complete, false);
|
||||
}
|
||||
);
|
||||
});
|
||||
it('resolves if task returns something falsey', function() {
|
||||
var task = function() {};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
it('resolves if task returns something falsey', () => {
|
||||
const task = function() {};
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
return taskWithTimeout();
|
||||
});
|
||||
it('resolves if task returns a non-promise', function() {
|
||||
var task = function() {
|
||||
it('resolves if task returns a non-promise', () => {
|
||||
const task = function() {
|
||||
return 'hi!';
|
||||
};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
return taskWithTimeout().then(function(result) {
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task);
|
||||
return taskWithTimeout().then(result => {
|
||||
assert.strictEqual(result, 'hi!');
|
||||
});
|
||||
});
|
||||
it('rejects if task throws (and does not log about taking too long)', function() {
|
||||
var error = new Error('Task is throwing!');
|
||||
var task = function() {
|
||||
const error = new Error('Task is throwing!');
|
||||
const task = function() {
|
||||
throw error;
|
||||
};
|
||||
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
|
||||
const taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
|
||||
timeout: 10,
|
||||
});
|
||||
return taskWithTimeout().then(
|
||||
function(result) {
|
||||
result => {
|
||||
throw new Error('Overall task should reject!');
|
||||
},
|
||||
function(flowedError) {
|
||||
flowedError => {
|
||||
assert.strictEqual(flowedError, error);
|
||||
}
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,14 +1,12 @@
|
|||
(function() {
|
||||
'use strict';
|
||||
|
||||
describe('WebSocket-Resource', function() {
|
||||
describe('requests and responses', function() {
|
||||
it('receives requests and sends responses', function(done) {
|
||||
describe('WebSocket-Resource', () => {
|
||||
describe('requests and responses', () => {
|
||||
it('receives requests and sends responses', done => {
|
||||
// mock socket
|
||||
var request_id = '1';
|
||||
var socket = {
|
||||
send: function(data) {
|
||||
var message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
const request_id = '1';
|
||||
const socket = {
|
||||
send(data) {
|
||||
const message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
assert.strictEqual(
|
||||
message.type,
|
||||
textsecure.protobuf.WebSocketMessage.Type.RESPONSE
|
||||
|
|
@ -18,12 +16,12 @@
|
|||
assert.strictEqual(message.response.id.toString(), request_id);
|
||||
done();
|
||||
},
|
||||
addEventListener: function() {},
|
||||
addEventListener() {},
|
||||
};
|
||||
|
||||
// actual test
|
||||
var resource = new WebSocketResource(socket, {
|
||||
handleRequest: function(request) {
|
||||
const resource = new WebSocketResource(socket, {
|
||||
handleRequest(request) {
|
||||
assert.strictEqual(request.verb, 'PUT');
|
||||
assert.strictEqual(request.path, '/some/path');
|
||||
assertEqualArrayBuffers(
|
||||
|
|
@ -52,12 +50,12 @@
|
|||
});
|
||||
});
|
||||
|
||||
it('sends requests and receives responses', function(done) {
|
||||
it('sends requests and receives responses', done => {
|
||||
// mock socket and request handler
|
||||
var request_id;
|
||||
var socket = {
|
||||
send: function(data) {
|
||||
var message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
let request_id;
|
||||
const socket = {
|
||||
send(data) {
|
||||
const message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
assert.strictEqual(
|
||||
message.type,
|
||||
textsecure.protobuf.WebSocketMessage.Type.REQUEST
|
||||
|
|
@ -70,17 +68,17 @@
|
|||
);
|
||||
request_id = message.request.id;
|
||||
},
|
||||
addEventListener: function() {},
|
||||
addEventListener() {},
|
||||
};
|
||||
|
||||
// actual test
|
||||
var resource = new WebSocketResource(socket);
|
||||
const resource = new WebSocketResource(socket);
|
||||
resource.sendRequest({
|
||||
verb: 'PUT',
|
||||
path: '/some/path',
|
||||
body: new Uint8Array([1, 2, 3]).buffer,
|
||||
error: done,
|
||||
success: function(message, status, request) {
|
||||
success(message, status, request) {
|
||||
assert.strictEqual(message, 'OK');
|
||||
assert.strictEqual(status, 200);
|
||||
done();
|
||||
|
|
@ -101,19 +99,19 @@
|
|||
});
|
||||
});
|
||||
|
||||
describe('close', function() {
|
||||
before(function() {
|
||||
describe('close', () => {
|
||||
before(() => {
|
||||
window.WebSocket = MockSocket;
|
||||
});
|
||||
after(function() {
|
||||
after(() => {
|
||||
window.WebSocket = WebSocket;
|
||||
});
|
||||
it('closes the connection', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', function(server) {
|
||||
it('closes the connection', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', server => {
|
||||
server.on('close', done);
|
||||
});
|
||||
var resource = new WebSocketResource(
|
||||
const resource = new WebSocketResource(
|
||||
new WebSocket('ws://localhost:8081')
|
||||
);
|
||||
resource.close();
|
||||
|
|
@ -121,18 +119,18 @@
|
|||
});
|
||||
|
||||
describe.skip('with a keepalive config', function() {
|
||||
before(function() {
|
||||
before(() => {
|
||||
window.WebSocket = MockSocket;
|
||||
});
|
||||
after(function() {
|
||||
after(() => {
|
||||
window.WebSocket = WebSocket;
|
||||
});
|
||||
this.timeout(60000);
|
||||
it('sends keepalives once a minute', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', function(server) {
|
||||
server.on('message', function(data) {
|
||||
var message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
it('sends keepalives once a minute', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', server => {
|
||||
server.on('message', data => {
|
||||
const message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
assert.strictEqual(
|
||||
message.type,
|
||||
textsecure.protobuf.WebSocketMessage.Type.REQUEST
|
||||
|
|
@ -148,11 +146,11 @@
|
|||
});
|
||||
});
|
||||
|
||||
it('uses / as a default path', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', function(server) {
|
||||
server.on('message', function(data) {
|
||||
var message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
it('uses / as a default path', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8081');
|
||||
mockServer.on('connection', server => {
|
||||
server.on('message', data => {
|
||||
const message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
assert.strictEqual(
|
||||
message.type,
|
||||
textsecure.protobuf.WebSocketMessage.Type.REQUEST
|
||||
|
|
@ -170,9 +168,9 @@
|
|||
|
||||
it('optionally disconnects if no response', function(done) {
|
||||
this.timeout(65000);
|
||||
var mockServer = new MockServer('ws://localhost:8081');
|
||||
var socket = new WebSocket('ws://localhost:8081');
|
||||
mockServer.on('connection', function(server) {
|
||||
const mockServer = new MockServer('ws://localhost:8081');
|
||||
const socket = new WebSocket('ws://localhost:8081');
|
||||
mockServer.on('connection', server => {
|
||||
server.on('close', done);
|
||||
});
|
||||
new WebSocketResource(socket, { keepalive: true });
|
||||
|
|
@ -180,12 +178,12 @@
|
|||
|
||||
it('allows resetting the keepalive timer', function(done) {
|
||||
this.timeout(65000);
|
||||
var mockServer = new MockServer('ws://localhost:8081');
|
||||
var socket = new WebSocket('ws://localhost:8081');
|
||||
var startTime = Date.now();
|
||||
mockServer.on('connection', function(server) {
|
||||
server.on('message', function(data) {
|
||||
var message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
const mockServer = new MockServer('ws://localhost:8081');
|
||||
const socket = new WebSocket('ws://localhost:8081');
|
||||
const startTime = Date.now();
|
||||
mockServer.on('connection', server => {
|
||||
server.on('message', data => {
|
||||
const message = textsecure.protobuf.WebSocketMessage.decode(data);
|
||||
assert.strictEqual(
|
||||
message.type,
|
||||
textsecure.protobuf.WebSocketMessage.Type.REQUEST
|
||||
|
|
@ -200,8 +198,8 @@
|
|||
done();
|
||||
});
|
||||
});
|
||||
var resource = new WebSocketResource(socket, { keepalive: true });
|
||||
setTimeout(function() {
|
||||
const resource = new WebSocketResource(socket, { keepalive: true });
|
||||
setTimeout(() => {
|
||||
resource.resetKeepAliveTimer();
|
||||
}, 5000);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,14 +1,14 @@
|
|||
describe('TextSecureWebSocket', function() {
|
||||
var RealWebSocket = window.WebSocket;
|
||||
before(function() {
|
||||
describe('TextSecureWebSocket', () => {
|
||||
const RealWebSocket = window.WebSocket;
|
||||
before(() => {
|
||||
window.WebSocket = MockSocket;
|
||||
});
|
||||
after(function() {
|
||||
after(() => {
|
||||
window.WebSocket = RealWebSocket;
|
||||
});
|
||||
it('connects and disconnects', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8080');
|
||||
mockServer.on('connection', function(server) {
|
||||
it('connects and disconnects', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8080');
|
||||
mockServer.on('connection', server => {
|
||||
socket.close();
|
||||
server.close();
|
||||
done();
|
||||
|
|
@ -16,15 +16,15 @@ describe('TextSecureWebSocket', function() {
|
|||
var socket = new TextSecureWebSocket('ws://localhost:8080');
|
||||
});
|
||||
|
||||
it('sends and receives', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8080');
|
||||
mockServer.on('connection', function(server) {
|
||||
server.on('message', function(data) {
|
||||
it('sends and receives', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8080');
|
||||
mockServer.on('connection', server => {
|
||||
server.on('message', data => {
|
||||
server.send('ack');
|
||||
server.close();
|
||||
});
|
||||
});
|
||||
var socket = new TextSecureWebSocket('ws://localhost:8080');
|
||||
const socket = new TextSecureWebSocket('ws://localhost:8080');
|
||||
socket.onmessage = function(response) {
|
||||
assert.strictEqual(response.data, 'ack');
|
||||
socket.close();
|
||||
|
|
@ -33,9 +33,9 @@ describe('TextSecureWebSocket', function() {
|
|||
socket.send('syn');
|
||||
});
|
||||
|
||||
it('exposes the socket status', function(done) {
|
||||
var mockServer = new MockServer('ws://localhost:8082');
|
||||
mockServer.on('connection', function(server) {
|
||||
it('exposes the socket status', done => {
|
||||
const mockServer = new MockServer('ws://localhost:8082');
|
||||
mockServer.on('connection', server => {
|
||||
assert.strictEqual(socket.getStatus(), WebSocket.OPEN);
|
||||
server.close();
|
||||
socket.close();
|
||||
|
|
@ -49,11 +49,11 @@ describe('TextSecureWebSocket', function() {
|
|||
|
||||
it('reconnects', function(done) {
|
||||
this.timeout(60000);
|
||||
var mockServer = new MockServer('ws://localhost:8082');
|
||||
var socket = new TextSecureWebSocket('ws://localhost:8082');
|
||||
const mockServer = new MockServer('ws://localhost:8082');
|
||||
const socket = new TextSecureWebSocket('ws://localhost:8082');
|
||||
socket.onclose = function() {
|
||||
var mockServer = new MockServer('ws://localhost:8082');
|
||||
mockServer.on('connection', function(server) {
|
||||
const mockServer = new MockServer('ws://localhost:8082');
|
||||
mockServer.on('connection', server => {
|
||||
socket.close();
|
||||
server.close();
|
||||
done();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue