Port to soledad new async API

4 files changed, 442 insertions, 360 deletions

diff --git a/src/leap/keymanager/tests/__init__.py b/src/leap/keymanager/tests/__init__.py
index 1ea33b5..05b4487 100644
--- a/src/leap/keymanager/tests/__init__.py
+++ b/src/leap/keymanager/tests/__init__.py
@@ -18,37 +18,25 @@
 Base classes for the Key Manager tests.
 """
 
-from mock import Mock
+from twisted.internet.defer import gatherResults
+from twisted.trial import unittest
 
 from leap.common.testing.basetest import BaseLeapTest
 from leap.soledad.client import Soledad
 from leap.keymanager import KeyManager
+from leap.keymanager.openpgp import OpenPGPKey
 
 
 ADDRESS = 'leap@leap.se'
+ADDRESS_2 = 'anotheruser@leap.se'
 # XXX discover the gpg binary path
 GPG_BINARY_PATH = '/usr/bin/gpg'
 
 
-class KeyManagerWithSoledadTestCase(BaseLeapTest):
+class KeyManagerWithSoledadTestCase(unittest.TestCase, BaseLeapTest):
 
     def setUp(self):
-        # mock key fetching and storing so Soledad doesn't fail when trying to
-        # reach the server.
-        Soledad._get_secrets_from_shared_db = Mock(return_value=None)
-        Soledad._put_secrets_in_shared_db = Mock(return_value=None)
-
-        class MockSharedDB(object):
-
-            get_doc = Mock(return_value=None)
-            put_doc = Mock()
-            lock = Mock(return_value=('atoken', 300))
-            unlock = Mock(return_value=True)
-
-            def __call__(self):
-                return self
-
-        Soledad._shared_db = MockSharedDB()
+        self.setUpEnv()
 
         self._soledad = Soledad(
             u"leap@leap.se",
@@ -58,14 +46,32 @@ class KeyManagerWithSoledadTestCase(BaseLeapTest):
             server_url='',
             cert_file=None,
             auth_token=None,
+            syncable=False
         )
 
     def tearDown(self):
         km = self._key_manager()
-        for key in km.get_all_keys():
-            km._wrapper_map[key.__class__].delete_key(key)
-        for key in km.get_all_keys(private=True):
-            km._wrapper_map[key.__class__].delete_key(key)
+
+        def delete_keys(keys):
+            deferreds = []
+            for key in keys:
+                d = km._wrapper_map[key.__class__].delete_key(key)
+                deferreds.append(d)
+            return gatherResults(deferreds)
+
+        def get_and_delete_keys(_):
+            deferreds = []
+            for private in [True, False]:
+                d = km.get_all_keys(private=private)
+                d.addCallback(delete_keys)
+                deferreds.append(d)
+            return gatherResults(deferreds)
+
+        # wait for the indexes to be ready for the tear down
+        d = km._wrapper_map[OpenPGPKey].deferred_indexes
+        d.addCallback(get_and_delete_keys)
+        d.addCallback(lambda _: self.tearDownEnv())
+        return d
 
     def _key_manager(self, user=ADDRESS, url='', token=None):
         return KeyManager(user, url, self._soledad, token=token,
@@ -234,3 +240,62 @@ RZXoH+FTg9UAW87eqU610npOkT6cRaBxaMK/mDtGNdc=
 =JTFu
 -----END PGP PRIVATE KEY BLOCK-----
 """
+
+# key 7FEE575A: public key "anotheruser <anotheruser@leap.se>"
+PUBLIC_KEY_2 = """
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.10 (GNU/Linux)
+
+mI0EUYwJXgEEAMbTKHuPJ5/Gk34l9Z06f+0WCXTDXdte1UBoDtZ1erAbudgC4MOR
+gquKqoj3Hhw0/ILqJ88GcOJmKK/bEoIAuKaqlzDF7UAYpOsPZZYmtRfPC2pTCnXq
+Z1vdeqLwTbUspqXflkCkFtfhGKMq5rH8GV5a3tXZkRWZhdNwhVXZagC3ABEBAAG0
+IWFub3RoZXJ1c2VyIDxhbm90aGVydXNlckBsZWFwLnNlPoi4BBMBAgAiBQJRjAle
+AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRB/nfpof+5XWotuA/4tLN4E
+gUr7IfLy2HkHAxzw7A4rqfMN92DIM9mZrDGaWRrOn3aVF7VU1UG7MDkHfPvp/cFw
+ezoCw4s4IoHVc/pVlOkcHSyt4/Rfh248tYEJmFCJXGHpkK83VIKYJAithNccJ6Q4
+JE/o06Mtf4uh/cA1HUL4a4ceqUhtpLJULLeKo7iNBFGMCV4BBADsyQI7GR0wSAxz
+VayLjuPzgT+bjbFeymIhjuxKIEwnIKwYkovztW+4bbOcQs785k3Lp6RzvigTpQQt
+Z/hwcLOqZbZw8t/24+D+Pq9mMP2uUvCFFqLlVvA6D3vKSQ/XNN+YB919WQ04jh63
+yuRe94WenT1RJd6xU1aaUff4rKizuQARAQABiJ8EGAECAAkFAlGMCV4CGwwACgkQ
+f536aH/uV1rPZQQAqCzRysOlu8ez7PuiBD4SebgRqWlxa1TF1ujzfLmuPivROZ2X
+Kw5aQstxgGSjoB7tac49s0huh4X8XK+BtJBfU84JS8Jc2satlfwoyZ35LH6sDZck
+I+RS/3we6zpMfHs3vvp9xgca6ZupQxivGtxlJs294TpJorx+mFFqbV17AzQ=
+=Thdu
+-----END PGP PUBLIC KEY BLOCK-----
+"""
+
+PRIVATE_KEY_2 = """
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+Version: GnuPG v1.4.10 (GNU/Linux)
+
+lQHYBFGMCV4BBADG0yh7jyefxpN+JfWdOn/tFgl0w13bXtVAaA7WdXqwG7nYAuDD
+kYKriqqI9x4cNPyC6ifPBnDiZiiv2xKCALimqpcwxe1AGKTrD2WWJrUXzwtqUwp1
+6mdb3Xqi8E21LKal35ZApBbX4RijKuax/BleWt7V2ZEVmYXTcIVV2WoAtwARAQAB
+AAP7BLuSAx7tOohnimEs74ks8l/L6dOcsFQZj2bqs4AoY3jFe7bV0tHr4llypb/8
+H3/DYvpf6DWnCjyUS1tTnXSW8JXtx01BUKaAufSmMNg9blKV6GGHlT/Whe9uVyks
+7XHk/+9mebVMNJ/kNlqq2k+uWqJohzC8WWLRK+d1tBeqDsECANZmzltPaqUsGV5X
+C3zszE3tUBgptV/mKnBtopKi+VH+t7K6fudGcG+bAcZDUoH/QVde52mIIjjIdLje
+uajJuHUCAO1mqh+vPoGv4eBLV7iBo3XrunyGXiys4a39eomhxTy3YktQanjjx+ty
+GltAGCs5PbWGO6/IRjjvd46wh53kzvsCAO0J97gsWhzLuFnkxFAJSPk7RRlyl7lI
+1XS/x0Og6j9XHCyY1OYkfBm0to3UlCfkgirzCYlTYObCofzdKFIPDmSqHbQhYW5v
+dGhlcnVzZXIgPGFub3RoZXJ1c2VyQGxlYXAuc2U+iLgEEwECACIFAlGMCV4CGwMG
+CwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEH+d+mh/7ldai24D/i0s3gSBSvsh
+8vLYeQcDHPDsDiup8w33YMgz2ZmsMZpZGs6fdpUXtVTVQbswOQd8++n9wXB7OgLD
+izgigdVz+lWU6RwdLK3j9F+Hbjy1gQmYUIlcYemQrzdUgpgkCK2E1xwnpDgkT+jT
+oy1/i6H9wDUdQvhrhx6pSG2kslQst4qjnQHYBFGMCV4BBADsyQI7GR0wSAxzVayL
+juPzgT+bjbFeymIhjuxKIEwnIKwYkovztW+4bbOcQs785k3Lp6RzvigTpQQtZ/hw
+cLOqZbZw8t/24+D+Pq9mMP2uUvCFFqLlVvA6D3vKSQ/XNN+YB919WQ04jh63yuRe
+94WenT1RJd6xU1aaUff4rKizuQARAQABAAP9EyElqJ3dq3EErXwwT4mMnbd1SrVC
+rUJrNWQZL59mm5oigS00uIyR0SvusOr+UzTtd8ysRuwHy5d/LAZsbjQStaOMBILx
+77TJveOel0a1QK0YSMF2ywZMCKvquvjli4hAtWYz/EwfuzQN3t23jc5ny+GqmqD2
+3FUxLJosFUfLNmECAO9KhVmJi+L9dswIs+2Dkjd1eiRQzNOEVffvYkGYZyKxNiXF
+UA5kvyZcB4iAN9sWCybE4WHZ9jd4myGB0MPDGxkCAP1RsXJbbuD6zS7BXe5gwunO
+2q4q7ptdSl/sJYQuTe1KNP5d/uGsvlcFfsYjpsopasPjFBIncc/2QThMKlhoEaEB
+/0mVAxpT6SrEvUbJ18z7kna24SgMPr3OnPMxPGfvNLJY/Xv/A17YfoqjmByCvsKE
+JCDjopXtmbcrZyoEZbEht9mko4ifBBgBAgAJBQJRjAleAhsMAAoJEH+d+mh/7lda
+z2UEAKgs0crDpbvHs+z7ogQ+Enm4EalpcWtUxdbo83y5rj4r0TmdlysOWkLLcYBk
+o6Ae7WnOPbNIboeF/FyvgbSQX1POCUvCXNrGrZX8KMmd+Sx+rA2XJCPkUv98Hus6
+THx7N776fcYHGumbqUMYrxrcZSbNveE6SaK8fphRam1dewM0
+=a5gs
+-----END PGP PRIVATE KEY BLOCK-----
+"""
diff --git a/src/leap/keymanager/tests/test_keymanager.py b/src/leap/keymanager/tests/test_keymanager.py
index ee4462a..b8ef88a 100644
--- a/src/leap/keymanager/tests/test_keymanager.py
+++ b/src/leap/keymanager/tests/test_keymanager.py
@@ -23,12 +23,12 @@ Tests for the Key Manager.
 
 from datetime import datetime
 from mock import Mock
-from leap.common.testing.basetest import BaseLeapTest
+from twisted.internet.defer import inlineCallbacks
+from twisted.trial import unittest
+
 from leap.keymanager import (
-    openpgp,
     KeyNotFound,
     KeyAddressMismatch,
-    errors,
 )
 from leap.keymanager.openpgp import OpenPGPKey
 from leap.keymanager.keys import (
@@ -42,23 +42,16 @@ from leap.keymanager.validation import (
 from leap.keymanager.tests import (
     KeyManagerWithSoledadTestCase,
     ADDRESS,
+    ADDRESS_2,
     KEY_FINGERPRINT,
     PUBLIC_KEY,
+    PUBLIC_KEY_2,
     PRIVATE_KEY,
-    GPG_BINARY_PATH
+    PRIVATE_KEY_2,
 )
 
 
-ADDRESS_2 = 'anotheruser@leap.se'
-
-
-class KeyManagerUtilTestCase(BaseLeapTest):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
+class KeyManagerUtilTestCase(unittest.TestCase):
 
     def test_is_address(self):
         self.assertTrue(
@@ -128,227 +121,43 @@ class KeyManagerUtilTestCase(BaseLeapTest):
             'Wrong data in key.')
 
 
-class OpenPGPCryptoTestCase(KeyManagerWithSoledadTestCase):
-
-    def _test_openpgp_gen_key(self):
-        pgp = openpgp.OpenPGPScheme(self._soledad)
-        self.assertRaises(KeyNotFound, pgp.get_key, 'user@leap.se')
-        key = pgp.gen_key('user@leap.se')
-        self.assertIsInstance(key, openpgp.OpenPGPKey)
-        self.assertEqual(
-            ['user@leap.se'], key.address, 'Wrong address bound to key.')
-        self.assertEqual(
-            4096, key.length, 'Wrong key length.')
-
-    def test_openpgp_put_delete_key(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-        pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
-        key = pgp.get_key(ADDRESS, private=False)
-        pgp.delete_key(key)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-
-    def test_openpgp_put_ascii_key(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-        pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
-        key = pgp.get_key(ADDRESS, private=False)
-        self.assertIsInstance(key, openpgp.OpenPGPKey)
-        self.assertTrue(
-            ADDRESS in key.address, 'Wrong address bound to key.')
-        self.assertEqual(
-            4096, key.length, 'Wrong key length.')
-        pgp.delete_key(key)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-
-    def test_get_public_key(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-        pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
-        self.assertRaises(
-            KeyNotFound, pgp.get_key, ADDRESS, private=True)
-        key = pgp.get_key(ADDRESS, private=False)
-        self.assertTrue(ADDRESS in key.address)
-        self.assertFalse(key.private)
-        self.assertEqual(KEY_FINGERPRINT, key.fingerprint)
-        pgp.delete_key(key)
-        self.assertRaises(KeyNotFound, pgp.get_key, ADDRESS)
-
-    def test_openpgp_encrypt_decrypt(self):
-        # encrypt
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        data = 'data'
-        cyphertext = pgp.encrypt(data, pubkey)
-        # assert
-        self.assertTrue(cyphertext is not None)
-        self.assertTrue(cyphertext != '')
-        self.assertTrue(cyphertext != data)
-        self.assertTrue(pgp.is_encrypted(cyphertext))
-        self.assertTrue(pgp.is_encrypted(cyphertext))
-        # decrypt
-        self.assertRaises(
-            KeyNotFound, pgp.get_key, ADDRESS, private=True)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        privkey = pgp.get_key(ADDRESS, private=True)
-        decrypted, _ = pgp.decrypt(cyphertext, privkey)
-        self.assertEqual(decrypted, data)
-        pgp.delete_key(pubkey)
-        pgp.delete_key(privkey)
-        self.assertRaises(
-            KeyNotFound, pgp.get_key, ADDRESS, private=False)
-        self.assertRaises(
-            KeyNotFound, pgp.get_key, ADDRESS, private=True)
-
-    def test_verify_with_private_raises(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        signed = pgp.sign(data, privkey)
-        self.assertRaises(
-            AssertionError,
-            pgp.verify, signed, privkey)
-
-    def test_sign_with_public_raises(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
-        data = 'data'
-        self.assertRaises(
-            AssertionError,
-            pgp.sign, data, ADDRESS, OpenPGPKey)
-
-    def test_verify_with_wrong_key_raises(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        signed = pgp.sign(data, privkey)
-        pgp.put_ascii_key(PUBLIC_KEY_2, ADDRESS_2)
-        wrongkey = pgp.get_key(ADDRESS_2)
-        self.assertFalse(pgp.verify(signed, wrongkey))
-
-    def test_encrypt_sign_with_public_raises(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        self.assertRaises(
-            AssertionError,
-            pgp.encrypt, data, privkey, sign=pubkey)
-
-    def test_decrypt_verify_with_private_raises(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        encrypted_and_signed = pgp.encrypt(
-            data, pubkey, sign=privkey)
-        self.assertRaises(
-            AssertionError,
-            pgp.decrypt,
-            encrypted_and_signed, privkey, verify=privkey)
-
-    def test_decrypt_verify_with_wrong_key(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        encrypted_and_signed = pgp.encrypt(data, pubkey, sign=privkey)
-        pgp.put_ascii_key(PUBLIC_KEY_2, ADDRESS_2)
-        wrongkey = pgp.get_key(ADDRESS_2)
-        decrypted, validsign = pgp.decrypt(encrypted_and_signed, privkey,
-                                           verify=wrongkey)
-        self.assertEqual(decrypted, data)
-        self.assertFalse(validsign)
-
-    def test_sign_verify(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        signed = pgp.sign(data, privkey, detach=False)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        self.assertTrue(pgp.verify(signed, pubkey))
-
-    def test_encrypt_sign_decrypt_verify(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        privkey = pgp.get_key(ADDRESS, private=True)
-        pgp.put_ascii_key(PRIVATE_KEY_2, ADDRESS_2)
-        pubkey2 = pgp.get_key(ADDRESS_2, private=False)
-        privkey2 = pgp.get_key(ADDRESS_2, private=True)
-        data = 'data'
-        encrypted_and_signed = pgp.encrypt(
-            data, pubkey2, sign=privkey)
-        res, validsign = pgp.decrypt(
-            encrypted_and_signed, privkey2, verify=pubkey)
-        self.assertEqual(data, res)
-        self.assertTrue(validsign)
-
-    def test_sign_verify_detached_sig(self):
-        pgp = openpgp.OpenPGPScheme(
-            self._soledad, gpgbinary=GPG_BINARY_PATH)
-        pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
-        data = 'data'
-        privkey = pgp.get_key(ADDRESS, private=True)
-        signature = pgp.sign(data, privkey, detach=True)
-        pubkey = pgp.get_key(ADDRESS, private=False)
-        validsign = pgp.verify(data, pubkey, detached_sig=signature)
-        self.assertTrue(validsign)
-
-
 class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
 
+    @inlineCallbacks
     def test_get_all_keys_in_db(self):
         km = self._key_manager()
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
         # get public keys
-        keys = km.get_all_keys(False)
+        keys = yield km.get_all_keys(False)
         self.assertEqual(len(keys), 1, 'Wrong number of keys')
         self.assertTrue(ADDRESS in keys[0].address)
         self.assertFalse(keys[0].private)
         # get private keys
-        keys = km.get_all_keys(True)
+        keys = yield km.get_all_keys(True)
         self.assertEqual(len(keys), 1, 'Wrong number of keys')
         self.assertTrue(ADDRESS in keys[0].address)
         self.assertTrue(keys[0].private)
 
+    @inlineCallbacks
     def test_get_public_key(self):
         km = self._key_manager()
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
         # get the key
-        key = km.get_key(ADDRESS, OpenPGPKey, private=False,
-                         fetch_remote=False)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, private=False,
+                               fetch_remote=False)
         self.assertTrue(key is not None)
         self.assertTrue(ADDRESS in key.address)
         self.assertEqual(
             key.fingerprint.lower(), KEY_FINGERPRINT.lower())
         self.assertFalse(key.private)
 
+    @inlineCallbacks
     def test_get_private_key(self):
         km = self._key_manager()
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
         # get the key
-        key = km.get_key(ADDRESS, OpenPGPKey, private=True,
-                         fetch_remote=False)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, private=True,
+                               fetch_remote=False)
         self.assertTrue(key is not None)
         self.assertTrue(ADDRESS in key.address)
         self.assertEqual(
@@ -357,17 +166,17 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
 
     def test_send_key_raises_key_not_found(self):
         km = self._key_manager()
-        self.assertRaises(
-            KeyNotFound,
-            km.send_key, OpenPGPKey)
+        d = km.send_key(OpenPGPKey)
+        return self.assertFailure(d, KeyNotFound)
 
+    @inlineCallbacks
     def test_send_key(self):
         """
         Test that request is well formed when sending keys to server.
         """
         token = "mytoken"
         km = self._key_manager(token=token)
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PUBLIC_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PUBLIC_KEY, ADDRESS)
         km._fetcher.put = Mock()
         # the following data will be used on the send
         km.ca_cert_path = 'capath'
@@ -375,10 +184,11 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
         km.uid = 'myuid'
         km.api_uri = 'apiuri'
         km.api_version = 'apiver'
-        km.send_key(OpenPGPKey)
+        yield km.send_key(OpenPGPKey)
         # setup expected args
+        pubkey = yield km.get_key(km._address, OpenPGPKey)
         data = {
-            km.PUBKEY_KEY: km.get_key(km._address, OpenPGPKey).key_data,
+            km.PUBKEY_KEY: pubkey.key_data,
         }
         url = '%s/%s/users/%s.json' % ('apiuri', 'apiver', 'myuid')
         km._fetcher.put.assert_called_once_with(
@@ -386,7 +196,7 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
             headers={'Authorization': 'Token token=%s' % token},
         )
 
-    def test__fetch_keys_from_server(self):
+    def test_fetch_keys_from_server(self):
         """
         Test that the request is well formed when fetching keys from server.
         """
@@ -406,15 +216,19 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
         km._fetcher.get = Mock(
             return_value=Response())
         km.ca_cert_path = 'cacertpath'
-        # do the fetch
-        km._fetch_keys_from_server(ADDRESS_2)
-        # and verify the call
-        km._fetcher.get.assert_called_once_with(
-            'http://nickserver.domain',
-            data={'address': ADDRESS_2},
-            verify='cacertpath',
-        )
 
+        def verify_the_call(_):
+            km._fetcher.get.assert_called_once_with(
+                'http://nickserver.domain',
+                data={'address': ADDRESS_2},
+                verify='cacertpath',
+            )
+
+        d = km._fetch_keys_from_server(ADDRESS_2)
+        d.addCallback(verify_the_call)
+        return d
+
+    @inlineCallbacks
     def test_get_key_fetches_from_server(self):
         """
         Test that getting a key successfuly fetches from server.
@@ -435,26 +249,26 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
         km._fetcher.get = Mock(return_value=Response())
         km.ca_cert_path = 'cacertpath'
         # try to key get without fetching from server
-        self.assertRaises(
-            KeyNotFound, km.get_key, ADDRESS, OpenPGPKey,
-            fetch_remote=False
-        )
+        d = km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
+        yield self.assertFailure(d, KeyNotFound)
         # try to get key fetching from server.
-        key = km.get_key(ADDRESS, OpenPGPKey)
+        key = yield km.get_key(ADDRESS, OpenPGPKey)
         self.assertIsInstance(key, OpenPGPKey)
         self.assertTrue(ADDRESS in key.address)
 
+    @inlineCallbacks
     def test_put_key_ascii(self):
         """
         Test that putting ascii key works
         """
         km = self._key_manager(url='http://nickserver.domain')
 
-        km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
-        key = km.get_key(ADDRESS, OpenPGPKey)
+        yield km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
+        key = yield km.get_key(ADDRESS, OpenPGPKey)
         self.assertIsInstance(key, OpenPGPKey)
         self.assertTrue(ADDRESS in key.address)
 
+    @inlineCallbacks
     def test_fetch_uri_ascii_key(self):
         """
         Test that fetch key downloads the ascii key and gets included in
@@ -469,8 +283,8 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
         km._fetcher.get = Mock(return_value=Response())
         km.ca_cert_path = 'cacertpath'
 
-        km.fetch_key(ADDRESS, "http://site.domain/key", OpenPGPKey)
-        key = km.get_key(ADDRESS, OpenPGPKey)
+        yield km.fetch_key(ADDRESS, "http://site.domain/key", OpenPGPKey)
+        key = yield km.get_key(ADDRESS, OpenPGPKey)
         self.assertEqual(KEY_FINGERPRINT, key.fingerprint)
 
     def test_fetch_uri_empty_key(self):
@@ -485,8 +299,8 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
 
         km._fetcher.get = Mock(return_value=Response())
         km.ca_cert_path = 'cacertpath'
-        self.assertRaises(KeyNotFound, km.fetch_key,
-                          ADDRESS, "http://site.domain/key", OpenPGPKey)
+        d = km.fetch_key(ADDRESS, "http://site.domain/key", OpenPGPKey)
+        return self.assertFailure(d, KeyNotFound)
 
     def test_fetch_uri_address_differ(self):
         """
@@ -501,120 +315,66 @@ class KeyManagerKeyManagementTestCase(KeyManagerWithSoledadTestCase):
 
         km._fetcher.get = Mock(return_value=Response())
         km.ca_cert_path = 'cacertpath'
-        self.assertRaises(KeyAddressMismatch, km.fetch_key,
-                          ADDRESS_2, "http://site.domain/key", OpenPGPKey)
+        d = km.fetch_key(ADDRESS_2, "http://site.domain/key", OpenPGPKey)
+        return self.assertFailure(d, KeyAddressMismatch)
 
 
 class KeyManagerCryptoTestCase(KeyManagerWithSoledadTestCase):
 
     RAW_DATA = 'data'
 
+    @inlineCallbacks
     def test_keymanager_openpgp_encrypt_decrypt(self):
         km = self._key_manager()
         # put raw private key
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY_2, ADDRESS_2)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(
+            PRIVATE_KEY_2, ADDRESS_2)
         # encrypt
-        encdata = km.encrypt(self.RAW_DATA, ADDRESS, OpenPGPKey,
-                             sign=ADDRESS_2, fetch_remote=False)
+        encdata = yield km.encrypt(self.RAW_DATA, ADDRESS, OpenPGPKey,
+                                   sign=ADDRESS_2, fetch_remote=False)
         self.assertNotEqual(self.RAW_DATA, encdata)
         # decrypt
-        rawdata, signingkey = km.decrypt(encdata, ADDRESS, OpenPGPKey,
-                                         verify=ADDRESS_2, fetch_remote=False)
+        rawdata, signingkey = yield km.decrypt(
+            encdata, ADDRESS, OpenPGPKey, verify=ADDRESS_2, fetch_remote=False)
         self.assertEqual(self.RAW_DATA, rawdata)
-        key = km.get_key(ADDRESS_2, OpenPGPKey, private=False,
-                         fetch_remote=False)
+        key = yield km.get_key(ADDRESS_2, OpenPGPKey, private=False,
+                               fetch_remote=False)
         self.assertEqual(signingkey.fingerprint, key.fingerprint)
 
+    @inlineCallbacks
     def test_keymanager_openpgp_encrypt_decrypt_wrong_sign(self):
         km = self._key_manager()
         # put raw keys
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY_2, ADDRESS_2)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(
+            PRIVATE_KEY_2, ADDRESS_2)
         # encrypt
-        encdata = km.encrypt(self.RAW_DATA, ADDRESS, OpenPGPKey,
-                             sign=ADDRESS_2, fetch_remote=False)
+        encdata = yield km.encrypt(self.RAW_DATA, ADDRESS, OpenPGPKey,
+                                   sign=ADDRESS_2, fetch_remote=False)
         self.assertNotEqual(self.RAW_DATA, encdata)
         # verify
-        rawdata, signingkey = km.decrypt(encdata, ADDRESS, OpenPGPKey,
-                                         verify=ADDRESS, fetch_remote=False)
+        rawdata, signingkey = yield km.decrypt(
+            encdata, ADDRESS, OpenPGPKey, verify=ADDRESS, fetch_remote=False)
         self.assertEqual(self.RAW_DATA, rawdata)
         self.assertTrue(signingkey is None)
 
+    @inlineCallbacks
     def test_keymanager_openpgp_sign_verify(self):
         km = self._key_manager()
         # put raw private keys
-        km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
-        signdata = km.sign(self.RAW_DATA, ADDRESS, OpenPGPKey, detach=False)
+        yield km._wrapper_map[OpenPGPKey].put_ascii_key(PRIVATE_KEY, ADDRESS)
+        signdata = yield km.sign(self.RAW_DATA, ADDRESS, OpenPGPKey,
+                                 detach=False)
         self.assertNotEqual(self.RAW_DATA, signdata)
         # verify
-        signingkey = km.verify(signdata, ADDRESS, OpenPGPKey,
+        signingkey = yield km.verify(signdata, ADDRESS, OpenPGPKey,
+                                     fetch_remote=False)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, private=False,
                                fetch_remote=False)
-        key = km.get_key(ADDRESS, OpenPGPKey, private=False,
-                         fetch_remote=False)
         self.assertEqual(signingkey.fingerprint, key.fingerprint)
 
 
-# Key material for testing
-
-# key 7FEE575A: public key "anotheruser <anotheruser@leap.se>"
-PUBLIC_KEY_2 = """
------BEGIN PGP PUBLIC KEY BLOCK-----
-Version: GnuPG v1.4.10 (GNU/Linux)
-
-mI0EUYwJXgEEAMbTKHuPJ5/Gk34l9Z06f+0WCXTDXdte1UBoDtZ1erAbudgC4MOR
-gquKqoj3Hhw0/ILqJ88GcOJmKK/bEoIAuKaqlzDF7UAYpOsPZZYmtRfPC2pTCnXq
-Z1vdeqLwTbUspqXflkCkFtfhGKMq5rH8GV5a3tXZkRWZhdNwhVXZagC3ABEBAAG0
-IWFub3RoZXJ1c2VyIDxhbm90aGVydXNlckBsZWFwLnNlPoi4BBMBAgAiBQJRjAle
-AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRB/nfpof+5XWotuA/4tLN4E
-gUr7IfLy2HkHAxzw7A4rqfMN92DIM9mZrDGaWRrOn3aVF7VU1UG7MDkHfPvp/cFw
-ezoCw4s4IoHVc/pVlOkcHSyt4/Rfh248tYEJmFCJXGHpkK83VIKYJAithNccJ6Q4
-JE/o06Mtf4uh/cA1HUL4a4ceqUhtpLJULLeKo7iNBFGMCV4BBADsyQI7GR0wSAxz
-VayLjuPzgT+bjbFeymIhjuxKIEwnIKwYkovztW+4bbOcQs785k3Lp6RzvigTpQQt
-Z/hwcLOqZbZw8t/24+D+Pq9mMP2uUvCFFqLlVvA6D3vKSQ/XNN+YB919WQ04jh63
-yuRe94WenT1RJd6xU1aaUff4rKizuQARAQABiJ8EGAECAAkFAlGMCV4CGwwACgkQ
-f536aH/uV1rPZQQAqCzRysOlu8ez7PuiBD4SebgRqWlxa1TF1ujzfLmuPivROZ2X
-Kw5aQstxgGSjoB7tac49s0huh4X8XK+BtJBfU84JS8Jc2satlfwoyZ35LH6sDZck
-I+RS/3we6zpMfHs3vvp9xgca6ZupQxivGtxlJs294TpJorx+mFFqbV17AzQ=
-=Thdu
------END PGP PUBLIC KEY BLOCK-----
-"""
-
-PRIVATE_KEY_2 = """
------BEGIN PGP PRIVATE KEY BLOCK-----
-Version: GnuPG v1.4.10 (GNU/Linux)
-
-lQHYBFGMCV4BBADG0yh7jyefxpN+JfWdOn/tFgl0w13bXtVAaA7WdXqwG7nYAuDD
-kYKriqqI9x4cNPyC6ifPBnDiZiiv2xKCALimqpcwxe1AGKTrD2WWJrUXzwtqUwp1
-6mdb3Xqi8E21LKal35ZApBbX4RijKuax/BleWt7V2ZEVmYXTcIVV2WoAtwARAQAB
-AAP7BLuSAx7tOohnimEs74ks8l/L6dOcsFQZj2bqs4AoY3jFe7bV0tHr4llypb/8
-H3/DYvpf6DWnCjyUS1tTnXSW8JXtx01BUKaAufSmMNg9blKV6GGHlT/Whe9uVyks
-7XHk/+9mebVMNJ/kNlqq2k+uWqJohzC8WWLRK+d1tBeqDsECANZmzltPaqUsGV5X
-C3zszE3tUBgptV/mKnBtopKi+VH+t7K6fudGcG+bAcZDUoH/QVde52mIIjjIdLje
-uajJuHUCAO1mqh+vPoGv4eBLV7iBo3XrunyGXiys4a39eomhxTy3YktQanjjx+ty
-GltAGCs5PbWGO6/IRjjvd46wh53kzvsCAO0J97gsWhzLuFnkxFAJSPk7RRlyl7lI
-1XS/x0Og6j9XHCyY1OYkfBm0to3UlCfkgirzCYlTYObCofzdKFIPDmSqHbQhYW5v
-dGhlcnVzZXIgPGFub3RoZXJ1c2VyQGxlYXAuc2U+iLgEEwECACIFAlGMCV4CGwMG
-CwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEH+d+mh/7ldai24D/i0s3gSBSvsh
-8vLYeQcDHPDsDiup8w33YMgz2ZmsMZpZGs6fdpUXtVTVQbswOQd8++n9wXB7OgLD
-izgigdVz+lWU6RwdLK3j9F+Hbjy1gQmYUIlcYemQrzdUgpgkCK2E1xwnpDgkT+jT
-oy1/i6H9wDUdQvhrhx6pSG2kslQst4qjnQHYBFGMCV4BBADsyQI7GR0wSAxzVayL
-juPzgT+bjbFeymIhjuxKIEwnIKwYkovztW+4bbOcQs785k3Lp6RzvigTpQQtZ/hw
-cLOqZbZw8t/24+D+Pq9mMP2uUvCFFqLlVvA6D3vKSQ/XNN+YB919WQ04jh63yuRe
-94WenT1RJd6xU1aaUff4rKizuQARAQABAAP9EyElqJ3dq3EErXwwT4mMnbd1SrVC
-rUJrNWQZL59mm5oigS00uIyR0SvusOr+UzTtd8ysRuwHy5d/LAZsbjQStaOMBILx
-77TJveOel0a1QK0YSMF2ywZMCKvquvjli4hAtWYz/EwfuzQN3t23jc5ny+GqmqD2
-3FUxLJosFUfLNmECAO9KhVmJi+L9dswIs+2Dkjd1eiRQzNOEVffvYkGYZyKxNiXF
-UA5kvyZcB4iAN9sWCybE4WHZ9jd4myGB0MPDGxkCAP1RsXJbbuD6zS7BXe5gwunO
-2q4q7ptdSl/sJYQuTe1KNP5d/uGsvlcFfsYjpsopasPjFBIncc/2QThMKlhoEaEB
-/0mVAxpT6SrEvUbJ18z7kna24SgMPr3OnPMxPGfvNLJY/Xv/A17YfoqjmByCvsKE
-JCDjopXtmbcrZyoEZbEht9mko4ifBBgBAgAJBQJRjAleAhsMAAoJEH+d+mh/7lda
-z2UEAKgs0crDpbvHs+z7ogQ+Enm4EalpcWtUxdbo83y5rj4r0TmdlysOWkLLcYBk
-o6Ae7WnOPbNIboeF/FyvgbSQX1POCUvCXNrGrZX8KMmd+Sx+rA2XJCPkUv98Hus6
-THx7N776fcYHGumbqUMYrxrcZSbNveE6SaK8fphRam1dewM0
-=a5gs
------END PGP PRIVATE KEY BLOCK-----
-"""
 import unittest
 if __name__ == "__main__":
     unittest.main()
diff --git a/src/leap/keymanager/tests/test_openpgp.py b/src/leap/keymanager/tests/test_openpgp.py
new file mode 100644
index 0000000..01cf341
--- /dev/null
+++ b/src/leap/keymanager/tests/test_openpgp.py
@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+# test_keymanager.py
+# Copyright (C) 2014 LEAP
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+"""
+Tests for the OpenPGP support on Key Manager.
+"""
+
+
+from twisted.internet.defer import inlineCallbacks
+
+from leap.keymanager import (
+    KeyNotFound,
+    openpgp,
+)
+from leap.keymanager.openpgp import OpenPGPKey
+from leap.keymanager.tests import (
+    KeyManagerWithSoledadTestCase,
+    ADDRESS,
+    ADDRESS_2,
+    KEY_FINGERPRINT,
+    PUBLIC_KEY,
+    PUBLIC_KEY_2,
+    PRIVATE_KEY,
+    PRIVATE_KEY_2,
+    GPG_BINARY_PATH
+)
+
+
+class OpenPGPCryptoTestCase(KeyManagerWithSoledadTestCase):
+
+    @inlineCallbacks
+    def _test_openpgp_gen_key(self):
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield self._assert_key_not_found(pgp, 'user@leap.se')
+        key = yield pgp.gen_key('user@leap.se')
+        self.assertIsInstance(key, openpgp.OpenPGPKey)
+        self.assertEqual(
+            ['user@leap.se'], key.address, 'Wrong address bound to key.')
+        self.assertEqual(
+            4096, key.length, 'Wrong key length.')
+
+    @inlineCallbacks
+    def test_openpgp_put_delete_key(self):
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+        yield pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
+        key = yield pgp.get_key(ADDRESS, private=False)
+        yield pgp.delete_key(key)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+
+    @inlineCallbacks
+    def test_openpgp_put_ascii_key(self):
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+        yield pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
+        key = yield pgp.get_key(ADDRESS, private=False)
+        self.assertIsInstance(key, openpgp.OpenPGPKey)
+        self.assertTrue(
+            ADDRESS in key.address, 'Wrong address bound to key.')
+        self.assertEqual(
+            4096, key.length, 'Wrong key length.')
+        yield pgp.delete_key(key)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+
+    @inlineCallbacks
+    def test_get_public_key(self):
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+        yield pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
+        yield self._assert_key_not_found(pgp, ADDRESS, private=True)
+        key = yield pgp.get_key(ADDRESS, private=False)
+        self.assertTrue(ADDRESS in key.address)
+        self.assertFalse(key.private)
+        self.assertEqual(KEY_FINGERPRINT, key.fingerprint)
+        yield pgp.delete_key(key)
+        yield self._assert_key_not_found(pgp, ADDRESS)
+
+    @inlineCallbacks
+    def test_openpgp_encrypt_decrypt(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+
+        # encrypt
+        yield pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        cyphertext = pgp.encrypt(data, pubkey)
+
+        self.assertTrue(cyphertext is not None)
+        self.assertTrue(cyphertext != '')
+        self.assertTrue(cyphertext != data)
+        self.assertTrue(pgp.is_encrypted(cyphertext))
+        self.assertTrue(pgp.is_encrypted(cyphertext))
+
+        # decrypt
+        yield self._assert_key_not_found(pgp, ADDRESS, private=True)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        decrypted, _ = pgp.decrypt(cyphertext, privkey)
+        self.assertEqual(decrypted, data)
+
+        yield pgp.delete_key(pubkey)
+        yield pgp.delete_key(privkey)
+        yield self._assert_key_not_found(pgp, ADDRESS, private=False)
+        yield self._assert_key_not_found(pgp, ADDRESS, private=True)
+
+    @inlineCallbacks
+    def test_verify_with_private_raises(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        signed = pgp.sign(data, privkey)
+        self.assertRaises(
+            AssertionError,
+            pgp.verify, signed, privkey)
+
+    @inlineCallbacks
+    def test_sign_with_public_raises(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PUBLIC_KEY, ADDRESS)
+        self.assertRaises(
+            AssertionError,
+            pgp.sign, data, ADDRESS, OpenPGPKey)
+
+    @inlineCallbacks
+    def test_verify_with_wrong_key_raises(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        signed = pgp.sign(data, privkey)
+        yield pgp.put_ascii_key(PUBLIC_KEY_2, ADDRESS_2)
+        wrongkey = yield pgp.get_key(ADDRESS_2)
+        self.assertFalse(pgp.verify(signed, wrongkey))
+
+    @inlineCallbacks
+    def test_encrypt_sign_with_public_raises(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        self.assertRaises(
+            AssertionError,
+            pgp.encrypt, data, privkey, sign=pubkey)
+
+    @inlineCallbacks
+    def test_decrypt_verify_with_private_raises(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        encrypted_and_signed = pgp.encrypt(
+            data, pubkey, sign=privkey)
+        self.assertRaises(
+            AssertionError,
+            pgp.decrypt,
+            encrypted_and_signed, privkey, verify=privkey)
+
+    @inlineCallbacks
+    def test_decrypt_verify_with_wrong_key(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        encrypted_and_signed = pgp.encrypt(data, pubkey, sign=privkey)
+        yield pgp.put_ascii_key(PUBLIC_KEY_2, ADDRESS_2)
+        wrongkey = yield pgp.get_key(ADDRESS_2)
+        decrypted, validsign = pgp.decrypt(encrypted_and_signed, privkey,
+                                           verify=wrongkey)
+        self.assertEqual(decrypted, data)
+        self.assertFalse(validsign)
+
+    @inlineCallbacks
+    def test_sign_verify(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        signed = pgp.sign(data, privkey, detach=False)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        validsign = pgp.verify(signed, pubkey)
+        self.assertTrue(validsign)
+
+    @inlineCallbacks
+    def test_encrypt_sign_decrypt_verify(self):
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+
+        yield pgp.put_ascii_key(PRIVATE_KEY_2, ADDRESS_2)
+        pubkey2 = yield pgp.get_key(ADDRESS_2, private=False)
+        privkey2 = yield pgp.get_key(ADDRESS_2, private=True)
+
+        data = 'data'
+        encrypted_and_signed = pgp.encrypt(
+            data, pubkey2, sign=privkey)
+        res, validsign = pgp.decrypt(
+            encrypted_and_signed, privkey2, verify=pubkey)
+        self.assertEqual(data, res)
+        self.assertTrue(validsign)
+
+    @inlineCallbacks
+    def test_sign_verify_detached_sig(self):
+        data = 'data'
+        pgp = openpgp.OpenPGPScheme(
+            self._soledad, gpgbinary=GPG_BINARY_PATH)
+        yield pgp.put_ascii_key(PRIVATE_KEY, ADDRESS)
+        privkey = yield pgp.get_key(ADDRESS, private=True)
+        signature = yield pgp.sign(data, privkey, detach=True)
+        pubkey = yield pgp.get_key(ADDRESS, private=False)
+        validsign = pgp.verify(data, pubkey, detached_sig=signature)
+        self.assertTrue(validsign)
+
+    def _assert_key_not_found(self, pgp, address, private=False):
+        d = pgp.get_key(address, private=private)
+        return self.assertFailure(d, KeyNotFound)
diff --git a/src/leap/keymanager/tests/test_validation.py b/src/leap/keymanager/tests/test_validation.py
index 400d36e..83a02e0 100644
--- a/src/leap/keymanager/tests/test_validation.py
+++ b/src/leap/keymanager/tests/test_validation.py
@@ -19,6 +19,7 @@ Tests for the Validation Levels
 """
 
 from datetime import datetime
+from twisted.internet.defer import inlineCallbacks
 
 from leap.keymanager.openpgp import OpenPGPKey
 from leap.keymanager.errors import (
@@ -35,51 +36,57 @@ from leap.keymanager.validation import ValidationLevel
 
 class ValidationLevelTestCase(KeyManagerWithSoledadTestCase):
 
+    @inlineCallbacks
     def test_none_old_key(self):
         km = self._key_manager()
-        km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
-        key = km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
+        yield km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
         self.assertEqual(key.fingerprint, KEY_FINGERPRINT)
 
+    @inlineCallbacks
     def test_cant_upgrade(self):
         km = self._key_manager()
-        km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS,
-                       validation=ValidationLevel.Provider_Trust)
-        self.assertRaises(KeyNotValidUpgrade, km.put_raw_key, UNRELATED_KEY,
-                          OpenPGPKey, ADDRESS)
+        yield km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS,
+                             validation=ValidationLevel.Provider_Trust)
+        d = km.put_raw_key(UNRELATED_KEY, OpenPGPKey, ADDRESS)
+        yield self.assertFailure(d, KeyNotValidUpgrade)
 
+    @inlineCallbacks
     def test_fingerprint_level(self):
         km = self._key_manager()
-        km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
-        km.put_raw_key(UNRELATED_KEY, OpenPGPKey, ADDRESS,
-                       validation=ValidationLevel.Fingerprint)
-        key = km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
+        yield km.put_raw_key(PUBLIC_KEY, OpenPGPKey, ADDRESS)
+        yield km.put_raw_key(UNRELATED_KEY, OpenPGPKey, ADDRESS,
+                             validation=ValidationLevel.Fingerprint)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
         self.assertEqual(key.fingerprint, UNRELATED_FINGERPRINT)
 
+    @inlineCallbacks
     def test_expired_key(self):
         km = self._key_manager()
-        km.put_raw_key(EXPIRED_KEY, OpenPGPKey, ADDRESS)
-        km.put_raw_key(UNRELATED_KEY, OpenPGPKey, ADDRESS)
-        key = km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
+        yield km.put_raw_key(EXPIRED_KEY, OpenPGPKey, ADDRESS)
+        yield km.put_raw_key(UNRELATED_KEY, OpenPGPKey, ADDRESS)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
         self.assertEqual(key.fingerprint, UNRELATED_FINGERPRINT)
 
+    @inlineCallbacks
     def test_expired_fail_lower_level(self):
         km = self._key_manager()
-        km.put_raw_key(EXPIRED_KEY, OpenPGPKey, ADDRESS,
-                       validation=ValidationLevel.Third_Party_Endorsement)
-        self.assertRaises(
-            KeyNotValidUpgrade,
-            km.put_raw_key,
+        yield km.put_raw_key(
+            EXPIRED_KEY, OpenPGPKey, ADDRESS,
+            validation=ValidationLevel.Third_Party_Endorsement)
+        d = km.put_raw_key(
             UNRELATED_KEY,
             OpenPGPKey,
             ADDRESS,
             validation=ValidationLevel.Provider_Trust)
+        yield self.assertFailure(d, KeyNotValidUpgrade)
 
+    @inlineCallbacks
     def test_roll_back(self):
         km = self._key_manager()
-        km.put_raw_key(EXPIRED_KEY_UPDATED, OpenPGPKey, ADDRESS)
-        km.put_raw_key(EXPIRED_KEY, OpenPGPKey, ADDRESS)
-        key = km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
+        yield km.put_raw_key(EXPIRED_KEY_UPDATED, OpenPGPKey, ADDRESS)
+        yield km.put_raw_key(EXPIRED_KEY, OpenPGPKey, ADDRESS)
+        key = yield km.get_key(ADDRESS, OpenPGPKey, fetch_remote=False)
         self.assertEqual(key.expiry_date, EXPIRED_KEY_NEW_EXPIRY_DATE)