Refactor complete public api to use promises

.jshintrc

@@ -0,0 +1,39 @@
+{
+	"indent": 2,
+	"strict": true,
+	"globalstrict": true,
+	"node": true,
+	"browser": true,
+	"nonew": true,
+	"curly": true,
+	"eqeqeq": true,
+	"immed": true,
+	"newcap": true,
+	"regexp": true,
+	"evil": true,
+	"eqnull": true,
+	"expr": true,
+	"trailing": true,
+	"undef": true,
+	"unused": true,
+
+	"predef": [
+			"console",
+			"Promise",
+			"importScripts",
+			"process",
+			"Event",
+			"self",
+			"describe",
+			"it",
+			"sinon",
+			"mocha",
+            "before",
+            "beforeEach",
+            "after",
+            "afterEach"
+	],
+
+	"globals": {
+	}
+}

Gruntfile.js

@@ -38,7 +38,7 @@ module.exports = function(grunt) {
           'test/lib/unittests-bundle.js': [ './test/unittests.js' ]
         },
         options: {
-          external: [ 'openpgp', 'crypto', 'node-localstorage' ]
+          external: [ 'openpgp', 'crypto', 'node-localstorage', 'es6-promise']
         }
       }
     },
@@ -116,7 +116,7 @@ module.exports = function(grunt) {
         expand: true,
         flatten: true,
         cwd: 'node_modules/',
-        src: ['mocha/mocha.css', 'mocha/mocha.js', 'chai/chai.js'],
+        src: ['mocha/mocha.css', 'mocha/mocha.js', 'chai/chai.js', 'es6-promise/dist/promise*.js'],
         dest: 'test/lib/'
       }
     },

package.json

@@ -29,6 +29,7 @@
   "devDependencies": {
     "browserify": "~2.35",
     "chai": "~1.8.1",
+    "es6-promise": "1.0.0",
     "grunt": "~0.4.2",
     "grunt-browserify": "~1.2.11",
     "grunt-cli": "~0.1.13",

src/cleartext.js

@@ -23,6 +23,8 @@
  * @module cleartext
  */
 
+'use strict';
+
 var config = require('./config'),
   packet = require('./packet'),
   enums = require('./enums.js'),

src/enums.js

@@ -1,3 +1,5 @@
+'use strict';
+
 /**
  * @module enums
  */

src/index.js

@@ -1,3 +1,4 @@
+'use strict';
 
 module.exports = require('./openpgp.js');
 /**

src/key.js

@@ -23,6 +23,8 @@
  * @module key
  */
 
+'use strict';
+
 var packet = require('./packet'),
   enums = require('./enums.js'),
   armor = require('./encoding/armor.js'),

src/message.js

@@ -24,6 +24,8 @@
  * @module message
  */
 
+'use strict';
+
 var packet = require('./packet'),
   enums = require('./enums.js'),
   armor = require('./encoding/armor.js'),

src/openpgp.js

@@ -31,10 +31,10 @@
  * @module openpgp
  */
 
+'use strict';
+
 var armor = require('./encoding/armor.js'),
-  packet = require('./packet'),
   enums = require('./enums.js'),
-  config = require('./config'),
   message = require('./message.js'),
   cleartext = require('./cleartext.js'),
   key = require('./key.js'),
@@ -55,18 +55,16 @@ function initWorker(path) {
  * Encrypts message text with keys
  * @param  {(Array<module:key~Key>|module:key~Key)}  keys array of keys or single key, used to encrypt the message
  * @param  {String} text message as native JavaScript string
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {String}      encrypted ASCII armored message
  * @static
  */
-function encryptMessage(keys, text, callback) {
+function encryptMessage(keys, text) {
   if (!keys.length) {
     keys = [keys];
   }
 
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.encryptMessage(keys, text, callback);
+    return asyncProxy.encryptMessage(keys, text);
-    return;
   }
 
   return execute(function() {
@@ -75,7 +73,7 @@ function encryptMessage(keys, text, callback) {
     msg = msg.encrypt(keys);
     armored = armor.encode(enums.armor.message, msg.packets.write());
     return armored;
-  }, callback);
+  });
 }
 
 /**
@@ -83,18 +81,16 @@ function encryptMessage(keys, text, callback) {
  * @param  {(Array<module:key~Key>|module:key~Key)}  publicKeys array of keys or single key, used to encrypt the message
  * @param  {module:key~Key}    privateKey private key with decrypted secret key data for signing
  * @param  {String} text       message as native JavaScript string
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {String}            encrypted ASCII armored message
  * @static
  */
-function signAndEncryptMessage(publicKeys, privateKey, text, callback) {
+function signAndEncryptMessage(publicKeys, privateKey, text) {
   if (!publicKeys.length) {
     publicKeys = [publicKeys];
   }
 
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.signAndEncryptMessage(publicKeys, privateKey, text, callback);
+    return asyncProxy.signAndEncryptMessage(publicKeys, privateKey, text);
-    return;
   }
 
   return execute(function() {
@@ -104,28 +100,26 @@ function signAndEncryptMessage(publicKeys, privateKey, text, callback) {
     msg = msg.encrypt(publicKeys);
     armored = armor.encode(enums.armor.message, msg.packets.write());
     return armored;
-  }, callback);
+  });
 }
 
 /**
  * Decrypts message
  * @param  {module:key~Key}     privateKey private key with decrypted secret key data
  * @param  {module:message~Message} msg    the message object with the encrypted data
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {(String|null)}        decrypted message as as native JavaScript string
  *                              or null if no literal data found
  * @static
  */
-function decryptMessage(privateKey, msg, callback) {
+function decryptMessage(privateKey, msg) {
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.decryptMessage(privateKey, msg, callback);
+    return asyncProxy.decryptMessage(privateKey, msg);
-    return;
   }
 
   return execute(function() {
     msg = msg.decrypt(privateKey);
     return msg.getText();
-  }, callback);
+  });
 }
 
 /**
@@ -133,20 +127,18 @@ function decryptMessage(privateKey, msg, callback) {
  * @param  {module:key~Key}     privateKey private key with decrypted secret key data
  * @param  {(Array<module:key~Key>|module:key~Key)}  publicKeys array of keys or single key, to verify signatures
  * @param  {module:message~Message} msg    the message object with signed and encrypted data
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {{text: String, signatures: Array<{keyid: module:type/keyid, valid: Boolean}>}}
  *                              decrypted message as as native JavaScript string
  *                              with verified signatures or null if no literal data found
  * @static
  */
-function decryptAndVerifyMessage(privateKey, publicKeys, msg, callback) {
+function decryptAndVerifyMessage(privateKey, publicKeys, msg) {
   if (!publicKeys.length) {
     publicKeys = [publicKeys];
   }
 
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.decryptAndVerifyMessage(privateKey, publicKeys, msg, callback);
+    return asyncProxy.decryptAndVerifyMessage(privateKey, publicKeys, msg);
-    return;
   }
 
   return execute(function() {
@@ -158,51 +150,47 @@ function decryptAndVerifyMessage(privateKey, publicKeys, msg, callback) {
       return result;
     }
     return null;
-  }, callback);
+  });
 }
 
 /**
  * Signs a cleartext message
  * @param  {(Array<module:key~Key>|module:key~Key)}  privateKeys array of keys or single key with decrypted secret key data to sign cleartext
  * @param  {String} text        cleartext
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {String}             ASCII armored message
  * @static
  */
-function signClearMessage(privateKeys, text, callback) {
+function signClearMessage(privateKeys, text) {
   if (!privateKeys.length) {
     privateKeys = [privateKeys];
   }
 
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.signClearMessage(privateKeys, text, callback);
+    return asyncProxy.signClearMessage(privateKeys, text);
-    return;
   }
 
   return execute(function() {
     var cleartextMessage = new cleartext.CleartextMessage(text);
     cleartextMessage.sign(privateKeys);
     return cleartextMessage.armor();
-  }, callback);
+  });
 }
 
 /**
  * Verifies signatures of cleartext signed message
  * @param  {(Array<module:key~Key>|module:key~Key)}  publicKeys array of keys or single key, to verify signatures
  * @param  {module:cleartext~CleartextMessage} msg    cleartext message object with signatures
- * @param  {function} callback (optional) callback(error, result) for async style
  * @return {{text: String, signatures: Array<{keyid: module:type/keyid, valid: Boolean}>}}
  *                                       cleartext with status of verified signatures
  * @static
  */
-function verifyClearSignedMessage(publicKeys, msg, callback) {
+function verifyClearSignedMessage(publicKeys, msg) {
   if (!publicKeys.length) {
     publicKeys = [publicKeys];
   }
 
-  if (useWorker(callback)) {
+  if (useWorker()) {
-    asyncProxy.verifyClearSignedMessage(publicKeys, msg, callback);
+    return asyncProxy.verifyClearSignedMessage(publicKeys, msg);
-    return;
   }
 
   return execute(function() {
@@ -213,7 +201,7 @@ function verifyClearSignedMessage(publicKeys, msg, callback) {
     result.text = msg.getText();
     result.signatures = msg.verify(publicKeys);
     return result;
-  }, callback);
+  });
 }
 
 /**
@@ -225,15 +213,13 @@ function verifyClearSignedMessage(publicKeys, msg, callback) {
  * @param {String}  options.userId     assumes already in form of "User Name <username@email.com>"
  * @param {String}  options.passphrase The passphrase used to encrypt the resulting private key
  * @param {Boolean} [options.unlocked=false]    The secret part of the generated key is unlocked
- * @param  {function} callback(error, result) The required callback
  * @return {Object} {key: module:key~Key, privateKeyArmored: String, publicKeyArmored: String}
  * @static
  */
 function generateKeyPair(options) {
   // use web worker if web crypto apis are not supported
   if (!util.getWebCrypto() && useWorker()) {
-    asyncProxy.generateKeyPair(options);
+    return asyncProxy.generateKeyPair(options);
-    return;
   }
 
   return key.generate(options).then(function(newKey) {
@@ -243,10 +229,7 @@ function generateKeyPair(options) {
     result.publicKeyArmored = newKey.toPublic().armor();
     return result;
 
-  }).catch(function(err) {
+  }).catch(onError.bind(null, 'Error generating keypair!'));
-    console.error(err.stack);
-    throw new Error('Error generating keypair!');
-  });
 }
 
 //
@@ -270,28 +253,36 @@ function useWorker(callback) {
 }
 
 /**
- * Command pattern that handles async calls gracefully
+ * Command pattern that wraps synchronous code into a promise
+ * @param  {function} cmd     The synchronous function with a return value
+ *                            to be wrapped in a promise
+ * @param  {String}   errMsg  A human readable error Message
+ * @return {Promise}          The promise wrapped around cmd
  */
-function execute(cmd, callback) {
+function execute(cmd, errMsg) {
-  var result;
+  // wrap the sync cmd in a promise
+  var promise = new Promise(function(resolve) {
+    var result = cmd();
+    resolve(result);
+  });
 
-  try {
+  // handler error globally
-    result = cmd();
+  promise.catch(onError.bind(null, errMsg));
-  } catch (err) {
+
-    if (callback) {
+  return promise;
-      callback(err);
-      return;
 }
 
-    throw err;
+/**
-  }
+ * Global error handler that logs the stack trace and
-
+ *   rethrows a high lvl error message
-  if (callback) {
+ * @param  {String} message   A human readable high level error Message
-    callback(null, result);
+ * @param  {Error}  error     The internal error that caused the failure
-    return;
+ */
-  }
+function onError(message, error) {
-
+  // log the stack trace
-  return result;
+  console.error(error.stack);
+  // rethrow new high level error for api users
+  throw new Error(message);
 }
 
 exports.initWorker = initWorker;

src/util.js

@@ -21,6 +21,8 @@
  * @module util
  */
 
+'use strict';
+
 var config = require('./config');
 
 module.exports = {

test/general/basic.js

@@ -10,16 +10,16 @@ describe('Basic', function() {
   describe("Key generation/encryption/decryption", function() {
     var testHelper = function(passphrase, userid, message, done) {
       var opt = {numBits: 512, userId: userid, passphrase: passphrase};
-      openpgp.generateKeyPair(opt, function(err, key) {
+      var privKey;
-        expect(err).to.not.exist;
+      var pubKey;
+
+      openpgp.generateKeyPair(opt).then(function(key) {
 
         expect(key).to.exist;
         expect(key.key).to.exist;
         expect(key.privateKeyArmored).to.exist;
         expect(key.publicKeyArmored).to.exist;
 
-        var info = '\npassphrase: ' + passphrase + '\n' + 'userid: ' + userid + '\n' + 'message: ' + message;
-
         var privKeys = openpgp.key.readArmored(key.privateKeyArmored);
         var publicKeys = openpgp.key.readArmored(key.publicKeyArmored);
 
@@ -27,29 +27,28 @@ describe('Basic', function() {
         expect(privKeys.err).to.not.exist;
         expect(privKeys.keys).to.have.length(1);
 
-        var privKey = privKeys.keys[0];
+        privKey = privKeys.keys[0];
-        var pubKey = publicKeys.keys[0];
+        pubKey = publicKeys.keys[0];
 
         expect(privKey).to.exist;
         expect(pubKey).to.exist;
 
         var success = privKey.decrypt(passphrase);
-
         expect(success).to.be.true;
 
-        var encrypted = openpgp.signAndEncryptMessage([pubKey], privKey, message);
+        return openpgp.signAndEncryptMessage([pubKey], privKey, message);
+
+      }).then(function(encrypted) {
 
         expect(encrypted).to.exist;
-
         var msg = openpgp.message.readArmored(encrypted);
-
         expect(msg).to.exist;
-
         var keyids = msg.getEncryptionKeyIds();
-
         expect(keyids).to.exist;
 
-        var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], msg);
+        return openpgp.decryptAndVerifyMessage(privKey, [pubKey], msg);
+
+      }).then(function(decrypted) {
         expect(decrypted).to.exist;
         expect(decrypted.signatures[0].valid).to.be.true;
         expect(decrypted.text).to.equal(message);
@@ -69,35 +68,44 @@ describe('Basic', function() {
       var userid = 'Test McTestington <test@example.com>';
       var passphrase = 'password';
       var message = 'hello world';
+      var privKey;
+      var pubKey;
+      var msg;
 
       var opt = {numBits: 512, userId: userid, passphrase: passphrase};
-      openpgp.generateKeyPair(opt, function(err, key) {
+      openpgp.generateKeyPair(opt).then(function(key) {
-        expect(err).to.not.exist;
 
         var privKeys = openpgp.key.readArmored(key.privateKeyArmored);
         var publicKeys = openpgp.key.readArmored(key.publicKeyArmored);
 
-        var privKey = privKeys.keys[0];
+        privKey = privKeys.keys[0];
-        var pubKey = publicKeys.keys[0];
+        pubKey = publicKeys.keys[0];
 
         var success = privKey.decrypt(passphrase);
+        expect(success).to.be.true;
 
-        var encrypted = openpgp.signAndEncryptMessage([pubKey], privKey, message);
+        return openpgp.signAndEncryptMessage([pubKey], privKey, message);
 
-        var msg = openpgp.message.readArmored(encrypted);
+      }).then(function(encrypted) {
+
+        msg = openpgp.message.readArmored(encrypted);
         expect(msg).to.exist;
 
-        openpgp.generateKeyPair(opt, function(err, anotherKey) {
+        return openpgp.generateKeyPair(opt);
-          expect(err).to.not.exist;
+
+      }).then(function(anotherKey) {
 
         var anotherPubKey = openpgp.key.readArmored(anotherKey.publicKeyArmored).keys[0];
 
-          var decrypted = openpgp.decryptAndVerifyMessage(privKey, [anotherPubKey], msg);
+        return openpgp.decryptAndVerifyMessage(privKey, [anotherPubKey], msg);
+
+      }).then(function(decrypted) {
+
         expect(decrypted).to.exist;
         expect(decrypted.signatures[0].valid).to.be.null;
         expect(decrypted.text).to.equal(message);
         done();
-        });
+
       });
     });
 
@@ -105,7 +113,9 @@ describe('Basic', function() {
       // init test data
       function randomString(length, chars) {
         var result = '';
-        for (var i = length; i > 0; --i) result += chars[Math.round(Math.random() * (chars.length - 1))];
+        for (var i = length; i > 0; --i) {
+          result += chars[Math.round(Math.random() * (chars.length - 1))];
+        }
         return result;
       }
       var message = randomString(1024*1024*3, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
@@ -114,10 +124,7 @@ describe('Basic', function() {
       var passphrase = 'password';
 
       var opt = {numBits: 512, userId: userid, passphrase: passphrase};
-      openpgp.generateKeyPair(opt, function(err, key) {
+      openpgp.generateKeyPair(opt).then(function(key) {
-        expect(err).to.not.exist;
-
-        var info = '\npassphrase: ' + passphrase + '\n' + 'userid: ' + userid + '\n' + 'message: ' + message;
 
         var privKeys = openpgp.key.readArmored(key.privateKeyArmored);
         var publicKeys = openpgp.key.readArmored(key.publicKeyArmored);
@@ -126,6 +133,7 @@ describe('Basic', function() {
         var pubKey = publicKeys.keys[0];
 
         var success = privKey.decrypt(passphrase);
+        expect(success).to.be.true;
 
         if (console.profile) {
           console.profile("encrypt/sign/verify/decrypt");
@@ -148,13 +156,15 @@ describe('Basic', function() {
 
         expect(keyids).to.exist;
 
-        var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], msg);
+        return openpgp.decryptAndVerifyMessage(privKey, [pubKey], msg);
+
+      }).then(function(decrypted) {
 
         expect(decrypted).to.exist;
         expect(decrypted.signatures[0].valid).to.be.true;
         expect(decrypted.text).to.equal(message);
-
         done();
+
       });
     });
   });
@@ -240,7 +250,7 @@ describe('Basic', function() {
 
       expect(pubKey).to.exist;
 
-      var encrypted = openpgp.encryptMessage([pubKey], plaintext);
+      openpgp.encryptMessage([pubKey], plaintext).then(function(encrypted) {
 
         expect(encrypted).to.exist;
 
@@ -264,6 +274,9 @@ describe('Basic', function() {
         expect(keyids).to.exist;
         expect(keyids).to.have.length(1);
         done();
+
+      });
+
     });
 
     it('Decrypting key packet with wrong password returns false', function (done) {
@@ -274,16 +287,12 @@ describe('Basic', function() {
       done();
     });
 
-    var decrypted, error;
-
     it('Calling decryptMessage with not decrypted key packet leads to exception', function (done) {
-      function exceptionTest() {
+      openpgp.decryptMessage(privKey, message).catch(function(error) {
-        decrypted = openpgp.decryptMessage(privKey, message);
+        expect(error).to.exist;
-      }
-
-      expect(exceptionTest).to.throw(Error);
         done();
       });
+    });
 
     it('Decrypting key packet with correct password returns true', function (done) {
       var success = privKey.decryptKeyPacket(keyids, 'hello world');
@@ -293,16 +302,23 @@ describe('Basic', function() {
     });
 
     it('Encrypt plain text and afterwards decrypt leads to same result', function (done) {
-      decrypted = openpgp.decryptMessage(privKey, message);
+      openpgp.decryptMessage(privKey, message).then(function(decrypted) {
         expect(decrypted).to.exist;
         expect(decrypted).to.equal(plaintext);
         done();
       });
+    });
 
-    it('Decrypt message 2x', function() {
+    it('Decrypt message 2x', function(done) {
-      decrypted = openpgp.decryptMessage(privKey, message);
+      var decrypted1;
-      var decrypted2 = openpgp.decryptMessage(privKey, message);
+
-      expect(decrypted).to.equal(decrypted2);
+      openpgp.decryptMessage(privKey, message).then(function(decrypted) {
+        decrypted1 = decrypted;
+        return openpgp.decryptMessage(privKey, message);
+      }).then(function(decrypted2) {
+        expect(decrypted1).to.equal(decrypted2);
+        done();
+      });
     });
 
   });
@@ -360,16 +376,18 @@ describe('Basic', function() {
         '-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
 
     it('Decrypt message', function (done) {
-      var privKey, message, decrypted;
+      var privKey, message;
 
       privKey = openpgp.key.readArmored(priv_key).keys[0];
       privKey.decrypt('1234');
       message = openpgp.message.readArmored(pgp_msg);
-      decrypted = openpgp.decryptMessage(privKey, message);
 
+      openpgp.decryptMessage(privKey, message).then(function(decrypted) {
         expect(decrypted).to.equal('hello 3des\n');
         done();
       });
+
+    });
   });
 
   describe("Misc.", function() {

test/general/key.js

@@ -635,8 +635,7 @@ var pgp_desktop_priv =
       expect(key.users[0].selfCertifications[0].features).to.eql(openpgp.config.integrity_protect ? [1] : null); // modification detection
     };
     var opt = {numBits: 512, userId: 'test', passphrase: 'hello'};
-    openpgp.generateKeyPair(opt, function(err, key) {
+    openpgp.generateKeyPair(opt).then(function(key) {
-      expect(err).to.not.exist;
       testPref(key.key);
       testPref(openpgp.key.readArmored(key.publicKeyArmored).keys[0]);
       done();
@@ -659,8 +658,7 @@ var pgp_desktop_priv =
 
   it('Generated key is not unlocked by default', function(done) {
     var opt = {numBits: 512, userId: 'test', passphrase: '123'};
-    openpgp.generateKeyPair(opt, function(err, key) {
+    openpgp.generateKeyPair(opt).then(function(key) {
-      expect(err).to.not.exist;
       var msg = openpgp.message.fromText('hello').encrypt([key.key]);
       msg = msg.decrypt.bind(msg, key.key);
       expect(msg).to.throw('Private key is not decrypted.');

test/general/packet.js

@@ -119,11 +119,9 @@ describe("Packet", function() {
   it('Public key encrypted symmetric key packet', function(done) {
     var rsa = new openpgp.crypto.publicKey.rsa();
 
-    rsa.generate(512, "10001", function(error, mpiGen) {
+    rsa.generate(512, "10001").then(function(mpiGen) {
-      expect(error).to.not.exist;
 
       var mpi = [mpiGen.n, mpiGen.ee, mpiGen.d, mpiGen.p, mpiGen.q, mpiGen.u];
-
       mpi = mpi.map(function(k) {
         var mpi = new openpgp.MPI();
         mpi.fromBigInteger(k);
@@ -380,15 +378,12 @@ describe("Packet", function() {
 
   it('Writing and encryption of a secret key packet.', function(done) {
     var key = new openpgp.packet.List();
-    key.push(new openpgp.packet.SecretKey);
+    key.push(new openpgp.packet.SecretKey());
 
     var rsa = new openpgp.crypto.publicKey.rsa();
 
-    rsa.generate(512, "10001", function(err, mipGen) {
+    rsa.generate(512, "10001").then(function(mipGen) {
-        expect(err).to.not.exist;
-
       var mpi = [mipGen.n, mipGen.ee, mipGen.d, mipGen.p, mipGen.q, mipGen.u];
-
       mpi = mpi.map(function(k) {
         var mpi = new openpgp.MPI();
         mpi.fromBigInteger(k);
@@ -413,13 +408,10 @@ describe("Packet", function() {
   it('Writing and verification of a signature packet.', function(done) {
     var key = new openpgp.packet.SecretKey();
 
-    var rsa = new openpgp.crypto.publicKey.rsa;
+    var rsa = new openpgp.crypto.publicKey.rsa();
-
-    rsa.generate(512, "10001", function(err, mpiGen) {
-        expect(err).to.not.exist;
 
+    rsa.generate(512, "10001").then(function(mpiGen) {
         var mpi = [mpiGen.n, mpiGen.ee, mpiGen.d, mpiGen.p, mpiGen.q, mpiGen.u];
-
         mpi = mpi.map(function(k) {
           var mpi = new openpgp.MPI();
           mpi.fromBigInteger(k);

test/general/signature.js

@@ -262,11 +262,12 @@ describe("Signature", function() {
     var pub_key = openpgp.key.readArmored(pub_key_arm1).keys[0];
     var msg = openpgp.message.readArmored(msg_arm1);
     priv_key.decrypt("abcd");
-    var decrypted = openpgp.decryptAndVerifyMessage(priv_key, [pub_key], msg);
+    openpgp.decryptAndVerifyMessage(priv_key, [pub_key], msg).then(function(decrypted) {
       expect(decrypted).to.exist;
       expect(decrypted.signatures[0].valid).to.be.true;
       done();
     });
+  });
 
   it('Testing GnuPG stripped-key extensions', function(done) {
     // exercises the GnuPG s2k type 1001 extension:
@@ -383,14 +384,14 @@ describe("Signature", function() {
     var keyids = esMsg.getEncryptionKeyIds();
     privKey.decryptKeyPacket(keyids, 'hello world');
 
-    var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg);
+    openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg).then(function(decrypted) {
-
       expect(decrypted).to.exist;
       expect(decrypted.text).to.equal(plaintext);
       expect(decrypted.signatures).to.have.length(1);
       expect(decrypted.signatures[0].valid).to.be.true;
       done();
     });
+  });
 
   it('Verify signature of signed and encrypted message from PGP 10.3.0 with openpgp.decryptAndVerifyMessage', function(done) {
     var msg_armor =
@@ -419,8 +420,7 @@ describe("Signature", function() {
     var keyids = esMsg.getEncryptionKeyIds();
     privKey.decryptKeyPacket(keyids, 'hello world');
 
-    var decrypted = openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg);
+    openpgp.decryptAndVerifyMessage(privKey, [pubKey], esMsg).then(function(decrypted) {
-
       expect(decrypted).to.exist;
       expect(decrypted.text).to.equal(plaintext);
       expect(decrypted.signatures).to.have.length(1);
@@ -428,6 +428,8 @@ describe("Signature", function() {
       done();
     });
 
+  });
+
   it('Verify signed message with two one pass signatures', function(done) {
     var msg_armor =
       [ '-----BEGIN PGP MESSAGE-----',
@@ -504,8 +506,7 @@ describe("Signature", function() {
     expect(pubKey2.getKeyPacket(keyids)).to.exist;
     expect(pubKey3.getKeyPacket(keyids)).to.exist;
 
-    var cleartextSig = openpgp.verifyClearSignedMessage([pubKey2, pubKey3], csMsg);
+    openpgp.verifyClearSignedMessage([pubKey2, pubKey3], csMsg).then(function(cleartextSig) {
-
       expect(cleartextSig).to.exist;
       expect(cleartextSig.text).to.equal(plaintext);
       expect(cleartextSig.signatures).to.have.length(2);
@@ -513,6 +514,7 @@ describe("Signature", function() {
       expect(cleartextSig.signatures[1].valid).to.be.true;
       done();
     });
+  });
 
   it('Sign text with openpgp.signClearMessage and verify with openpgp.verifyClearSignedMessage leads to same cleartext and valid signatures', function(done) {
     var plaintext = 'short message\nnext line\n한국어/조선말';
@@ -520,12 +522,12 @@ describe("Signature", function() {
     var privKey = openpgp.key.readArmored(priv_key_arm2).keys[0];
     privKey.getSigningKeyPacket().decrypt('hello world');
 
-    var clearSignedArmor = openpgp.signClearMessage([privKey], plaintext);
+    openpgp.signClearMessage([privKey], plaintext).then(function(clearSignedArmor) {
 
       var csMsg = openpgp.cleartext.readArmored(clearSignedArmor);
+      return openpgp.verifyClearSignedMessage([pubKey], csMsg);
 
-    var cleartextSig = openpgp.verifyClearSignedMessage([pubKey], csMsg);
+    }).then(function(cleartextSig) {
-
       expect(cleartextSig).to.exist;
       expect(cleartextSig.text).to.equal(plaintext.replace(/\r/g,''));
       expect(cleartextSig.signatures).to.have.length(1);
@@ -533,6 +535,8 @@ describe("Signature", function() {
       done();
     });
 
+  });
+
   it('Verify primary key revocation signature', function(done) {
     var pubKey = openpgp.key.readArmored(pub_revoked).keys[0];
 
@@ -638,9 +642,7 @@ describe("Signature", function() {
 
   it('Sign message with key without password', function(done) {
     var opt = {numBits: 512, userId: 'ABC', passphrase: null};
-    openpgp.generateKeyPair(opt, function(err, gen) {
+    openpgp.generateKeyPair(opt).then(function(gen) {
-      expect(err).to.not.exist;
-
       var key = gen.key;
 
       var message = openpgp.message.fromText('hello world');

test/unittests.html

@@ -9,7 +9,10 @@
   <body>
     <div id="mocha"></div>
 
-    <!--<script src="lib/jquery.min.js"></script>-->
+    <!-- polyfills -->
+    <script src="lib/promise-1.0.0.js"></script>
+
+    <!-- libs -->
     <script src="../dist/openpgp.js"></script>
     <script src="lib/chai.js"></script>
     <script src="lib/mocha.js"></script>

test/unittests.js

@@ -1,3 +1,8 @@
+if (typeof window === 'undefined') {
+  // load ES6 Promises polyfill under node.js
+  require('es6-promise').polyfill();
+}
+
 describe('Unit Tests', function () {
   require('./general');
   require('./crypto');