Differential D28824 Diff 80210 messagecomposer/autotests/encryptjobtest.cpp

Changeset View

Standalone View

View Options

messagecomposer/autotests/encryptjobtest.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Line(s)
53#include <decryptionresult.h> 53​#include <decryptionresult.h>
54 54​
55QTEST_MAIN(EncryptJobTest) 55​QTEST_MAIN(EncryptJobTest)
56 56​
57using namespace MessageComposer; 57​using namespace MessageComposer;
58 58​
59void EncryptJobTest::initTestCase() 59​void EncryptJobTest::initTestCase()
60{ 60​{
61 MessageComposer::Test::setupEnv(); 61​ Test::setupEnv();
62} 62​}
63 63​
64void EncryptJobTest::testContentDirect() 64​void EncryptJobTest::testContentDirect()
65{ 65​{
66 MessageComposer::Composer *composer = new MessageComposer::Composer; 66​ Composer composer;
67 QVector<QByteArray> charsets; 67​ const QVector<QByteArray> charsets = {"us-ascii"};
68 charsets << "us-ascii"; 68​ composer.globalPart()->setCharsets(charsets);
69 composer->globalPart()->setCharsets(charsets); 69​
70 MessageComposer::TextPart *part = new MessageComposer::TextPart(this); 70​ TextPart part;
71 part->setWordWrappingEnabled(false); 71​ part.setWordWrappingEnabled(false);
72 part->setCleanPlainText(QStringLiteral("one flew over the cuckoo's nest")); 72​ part.setCleanPlainText(QStringLiteral("one flew over the cuckoo's nest"));
73 73​
74 MessageComposer::MainTextJob *mainTextJob = new MessageComposer::MainTextJob(part, composer); 74​ auto mainTextJob = new MainTextJob(&part, &composer);
75 75​
76 QVERIFY(composer); ​
77 QVERIFY(mainTextJob); 76​ QVERIFY(mainTextJob);
78 77​
79 VERIFYEXEC(mainTextJob); 78​ VERIFYEXEC(mainTextJob);
80 79​
81 std::vector< GpgME::Key > keys = MessageComposer::Test::getKeys(); 80​ const std::vector< GpgME::Key > &keys = Test::getKeys();
82 81​
83 MessageComposer::EncryptJob *eJob = new MessageComposer::EncryptJob(composer); 82​ auto eJob = new EncryptJob(&composer);
84 83​
85 QVERIFY(eJob); 84​ QVERIFY(eJob);
86 85​
87 QStringList recipients; 86​ const QStringList recipients = {QStringLiteral("test@kolab.org")};
88 recipients << QString::fromLocal8Bit("test@kolab.org"); ​
89 87​
90 eJob->setContent(mainTextJob->content()); 88​ eJob->setContent(mainTextJob->content());
91 eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat); 89​ eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat);
92 eJob->setRecipients(recipients); 90​ eJob->setRecipients(recipients);
93 eJob->setEncryptionKeys(keys); 91​ eJob->setEncryptionKeys(keys);
94 92​
95 checkEncryption(eJob); 93​ checkEncryption(eJob);
96} 94​}
97 95​
98void EncryptJobTest::testContentChained() 96​void EncryptJobTest::testContentChained()
99{ 97​{
100 MessageComposer::Composer *composer = new MessageComposer::Composer; 98​ Composer composer;
101 QVector<QByteArray> charsets; 99​ const QVector<QByteArray> charsets = {"us-ascii"};
102 charsets << "us-ascii"; 100​ composer.globalPart()->setCharsets(charsets);
103 composer->globalPart()->setCharsets(charsets); ​
104 MessageComposer::TextPart *part = new MessageComposer::TextPart(this); ​
105 part->setWordWrappingEnabled(false); ​
106 part->setCleanPlainText(QStringLiteral("one flew over the cuckoo's nest")); ​
107 101​
108 MessageComposer::MainTextJob *mainTextJob = new MessageComposer::MainTextJob(part, composer); 102​ TextPart part;
103​ part.setWordWrappingEnabled(false);
104​ part.setCleanPlainText(QStringLiteral("one flew over the cuckoo's nest"));
105​
106​ auto mainTextJob = new MainTextJob(&part, &composer);
109 107​
110 QVERIFY(composer); ​
111 QVERIFY(mainTextJob); 108​ QVERIFY(mainTextJob);
112 109​
113 VERIFYEXEC(mainTextJob); 110​ VERIFYEXEC(mainTextJob);
114 111​
115 std::vector< GpgME::Key > keys = MessageComposer::Test::getKeys(); 112​ const std::vector< GpgME::Key > &keys = Test::getKeys();
116 MessageComposer::EncryptJob *eJob = new MessageComposer::EncryptJob(composer); 113​ auto eJob = new EncryptJob(&composer);
117 114​
118 QStringList recipients; 115​ const QStringList recipients = {QStringLiteral("test@kolab.org")};
119 recipients << QString::fromLocal8Bit("test@kolab.org"); ​
120 116​
121 eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat); 117​ eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat);
122 eJob->setRecipients(recipients); 118​ eJob->setRecipients(recipients);
123 eJob->setEncryptionKeys(keys); 119​ eJob->setEncryptionKeys(keys);
124 eJob->setContent(mainTextJob->content()); 120​ eJob->setContent(mainTextJob->content());
125 121​
126 checkEncryption(eJob); 122​ checkEncryption(eJob);
127} 123​}
128 124​
129void EncryptJobTest::testContentSubjobChained() 125​void EncryptJobTest::testContentSubjobChained()
130{ 126​{
131 std::vector< GpgME::Key > keys = MessageComposer::Test::getKeys(); 127​ const std::vector< GpgME::Key > &keys = Test::getKeys();
132 128​
133 QByteArray data(QString::fromLocal8Bit("one flew over the cuckoo's nest").toUtf8()); 129​ const QByteArray data(QStringLiteral("one flew over the cuckoo's nest").toUtf8());
134 KMime::Message skeletonMessage; 130​ KMime::Message skeletonMessage;
135 131​
136 KMime::Content *content = new KMime::Content; 132​ KMime::Content *content = new KMime::Content;
137 content->contentType(true)->setMimeType("text/plain"); 133​ content->contentType(true)->setMimeType("text/plain");
138 content->setBody(data); 134​ content->setBody(data);
139 135​
140 auto tJob = new TransparentJob; 136​ auto tJob = new TransparentJob;
141 tJob->setContent(content); 137​ tJob->setContent(content);
142 138​
143 QStringList recipients; 139​ const QStringList recipients = {QStringLiteral("test@kolab.org")};
144 recipients << QString::fromLocal8Bit("test@kolab.org"); ​
145 140​
146 Composer composer; 141​ Composer composer;
147 auto eJob = new MessageComposer::EncryptJob(&composer); 142​ auto eJob = new EncryptJob(&composer);
148 143​
149 eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat); 144​ eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat);
150 eJob->setRecipients(recipients); 145​ eJob->setRecipients(recipients);
151 eJob->setEncryptionKeys(keys); 146​ eJob->setEncryptionKeys(keys);
152 eJob->setSkeletonMessage(&skeletonMessage); 147​ eJob->setSkeletonMessage(&skeletonMessage);
153 eJob->appendSubjob(tJob); 148​ eJob->appendSubjob(tJob);
154 149​
155 checkEncryption(eJob); 150​ checkEncryption(eJob);
156} 151​}
157 152​
158void EncryptJobTest::testHeaders() 153​void EncryptJobTest::testHeaders()
159{ 154​{
160 std::vector< GpgME::Key > keys = MessageComposer::Test::getKeys(); 155​ const std::vector< GpgME::Key > &keys = Test::getKeys();
161 156​
162 MessageComposer::EncryptJob *eJob = new MessageComposer::EncryptJob(this); 157​ auto eJob = new EncryptJob(this);
163 158​
164 QVERIFY(eJob); 159​ QVERIFY(eJob);
165 160​
166 QByteArray data(QString::fromLocal8Bit("one flew over the cuckoo's nest").toUtf8()); 161​ const QByteArray data(QStringLiteral("one flew over the cuckoo's nest").toUtf8());
167 KMime::Content *content = new KMime::Content; 162​ auto content = new KMime::Content;
168 content->setBody(data); 163​ content->setBody(data);
169 164​
170 QStringList recipients; 165​ const QStringList recipients = {QStringLiteral("test@kolab.org")};
171 recipients << QString::fromLocal8Bit("test@kolab.org"); ​
172 166​
173 eJob->setContent(content); 167​ eJob->setContent(content);
174 eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat); 168​ eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat);
175 eJob->setRecipients(recipients); 169​ eJob->setRecipients(recipients);
176 eJob->setEncryptionKeys(keys); 170​ eJob->setEncryptionKeys(keys);
177 171​
178 VERIFYEXEC(eJob); 172​ VERIFYEXEC(eJob);
179 173​
180 QByteArray mimeType("multipart/encrypted"); 174​ QByteArray mimeType("multipart/encrypted");
181 QByteArray charset("ISO-8859-1"); 175​ QByteArray charset("ISO-8859-1");
182 176​
183 KMime::Content *result = eJob->content(); 177​ KMime::Content *result = eJob->content();
184 result->assemble(); 178​ result->assemble();
185 179​
186 QVERIFY(result->contentType(false)); 180​ QVERIFY(result->contentType(false));
187 QCOMPARE(result->contentType()->mimeType(), mimeType); 181​ QCOMPARE(result->contentType()->mimeType(), mimeType);
188 QCOMPARE(result->contentType()->charset(), charset); 182​ QCOMPARE(result->contentType()->charset(), charset);
189 QCOMPARE(result->contentType()->parameter(QString::fromLocal8Bit("protocol")), QString::fromLocal8Bit("application/pgp-encrypted")); 183​ QCOMPARE(result->contentType()->parameter(QStringLiteral("protocol")), QStringLiteral("application/pgp-encrypted"));
190 QCOMPARE(result->contentTransferEncoding()->encoding(), KMime::Headers::CE7Bit); 184​ QCOMPARE(result->contentTransferEncoding()->encoding(), KMime::Headers::CE7Bit);
185​
186​ delete result;
191} 187​}
192 188​
193void EncryptJobTest::testProtectedHeaders_data() 189​void EncryptJobTest::testProtectedHeaders_data()
194{ 190​{
195 QTest::addColumn<bool>("protectedHeaders"); 191​ QTest::addColumn<bool>("protectedHeaders");
196 QTest::addColumn<bool>("protectedHeadersObvoscate"); 192​ QTest::addColumn<bool>("protectedHeadersObvoscate");
197 QTest::addColumn<QString>("referenceFile"); 193​ QTest::addColumn<QString>("referenceFile");
198 194​
199 QTest::newRow("simple-obvoscate") << true << true << QStringLiteral("protected_headers-obvoscate.mbox"); 195​ QTest::newRow("simple-obvoscate") << true << true << QStringLiteral("protected_headers-obvoscate.mbox");
200 QTest::newRow("simple-non-obvoscate") << true << false << QStringLiteral("protected_headers-non-obvoscate.mbox"); 196​ QTest::newRow("simple-non-obvoscate") << true << false << QStringLiteral("protected_headers-non-obvoscate.mbox");
201 QTest::newRow("non-protected_headers") << false << false << QStringLiteral("non-protected_headers.mbox"); 197​ QTest::newRow("non-protected_headers") << false << false << QStringLiteral("non-protected_headers.mbox");
202} 198​}
203 199​
204void EncryptJobTest::testProtectedHeaders() 200​void EncryptJobTest::testProtectedHeaders()
205{ 201​{
206 QFETCH(bool,protectedHeaders); 202​ QFETCH(bool,protectedHeaders);
207 QFETCH(bool, protectedHeadersObvoscate); 203​ QFETCH(bool, protectedHeadersObvoscate);
208 QFETCH(QString, referenceFile); 204​ QFETCH(QString, referenceFile);
209 205​
210 std::vector< GpgME::Key > keys = MessageComposer::Test::getKeys(); 206​ const std::vector< GpgME::Key > &keys = Test::getKeys();
211 207​
212 MessageComposer::Composer composer; 208​ Composer composer;
213 MessageComposer::EncryptJob *eJob = new MessageComposer::EncryptJob(&composer); 209​ EncryptJob *eJob = new EncryptJob(&composer);
214 210​
215 QVERIFY(eJob); 211​ QVERIFY(eJob);
216 212​
217 const QByteArray data(QString::fromLocal8Bit("one flew over the cuckoo's nest").toUtf8()); 213​ const QByteArray data(QStringLiteral("one flew over the cuckoo's nest").toUtf8());
218 const QString subject(QStringLiteral("asdfghjklö")); 214​ const QString subject(QStringLiteral("asdfghjklö"));
219 215​
220 KMime::Content *content = new KMime::Content; 216​ auto content = new KMime::Content;
221 content->contentType(true)->setMimeType("text/plain"); 217​ content->contentType(true)->setMimeType("text/plain");
222 content->setBody(data); 218​ content->setBody(data);
223 219​
224 KMime::Message skeletonMessage; 220​ KMime::Message skeletonMessage;
225 skeletonMessage.contentType(true)->setMimeType("foo/bla"); 221​ skeletonMessage.contentType(true)->setMimeType("foo/bla");
226 skeletonMessage.to(true)->from7BitString("to@test.de, to2@test.de"); 222​ skeletonMessage.to(true)->from7BitString("to@test.de, to2@test.de");
227 skeletonMessage.cc(true)->from7BitString("cc@test.de, cc2@test.de"); 223​ skeletonMessage.cc(true)->from7BitString("cc@test.de, cc2@test.de");
228 skeletonMessage.bcc(true)->from7BitString("bcc@test.de, bcc2@test.de"); 224​ skeletonMessage.bcc(true)->from7BitString("bcc@test.de, bcc2@test.de");
229 skeletonMessage.subject(true)->fromUnicodeString(subject, "utf-8"); 225​ skeletonMessage.subject(true)->fromUnicodeString(subject, "utf-8");
230 226​
231 QStringList recipients; 227​ const QStringList recipients = {QStringLiteral("test@kolab.org")};
232 recipients << QString::fromLocal8Bit("test@kolab.org"); ​
233 228​
234 eJob->setContent(content); 229​ eJob->setContent(content);
235 eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat); 230​ eJob->setCryptoMessageFormat(Kleo::OpenPGPMIMEFormat);
236 eJob->setRecipients(recipients); 231​ eJob->setRecipients(recipients);
237 eJob->setEncryptionKeys(keys); 232​ eJob->setEncryptionKeys(keys);
238 eJob->setSkeletonMessage(&skeletonMessage); 233​ eJob->setSkeletonMessage(&skeletonMessage);
239 eJob->setProtectedHeaders(protectedHeaders); 234​ eJob->setProtectedHeaders(protectedHeaders);
240 eJob->setProtectedHeadersObvoscate(protectedHeadersObvoscate); 235​ eJob->setProtectedHeadersObvoscate(protectedHeadersObvoscate);
241 236​
242 VERIFYEXEC(eJob); 237​ VERIFYEXEC(eJob);
243 238​
244 if (protectedHeadersObvoscate) { 239​ if (protectedHeadersObvoscate) {
245 QCOMPARE(skeletonMessage.subject()->as7BitString(false), "..."); 240​ QCOMPARE(skeletonMessage.subject()->as7BitString(false), "...");
246 } else { 241​ } else {
247 QCOMPARE(skeletonMessage.subject()->asUnicodeString(), subject); 242​ QCOMPARE(skeletonMessage.subject()->asUnicodeString(), subject);
248 } 243​ }
249 244​
250 KMime::Content *result = eJob->content(); 245​ KMime::Content *result = eJob->content();
251 result->assemble(); 246​ result->assemble();
252 247​
253 KMime::Content *encPart = MessageComposer::Util::findTypeInMessage(result, "application", "octet-stream"); 248​ KMime::Content *encPart = Util::findTypeInMessage(result, "application", "octet-stream");
254 KMime::Content tempNode; 249​ KMime::Content tempNode;
255 { 250​ {
256 QByteArray plainText; 251​ QByteArray plainText;
257 auto job = QGpgME::openpgp()->decryptVerifyJob(); 252​ auto job = QGpgME::openpgp()->decryptVerifyJob();
258 job->exec(encPart->encodedBody(), plainText); 253​ job->exec(encPart->encodedBody(), plainText);
259 254​
260 tempNode.setContent(KMime::CRLFtoLF(plainText.constData())); 255​ tempNode.setContent(KMime::CRLFtoLF(plainText.constData()));
261 tempNode.parse(); 256​ tempNode.parse();
Show All 12 Lines
274 if (!encodedContent.endsWith('\n')) { 269​ if (!encodedContent.endsWith('\n')) {
275 f.write("\n"); 270​ f.write("\n");
276 } 271​ }
277 f.close(); 272​ f.close();
278 273​
279 Test::compareFile(referenceFile, QStringLiteral(MAIL_DATA_DIR "/")+referenceFile); 274​ Test::compareFile(referenceFile, QStringLiteral(MAIL_DATA_DIR "/")+referenceFile);
280} 275​}
281 276​
282void EncryptJobTest::checkEncryption(MessageComposer::EncryptJob *eJob) 277​void EncryptJobTest::checkEncryption(EncryptJob *eJob)
283{ 278​{
284 VERIFYEXEC(eJob); 279​ VERIFYEXEC(eJob);
285 280​
286 KMime::Content *result = eJob->content(); 281​ KMime::Content *result = eJob->content();
287 Q_ASSERT(result); 282​ Q_ASSERT(result);
288 result->assemble(); 283​ result->assemble();
289 284​
290 ComposerTestUtil::verifyEncryption(result, QString::fromLocal8Bit("one flew over the cuckoo's nest").toUtf8(), Kleo::OpenPGPMIMEFormat); 285​ ComposerTestUtil::verifyEncryption(result, QStringLiteral("one flew over the cuckoo's nest").toUtf8(), Kleo::OpenPGPMIMEFormat);
286​
287​ delete result;
291} 288​}