sink/tests/mailtest.cpp

0001 /*
0002  *   Copyright (C) 2016 Christian Mollekopf <chrigi_1@fastmail.fm>
0003  *
0004  *   This program is free software; you can redistribute it and/or modify
0005  *   it under the terms of the GNU General Public License as published by
0006  *   the Free Software Foundation; either version 2 of the License, or
0007  *   (at your option) any later version.
0008  *
0009  *   This program is distributed in the hope that it will be useful,
0010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
0011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0012  *   GNU General Public License for more details.
0013  *
0014  *   You should have received a copy of the GNU General Public License
0015  *   along with this program; if not, write to the
0016  *   Free Software Foundation, Inc.,
0017  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
0018  */
0019 #include "mailtest.h"
0020
0021 #include <QTest>
0022
0023 #include <QString>
0024 #include <KMime/Message>
0025
0026 #include "store.h"
0027 #include "resourcecontrol.h"
0028 #include "log.h"
0029 #include "test.h"
0030
0031 using namespace Sink;
0032 using namespace Sink::ApplicationDomain;
0033
0034 void MailTest::initTestCase()
0035 {
0036     Test::initTest();
0037     QVERIFY(isBackendAvailable());
0038     resetTestEnvironment();
0039     auto resource = createResource();
0040     QVERIFY(!resource.getResourceType().isEmpty());
0041     QVERIFY(!resource.identifier().isEmpty());
0042
0043     VERIFYEXEC(Store::create(resource));
0044
0045     mResourceInstanceIdentifier = resource.identifier();
0046
0047     //Load the capabilities
0048     resource = Store::readOne<Sink::ApplicationDomain::SinkResource>(Sink::Query{resource});
0049     mCapabilities = resource.getCapabilities();
0050 }
0051
0052 void MailTest::cleanup()
0053 {
0054     VERIFYEXEC(Store::removeDataFromDisk(mResourceInstanceIdentifier));
0055 }
0056
0057 void MailTest::init()
0058 {
0059     VERIFYEXEC(ResourceControl::start(mResourceInstanceIdentifier));
0060 }
0061
0062 void MailTest::testCreateModifyDeleteFolder()
0063 {
0064     int baseCount = 0;
0065     //First figure out how many folders we have by default
0066     {
0067         auto job = Store::fetchAll<Folder>(Query())
0068             .then([&](const QList<Folder::Ptr> &folders) {
0069                 baseCount = folders.size();
0070             });
0071         VERIFYEXEC(job);
0072     }
0073
0074     QString name = "name";
0075     QByteArray icon = "icon";
0076
0077     auto folder = Folder::create(mResourceInstanceIdentifier);
0078     folder.setName(name);
0079     folder.setIcon(icon);
0080
0081     VERIFYEXEC(Store::create(folder));
0082     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0083     {
0084         auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
0085             .then([=](const QList<Folder::Ptr> &folders) {
0086                 QCOMPARE(folders.size(), baseCount + 1);
0087                 QHash<QString, Folder::Ptr> foldersByName;
0088                 for (const auto &folder : folders) {
0089                     foldersByName.insert(folder->getName(), folder);
0090                 }
0091                 QVERIFY(foldersByName.contains(name));
0092                 auto folder = *foldersByName.value(name);
0093                 QCOMPARE(folder.getName(), name);
0094                 QCOMPARE(folder.getIcon(), icon);
0095             });
0096         VERIFYEXEC(job);
0097     }
0098     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0099     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
0100
0101     if (!mCapabilities.contains("-folder.rename")) {
0102         QString name2 = "name2";
0103         QByteArray icon2 = "icon2";
0104         folder.setName(name2);
0105         folder.setIcon(icon2);
0106
0107         VERIFYEXEC(Store::modify(folder));
0108         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0109         {
0110             auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
0111                 .then([=](const QList<Folder::Ptr> &folders) {
0112                     QCOMPARE(folders.size(), baseCount + 1);
0113                     QHash<QString, Folder::Ptr> foldersByName;
0114                     for (const auto &folder : folders) {
0115                         foldersByName.insert(folder->getName(), folder);
0116                     }
0117                     QVERIFY(foldersByName.contains(name2));
0118                     auto folder = *foldersByName.value(name2);
0119                     QCOMPARE(folder.getName(), name2);
0120                     QCOMPARE(folder.getIcon(), icon2);
0121                 });
0122             VERIFYEXEC(job);
0123         }
0124         VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0125         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
0126     }
0127
0128     VERIFYEXEC(Store::remove(folder));
0129     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0130     {
0131         auto job = Store::fetchAll<Folder>(Query().request<Folder::Name>().request<Folder::Icon>())
0132             .then([=](const QList<Folder::Ptr> &folders) {
0133                 QCOMPARE(folders.size(), baseCount);
0134             });
0135         VERIFYEXEC(job);
0136     }
0137     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0138     //This is not currently possible to check. The local folder and mapping has already been removed.
0139     // VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, false)));
0140 }
0141
0142 void MailTest::testCreateModifyDeleteMail()
0143 {
0144     const auto subject = QString::fromUtf8("äéiöü");
0145     const auto from = QString::fromUtf8("äéiöü <example@example.org>");
0146
0147     auto folder = Folder::create(mResourceInstanceIdentifier);
0148     folder.setName("folder");
0149     VERIFYEXEC(Store::create(folder));
0150
0151     auto message = KMime::Message::Ptr::create();
0152     message->subject(true)->fromUnicodeString(subject, "utf8");
0153     message->from(true)->fromUnicodeString(from, "utf8");
0154     message->assemble();
0155
0156     auto mail = Mail::create(mResourceInstanceIdentifier);
0157     mail.setMimeMessage(message->encodedContent(true));
0158     mail.setFolder(folder);
0159
0160     VERIFYEXEC(Store::create(mail));
0161     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0162     {
0163         auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Sender>())
0164             .then([=](const QList<Mail::Ptr> &mails) {
0165                 QCOMPARE(mails.size(), 1);
0166                 auto mail = *mails.first();
0167                 QCOMPARE(mail.getSubject(), subject);
0168                 QCOMPARE(mail.getSender().name, QString::fromUtf8("äéiöü"));
0169                 QCOMPARE(mail.getSender().emailAddress, QString::fromUtf8("example@example.org"));
0170                 QCOMPARE(mail.getFolder(), folder.identifier());
0171                 KMime::Message m;
0172                 m.setContent(KMime::CRLFtoLF(mail.getMimeMessage()));
0173                 m.parse();
0174                 QCOMPARE(m.subject(true)->asUnicodeString(), subject);
0175             });
0176         VERIFYEXEC(job);
0177     }
0178
0179     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0180     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
0181     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::PropertyInspection(mail, Mail::Subject::name, subject)));
0182     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder)));
0183
0184     const auto subject2 = QString::fromLatin1("Foobar2");
0185     auto message2 = KMime::Message::Ptr::create();
0186     message2->subject(true)->fromUnicodeString(subject2, "utf8");
0187     message2->assemble();
0188     mail.setMimeMessage(message2->encodedContent(true));
0189
0190     VERIFYEXEC(Store::modify(mail));
0191     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0192     {
0193         auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
0194             .then([=](const QList<Mail::Ptr> &mails) {
0195                 QCOMPARE(mails.size(), 1);
0196                 auto mail = *mails.first();
0197                 QCOMPARE(mail.getSubject(), subject2);
0198                 QCOMPARE(mail.getFolder(), folder.identifier());
0199                 KMime::Message m;
0200                 m.setContent(KMime::CRLFtoLF(mail.getMimeMessage()));
0201                 m.parse();
0202                 QCOMPARE(m.subject(true)->asUnicodeString(), subject2);
0203             });
0204         VERIFYEXEC(job);
0205     }
0206     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0207     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
0208     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::PropertyInspection(mail, Mail::Subject::name, subject2)));
0209     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder)));
0210
0211     VERIFYEXEC(Store::remove(mail));
0212     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0213     {
0214         auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>())
0215             .then([=](const QList<Mail::Ptr> &mails) {
0216                 QCOMPARE(mails.size(), 0);
0217             });
0218         VERIFYEXEC(job);
0219     }
0220     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0221     // VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, false)));
0222     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder)));
0223 }
0224
0225 void MailTest::testMoveMail()
0226 {
0227     const auto subject = QString::fromLatin1("Foobar");
0228
0229     auto folder = Folder::create(mResourceInstanceIdentifier);
0230     folder.setName("folder2");
0231     VERIFYEXEC(Store::create(folder));
0232
0233     auto folder1 = Folder::create(mResourceInstanceIdentifier);
0234     folder1.setName("folder3");
0235     VERIFYEXEC(Store::create(folder1));
0236
0237     auto message = KMime::Message::Ptr::create();
0238     message->subject(true)->fromUnicodeString(subject, "utf8");
0239     message->assemble();
0240
0241     auto mail = Mail::create(mResourceInstanceIdentifier);
0242     mail.setMimeMessage(message->encodedContent(true));
0243     mail.setFolder(folder);
0244
0245     VERIFYEXEC(Store::create(mail));
0246     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0247
0248     Mail modifiedMail;
0249     {
0250         auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
0251             .then([=, &modifiedMail](const QList<Mail::Ptr> &mails) {
0252                 QCOMPARE(mails.size(), 1);
0253                 auto mail = *mails.first();
0254                 modifiedMail = mail;
0255                 QCOMPARE(mail.getFolder(), folder.identifier());
0256                 QVERIFY(!mail.getMimeMessage().isEmpty());
0257             });
0258         VERIFYEXEC(job);
0259     }
0260
0261     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder)));
0262
0263     modifiedMail.setFolder(folder1);
0264
0265     VERIFYEXEC(Store::modify(modifiedMail));
0266     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0267     {
0268         auto job = Store::fetchAll<Mail>(Query().request<Mail::Folder>().request<Mail::Subject>().request<Mail::MimeMessage>())
0269             .then([=](const QList<Mail::Ptr> &mails) {
0270                 QCOMPARE(mails.size(), 1);
0271                 auto mail = *mails.first();
0272                 QCOMPARE(mail.getFolder(), folder1.identifier());
0273                 QVERIFY(!mail.getMimeMessage().isEmpty());
0274             });
0275         VERIFYEXEC(job);
0276     }
0277     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder)));
0278     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::CacheIntegrityInspection(folder1)));
0279 }
0280
0281 void MailTest::testMarkMailAsRead()
0282 {
0283     auto folder = Folder::create(mResourceInstanceIdentifier);
0284     folder.setName("anotherfolder");
0285     VERIFYEXEC(Store::create(folder));
0286
0287     auto message = KMime::Message::Ptr::create();
0288     message->subject(true)->fromUnicodeString("subject", "utf8");
0289     message->assemble();
0290
0291     auto mail = Mail::create(mResourceInstanceIdentifier);
0292     mail.setMimeMessage(message->encodedContent(true));
0293     mail.setFolder(folder);
0294     mail.setUnread(true);
0295     VERIFYEXEC(Store::create(mail));
0296     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0297
0298     auto job = Store::fetchAll<Mail>(Query()
0299                                         .resourceFilter(mResourceInstanceIdentifier)
0300                                         .request<Mail::Folder>()
0301                                         .request<Mail::Subject>()
0302                                     )
0303         .then<void, QList<Mail::Ptr>>([this](const QList<Mail::Ptr> &mails) {
0304             ASYNCCOMPARE(mails.size(), 1);
0305             auto mail = mails.first();
0306             mail->setUnread(false);
0307             return Store::modify(*mail)
0308                 .then<void>(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier)) // The change needs to be replayed already
0309                 .then(ResourceControl::inspect<Mail>(ResourceControl::Inspection::PropertyInspection(*mail, Mail::Unread::name, false)))
0310                 .then(ResourceControl::inspect<Mail>(ResourceControl::Inspection::PropertyInspection(*mail, Mail::Subject::name, mail->getSubject())));
0311         });
0312     VERIFYEXEC(job);
0313
0314     // Verify that we can still query for all relevant information
0315     auto job2 = Store::fetchAll<Mail>(Query()
0316                                         .resourceFilter(mResourceInstanceIdentifier)
0317                                         .request<Mail::Folder>()
0318                                         .request<Mail::Subject>()
0319                                         .request<Mail::MimeMessage>()
0320                                         .request<Mail::Unread>()
0321                                     )
0322         .then<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
0323             ASYNCCOMPARE(mails.size(), 1);
0324             auto mail = mails.first();
0325             ASYNCVERIFY(!mail->getSubject().isEmpty());
0326             ASYNCCOMPARE(mail->getUnread(), false);
0327             ASYNCVERIFY(!mail->getMimeMessage().isEmpty());
0328             return KAsync::null<void>();
0329         });
0330     VERIFYEXEC(job2);
0331
0332     //Verify we can mark the mail as unread again
0333     {
0334         auto readMail = Store::readOne<Mail>(Query{mail});
0335         readMail.setUnread(true);
0336         VERIFYEXEC(Store::modify(readMail));
0337         VERIFYEXEC(ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
0338         VERIFYEXEC(ResourceControl::inspect<Mail>(ResourceControl::Inspection::PropertyInspection(readMail, Mail::Unread::name, true)));
0339     }
0340 }
0341
0342 void MailTest::testCreateDraft()
0343 {
0344     if (!mCapabilities.contains(ResourceCapabilities::Mail::drafts)) {
0345         QSKIP("Resource doesn't have the drafts capability");
0346     }
0347
0348     auto message = KMime::Message::Ptr::create();
0349     message->subject(true)->fromUnicodeString(QString::fromLatin1("Foobar"), "utf8");
0350     message->assemble();
0351
0352     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
0353     mail.setMimeMessage(message->encodedContent(true));
0354     mail.setDraft(true);
0355
0356     VERIFYEXEC(Store::create(mail));
0357     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0358
0359     QByteArray folderIdentifier;
0360
0361     auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
0362     folderIdentifier = createdDraft.getFolder();
0363     QVERIFY(!folderIdentifier.isEmpty());
0364
0365     //Ensure we can also query by folder
0366     {
0367         auto mails = Store::read<ApplicationDomain::Mail>(Query().filter<Mail::Folder>(folderIdentifier));
0368         bool found = false;
0369         for (const auto &m : mails) {
0370             if (m.identifier() == mail.identifier()) {
0371                 found = true;
0372             }
0373         }
0374         QVERIFY(found);
0375     }
0376
0377     //Ensure the folder is also existing
0378     {
0379         ApplicationDomain::Folder folder;
0380         auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier));
0381         QCOMPARE(folders.size(), 1);
0382         folder = folders.first();
0383         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
0384     }
0385     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
0386 }
0387
0388 void MailTest::testModifyMailToDraft()
0389 {
0390     if (!mCapabilities.contains(ResourceCapabilities::Mail::drafts)) {
0391         QSKIP("Resource doesn't have the drafts capability");
0392     }
0393
0394     auto folder = Folder::create(mResourceInstanceIdentifier);
0395     folder.setName("sdljldskjf");
0396     VERIFYEXEC(Store::create(folder));
0397
0398     auto message = KMime::Message::Ptr::create();
0399     message->subject(true)->fromUnicodeString(QString::fromLatin1("Foobar"), "utf8");
0400     message->assemble();
0401
0402     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
0403     mail.setMimeMessage(message->encodedContent(true));
0404     mail.setDraft(false);
0405     mail.setFolder(folder);
0406
0407     VERIFYEXEC(Store::create(mail));
0408     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0409
0410     auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
0411     modifiedMail.setDraft(true);
0412     VERIFYEXEC(Store::modify(modifiedMail));
0413     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0414     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0415
0416     QByteArray folderIdentifier;
0417     {
0418         auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
0419         folderIdentifier = createdDraft.getFolder();
0420         QVERIFY(!folderIdentifier.isEmpty());
0421     }
0422
0423     //Ensure the folder is also existing
0424     {
0425         ApplicationDomain::Folder folder;
0426         auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
0427         QCOMPARE(folders.size(), 1);
0428         folder = folders.first();
0429         QVERIFY(folder.getSpecialPurpose().contains("drafts"));
0430         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
0431     }
0432     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
0433 }
0434
0435 void MailTest::testModifyMailToTrash()
0436 {
0437     if (!mCapabilities.contains(ResourceCapabilities::Mail::trash)) {
0438         QSKIP("Resource doesn't have the trash capability");
0439     }
0440
0441     auto folder = Folder::create(mResourceInstanceIdentifier);
0442     folder.setName("sdljldskjf2");
0443     VERIFYEXEC(Store::create(folder));
0444
0445     auto message = KMime::Message::Ptr::create();
0446     message->subject(true)->fromUnicodeString(QString::fromLatin1("Foobar"), "utf8");
0447     message->assemble();
0448
0449     auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
0450     mail.setMimeMessage(message->encodedContent(true));
0451     mail.setTrash(false);
0452     mail.setFolder(folder);
0453
0454     VERIFYEXEC(Store::create(mail));
0455     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0456
0457     auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
0458     modifiedMail.setTrash(true);
0459     VERIFYEXEC(Store::modify(modifiedMail));
0460     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
0461     VERIFYEXEC(ResourceControl::flushReplayQueue(QByteArrayList() << mResourceInstanceIdentifier));
0462
0463     QByteArray folderIdentifier;
0464     {
0465         auto createdMail = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
0466         folderIdentifier = createdMail.getFolder();
0467         QVERIFY(!folderIdentifier.isEmpty());
0468     }
0469
0470     //Ensure the folder is also existing
0471     {
0472         ApplicationDomain::Folder folder;
0473         auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
0474         QCOMPARE(folders.size(), 1);
0475         folder = folders.first();
0476         QVERIFY(folder.getSpecialPurpose().contains("trash"));
0477         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
0478     }
0479     VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Mail>(ResourceControl::Inspection::ExistenceInspection(mail, true)));
0480 }
0481