class KeyManagerWithSoledadTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.setUpEnv()
self.gpg_binary_path = self._find_gpg()
self._soledad = Soledad(
u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
syncable=False
)
def tearDown(self):
km = self._key_manager()
# wait for the indexes to be ready for the tear down
d = km._wrapper_map[OpenPGPKey].deferred_init
d.addCallback(lambda _: self.delete_all_keys(km))
d.addCallback(lambda _: self.tearDownEnv())
d.addCallback(lambda _: self._soledad.close())
return d
def delete_all_keys(self, km):
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 check_deleted(_, private):
d = km.get_all_keys(private=private)
d.addCallback(lambda keys: self.assertEqual(keys, []))
return d
deferreds = []
for private in [True, False]:
d = km.get_all_keys(private=private)
d.addCallback(delete_keys)
d.addCallback(check_deleted, private)
deferreds.append(d)
return gatherResults(deferreds)
def _key_manager(self, user=ADDRESS, url='', token=None,
ca_cert_path=None):
return KeyManager(user, url, self._soledad, token=token,
gpgbinary=self.gpg_binary_path,
ca_cert_path=ca_cert_path)
def _find_gpg(self):
gpg_path = distutils.spawn.find_executable('gpg')
if gpg_path is not None:
return os.path.realpath(gpg_path)
else:
return "/usr/bin/gpg"
class KeyManagerWithSoledadTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.gpg_binary_path = get_gpg_bin_path()
self._soledad = Soledad(u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
shared_db=defaultMockSharedDB())
self.km = self._key_manager()
class Response(object):
code = 200
phrase = ''
def deliverBody(self, x):
return ''
self.km._nicknym._async_client_pinned.request = Mock(
return_value=defer.succeed(Response()))
d1 = self.km.put_raw_key(PRIVATE_KEY, ADDRESS)
d2 = self.km.put_raw_key(PRIVATE_KEY_2, ADDRESS_2)
return gatherResults([d1, d2])
def tearDown(self):
km = self._key_manager()
# wait for the indexes to be ready for the tear down
d = km._openpgp.deferred_init
d.addCallback(lambda _: self.delete_all_keys(km))
d.addCallback(lambda _: self._soledad.close())
return d
def delete_all_keys(self, km):
def delete_keys(keys):
deferreds = []
for key in keys:
d = km._openpgp.delete_key(key)
deferreds.append(d)
return gatherResults(deferreds)
def check_deleted(_, private):
d = km.get_all_keys(private=private)
d.addCallback(lambda keys: self.assertEqual(keys, []))
return d
deferreds = []
for private in [True, False]:
d = km.get_all_keys(private=private)
d.addCallback(delete_keys)
d.addCallback(check_deleted, private)
deferreds.append(d)
return gatherResults(deferreds)
def _key_manager(self,
user=ADDRESS,
url='',
token=None,
ca_cert_path=None):
return KeyManager(user,
url,
self._soledad,
token=token,
gpgbinary=self.gpg_binary_path,
ca_cert_path=ca_cert_path)
class KeyManagerWithSoledadTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.gpg_binary_path = get_gpg_bin_path()
# TODO: we pass a fake shared database to soledad because we don't want
# it o try to reach network to lookup a stored secret in the shared
# database. This logic still has to be improved in soledad itself to
# account for tests, and when that is done we can remove this from
# here.
class FakeSharedDb(object):
def get_doc(self, doc_id):
return None
def put_doc(self, doc):
return None
self._soledad = Soledad(
u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
shared_db=FakeSharedDb(),
)
def tearDown(self):
km = self._key_manager()
# wait for the indexes to be ready for the tear down
d = km._openpgp.deferred_init
d.addCallback(lambda _: self.delete_all_keys(km))
d.addCallback(lambda _: self._soledad.close())
return d
def delete_all_keys(self, km):
def delete_keys(keys):
deferreds = []
for key in keys:
d = km._openpgp.delete_key(key)
deferreds.append(d)
return gatherResults(deferreds)
def check_deleted(_, private):
d = km.get_all_keys(private=private)
d.addCallback(lambda keys: self.assertEqual(keys, []))
return d
deferreds = []
for private in [True, False]:
d = km.get_all_keys(private=private)
d.addCallback(delete_keys)
d.addCallback(check_deleted, private)
deferreds.append(d)
return gatherResults(deferreds)
def _key_manager(self,
user=ADDRESS,
url='',
token=None,
ca_cert_path=None):
return KeyManager(user,
url,
self._soledad,
token=token,
gpgbinary=self.gpg_binary_path,
ca_cert_path=ca_cert_path)
def get_public_binary_key(self):
with open(PATH + '/public_key.bin', 'r') as binary_public_key:
return binary_public_key.read()
def get_private_binary_key(self):
with open(PATH + '/private_key.bin', 'r') as binary_private_key:
return binary_private_key.read()
class KeyManagerWithSoledadTestCase(unittest.TestCase, BaseLeapTest):
def setUp(self):
self.gpg_binary_path = self._find_gpg()
self._soledad = Soledad(
u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
syncable=False
)
def tearDown(self):
km = self._key_manager()
# wait for the indexes to be ready for the tear down
d = km._openpgp.deferred_init
d.addCallback(lambda _: self.delete_all_keys(km))
d.addCallback(lambda _: self._soledad.close())
return d
def delete_all_keys(self, km):
def delete_keys(keys):
deferreds = []
for key in keys:
d = km._openpgp.delete_key(key)
deferreds.append(d)
return gatherResults(deferreds)
def check_deleted(_, private):
d = km.get_all_keys(private=private)
d.addCallback(lambda keys: self.assertEqual(keys, []))
return d
deferreds = []
for private in [True, False]:
d = km.get_all_keys(private=private)
d.addCallback(delete_keys)
d.addCallback(check_deleted, private)
deferreds.append(d)
return gatherResults(deferreds)
def _key_manager(self, user=ADDRESS, url='', token=None,
ca_cert_path=None):
return KeyManager(user, url, self._soledad, token=token,
gpgbinary=self.gpg_binary_path,
ca_cert_path=ca_cert_path)
def _find_gpg(self):
gpg_path = distutils.spawn.find_executable('gpg')
if gpg_path is not None:
return os.path.realpath(gpg_path)
else:
return "/usr/bin/gpg"
def get_public_binary_key(self):
with open(PATH + '/public_key.bin', 'r') as binary_public_key:
return binary_public_key.read()
def get_private_binary_key(self):
with open(
PATH + '/private_key.bin', 'r') as binary_private_key:
return binary_private_key.read()
