Qt: Add encryption test and refactor testsuite

* lang/qt/tests/Makefile.am: Add t-encrypt and t-support.
* lang/qt/tests/t-support.cpp, lang/qt/tests/t-support.c (QGpgMETest):
New. Class to handle common cleanup / init.
* lang/qt/tests/t-keylist.cpp,
lang/qt/tests/t-keylocate.cpp,
lang/qt/tests/t-ownertrust.cpp,
lang/qt/tests/t-tofuinfo.cpp: Inherit QGpgMETest.
* lang/qt/tests/t-encrypt.cpp: New. Test Symetric and Asymectric
encryption. Mixed encryption test is disabled.

lang/qt/tests/Makefile.am

@@ -24,9 +24,11 @@ TESTS_ENVIRONMENT = GNUPGHOME=$(abs_builddir)
 
 EXTRA_DIST = initial.test
 
-TESTS = initial.test t-keylist t-keylocate t-ownertrust t-tofuinfo
+TESTS = initial.test t-keylist t-keylocate t-ownertrust t-tofuinfo \
+        t-encrypt
 
-moc_files = t-keylist.moc t-keylocate.moc t-ownertrust.moc t-tofuinfo.moc
+moc_files = t-keylist.moc t-keylocate.moc t-ownertrust.moc t-tofuinfo.moc \
+            t-encrypt.moc t-support.hmoc
 
 AM_LDFLAGS = -no-install
 
@@ -46,16 +48,19 @@ check-local: ./pubring-stamp
 # add this dependency:
 initial.test : check-local
 
-t_keylist_SOURCES = t-keylist.cpp
+support_src = t-support.h t-support.cpp
-t_keylocate_SOURCES = t-keylocate.cpp
+
-t_ownertrust_SOURCES = t-ownertrust.cpp
+t_keylist_SOURCES = t-keylist.cpp $(support_src)
-t_tofuinfo_SOURCES = t-tofuinfo.cpp t-support.h
+t_keylocate_SOURCES = t-keylocate.cpp $(support_src)
+t_ownertrust_SOURCES = t-ownertrust.cpp $(support_src)
+t_tofuinfo_SOURCES = t-tofuinfo.cpp $(support_src)
+t_encrypt_SOURCES = t-encrypt.cpp $(support_src)
 
 nodist_t_keylist_SOURCES = $(moc_files)
 
 BUILT_SOURCES = $(moc_files)
 
-noinst_PROGRAMS = t-keylist t-keylocate t-ownertrust t-tofuinfo
+noinst_PROGRAMS = t-keylist t-keylocate t-ownertrust t-tofuinfo t-encrypt
 
 CLEANFILES = secring.gpg pubring.gpg pubring.kbx trustdb.gpg dirmngr.conf \
 	gpg-agent.conf pubring.kbx~ S.gpg-agent gpg.conf pubring.gpg~ \
@@ -82,3 +87,6 @@ export GNUPGHOME := $(abs_builddir)
 
 .cpp.moc:
 	$(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@
+
+.h.hmoc:
+	$(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@

lang/qt/tests/t-encrypt.cpp

@@ -0,0 +1,194 @@
+/* t-encrypt.cpp
+
+    This file is part of qgpgme, the Qt API binding for gpgme
+    Copyright (c) 2016 Intevation GmbH
+
+    QGpgME 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 2 of the
+    License, or (at your option) any later version.
+
+    QGpgME 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, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+    In addition, as a special exception, the copyright holders give
+    permission to link the code of this program with any edition of
+    the Qt library by Trolltech AS, Norway (or with modified versions
+    of Qt that use the same license as Qt), and distribute linked
+    combinations including the two.  You must obey the GNU General
+    Public License in all respects for all of the code used other than
+    Qt.  If you modify this file, you may extend this exception to
+    your version of the file, but you are not obligated to do so.  If
+    you do not wish to do so, delete this exception statement from
+    your version.
+*/
+#include <QDebug>
+#include <QTest>
+#include <QTemporaryDir>
+#include "keylistjob.h"
+#include "encryptjob.h"
+#include "qgpgmeencryptjob.h"
+#include "encryptionresult.h"
+#include "decryptionresult.h"
+#include "qgpgmedecryptjob.h"
+#include "qgpgmebackend.h"
+#include "keylistresult.h"
+#include "t-support.h"
+
+using namespace QGpgME;
+using namespace GpgME;
+
+class EncryptionTest : public QGpgMETest
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+
+    void testSimpleEncryptDecrypt()
+    {
+        auto listjob = openpgp()->keyListJob(false, false, false);
+        std::vector<Key> keys;
+        auto keylistresult = listjob->exec(QStringList() << QStringLiteral("alfa@example.net"),
+                                          false, keys);
+        Q_ASSERT(!keylistresult.error());
+        Q_ASSERT(keys.size() == 1);
+        delete listjob;
+
+        auto job = openpgp()->encryptJob(/*ASCII Armor */true, /* Textmode */ true);
+        Q_ASSERT(job);
+        QByteArray cipherText;
+        auto result = job->exec(keys, QStringLiteral("Hello World").toUtf8(), Context::AlwaysTrust, cipherText);
+        delete job;
+        Q_ASSERT(!result.error());
+        const auto cipherString = QString::fromUtf8(cipherText);
+        Q_ASSERT(cipherString.startsWith("-----BEGIN PGP MESSAGE-----"));
+
+        /* Now decrypt */
+        auto ctx = Context::createForProtocol(OpenPGP);
+        ctx->setPassphraseProvider(new TestPassphraseProvider);
+        ctx->setPinentryMode(Context::PinentryLoopback);
+        auto decJob = new QGpgMEDecryptJob(ctx);
+        QByteArray plainText;
+        auto decResult = decJob->exec(cipherText, plainText);
+        Q_ASSERT(!result.error());
+        Q_ASSERT(QString::fromUtf8(plainText) == QStringLiteral("Hello World"));
+        delete decJob;
+    }
+
+    void testSymmetricEncryptDecrypt()
+    {
+        auto ctx = Context::createForProtocol(OpenPGP);
+        ctx->setPassphraseProvider(new TestPassphraseProvider);
+        ctx->setPinentryMode(Context::PinentryLoopback);
+        ctx->setArmor(true);
+        ctx->setTextMode(true);
+        auto job = new QGpgMEEncryptJob(ctx);
+        QByteArray cipherText;
+        auto result = job->exec(std::vector<Key>(), QStringLiteral("Hello symmetric World").toUtf8(), Context::AlwaysTrust, cipherText);
+        delete job;
+        Q_ASSERT(!result.error());
+        const auto cipherString = QString::fromUtf8(cipherText);
+        Q_ASSERT(cipherString.startsWith("-----BEGIN PGP MESSAGE-----"));
+
+        killAgent(mDir.path());
+
+        auto ctx2 = Context::createForProtocol(OpenPGP);
+        ctx2->setPassphraseProvider(new TestPassphraseProvider);
+        ctx2->setPinentryMode(Context::PinentryLoopback);
+        auto decJob = new QGpgMEDecryptJob(ctx2);
+        QByteArray plainText;
+        auto decResult = decJob->exec(cipherText, plainText);
+        Q_ASSERT(!result.error());
+        Q_ASSERT(QString::fromUtf8(plainText) == QStringLiteral("Hello symmetric World"));
+        delete decJob;
+    }
+
+private:
+    /* Loopback and passphrase provider don't work for mixed encryption.
+     * So this test is disabled until gnupg(?) is fixed for this. */
+    void testMixedEncryptDecrypt()
+    {
+        auto listjob = openpgp()->keyListJob(false, false, false);
+        std::vector<Key> keys;
+        auto keylistresult = listjob->exec(QStringList() << QStringLiteral("alfa@example.net"),
+                                          false, keys);
+        Q_ASSERT(!keylistresult.error());
+        Q_ASSERT(keys.size() == 1);
+        delete listjob;
+
+        auto ctx = Context::createForProtocol(OpenPGP);
+        ctx->setPassphraseProvider(new TestPassphraseProvider);
+        ctx->setPinentryMode(Context::PinentryLoopback);
+        ctx->setArmor(true);
+        ctx->setTextMode(true);
+        auto job = new QGpgMEEncryptJob(ctx);
+        QByteArray cipherText;
+        printf("Before exec, flags: %x\n", Context::Symmetric | Context::AlwaysTrust);
+        auto result = job->exec(keys, QStringLiteral("Hello symmetric World").toUtf8(),
+                                static_cast<Context::EncryptionFlags>(Context::Symmetric | Context::AlwaysTrust),
+                                cipherText);
+        printf("After exec\n");
+        delete job;
+        Q_ASSERT(!result.error());
+        printf("Cipher:\n%s\n", cipherText.constData());
+        const auto cipherString = QString::fromUtf8(cipherText);
+        Q_ASSERT(cipherString.startsWith("-----BEGIN PGP MESSAGE-----"));
+
+        killAgent(mDir.path());
+
+        /* Now create a new homedir which with we test symetric decrypt. */
+        QTemporaryDir tmp;
+        qputenv("GNUPGHOME", tmp.path().toUtf8());
+        QFile agentConf(tmp.path() + QStringLiteral("/gpg-agent.conf"));
+        Q_ASSERT(agentConf.open(QIODevice::WriteOnly));
+        agentConf.write("allow-loopback-pinentry");
+        agentConf.close();
+
+        auto ctx2 = Context::createForProtocol(OpenPGP);
+        ctx2->setPassphraseProvider(new TestPassphraseProvider);
+        ctx2->setPinentryMode(Context::PinentryLoopback);
+        ctx2->setTextMode(true);
+        auto decJob = new QGpgMEDecryptJob(ctx2);
+        QByteArray plainText;
+        auto decResult = decJob->exec(cipherText, plainText);
+        Q_ASSERT(!decResult.error());
+        qDebug() << "Plain: " << plainText;
+        Q_ASSERT(QString::fromUtf8(plainText) == QStringLiteral("Hello symmetric World"));
+        delete decJob;
+
+        killAgent(tmp.path());
+        qputenv("GNUPGHOME", mDir.path().toUtf8());
+    }
+
+public Q_SLOT:
+
+    void initTestCase()
+    {
+        QGpgMETest::initTestCase();
+        const QString gpgHome = qgetenv("GNUPGHOME");
+        qputenv("GNUPGHOME", mDir.path().toUtf8());
+        Q_ASSERT(mDir.isValid());
+        QFile agentConf(mDir.path() + QStringLiteral("/gpg-agent.conf"));
+        Q_ASSERT(agentConf.open(QIODevice::WriteOnly));
+        agentConf.write("allow-loopback-pinentry");
+        agentConf.close();
+        Q_ASSERT(QFile::copy(gpgHome + QStringLiteral("/pubring.gpg"),
+                 mDir.path() + QStringLiteral("/pubring.gpg")));
+        Q_ASSERT(QFile::copy(gpgHome + QStringLiteral("/secring.gpg"),
+                 mDir.path() + QStringLiteral("/secring.gpg")));
+
+    }
+
+private:
+    QTemporaryDir mDir;
+};
+
+QTEST_MAIN(EncryptionTest)
+
+#include "t-encrypt.moc"

lang/qt/tests/t-keylist.cpp

@@ -37,10 +37,12 @@
 #include "qgpgmebackend.h"
 #include "keylistresult.h"
 
+#include "t-support.h"
+
 using namespace QGpgME;
 using namespace GpgME;
 
-class KeyListTest : public QObject
+class KeyListTest : public QGpgMETest
 {
     Q_OBJECT
 
@@ -48,7 +50,6 @@ Q_SIGNALS:
     void asyncDone();
 
 private Q_SLOTS:
-
     void testSingleKeyListSync()
     {
         KeyListJob *job = openpgp()->keyListJob(false, false, false);
@@ -99,19 +100,9 @@ private Q_SLOTS:
         QSignalSpy spy (this, SIGNAL(asyncDone()));
         Q_ASSERT(spy.wait());
     }
-
-    void initTestCase()
-    {
-        const QString gpgHome = qgetenv("GNUPGHOME");
-        QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set.");
-    }
-
-    void cleanupTestCase()
-    {
-        QCoreApplication::sendPostedEvents();
-    }
 };
 
 QTEST_MAIN(KeyListTest)
 
 #include "t-keylist.moc"
+#include "t-support.moc"

lang/qt/tests/t-keylocate.cpp

@@ -37,10 +37,12 @@
 #include "keylistresult.h"
 #include "engineinfo.h"
 
+#include "t-support.h"
+
 using namespace QGpgME;
 using namespace GpgME;
 
-class KeyLocateTest : public QObject
+class KeyLocateTest : public QGpgMETest
 {
     Q_OBJECT
 
@@ -119,16 +121,6 @@ private Q_SLOTS:
         Q_ASSERT(spy.wait());
     }
 
-    void initTestCase()
-    {
-        const QString gpgHome = qgetenv("GNUPGHOME");
-        QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set.");
-    }
-
-    void cleanupTestCase()
-    {
-        QCoreApplication::sendPostedEvents();
-    }
 private:
     QString mTestpattern;
 };

lang/qt/tests/t-ownertrust.cpp

@@ -37,10 +37,12 @@
 #include "keylistresult.h"
 #include "changeownertrustjob.h"
 
+#include "t-support.h"
+
 using namespace QGpgME;
 using namespace GpgME;
 
-class ChangeOwnerTrustTest: public QObject
+class ChangeOwnerTrustTest: public QGpgMETest
 {
     Q_OBJECT
 
@@ -98,17 +100,6 @@ private Q_SLOTS:
         key = keys.front();
         Q_ASSERT (key.ownerTrust() == Key::Unknown);
     }
-
-    void initTestCase()
-    {
-        const QString gpgHome = qgetenv("GNUPGHOME");
-        QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set.");
-    }
-
-    void cleanupTestCase()
-    {
-        QCoreApplication::sendPostedEvents();
-    }
 };
 
 QTEST_MAIN(ChangeOwnerTrustTest)

lang/qt/tests/t-support.cpp

@@ -0,0 +1,63 @@
+/* t-support.cpp
+
+    This file is part of qgpgme, the Qt API binding for gpgme
+    Copyright (c) 2016 Intevation GmbH
+
+    QGpgME 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 2 of the
+    License, or (at your option) any later version.
+
+    QGpgME 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, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+    In addition, as a special exception, the copyright holders give
+    permission to link the code of this program with any edition of
+    the Qt library by Trolltech AS, Norway (or with modified versions
+    of Qt that use the same license as Qt), and distribute linked
+    combinations including the two.  You must obey the GNU General
+    Public License in all respects for all of the code used other than
+    Qt.  If you modify this file, you may extend this exception to
+    your version of the file, but you are not obligated to do so.  If
+    you do not wish to do so, delete this exception statement from
+    your version.
+*/
+
+#include "t-support.h"
+
+#include <QTest>
+
+void QGpgMETest::initTestCase()
+{
+    const QString gpgHome = qgetenv("GNUPGHOME");
+    QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set.");
+}
+
+void QGpgMETest::cleanupTestCase()
+{
+    QCoreApplication::sendPostedEvents();
+    killAgent();
+    printf("Killed agent\n");
+}
+#include <QDebug>
+void killAgent(const QString& dir)
+{
+    QProcess proc;
+    proc.setProgram(QStringLiteral("gpg-connect-agent"));
+    QStringList arguments;
+    arguments << "-S " << dir + "/S.gpg-agent";
+    proc.start();
+    proc.waitForStarted();
+    proc.write("KILLAGENT\n");
+    proc.write("BYE\n");
+    proc.closeWriteChannel();
+    proc.waitForFinished();
+}
+
+#include "t-support.hmoc"

lang/qt/tests/t-support.h

@@ -28,9 +28,14 @@
     you do not wish to do so, delete this exception statement from
     your version.
 */
+#ifndef T_SUPPORT_H
+#define T_SUPPORT_H
 
 #include "interfaces/passphraseprovider.h"
 #include <QtGlobal>
+#include <QProcess>
+#include <QCoreApplication>
+#include <QObject>
 
 namespace GpgME
 {
@@ -43,5 +48,17 @@ public:
         return strdup("abc");
     }
 };
-
 } // namespace GpgME
+
+void killAgent(const QString &dir = qgetenv("GNUPGHOME"));
+
+class QGpgMETest : public QObject
+{
+    Q_OBJECT
+
+public Q_SLOTS:
+    void initTestCase();
+    void cleanupTestCase();
+};
+
+#endif // T_SUPPORT_H

lang/qt/tests/t-tofuinfo.cpp

@@ -55,7 +55,7 @@ static const char testMsg1[] =
 "=Crq6\n"
 "-----END PGP MESSAGE-----\n";
 
-class TofuInfoTest: public QObject
+class TofuInfoTest: public QGpgMETest
 {
     Q_OBJECT
 
@@ -216,8 +216,8 @@ private /* FIXME Disabled until GnuPG-Bug-Id 2405 is fixed Q_SLOTS */:
 
     void initTestCase()
     {
+        QGpgMETest::initTestCase();
         const QString gpgHome = qgetenv("GNUPGHOME");
-        QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set.");
         qputenv("GNUPGHOME", mDir.path().toUtf8());
         Q_ASSERT(mDir.isValid());
         QFile conf(mDir.path() + QStringLiteral("/gpg.conf"));