diff --git a/tests/common.cpp b/tests/common.cpp
index 4dd6ab96..74066c90 100644
--- a/tests/common.cpp
+++ b/tests/common.cpp
@@ -1,70 +1,71 @@
 #include "common.h"
 #include "../kgpginterface.h"
 #include "../kgpgsettings.h"
+#include "../transactions/kgpgtransaction.h"
 
-#include <QDateTime>
+#include <gpgme.h>
 #include <QDir>
 #include <QFile>
 #include <QIODevice>
-#include <QLatin1String>
 #include <QProcess>
-#include <stdlib.h>
+#include <QString>
 
 bool resetGpgConf()
 {
 	const QString dot_gpg(QLatin1String(".gnupg"));
 	QDir dir(dot_gpg);
 	dir.removeRecursively();
 	if (!QDir::current().mkdir(dot_gpg))
 		return false;
 	if (!QFile::setPermissions(QDir::currentPath() + QLatin1Char('/') + dot_gpg,
-				   QFileDevice::ReadOwner | QFileDevice::WriteOwner |
-					   QFileDevice::ExeOwner))
+				   QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ExeOwner))
 		return false;
 	return QFile::copy(QLatin1String("gnupg/gpg.conf"), QLatin1String(".gnupg/gpg.conf"));
 }
 
 QString readFile(const QString &filename)
 {
 	QFile file(filename);
-	file.open(QIODevice::ReadOnly);
-	return QLatin1String(file.readAll());
+	if (file.open(QIODevice::ReadOnly))
+		return QLatin1String(file.readAll());
+	else
+		return QString();
 }
 
 void addGpgKey(const QString &file, const QString &password)
 {
 	QString conf = QLatin1String(".gnupg/gpg.conf");
 	QString gpgHome = QLatin1String(".gnupg");
 	QString command = QLatin1String("gpg");
 	QStringList args;
 	args.push_back(QLatin1String("--no-secmem-warning"));
 	args.push_back(QLatin1String("--no-tty"));
 	args.push_back(QLatin1String("--batch"));
 	if (!password.isEmpty()) {
 		args.push_back(QLatin1String("--passphrase"));
 		args.push_back(password);
 	}
 	args.push_back(QLatin1String("--options"));
 	args.push_back(conf);
 	args.push_back(QLatin1String("--homedir"));
 	args.push_back(gpgHome);
 	args.push_back(QLatin1String("--debug-level"));
 	args.push_back(QLatin1String("none"));
 	args.push_back(QLatin1String("--status-fd=1"));
 	args.push_back(QLatin1String("--import"));
 	args.push_back(QLatin1String("--allow-secret-key-import"));
 	args.push_back(QLatin1String("--command-fd=0"));
 	args.push_back(file);
 	QProcess process;
 	process.execute(command, args);
 	qDebug() << "Added Gpg key: " << file;
 }
 
-void addPasswordArguments(KGpgTransaction *transaction, QString passphrase)
+void addPasswordArguments(KGpgTransaction *transaction, const QString &passphrase)
 {
 	transaction->addArgument(QLatin1String("--batch"));
 	transaction->addArgument(QLatin1String("--passphrase"));
 	transaction->addArgument(passphrase);
 	transaction->addArgument(QLatin1String("--pinentry-mode"));
 	transaction->addArgument(QLatin1String("loopback"));
 }
diff --git a/tests/common.h b/tests/common.h
index d274a0fd..7bd93bec 100644
--- a/tests/common.h
+++ b/tests/common.h
@@ -1,12 +1,13 @@
 #ifndef COMMON_TEST_H
 #define COMMON_TEST_H
-#include "../transactions/kgpgtransaction.h"
 
-#include <gpgme.h>
 #include <QString>
 
+class KGpgTransaction;
+
 bool resetGpgConf();
 QString readFile(const QString& filename);
 void addGpgKey(const QString& file, const QString& password = QString());
-void addPasswordArguments(KGpgTransaction *transaction, QString passphrase);
+void addPasswordArguments(KGpgTransaction *transaction, const QString &passphrase);
+
 #endif
diff --git a/tests/kgpgchangedisable.cpp b/tests/kgpgchangedisable.cpp
index 5e8c1238..088662a7 100644
--- a/tests/kgpgchangedisable.cpp
+++ b/tests/kgpgchangedisable.cpp
@@ -1,49 +1,48 @@
 #include "kgpgchangedisable.h"
 #include "../transactions/kgpgchangedisable.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
 #include <QSignalSpy>
+#include <QtTest/QtTest>
 
 void KGpgChangeDisableTest::init()
 {
 	QVERIFY(resetGpgConf());
 	addGpgKey(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) {
-		// QEXPECT_FAIL("", "Test is broken. Possible bug!", Continue);
 		QCOMPARE(result, KGpgTransaction::TS_OK);
 	});
 	transaction->start();
 	QVERIFY(spy.wait());
 	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());
 	QObject::connect(transaction, &KGpgChangeDisable::done, [](int result) {
-		// QEXPECT_FAIL("", "Test is broken. Possible bug!", Continue);
 		QCOMPARE(result, KGpgTransaction::TS_OK);
 	});
 	transaction->setDisable(false);
 	transaction->start();
 	QVERIFY(spy.wait());
 	KgpgCore::KgpgKeyList keyList = KgpgInterface::readPublicKeys(QStringList(keyID));
 	QVERIFY(!keyList.isEmpty());
 	QVERIFY(keyList.first().valid());
 }
 
 QTEST_MAIN(KGpgChangeDisableTest)
diff --git a/tests/kgpgchangedisable.h b/tests/kgpgchangedisable.h
index 246d0ad1..4857c4e2 100644
--- a/tests/kgpgchangedisable.h
+++ b/tests/kgpgchangedisable.h
@@ -1,13 +1,14 @@
 #ifndef KGPGCHANGEDISABLE_TEST_H
 #define KGPGCHANGEDISABLE_TEST_H
-#include <QtTest/QtTest>
+
+#include <QObject>
 
 class KGpgChangeDisableTest : public QObject {
 	Q_OBJECT
 private slots:
 	void init();
 	void testDisableKey();
 	void testEnableKey();
 };
 
 #endif
diff --git a/tests/kgpgchangetrust.cpp b/tests/kgpgchangetrust.cpp
index a5ec7f99..bbdb434a 100644
--- a/tests/kgpgchangetrust.cpp
+++ b/tests/kgpgchangetrust.cpp
@@ -1,39 +1,40 @@
 #include "kgpgchangetrust.h"
 #include "../transactions/kgpgchangetrust.h"
 #include "../kgpginterface.h"
 #include "common.h"
 
-#include <QLatin1String>
+#include <QString>
 #include <QSignalSpy>
+#include <QtTest/QtTest>
 
 void KGpgChangeTrustTest::init()
 {
 	QVERIFY(resetGpgConf());
 }
 
 void KGpgChangeTrustTest::testChangeTrust()
 {
 	QFETCH(gpgme_validity_t, target_trust);
 	QLatin1String keyID("BA7695F3C550DF14");
 	addGpgKey(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, KGpgTransaction::TS_OK); });
 	transaction->start();
 	QVERIFY(spy.wait());
 	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;
 }
 
-// #include "kgpgchangetrust.moc"
 QTEST_MAIN(KGpgChangeTrustTest)
diff --git a/tests/kgpgchangetrust.h b/tests/kgpgchangetrust.h
index 4e9ce52e..f9a93efe 100644
--- a/tests/kgpgchangetrust.h
+++ b/tests/kgpgchangetrust.h
@@ -1,16 +1,18 @@
 #ifndef KGPGCHANGETRUST_TEST_H
 #define KGPGCHANGETRUST_TEST_H
+
 #include <gpgme.h>
-#include <QtTest/QtTest>
+#include <QMetaType>
+#include <QObject>
 
 class KGpgChangeTrustTest : public QObject {
 	Q_OBJECT
 private slots:
 	void init();
 	void testChangeTrust();
 	void testChangeTrust_data();
-
 };
 
 Q_DECLARE_METATYPE(gpgme_validity_t)
+
 #endif
diff --git a/tests/kgpgimport.cpp b/tests/kgpgimport.cpp
index c71a7092..474b0385 100644
--- a/tests/kgpgimport.cpp
+++ b/tests/kgpgimport.cpp
@@ -1,149 +1,137 @@
 #include "kgpgimport.h"
 #include "../transactions/kgpgimport.h"
 #include "common.h"
 
-#include <QFile>
-#include <QIODevice>
-#include <QLatin1String>
-#include <QLatin1Char>
 #include <QList>
 #include <QString>
 #include <QStringList>
 #include <QSignalSpy>
+#include <QtTest/QtTest>
 #include <QTextStream>
 #include <QUrl>
 
 void KGpgImportTest::init()
 {
 	QVERIFY(resetGpgConf());
 }
 
 void KGpgImportTest::testImportTextKey()
 {
 	QString key = readFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	KGpgImport *transaction = new KGpgImport(this, key);
 	QSignalSpy spy(transaction, &KGpgImport::done);
-	transaction->start();
 	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, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgImportTest::testImportKeyFromFile()
 {
 	QList<QUrl> list;
-	list.append(
-		QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
+	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
-	transaction->start();
 	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, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgImportTest::testImportSameKeyTwice()
 {
 	QList<QUrl> list;
-	list.append(
-		QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
+	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());
-	transaction->start();
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
 		QCOMPARE(transaction->getImportedKeys().size(), 1);
 		QString keyID = QLatin1String("BA7695F3C550DF14");
-		QString duplicateMsg =
-			QLatin1String("IMPORT_OK 0 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
+		QString duplicateMsg = QLatin1String("IMPORT_OK 0 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		qDebug() << "MESSAGES: " << transaction->getMessages();
 		QVERIFY(transaction->getImportedKeys().first().startsWith(keyID));
-		QVERIFY(transaction->getMessages()
-				.join(QLatin1Char(' '))
-				.contains(duplicateMsg));
+		QVERIFY(transaction->getMessages().join(QLatin1Char(' ')).contains(duplicateMsg));
 		QEXPECT_FAIL("", "Test is broken. Possible bug!", Continue);
 		QCOMPARE(result, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgImportTest::testImportIdsAll()
 {
 	QList<QUrl> list;
-	list.append(
-		QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
+	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
-	transaction->start();
 	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, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgImportTest::testImportIdsUnchanged()
 {
 	addGpgKey(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc"));
 	QList<QUrl> list;
-	list.append(
-		QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
+	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
-	transaction->start();
 	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, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgImportTest::testLogMessage()
 {
 	QList<QUrl> list;
-	list.append(
-		QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
+	list.append(QUrl::fromLocalFile(QLatin1String("keys/kgpgtest_BA7695F3C550DF14_pub.asc")));
 	KGpgImport *transaction = new KGpgImport(this, list);
 	QSignalSpy spy(transaction, &KGpgImport::done);
-	transaction->start();
 	QObject::connect(transaction, &KGpgImport::done, [transaction](int result) {
-		QString msg =
-			QLatin1String("IMPORT_OK 1 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
+		QString msg = QLatin1String("IMPORT_OK 1 FBAF08DD7D9D0921C15DDA9FBA7695F3C550DF14");
 		QVERIFY(transaction->getMessages().join(QLatin1Char(' ')).contains(msg));
 		QCOMPARE(result, KGpgTransaction::TS_OK);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 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);
-	transaction->start();
 	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());
 }
 
 QTEST_MAIN(KGpgImportTest)
diff --git a/tests/kgpgimport.h b/tests/kgpgimport.h
index 8260650f..32ca89a7 100644
--- a/tests/kgpgimport.h
+++ b/tests/kgpgimport.h
@@ -1,20 +1,20 @@
 #ifndef KGPGIMPORT_TEST_H
 #define KGPGIMPORT_TEST_H
 
-#include <QtTest/QtTest>
+#include <QObject>
 
 class KGpgImportTest: public QObject
 {
 	Q_OBJECT
 private slots:
 	void init();
 	void testImportTextKey();
 	void testImportIdsAll();
 	void testImportIdsUnchanged();
 	void testImportKeyFromFile();
 	void testImportSameKeyTwice();
 	void testLogMessage();
 	void testImportSecretKey();
 };
 
 #endif
diff --git a/tests/kgpgverify.cpp b/tests/kgpgverify.cpp
index 0e885991..5ee23d73 100644
--- a/tests/kgpgverify.cpp
+++ b/tests/kgpgverify.cpp
@@ -1,78 +1,80 @@
 #include "kgpgverify.h"
 #include "../transactions/kgpgverify.h"
 #include "common.h"
 
 #include <QList>
-#include <QLatin1String>
+#include <QString>
 #include <QSignalSpy>
+#include <QtTest/QtTest>
+#include <QUrl>
 
 void KGpgVerifyTest::init()
 {
 	QVERIFY(resetGpgConf());
 }
 
 void KGpgVerifyTest::testVerifySignedText()
 {
 	addGpgKey(QLatin1String("keys/kgpgtest_BA7695F3C550DF14.asc"));
 	QString text = readFile(QLatin1String("keys/signed_text"));
 	KGpgVerify *transaction = new KGpgVerify(this, text);
 	QSignalSpy spy(transaction, &KGpgVerify::done);
-	transaction->start();
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, KGpgTransaction::TS_OK); });
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgVerifyTest::testVerifySignedFile()
 {
 	addGpgKey(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);
-	transaction->start();
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, KGpgTransaction::TS_OK); });
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 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);
-	transaction->start();
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, KGpgVerify::TS_MISSING_KEY); });
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 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);
-	transaction->start();
 	QObject::connect(transaction, &KGpgVerify::done, [transaction]() {
 		QString keyID = QLatin1String("7882C615210F1022");
 		QVERIFY(transaction->missingId().compare(keyID) == 0);
 	});
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 void KGpgVerifyTest::testVerifyReturnBadSignature()
 {
 	QList<QUrl> list;
 	addGpgKey(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);
-	transaction->start();
 	QObject::connect(transaction, &KGpgVerify::done,
 			 [](int result) { QCOMPARE(result, KGpgVerify::TS_BAD_SIGNATURE); });
+	transaction->start();
 	QVERIFY(spy.wait());
 }
 
 QTEST_MAIN(KGpgVerifyTest)
diff --git a/tests/kgpgverify.h b/tests/kgpgverify.h
index 95abdf62..32dc0e5d 100644
--- a/tests/kgpgverify.h
+++ b/tests/kgpgverify.h
@@ -1,13 +1,18 @@
-#include <QtTest/QtTest>
+#ifndef KGPGVERIFYTEST_H
+#define KGPGVERIFYTEST_H
+
+#include <QObject>
 
 class KGpgVerifyTest: public QObject
 {
 	Q_OBJECT
 private slots:
 	void init();
 	void testVerifySignedText();
 	void testVerifySignedFile();
 	void testVerifyReturnMissingKey();
 	void testVerifyMissingId();
 	void testVerifyReturnBadSignature();
 };
+
+#endif // KGPGVERIFYTEST_H