← Back to branch summary

~ubuntu-branches/ubuntu/precise/kdepim/precise-proposed

« back to all changes in this revision

Viewing changes to messagecomposer/tests/cryptofunctions.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2011-12-15 14:17:51 UTC
  • mfrom: (0.2.20)
  • Revision ID: package-import@ubuntu.com-20111215141751-yg890pa7vnlo34e0
Tags: 4:4.7.90-0ubuntu1
new upstream beta release

Show diffs side-by-side

added added

removed removed

Lines of Context:
messagecomposer/tests/cryptofunctions.cpp
44
44
#include <gpgme++/keylistresult.h>
45
45
#include <messagecore/tests/util.h>
46
46
 
 
47
// This is used to override the default message output handler. In unit tests, the special message
 
48
// output handler can write messages to stdout delayed, i.e. after the actual kDebug() call. This
 
49
// interfers with KPGP, since KPGP reads output from stdout, which needs to be kept clean.
 
50
void nullMessageOutput(QtMsgType type, const char *msg)
 
51
{
 
52
  Q_UNUSED(type);
 
53
  Q_UNUSED(msg);
 
54
}
 
55
 
47
56
bool ComposerTestUtil::verifySignature( KMime::Content* content, QByteArray signedContent, Kleo::CryptoMessageFormat f ) {
48
57
 
49
58
  // store it in a KMime::Message, that's what OTP needs
56
65
  TestCSSHelper testCSSHelper;
57
66
  MessageCore::Test::TestObjectTreeSource testSource( &testWriter, &testCSSHelper );
58
67
  MessageViewer::NodeHelper* nh = new MessageViewer::NodeHelper;
59
 
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, false, true, 0 );
 
68
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, true, 0 );
60
69
  MessageViewer::ProcessResult pResult( nh );
61
70
 
62
71
  // ensure the signed part exists and is parseable
74
83
 
75
84
    return true;
76
85
  } else if( f & Kleo::InlineOpenPGPFormat ) {
 
86
    qInstallMsgHandler(nullMessageOutput);
77
87
    otp.processTextPlainSubtype( resultMessage, pResult );
78
 
 
79
 
    otp.writeBodyString( resultMessage->encodedContent(),
80
 
                           resultMessage->from()->asUnicodeString() ,
81
 
                           nh->codec( resultMessage ),
82
 
                           pResult, true );
83
 
                          
84
 
    Q_ASSERT( pResult.inlineSignatureState() == MessageViewer::KMMsgPartiallySigned );
 
88
    qInstallMsgHandler(0);
 
89
    Q_ASSERT( pResult.inlineSignatureState() == MessageViewer::KMMsgFullySigned );
85
90
 
86
91
    return true;
87
92
  } else if( f & Kleo::AnySMIME ) {
97
102
    Q_ASSERT( nh->signatureState( resultMessage ) == MessageViewer::KMMsgFullySigned );
98
103
 
99
104
    // make sure the good sig is of what we think it is
100
 
    Q_ASSERT( otp.rawReplyString() == signedContent );
 
105
    Q_ASSERT( otp.rawDecryptedBody() == signedContent );
101
106
 
102
107
    return true;
103
108
  }
118
123
  TestCSSHelper testCSSHelper;
119
124
  MessageCore::Test::TestObjectTreeSource testSource( &testWriter, &testCSSHelper );
120
125
  MessageViewer::NodeHelper* nh = new MessageViewer::NodeHelper;
121
 
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, false, true, 0 );
 
126
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, true, 0 );
122
127
  MessageViewer::ProcessResult pResult( nh );
123
128
 
124
129
  if( f & Kleo::OpenPGPMIMEFormat ) {
139
144
    QString ref = QString::fromUtf8( encrContent ).trimmed();
140
145
    Q_ASSERT( body == ref );
141
146
*/
142
 
//     kDebug() << "raw:" << otp.rawReplyString();
 
147
//     kDebug() << "raw:" << otp.rawDecryptedBody();
143
148
//     kDebug() << "textContent:" << otp.textualContent();
144
 
    Q_ASSERT( otp.rawReplyString()== encrContent );
 
149
    Q_ASSERT( otp.rawDecryptedBody()== encrContent );
145
150
 
146
151
    return true;
147
152
    
148
153
  } else if( f & Kleo::InlineOpenPGPFormat ) {
 
154
    qInstallMsgHandler(nullMessageOutput);
149
155
    otp.processTextPlainSubtype( resultMessage, pResult );
150
 
 
151
 
    otp.writeBodyString( resultMessage->encodedContent(),
152
 
                           resultMessage->from()->asUnicodeString() ,
153
 
                           nh->codec( resultMessage ),
154
 
                           pResult, true );
155
 
 
156
 
    Q_ASSERT( pResult.inlineEncryptionState() == MessageViewer::KMMsgPartiallyEncrypted );
 
156
    qInstallMsgHandler(0);
 
157
    Q_ASSERT( pResult.inlineEncryptionState() == MessageViewer::KMMsgFullyEncrypted );
157
158
 
158
159
    return true;
159
160
  } else if( f & Kleo::AnySMIME) {
162
163
    Q_ASSERT( encPart );
163
164
    otp.parseObjectTree( resultMessage );
164
165
    Q_ASSERT( nh->encryptionState( resultMessage ) == MessageViewer::KMMsgFullyEncrypted );
165
 
    Q_ASSERT( otp.rawReplyString() == encrContent );
 
166
    Q_ASSERT( otp.rawDecryptedBody() == encrContent );
166
167
 
167
168
    return true;
168
169
  }
182
183
  TestCSSHelper testCSSHelper;
183
184
  MessageCore::Test::TestObjectTreeSource testSource( &testWriter, &testCSSHelper );
184
185
  MessageViewer::NodeHelper* nh = new MessageViewer::NodeHelper;
185
 
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, false, true, 0  );
 
186
  MessageViewer::ObjectTreeParser otp( &testSource, nh, 0, false, true, 0  );
186
187
  MessageViewer::ProcessResult pResult( nh );
187
188
 
188
189
  if( f & Kleo::OpenPGPMIMEFormat ) {
196
197
 
197
198
    KMime::Content* signedPart = MessageCore::NodeHelper::nextSibling( encPart );
198
199
//       kDebug() << "resultMessage:" << resultMessage->encodedContent();
199
 
//       kDebug() << "resultMessage rawresultstr:" << otp.rawReplyString() << "signed?" << resultMessage;
 
200
//       kDebug() << "resultMessage rawresultstr:" << otp.rawDecryptedBody() << "signed?" << resultMessage;
200
201
//       kDebug() << "signed Part:" << signedPart->encodedContent() << "Signed?" << ( nh->signatureState( signedPart ) == MessageViewer::KMMsgFullySigned );
201
202
    QList< KMime::Content* > extra = nh->extraContents( resultMessage.get() );
202
203
    kDebug() << "got extra:" << extra.size() << "for" << resultMessage;
205
206
    Q_ASSERT( extra.size() == 1 );
206
207
    Q_ASSERT( nh->signatureState( extra[ 0 ]  ) == MessageViewer::KMMsgFullySigned );
207
208
 
208
 
//     kDebug() << "raw reply and orig: " << otp.rawReplyString() << origContent;
209
 
    Q_ASSERT( otp.rawReplyString() == origContent );
 
209
//     kDebug() << "raw reply and orig: " << otp.rawDecryptedBody() << origContent;
 
210
    Q_ASSERT( otp.rawDecryptedBody() == origContent );
210
211
    return true;
211
212
  } else if( f & Kleo::InlineOpenPGPFormat ) {
 
213
    qInstallMsgHandler(nullMessageOutput);
212
214
    otp.processTextPlainSubtype( resultMessage.get(), pResult );
213
 
 
214
 
    otp.writeBodyString( resultMessage->encodedContent(),
215
 
                           resultMessage->from()->asUnicodeString() ,
216
 
                           nh->codec( resultMessage.get() ),
217
 
                           pResult, true );
218
 
 
219
 
    Q_ASSERT( pResult.inlineEncryptionState() == MessageViewer::KMMsgPartiallyEncrypted );
220
 
    Q_ASSERT( pResult.inlineSignatureState() == MessageViewer::KMMsgPartiallySigned );
 
215
    qInstallMsgHandler(0);
 
216
    Q_ASSERT( pResult.inlineEncryptionState() == MessageViewer::KMMsgFullyEncrypted );
 
217
    Q_ASSERT( pResult.inlineSignatureState() == MessageViewer::KMMsgFullySigned );
221
218
 
222
219
    return true;
223
220
  } else if( f & Kleo::AnySMIME ) {
230
227
    QList< KMime::Content* > extra = nh->extraContents( resultMessage.get() );
231
228
    kDebug() << "size:" << extra.size();
232
229
    Q_ASSERT( nh->signatureState( extra[ extra.size() - 1 ] ) == MessageViewer::KMMsgFullySigned );
233
 
    Q_ASSERT( otp.rawReplyString() == origContent );
 
230
    Q_ASSERT( otp.rawDecryptedBody() == origContent );
234
231
 
235
232
    return true;
236
233
  }