diff --git a/tests/kgpgaddphoto.cpp b/tests/kgpgaddphoto.cpp
index fed6d37f..01199cf1 100644
--- a/tests/kgpgaddphoto.cpp
+++ b/tests/kgpgaddphoto.cpp
@@ -1,29 +1,29 @@
 #include "kgpgaddphoto.h"
 #include "../transactions/kgpgaddphoto.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
 #include <QSignalSpy>
 #include <QtTest>
 
 void KGpgAddPhotoTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgAddPhotoTest::testAddPhoto()
 {
 	const QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 	QString keyID = QLatin1String("BA7695F3C550DF14");
 	QString imagepath = QLatin1String("keys/image_small.jpg");
 	KGpgAddPhoto *transaction = new KGpgAddPhoto(this, keyID, imagepath);
 	addPasswordArguments(transaction, passphrase);
 	QSignalSpy spy(transaction, &KGpgAddPhoto::done);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QVERIFY(hasPhoto(m_tempdir, keyID));
 }
 
 QTEST_MAIN(KGpgAddPhotoTest)
diff --git a/tests/kgpgadduid.cpp b/tests/kgpgadduid.cpp
index 04632277..f15d4833 100644
--- a/tests/kgpgadduid.cpp
+++ b/tests/kgpgadduid.cpp
@@ -1,81 +1,81 @@
 #include "kgpgadduid.h"
 #include "../transactions/kgpgadduid.h"
 #include "../kgpginterface.h"
 #include "../kgpgsettings.h"
 #include "common.h"
 
 #include <QLatin1String>
 #include <QSignalSpy>
 #include <QString>
 #include <QtTest>
 
 void KGpgAddUidTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 }
 
 void KGpgAddUidTest::testAddUid()
 {
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 
 	QString keyId = QLatin1String("BA7695F3C550DF14");
 
 	QFETCH(QString, uid_name);
 	QFETCH(QString, uid_email);
 	QFETCH(QString, uid_comment);
 	KGpgAddUid *transaction = new KGpgAddUid(this, keyId, uid_name, uid_email, uid_comment);
 	addPasswordArguments(transaction, passphrase);
 	QObject::connect(transaction, &KGpgAddUid::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(transaction, &KGpgAddUid::done);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	KgpgCore::KgpgKeyList keyList = KgpgInterface::readPublicKeys();
 	QCOMPARE(keyList.size(), 1);
 	KgpgCore::KgpgKey key = keyList.first();
 	QCOMPARE(key.name(), uid_name);
 	QCOMPARE(key.email(), uid_email);
 	QCOMPARE(key.comment(), uid_comment);
 	QCOMPARE(key.fullId(), keyId);
 }
 
 void KGpgAddUidTest::testAddUid_data()
 {
 	QTest::addColumn<QString>("uid_name");
 	QTest::addColumn<QString>("uid_email");
 	QTest::addColumn<QString>("uid_comment");
 
 	QTest::newRow("all fields") << QString(QLatin1String("Test name"))
 			<< QString(QLatin1String("test@kde.org"))
 			<< QString(QLatin1String("Test comment"));
 	QTest::newRow("only name") << QString(QLatin1String("Test name 2"))
 			<< QString() << QString();
 	QTest::newRow("name and comment") << QString(QLatin1String("Test name 2"))
 			<< QString() << QString(QLatin1String("another comment"));
 }
 
 void KGpgAddUidTest::testAddUidInvalid()
 {
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 
 	QString keyId = QLatin1String("BA7695F3C550DF14");
 	QString name = QLatin1String("Test name");
 	QString email = QLatin1String("a b"); // intentionally invalid
 	QString comment = QLatin1String("Test comment");
 	KGpgAddUid *transaction = new KGpgAddUid(this, keyId, name, email, comment);
 	QObject::connect(transaction, &KGpgAddUid::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgAddUid::TS_INVALID_EMAIL)); });
 	QSignalSpy spy(transaction, &KGpgAddUid::done);
 	transaction->start();
 
 	// for whatever reason spy.wait() does not work here
 	int i = 0;
 	while (spy.isEmpty() && i++ < 50)
 		QTest::qWait(250);
 	QCOMPARE(spy.count(), 1);
 }
 
 QTEST_MAIN(KGpgAddUidTest)
diff --git a/tests/kgpgchangedisable.cpp b/tests/kgpgchangedisable.cpp
index c1fd1143..8e967f80 100644
--- a/tests/kgpgchangedisable.cpp
+++ b/tests/kgpgchangedisable.cpp
@@ -1,48 +1,48 @@
 #include "kgpgchangedisable.h"
 #include "../transactions/kgpgchangedisable.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
 #include <QSignalSpy>
 #include <QtTest>
 
 void KGpgChangeDisableTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 }
 
 void KGpgChangeDisableTest::testDisableKey()
 {
 	const QString keyID = QLatin1String("FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 	KGpgChangeDisable *transaction = new KGpgChangeDisable(this, keyID, true);
 	QSignalSpy spy(transaction, &KGpgChangeDisable::done);
 	QObject::connect(transaction, &KGpgChangeDisable::done, [](int result) {
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	KgpgCore::KgpgKeyList keyList = KgpgInterface::readPublicKeys(QStringList(keyID));
 	QVERIFY(!keyList.isEmpty());
 	QVERIFY(!keyList.first().valid());
 }
 
 void KGpgChangeDisableTest::testEnableKey()
 {
 	const QString keyID = QLatin1String("FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 	KGpgChangeDisable *transaction = new KGpgChangeDisable(this, keyID, true);
 	QSignalSpy spy(transaction, &KGpgChangeDisable::done);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QObject::connect(transaction, &KGpgChangeDisable::done, [](int result) {
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->setDisable(false);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	KgpgCore::KgpgKeyList keyList = KgpgInterface::readPublicKeys(QStringList(keyID));
 	QVERIFY(!keyList.isEmpty());
 	QVERIFY(keyList.first().valid());
 }
 
 QTEST_MAIN(KGpgChangeDisableTest)
diff --git a/tests/kgpgchangetrust.cpp b/tests/kgpgchangetrust.cpp
index eee347f7..64b1ea6e 100644
--- a/tests/kgpgchangetrust.cpp
+++ b/tests/kgpgchangetrust.cpp
@@ -1,40 +1,40 @@
 #include "kgpgchangetrust.h"
 #include "../transactions/kgpgchangetrust.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
 #include <QString>
 #include <QSignalSpy>
 #include <QtTest>
 
 void KGpgChangeTrustTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgChangeTrustTest::testChangeTrust()
 {
 	QFETCH(gpgme_validity_t, target_trust);
 	QLatin1String keyID("BA7695F3C550DF14");
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"));
 	KGpgChangeTrust *transaction = new KGpgChangeTrust(this, keyID, target_trust);
 	QSignalSpy spy(transaction, &KGpgChangeTrust::done);
 	QObject::connect(transaction, &KGpgChangeTrust::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	KgpgCore::KgpgKeyList keyList = KgpgInterface::readPublicKeys(QStringList(keyID));
 	QVERIFY(!keyList.isEmpty());
 	QCOMPARE(keyList.first().ownerTrust(), target_trust);
 }
 
 void KGpgChangeTrustTest::testChangeTrust_data()
 {
 	QTest::addColumn<gpgme_validity_t>("target_trust");
 	QTest::newRow("ultimate") << GPGME_VALIDITY_ULTIMATE;
 	QTest::newRow("full") << GPGME_VALIDITY_FULL;
 	QTest::newRow("marginal") << GPGME_VALIDITY_MARGINAL;
 	QTest::newRow("never") << GPGME_VALIDITY_NEVER;
 }
 
 QTEST_MAIN(KGpgChangeTrustTest)
diff --git a/tests/kgpgdecrypt.cpp b/tests/kgpgdecrypt.cpp
index d04085e3..38add7d5 100644
--- a/tests/kgpgdecrypt.cpp
+++ b/tests/kgpgdecrypt.cpp
@@ -1,37 +1,37 @@
 #include "kgpgdecrypt.h"
 #include "../transactions/kgpgdecrypt.h"
 #include "common.h"
 
 #include <QSignalSpy>
 #include <QtTest>
 
 void KGpgDecryptTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgDecryptTest::testDecrypt(){
 	QFETCH(QString, encryptedFile);
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 	QString text = readFile(QLatin1String("keys/sample_text"));
 	QString encryptedText = readFile(encryptedFile);
 	KGpgDecrypt *transaction = new KGpgDecrypt(this, encryptedText);
 	QObject::connect(transaction, &KGpgDecrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(transaction, &KGpgDecrypt::done);
 	addPasswordArguments(transaction, passphrase);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QVERIFY(text.compare(transaction->decryptedText().join(QLatin1Char('\n'))));
 }
 
 void KGpgDecryptTest::testDecrypt_data(){
 	QTest::addColumn<QString>("encryptedFile");
 	QTest::newRow("AsciiArmored") << QString(QLatin1String("keys/encrypt_text.txt"));
 	QTest::newRow("HideKeyId") << QString(QLatin1String("keys/encrypt_text_hide_key_id.txt"));
 	QTest::newRow("Symmetrical") << QString(QLatin1String("keys/encrypted_symmetrical.txt"));
 }
 
 QTEST_MAIN(KGpgDecryptTest)
diff --git a/tests/kgpgdelkey.cpp b/tests/kgpgdelkey.cpp
index c5a1eb07..1d40213f 100644
--- a/tests/kgpgdelkey.cpp
+++ b/tests/kgpgdelkey.cpp
@@ -1,46 +1,46 @@
 #include "kgpgdelkey.h"
 #include "../core/kgpgkey.h"
 #include "../core/KGpgRootNode.h"
 #include "../kgpginterface.h"
 #include "../model/kgpgitemmodel.h"
 #include "../transactions/kgpgdelkey.h"
 #include "common.h"
 
 #include <QSignalSpy>
 #include <QtTest>
 
 void KGpgDelKeyTest::init()
 {
 	resetGpgConf(m_tempdir);
 }
 
 void KGpgDelKeyTest::testDeleteKey()
 {
 	QFETCH(QString, passphrase);
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 	QString keyId = QLatin1String("BA7695F3C550DF14");
 	KGpgItemModel *model = new KGpgItemModel(this);
 	KGpgRootNode *rootNode = new KGpgRootNode(model);
 	rootNode->addKeys(QStringList(keyId));
 	KGpgKeyNode *keyNode = rootNode->findKey(keyId);
 	QVERIFY(keyNode != nullptr);
 	KGpgDelKey *transaction = new KGpgDelKey(this, keyNode);
 	QObject::connect(transaction, &KGpgDelKey::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(transaction, &KGpgDelKey::done);
 	transaction->addArgument("--yes");
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QCOMPARE(KgpgInterface::readSecretKeys().size(), 0);
 	QCOMPARE(KgpgInterface::readPublicKeys().size(), 0);
 }
 
 void KGpgDelKeyTest::testDeleteKey_data()
 {
 	QTest::addColumn<QString>("passphrase");
 	QTest::newRow("public") << QString();
 	QTest::newRow("secret")
 		<< readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 }
 
 QTEST_MAIN(KGpgDelKeyTest)
diff --git a/tests/kgpgencrypt.cpp b/tests/kgpgencrypt.cpp
index 29996c77..7a719c27 100644
--- a/tests/kgpgencrypt.cpp
+++ b/tests/kgpgencrypt.cpp
@@ -1,143 +1,143 @@
 #include "kgpgencrypt.h"
 
 #include "common.h"
 #include "../transactions/kgpgencrypt.h"
 #include "../transactions/kgpgdecrypt.h"
 
 #include <QLatin1Char>
 #include <QLatin1String>
 #include <QSignalSpy>
 #include <QStringList>
 #include <QtTest>
 
 void KGpgEncryptTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgEncryptTest::testAsciiArmoredEncryption()
 {
 	//Add keys to keyring
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 
 	//Encrypt text
 	QString text = readFile(QLatin1String("keys/sample_text"));
 	QStringList userIds(QLatin1String("Test KGpg"));
 	KGpgEncrypt *encryption = new KGpgEncrypt(
 		this, userIds, text,
 		KGpgEncrypt::AsciiArmored | KGpgEncrypt::AllowUntrustedEncryption);
 	QObject::connect(encryption, &KGpgEncrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(encryption, &KGpgEncrypt::done);
 	encryption->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 
 	QString encryptedText = encryption->encryptedText().join("\n");
 	//Check if the encrypted text has a header and footer
 	QVERIFY(encryptedText.startsWith(QLatin1String("-----BEGIN PGP MESSAGE-----")));
 	QVERIFY(encryptedText.endsWith(QLatin1String("-----END PGP MESSAGE-----")));
 	//Test if encrypted text contains "KGpg"
 	QVERIFY(!encryptedText.contains(QLatin1String("KGpg")));
 	// check that the helper function also thinks it's encrypted
 	QVERIFY(KGpgDecrypt::isEncryptedText(encryptedText, nullptr, nullptr));
 	int startPos = -1;
 	QVERIFY(KGpgDecrypt::isEncryptedText(encryptedText, &startPos, nullptr));
 	QCOMPARE(startPos, 0);
 
 	//Decrypt encrypted text
 	KGpgDecrypt *decryption = new KGpgDecrypt(this, encryptedText);
 	QObject::connect(decryption, &KGpgDecrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy2(decryption, &KGpgDecrypt::done);
 	addPasswordArguments(decryption, passphrase);
 	decryption->start();
 	QVERIFY(spy2.wait());
 
 	//Check if decrypted text is equal to original text
 	QVERIFY(text.compare(decryption->decryptedText().join(QLatin1Char('\n'))));
 }
 
 void KGpgEncryptTest::testHideKeyIdEncryption()
 {
 	//Add keys to keyring
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 
 	//Encrypt text
 	QString text = readFile(QLatin1String("keys/sample_text"));
 	QStringList userIds(QLatin1String("Test KGpg"));
 	KGpgEncrypt *encryption =
 		new KGpgEncrypt(this, userIds, text,
 				KGpgEncrypt::AsciiArmored | KGpgEncrypt::HideKeyId |
 					KGpgEncrypt::AllowUntrustedEncryption);
 	QObject::connect(encryption, &KGpgEncrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(encryption, &KGpgEncrypt::done);
 	encryption->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	
 	QString encryptedText = encryption->encryptedText().join("\n");
 	//Check if the encrypted text has a header and footer
 	QVERIFY(encryptedText.startsWith(QLatin1String("-----BEGIN PGP MESSAGE-----")));
 	QVERIFY(encryptedText.endsWith(QLatin1String("-----END PGP MESSAGE-----")));
 	//Test if encrypted text contains "KGpg"
 	QVERIFY(!encryptedText.contains(QLatin1String("KGpg")));
 	//Check if encrypted text contains key Id
 	QString keyId = QLatin1String("BA7695F3C550DF14");
 	QString log = encryption->getMessages().join(QLatin1Char('\n'));
 	QVERIFY(!log.contains(keyId));
 	
 	//Decrypt encrypted text
 	KGpgDecrypt *decryption = new KGpgDecrypt(this, encryptedText);
 	QObject::connect(decryption, &KGpgDecrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy2(decryption, &KGpgDecrypt::done);
 	addPasswordArguments(decryption, passphrase);
 	decryption->start();
 	QVERIFY(spy2.wait());
 
 	//Check if decrypted text is equal to original text
 	QVERIFY(text.compare(decryption->decryptedText().join(QLatin1Char('\n'))));
 }
 
 void KGpgEncryptTest::testSymmetricEncryption()
 {
 	QString passphrase = QLatin1String("symmetric key");
 	QString text = readFile(QLatin1String("keys/sample_text"));
 	QStringList userIds;
 	
 	//Encrypt text
 	KGpgEncrypt *encryption = new KGpgEncrypt(
 		this, userIds, text,
 		KGpgEncrypt::AsciiArmored | KGpgEncrypt::AllowUntrustedEncryption);
 	QObject::connect(encryption, &KGpgEncrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy(encryption, &KGpgEncrypt::done);
 	addPasswordArguments(encryption, passphrase);
 	encryption->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	
 	QString encryptedText = encryption->encryptedText().join("\n");
 	//Check if the encrypted text has a header and footer
 	QVERIFY(encryptedText.startsWith(QLatin1String("-----BEGIN PGP MESSAGE-----")));
 	QVERIFY(encryptedText.endsWith(QLatin1String("-----END PGP MESSAGE-----")));
 	//Test if encrypted text contains "KGpg"
 	QVERIFY(!encryptedText.contains(QLatin1String("KGpg")));
 	
 	//Decrypt encrypted text
 	KGpgDecrypt *decryption = new KGpgDecrypt(this, encryptedText);
 	QObject::connect(decryption, &KGpgDecrypt::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	QSignalSpy spy2(decryption, &KGpgDecrypt::done);
 	addPasswordArguments(decryption, passphrase);
 	decryption->start();
 	QVERIFY(spy2.wait());
 
 	//Check if decrypted text is equal to original text
 	QVERIFY(text.compare(decryption->decryptedText().join(QLatin1Char('\n'))));
 }
 
 QTEST_MAIN(KGpgEncryptTest)
diff --git a/tests/kgpgexport.cpp b/tests/kgpgexport.cpp
index 64ecf680..bcf5ca33 100644
--- a/tests/kgpgexport.cpp
+++ b/tests/kgpgexport.cpp
@@ -1,82 +1,82 @@
 #include "kgpgexport.h"
 #include "../transactions/kgpgexport.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
 #include <QSignalSpy>
 #include <QtTest>
 #include <QTemporaryFile>
 
 void KGpgExportTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgExportTest::testExportPublicKeyToFile()
 {
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QTemporaryFile file("key_pub.asc");
 	QVERIFY(file.open());
 	QString filename = file.fileName();
 
 	QStringList ids(QLatin1String("BA7695F3C550DF14"));
 	// Output in Ascii mode
 	QStringList options(QLatin1String("--armor"));
 	KGpgExport *transaction = new KGpgExport(this, ids, filename, options, false);
 	QSignalSpy spy(transaction, &KGpgExport::done);
 	QObject::connect(transaction, &KGpgExport::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QString exportedKey = readFile(filename);
 	QString key = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QVERIFY(key.compare(exportedKey) == 0);
 }
 
 void KGpgExportTest::testExportSecretKeyToFile()
 {
 	QString passphrase = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass"));
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"), passphrase);
 	QTemporaryFile file("key.asc");
 	QVERIFY(file.open());
 	QString filename = file.fileName();
 	QStringList ids(QLatin1String("BA7695F3C550DF14"));
 	// Output in Ascii mode
 	QStringList options(QLatin1String("--armor"));
 	KGpgExport *transaction = new KGpgExport(this, ids, filename, options, true);
 	addPasswordArguments(transaction, passphrase);
 	QSignalSpy spy(transaction, &KGpgExport::done);
 	QObject::connect(transaction, &KGpgExport::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 
 	//reset gpg home dir
 	QVERIFY(resetGpgConf(m_tempdir));
 	//Import exported key
 	addGpgKey(m_tempdir, filename, passphrase);
 	KgpgCore::KgpgKeyList keys = KgpgInterface::readSecretKeys();
 	QString keyID = QLatin1String("BA7695F3C550DF14");
 	QCOMPARE(keys.size(), 1);
 	QVERIFY(keys.first().fullId().compare(keyID) == 0);
 }
 
 void KGpgExportTest::testExportPublicKeyToStdOutput()
 {
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 
 	QStringList ids(QLatin1String("BA7695F3C550DF14"));
 	// Output in Ascii mode
 	QStringList options(QLatin1String("--armor"));
 	KGpgExport *transaction = new KGpgExport(this, ids, options, false);
 	QSignalSpy spy(transaction, &KGpgExport::done);
 	QObject::connect(transaction, &KGpgExport::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QString exportedKey = QLatin1String(transaction->getOutputData());
 	QString key = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QVERIFY(key.compare(exportedKey) == 0);
 }
 
 QTEST_MAIN(KGpgExportTest)
diff --git a/tests/kgpgimport.cpp b/tests/kgpgimport.cpp
index 15a190cb..55393bdc 100644
--- a/tests/kgpgimport.cpp
+++ b/tests/kgpgimport.cpp
@@ -1,138 +1,138 @@
 #include "kgpgimport.h"
 #include "../transactions/kgpgimport.h"
 #include "common.h"
 
 #include <QList>
 #include <QString>
 #include <QStringList>
 #include <QSignalSpy>
 #include <QtTest>
 #include <QTextStream>
 #include <QUrl>
 
 void KGpgImportTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgImportTest::testImportTextKey()
 {
 	QString key = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QVERIFY(KGpgImport::isKey(key));
 	KGpgImport *transaction = new KGpgImport(this, key);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction, key](int result) {
 		QCOMPARE(transaction->getImportedKeys().size(), 1);
 		QString keyID = QLatin1String("BA7695F3C550DF14");
 		QVERIFY(transaction->getImportedKeys().first().startsWith(keyID));
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testImportKeyFromFile()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QCOMPARE(transaction->getImportedKeys().size(), 1);
 		QString keyID = QLatin1String("BA7695F3C550DF14");
 		QVERIFY(transaction->getImportedKeys().first().startsWith(keyID));
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testImportSameKeyTwice()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QCOMPARE(transaction->getImportedKeys().size(), 1);
 		QString keyID = QLatin1String("BA7695F3C550DF14");
 		QString duplicateMsg = QLatin1String("IMPORT_OK 0 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		qDebug() << "MESSAGES: " << transaction->getMessages();
 		QVERIFY(transaction->getImportedKeys().first().startsWith(keyID));
 		QVERIFY(transaction->getMessages().join(QLatin1Char(' ')).contains(duplicateMsg));
 		QEXPECT_FAIL("", "Test is broken. Possible bug!", Continue);
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testImportIdsAll()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QCOMPARE(transaction->getImportedIds(-1).size(), 1);
 		QString fingerprint = QLatin1String("FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		QVERIFY(transaction->getImportedIds(-1).first().compare(fingerprint) == 0);
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testImportIdsUnchanged()
 {
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QCOMPARE(transaction->getImportedIds(0).size(), 1);
 		QString fingerprint = QLatin1String("FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		QVERIFY(transaction->getImportedIds(0).first().compare(fingerprint) == 0);
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testLogMessage()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QString msg = QLatin1String("IMPORT_OK 1 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		QVERIFY(transaction->getMessages().join(QLatin1Char(' ')).contains(msg));
 		QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgImportTest::testImportSecretKey()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	addPasswordArguments(transaction,
 			     readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.pass")));
 	QSignalSpy spy(transaction, &KGpgImport::done);
 	QObject::connect(transaction, &KGpgImport::done, [transaction]() {
 		QVERIFY(transaction->getImportedKeys().size() == 1);
 		QString keyID = QLatin1String("BA7695F3C550DF14");
 		QVERIFY(transaction->getImportedKeys().first().startsWith(keyID));
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 QTEST_MAIN(KGpgImportTest)
diff --git a/tests/kgpgverify.cpp b/tests/kgpgverify.cpp
index 731453e1..0afc9b88 100644
--- a/tests/kgpgverify.cpp
+++ b/tests/kgpgverify.cpp
@@ -1,80 +1,80 @@
 #include "kgpgverify.h"
 #include "../transactions/kgpgverify.h"
 #include "common.h"
 
 #include <QList>
 #include <QString>
 #include <QSignalSpy>
 #include <QtTest>
 #include <QUrl>
 
 void KGpgVerifyTest::init()
 {
 	QVERIFY(resetGpgConf(m_tempdir));
 }
 
 void KGpgVerifyTest::testVerifySignedText()
 {
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"));
 	QString text = readFile(QLatin1String("keys/signed_text"));
 	KGpgVerify *transaction = new KGpgVerify(this, text);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgVerifyTest::testVerifySignedFile()
 {
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"));
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/signed_text")));
 	KGpgVerify *transaction = new KGpgVerify(this, list);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgTransaction::TS_OK)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgVerifyTest::testVerifyReturnMissingKey()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/signed_text")));
 	KGpgVerify *transaction = new KGpgVerify(this, list);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgVerify::TS_MISSING_KEY)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgVerifyTest::testVerifyMissingId()
 {
 	QList<QUrl> list;
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/signed_text")));
 	KGpgVerify *transaction = new KGpgVerify(this, list);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
 	QObject::connect(transaction, &KGpgVerify::done, [transaction]() {
 		QString keyID = QLatin1String("7882C615210F1022");
 		QVERIFY(transaction->missingId().compare(keyID) == 0);
 	});
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 void KGpgVerifyTest::testVerifyReturnBadSignature()
 {
 	QList<QUrl> list;
 	addGpgKey(m_tempdir, QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"));
 	list.append(QUrl::fromLocalFile(QLatin1String("keys/signed_bad_sig")));
 	KGpgVerify *transaction = new KGpgVerify(this, list);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, static_cast<int>(KGpgVerify::TS_BAD_SIGNATURE)); });
 	transaction->start();
-	QVERIFY(spy.wait());
+	QVERIFY(spy.wait(10000));
 }
 
 QTEST_MAIN(KGpgVerifyTest)