qt,tests: Move remarks test out and extend it

* lang/qt/tests/t-various.cpp (testRemarks): Move out.
* lang/qt/tests/t-remarks.cpp: New.
* lang/qt/tests/Makefile.am: Update accordingly.
--
While t-various is nice to add a quick test for more
extensive stuff it is better to move it in its own test.

This also tests with a key that has only a single uid.

lang/qt/tests/Makefile.am

@@ -27,11 +27,11 @@ TESTS_ENVIRONMENT = GNUPGHOME=$(GNUPGHOME)
 EXTRA_DIST = initial.test
 
 TESTS = initial.test t-keylist t-keylocate t-ownertrust t-tofuinfo \
-        t-encrypt t-verify t-various t-config
+        t-encrypt t-verify t-various t-config t-remarks
 
 moc_files = t-keylist.moc t-keylocate.moc t-ownertrust.moc t-tofuinfo.moc \
             t-encrypt.moc t-support.hmoc t-wkspublish.moc t-verify.moc \
-            t-various.moc t-config.moc
+            t-various.moc t-config.moc t-remarks.moc
 
 AM_LDFLAGS = -no-install
 
@@ -56,6 +56,7 @@ t_wkspublish_SOURCES = t-wkspublish.cpp $(support_src)
 t_verify_SOURCES = t-verify.cpp $(support_src)
 t_various_SOURCES = t-various.cpp $(support_src)
 t_config_SOURCES = t-config.cpp $(support_src)
+t_remarks_SOURCES = t-remarks.cpp $(support_src)
 run_keyformailboxjob_SOURCES = run-keyformailboxjob.cpp
 
 nodist_t_keylist_SOURCES = $(moc_files)
@@ -63,7 +64,7 @@ nodist_t_keylist_SOURCES = $(moc_files)
 BUILT_SOURCES = $(moc_files) pubring-stamp
 
 noinst_PROGRAMS = t-keylist t-keylocate t-ownertrust t-tofuinfo t-encrypt \
-    run-keyformailboxjob t-wkspublish t-verify t-various t-config
+    run-keyformailboxjob t-wkspublish t-verify t-various t-config t-remarks
 
 CLEANFILES = secring.gpg pubring.gpg pubring.kbx trustdb.gpg dirmngr.conf \
 	gpg-agent.conf pubring.kbx~ S.gpg-agent gpg.conf pubring.gpg~ \

lang/qt/tests/t-remarks.cpp

@@ -0,0 +1,321 @@
+/* t-remarks.cpp
+
+    This file is part of qgpgme, the Qt API binding for gpgme
+    Copyright (c) 2017 by Bundesamt für Sicherheit in der Informationstechnik
+    Software engineering by 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.
+*/
+
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+
+#include <QDebug>
+#include <QTest>
+#include <QSignalSpy>
+#include <QTemporaryDir>
+#include "keylistjob.h"
+#include "protocol.h"
+#include "signkeyjob.h"
+#include "context.h"
+
+#include "t-support.h"
+
+using namespace QGpgME;
+using namespace GpgME;
+
+class TestRemarks: public QGpgMETest
+{
+    Q_OBJECT
+
+Q_SIGNALS:
+    void asyncDone();
+
+public:
+    // This test is disabled (no slot) because the behavior
+    // is not clearly defined. Better to prevent that
+    // case in the UI
+    void testRemarkOwnKey()
+    {
+        // Get the signing key (alfa)
+        auto ctx = Context::create(OpenPGP);
+        QVERIFY (ctx);
+        Error err;
+        auto seckey = ctx->key("A0FF4590BB6122EDEF6E3C542D727CC768697734", err, true);
+        QVERIFY (!seckey.isNull());
+        QVERIFY (!err);
+
+        // Create the job
+        auto job = openpgp()->signKeyJob();
+        QVERIFY (job);
+
+        // Hack in the passphrase provider
+        auto jobCtx = Job::context(job);
+        TestPassphraseProvider provider;
+        jobCtx->setPassphraseProvider(&provider);
+        jobCtx->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job->setExportable(false);
+        std::vector<unsigned int> uids;
+        uids.push_back(0);
+        job->setUserIDsToSign(uids);
+        job->setSigningKey(seckey);
+        job->setRemark(QStringLiteral("Just GNU it!"));
+        job->setDupeOk(true);
+
+        connect(job, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                        const QString,
+                                                        const GpgME::Error) {
+            Q_EMIT asyncDone();
+            if (err2) {
+                qDebug() << "Error: " << err2.asString();
+            }
+            QVERIFY(err2);
+        });
+
+        job->start(seckey);
+        QSignalSpy spy (this, SIGNAL(asyncDone()));
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+    }
+
+
+private Q_SLOTS:
+
+    void testRemarkReplaceSingleUID()
+    {
+        // Get the signing key (alfa)
+        auto ctx = Context::create(OpenPGP);
+        QVERIFY (ctx);
+        Error err;
+        auto seckey = ctx->key("A0FF4590BB6122EDEF6E3C542D727CC768697734", err, true);
+        QVERIFY (!seckey.isNull());
+        QVERIFY (!err);
+
+        // Get the target key (xray)
+        auto target = ctx->key("04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", err, false);
+        QVERIFY (!target.isNull());
+        QVERIFY (!err);
+        QVERIFY (target.numUserIDs());
+
+        // Create the job
+        auto job = openpgp()->signKeyJob();
+        QVERIFY (job);
+
+        // Hack in the passphrase provider
+        auto jobCtx = Job::context(job);
+        TestPassphraseProvider provider;
+        jobCtx->setPassphraseProvider(&provider);
+        jobCtx->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job->setExportable(false);
+        std::vector<unsigned int> uids;
+        uids.push_back(0);
+        job->setUserIDsToSign(uids);
+        job->setSigningKey(seckey);
+        job->setRemark(QStringLiteral("The quick brown fox jumps over the lazy dog"));
+
+        connect(job, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                        const QString,
+                                                        const GpgME::Error) {
+            Q_EMIT asyncDone();
+            QVERIFY(!err2);
+        });
+
+        job->start(target);
+        QSignalSpy spy (this, SIGNAL(asyncDone()));
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+
+        // At this point the remark should have been added.
+        target.update();
+        const char *remark = target.userID(0).remark(seckey, err);
+        QVERIFY(!err);
+        QVERIFY(remark);
+        QCOMPARE(QString::fromUtf8(remark), QStringLiteral("The quick brown fox "
+                                                           "jumps over the lazy dog"));
+
+        // Now replace the remark
+        auto job3 = openpgp()->signKeyJob();
+        QVERIFY (job3);
+
+        // Hack in the passphrase provider
+        auto jobCtx3 = Job::context(job3);
+        jobCtx3->setPassphraseProvider(&provider);
+        jobCtx3->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job3->setExportable(false);
+        job3->setUserIDsToSign(uids);
+        job3->setSigningKey(seckey);
+        job3->setDupeOk(true);
+        job3->setRemark(QStringLiteral("The quick brown fox jumps over Frodo"));
+
+        connect(job3, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                         const QString,
+                                                         const GpgME::Error) {
+            Q_EMIT asyncDone();
+            QVERIFY(!err2);
+        });
+
+        job3->start(target);
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+
+        target.update();
+        remark = target.userID(0).remark(seckey, err);
+        QVERIFY(!err);
+        QVERIFY(remark);
+        QCOMPARE(QString::fromUtf8(remark), QStringLiteral("The quick brown fox "
+                                                            "jumps over Frodo"));
+    }
+
+    void testRemarkReplaceMultiUID()
+    {
+        // Get the signing key (alfa)
+        auto ctx = Context::create(OpenPGP);
+        QVERIFY (ctx);
+        Error err;
+        auto seckey = ctx->key("A0FF4590BB6122EDEF6E3C542D727CC768697734", err, true);
+        QVERIFY (!seckey.isNull());
+        QVERIFY (!err);
+
+        // Get the target key (mallory / mike)
+        auto target = ctx->key("2686AA191A278013992C72EBBE794852BE5CF886", err, false);
+        QVERIFY (!target.isNull());
+        QVERIFY (!err);
+        QVERIFY (target.numUserIDs());
+
+        // Create the job
+        auto job = openpgp()->signKeyJob();
+        QVERIFY (job);
+
+        // Hack in the passphrase provider
+        auto jobCtx = Job::context(job);
+        TestPassphraseProvider provider;
+        jobCtx->setPassphraseProvider(&provider);
+        jobCtx->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job->setExportable(false);
+        std::vector<unsigned int> uids;
+        uids.push_back(0);
+        job->setUserIDsToSign(uids);
+        job->setSigningKey(seckey);
+        job->setRemark(QStringLiteral("Mallory is evil 😠"));
+
+        connect(job, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                        const QString,
+                                                        const GpgME::Error) {
+            Q_EMIT asyncDone();
+            QVERIFY(!err2);
+        });
+
+        job->start(target);
+        QSignalSpy spy (this, SIGNAL(asyncDone()));
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+
+        // At this point the remark should have been added.
+        target.update();
+        const char *remark = target.userID(0).remark(seckey, err);
+        QVERIFY(!err);
+        QVERIFY(remark);
+        QCOMPARE(QString::fromUtf8(remark), QStringLiteral("Mallory is evil 😠"));
+
+        // Try to replace it without dupeOK
+        auto job2 = openpgp()->signKeyJob();
+        QVERIFY (job2);
+
+        // Hack in the passphrase provider
+        auto jobCtx2 = Job::context(job2);
+        jobCtx2->setPassphraseProvider(&provider);
+        jobCtx2->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job2->setExportable(false);
+        job2->setUserIDsToSign(uids);
+        job2->setSigningKey(seckey);
+        job2->setRemark(QStringLiteral("Mallory is nice"));
+
+        connect(job2, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                         const QString,
+                                                         const GpgME::Error) {
+            Q_EMIT asyncDone();
+            QVERIFY(err2);
+        });
+
+        job2->start(target);
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+
+        // Now replace the remark
+        auto job3 = openpgp()->signKeyJob();
+        QVERIFY (job3);
+
+        // Hack in the passphrase provider
+        auto jobCtx3 = Job::context(job3);
+        jobCtx3->setPassphraseProvider(&provider);
+        jobCtx3->setPinentryMode(Context::PinentryLoopback);
+
+        // Setup the job
+        job3->setExportable(false);
+        job3->setUserIDsToSign(uids);
+        job3->setSigningKey(seckey);
+        job3->setDupeOk(true);
+        job3->setRemark(QStringLiteral("Mallory is nice"));
+
+        connect(job3, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
+                                                         const QString,
+                                                         const GpgME::Error) {
+            Q_EMIT asyncDone();
+            QVERIFY(!err2);
+        });
+
+        job3->start(target);
+        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
+
+        target.update();
+        remark = target.userID(0).remark(seckey, err);
+        QVERIFY(!err);
+        QVERIFY(remark);
+        QCOMPARE(QString::fromUtf8(remark), QStringLiteral("Mallory is nice"));
+    }
+
+    void initTestCase()
+    {
+        QGpgMETest::initTestCase();
+        const QString gpgHome = qgetenv("GNUPGHOME");
+        QVERIFY(copyKeyrings(gpgHome, mDir.path()));
+        qputenv("GNUPGHOME", mDir.path().toUtf8());
+    }
+
+private:
+    QTemporaryDir mDir;
+};
+
+QTEST_MAIN(TestRemarks)
+
+#include "t-remarks.moc"

lang/qt/tests/t-various.cpp

@@ -46,7 +46,6 @@
 #include "dn.h"
 #include "data.h"
 #include "dataprovider.h"
-#include "signkeyjob.h"
 
 #include "t-support.h"
 
@@ -171,116 +170,6 @@ private Q_SLOTS:
         QVERIFY(id_revoked);
     }
 
-    void testRemark()
-    {
-        // Get the signing key (alfa)
-        auto ctx = Context::create(OpenPGP);
-        QVERIFY (ctx);
-        Error err;
-        auto seckey = ctx->key("A0FF4590BB6122EDEF6E3C542D727CC768697734", err, true);
-        QVERIFY (!seckey.isNull());
-        QVERIFY (!err);
-
-        // Get the target key (mallory / mike)
-        auto target = ctx->key("2686AA191A278013992C72EBBE794852BE5CF886", err, false);
-        QVERIFY (!target.isNull());
-        QVERIFY (!err);
-        QVERIFY (target.numUserIDs());
-
-        // Create the job
-        auto job = openpgp()->signKeyJob();
-        QVERIFY (job);
-
-        // Hack in the passphrase provider
-        auto jobCtx = Job::context(job);
-        TestPassphraseProvider provider;
-        jobCtx->setPassphraseProvider(&provider);
-        jobCtx->setPinentryMode(Context::PinentryLoopback);
-
-        // Setup the job
-        job->setExportable(false);
-        std::vector<unsigned int> uids;
-        uids.push_back(0);
-        job->setUserIDsToSign(uids);
-        job->setSigningKey(seckey);
-        job->setRemark(QStringLiteral("Mallory is evil 😠"));
-
-        connect(job, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
-                                                        const QString,
-                                                        const GpgME::Error) {
-            Q_EMIT asyncDone();
-            QVERIFY(!err2);
-        });
-
-        job->start(target);
-        QSignalSpy spy (this, SIGNAL(asyncDone()));
-        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
-
-        // At this point the remark should have been added.
-        target.update();
-        const char *remark = target.userID(0).remark(seckey, err);
-        QVERIFY(!err);
-        Q_ASSERT(remark);
-        QCOMPARE(QString::fromUtf8(remark), QStringLiteral("Mallory is evil 😠"));
-
-        // Try to replace it without dupeOK
-        auto job2 = openpgp()->signKeyJob();
-        QVERIFY (job2);
-
-        // Hack in the passphrase provider
-        auto jobCtx2 = Job::context(job2);
-        jobCtx2->setPassphraseProvider(&provider);
-        jobCtx2->setPinentryMode(Context::PinentryLoopback);
-
-        // Setup the job
-        job2->setExportable(false);
-        job2->setUserIDsToSign(uids);
-        job2->setSigningKey(seckey);
-        job2->setRemark(QStringLiteral("Mallory is nice"));
-
-        connect(job2, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
-                                                         const QString,
-                                                         const GpgME::Error) {
-            Q_EMIT asyncDone();
-            QVERIFY(err2);
-        });
-
-        job2->start(target);
-        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
-
-        // Now replace the remark
-        auto job3 = openpgp()->signKeyJob();
-        QVERIFY (job3);
-
-        // Hack in the passphrase provider
-        auto jobCtx3 = Job::context(job3);
-        jobCtx3->setPassphraseProvider(&provider);
-        jobCtx3->setPinentryMode(Context::PinentryLoopback);
-
-        // Setup the job
-        job3->setExportable(false);
-        job3->setUserIDsToSign(uids);
-        job3->setSigningKey(seckey);
-        job3->setDupeOk(true);
-        job3->setRemark(QStringLiteral("Mallory is nice"));
-
-        connect(job3, &SignKeyJob::result, this, [this] (const GpgME::Error &err2,
-                                                         const QString,
-                                                         const GpgME::Error) {
-            Q_EMIT asyncDone();
-            QVERIFY(!err2);
-        });
-
-        job3->start(target);
-        QVERIFY(spy.wait(QSIGNALSPY_TIMEOUT));
-
-        target.update();
-        remark = target.userID(0).remark(seckey, err);
-        QVERIFY(!err);
-        Q_ASSERT(remark);
-        Q_ASSERT(QString::fromUtf8(remark) == QStringLiteral("Mallory is nice"));
-    }
-
     void testVersion()
     {
         QVERIFY(EngineInfo::Version("2.1.0") < EngineInfo::Version("2.1.1"));