← Back to branch summary

~ubuntu-branches/debian/stretch/akonadi/stretch

« back to all changes in this revision

Viewing changes to .pc/upstream_dont_leak_old_external_payload_files.patch/server/tests/unittest/partstreamertest.cpp

  • Committer: Package Import Robot
  • Author(s): Lisandro Damián Nicanor Pérez Meyer
  • Date: 2015-06-30 12:03:32 UTC
  • Revision ID: package-import@ubuntu.com-20150630120332-jzlmtqpwv0pa0tj0
Tags: 1.13.0-3
* Team upload.
* Apply upstream_dont_leak_old_external_payload_files.patch which fixes a bug
  that let old files be kept when they should be removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/upstream_dont_leak_old_external_payload_files.patch/server/tests/unittest/partstreamertest.cpp
 
1
/*
 
2
 * Copyright (C) 2014  Daniel Vrátil <dvratil@redhat.com>
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2.1 of the License, or (at your option) any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the Free Software
 
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 *
 
18
 */
 
19
 
 
20
#include <QObject>
 
21
 
 
22
#include "fakeakonadiserver.h"
 
23
#include "fakeconnection.h"
 
24
#include "akstandarddirs.h"
 
25
#include "akdebug.h"
 
26
#include "aktest.h"
 
27
#include "imapstreamparser.h"
 
28
#include "entities.h"
 
29
 
 
30
#include "storage/partstreamer.h"
 
31
#include <storage/parthelper.h>
 
32
 
 
33
#include <QtTest>
 
34
#include <QSettings>
 
35
 
 
36
using namespace Akonadi;
 
37
using namespace Akonadi::Server;
 
38
 
 
39
Q_DECLARE_METATYPE(Akonadi::Server::PimItem)
 
40
 
 
41
class PartStreamerTest : public QObject
 
42
{
 
43
    Q_OBJECT
 
44
 
 
45
public:
 
46
    PartStreamerTest()
 
47
    {
 
48
        qRegisterMetaType<Akonadi::Server::Response>();
 
49
 
 
50
        // Set a very small treshold for easier testing
 
51
        const QString serverConfigFile = AkStandardDirs::serverConfigFile(XdgBaseDirs::ReadWrite);
 
52
        QSettings settings(serverConfigFile, QSettings::IniFormat);
 
53
        settings.setValue(QLatin1String("General/SizeThreshold"), 5);
 
54
 
 
55
        try {
 
56
            FakeAkonadiServer::instance()->init();
 
57
        } catch (const FakeAkonadiServerException &e) {
 
58
            akError() << "Server exception: " << e.what();
 
59
            akFatal() << "Fake Akonadi Server failed to start up, aborting test";
 
60
        }
 
61
    }
 
62
 
 
63
    ~PartStreamerTest()
 
64
    {
 
65
        FakeAkonadiServer::instance()->quit();
 
66
    }
 
67
 
 
68
 
 
69
private Q_SLOTS:
 
70
    void slotStreamerResponseAvailable(const Akonadi::Server::Response &response)
 
71
    {
 
72
        const QByteArray string = response.asString();
 
73
        const qint64 fnStart = string.indexOf("[FILE ") + 6;
 
74
        const qint64 fnEnd = string.indexOf("]", fnStart);
 
75
        const QByteArray name = string.mid(fnStart, fnEnd - fnStart);
 
76
        const QString fileName = PartHelper::resolveAbsolutePath(name);
 
77
        qDebug() << string << fileName;
 
78
        QFile f(fileName);
 
79
        QVERIFY(!f.exists());
 
80
        QVERIFY(f.open(QIODevice::ReadWrite));
 
81
 
 
82
        QFETCH(QByteArray, expectedData);
 
83
        qDebug() << "Wrote" << f.write(expectedData) << "bytes to" << f.fileName();
 
84
        f.close();
 
85
    }
 
86
 
 
87
    void testStreamer_data()
 
88
    {
 
89
        QTest::addColumn<QByteArray>("expectedPartName");
 
90
        QTest::addColumn<QByteArray>("expectedData");
 
91
        QTest::addColumn<qint64>("expectedPartSize");
 
92
        QTest::addColumn<bool>("expectedChanged");
 
93
        QTest::addColumn<bool>("isExternal");
 
94
        QTest::addColumn<PimItem>("pimItem");
 
95
 
 
96
        PimItem item;
 
97
        item.setCollectionId(Collection::retrieveByName(QLatin1String("Col A")).id());
 
98
        item.setMimeType(MimeType::retrieveByName(QLatin1String("application/octet-stream")));
 
99
        item.setSize(1); // this will not match reality during the test, but that does not matter, as
 
100
                         // that's not the subject of this test
 
101
        QVERIFY(item.insert());
 
102
 
 
103
        // Order of these tests matters!
 
104
        QTest::newRow("item 1, internal") << QByteArray("PLD:DATA") << QByteArray("123") << 3ll << true << false << item;
 
105
        QTest::newRow("item 1, change to external") << QByteArray("PLD:DATA") << QByteArray("123456789") << 9ll << true << true << item;
 
106
        QTest::newRow("item 1, update external") << QByteArray("PLD:DATA") << QByteArray("987654321") << 9ll << true << true << item;
 
107
        QTest::newRow("item 1, external, no change") << QByteArray("PLD:DATA") << QByteArray("987654321") << 9ll << false << true << item;
 
108
        QTest::newRow("item 1, change to internal") << QByteArray("PLD:DATA") << QByteArray("1234") << 4ll << true << false << item;
 
109
        QTest::newRow("item 1, internal, no change") << QByteArray("PLD:DATA") << QByteArray("1234") << 4ll << false << false << item;
 
110
    }
 
111
 
 
112
    void testStreamer()
 
113
    {
 
114
        return;
 
115
        QFETCH(QByteArray, expectedPartName);
 
116
        QFETCH(QByteArray, expectedData);
 
117
        QFETCH(qint64, expectedPartSize);
 
118
        QFETCH(bool, expectedChanged);
 
119
        QFETCH(bool, isExternal);
 
120
        QFETCH(PimItem, pimItem);
 
121
 
 
122
        FakeConnection connection;
 
123
        ClientCapabilities capabilities;
 
124
        capabilities.setAkAppendStreaming(true);
 
125
        capabilities.setDirectStreaming(true);
 
126
        capabilities.setNoPayloadPath(true);
 
127
        connection.setCapabilities(capabilities);
 
128
 
 
129
        QBuffer buffer;
 
130
        QVERIFY(buffer.open(QIODevice::ReadWrite));
 
131
        buffer.write("PLD:DATA[0] {" + QByteArray::number(expectedPartSize) + "}\n");
 
132
        if (!isExternal) {
 
133
            buffer.write(expectedData);
 
134
        } else {
 
135
            buffer.write(")\n");
 
136
        }
 
137
        buffer.seek(0);
 
138
        ImapStreamParser parser(&buffer);
 
139
        const QByteArray command = parser.readString();
 
140
 
 
141
        PartStreamer streamer(&connection, &parser, pimItem);
 
142
        connect(&streamer, SIGNAL(responseAvailable(Akonadi::Server::Response)),
 
143
                this, SLOT(slotStreamerResponseAvailable(Akonadi::Server::Response)));
 
144
        QSignalSpy streamerSpy(&streamer, SIGNAL(responseAvailable(Akonadi::Server::Response)));
 
145
 
 
146
        QByteArray partName;
 
147
        qint64 partSize;
 
148
        bool changed = false;
 
149
 
 
150
        try {
 
151
            QVERIFY(streamer.stream(command, false, partName, partSize, &changed));
 
152
        } catch (const Exception &e) {
 
153
            qDebug() << e.type() << ":" << e.what();
 
154
            QFAIL("Caught an unexpected exception");
 
155
        }
 
156
 
 
157
        QCOMPARE(QString::fromUtf8(partName), QString::fromUtf8(expectedPartName));
 
158
        QCOMPARE(partSize, expectedPartSize);
 
159
        QCOMPARE(expectedChanged, changed);
 
160
 
 
161
        PimItem item = PimItem::retrieveById(pimItem.id());
 
162
        const QVector<Part> parts = item.parts();
 
163
        QVERIFY(parts.count() == 1);
 
164
        const Part part = parts[0];
 
165
        QCOMPARE(part.datasize(), expectedPartSize);
 
166
        QCOMPARE(part.external(), isExternal);
 
167
        const QByteArray data = part.data();
 
168
        if (isExternal) {
 
169
            QVERIFY(streamerSpy.count() == 1);
 
170
            QVERIFY(streamerSpy.first().count() == 1);
 
171
            const Response response = streamerSpy.first().first().value<Akonadi::Server::Response>();
 
172
            const QByteArray str = response.asString();
 
173
            const QByteArray expectedResponse = "+ STREAM [FILE " + QByteArray::number(part.id()) + "_r" + QByteArray::number(part.version()) + "]";
 
174
            QCOMPARE(QString::fromUtf8(str), QString::fromUtf8(expectedResponse));
 
175
 
 
176
            QFile file(PartHelper::resolveAbsolutePath(data));
 
177
            QVERIFY(file.exists());
 
178
            QCOMPARE(file.size(), expectedPartSize);
 
179
            QVERIFY(file.open(QIODevice::ReadOnly));
 
180
            const QByteArray fileData = file.readAll();
 
181
            QCOMPARE(QString::fromUtf8(fileData), QString::fromUtf8(expectedData));
 
182
            QCOMPARE(fileData, expectedData);
 
183
 
 
184
            // Make sure no previous versions are left behind in file_db_data
 
185
            for (int i = 0; i < part.version(); ++i) {
 
186
                const QByteArray fileName = QByteArray::number(part.id()) + "_r" + QByteArray::number(part.version());
 
187
                const QString filePath = PartHelper::resolveAbsolutePath(fileName);
 
188
                QVERIFY(!QFile::exists(filePath));
 
189
            }
 
190
        } else {
 
191
            QVERIFY(streamerSpy.isEmpty());
 
192
 
 
193
            QCOMPARE(QString::fromUtf8(data), QString::fromUtf8(expectedData));
 
194
            QCOMPARE(data, expectedData);
 
195
 
 
196
            // Make sure nothing is left behind in file_db_data
 
197
            for (int i = 0; i <= part.version(); ++i) {
 
198
                const QByteArray fileName = QByteArray::number(part.id()) + "_r" + QByteArray::number(part.version());
 
199
                const QString filePath = PartHelper::resolveAbsolutePath(fileName);
 
200
                QVERIFY(!QFile::exists(filePath));
 
201
            }
 
202
        }
 
203
    }
 
204
 
 
205
};
 
206
 
 
207
AKTEST_FAKESERVER_MAIN(PartStreamerTest)
 
208
 
 
209
#include "partstreamertest.moc"