mirrors/nextcloud-desktop
1
0
Fork 0
mirror of https://github.com/nextcloud/desktop.git synced 2024-11-22 21:15:55 +03:00
Code Issues Projects Releases Packages Wiki Activity
nextcloud-desktop/test/testsyncjournaldb.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

462 lines
18 KiB
C++
Raw Normal View History

Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
/*
* This software is in the public domain, furnished "as is", without technical
* support, and with no warranty, express or implied, as to its usefulness for
* any purpose.
* */
#include <QtTest>
#include <sqlite3.h>
Move SyncJournalDB to src/common
2017-09-01 19:11:43 +03:00
#include "common/syncjournaldb.h"
#include "common/syncjournalfilerecord.h"
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
Fix tests
2014-11-10 00:36:49 +03:00
using namespace OCC;
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
class TestSyncJournalDB : public QObject
{
Q_OBJECT
TestSyncJournalDB: Fix concurrent usage on CI
2017-07-03 15:08:10 +03:00
QTemporaryDir _tempDir;
Merge remote-tracking branch 'origin/2.3'
2017-07-12 11:06:04 +03:00
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
public:
TestSyncJournalDB()
Merge remote-tracking branch 'origin/2.3'
2017-07-12 11:06:04 +03:00
: _db((_tempDir.path() + "/sync.db"))
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
{
TestSyncJournalDB: Fix concurrent usage on CI
2017-07-03 15:08:10 +03:00
QVERIFY(_tempDir.isValid());
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
}
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
qint64 dropMsecs(QDateTime time)
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
{
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
return Utility::qDateTimeToTime_t(time);
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
}
private slots:
void initTestCase()
{
}
void cleanupTestCase()
{
Fix tests for syncjournaldb
2016-07-17 22:10:07 +03:00
const QString file = _db.databaseFilePath();
QFile::remove(file);
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
}
void testFileRecord()
{
SyncJournalDB: Allow callers of getFileRecord if the query failed The current implementation would return the same value whether the query failed or if no row would be found. This is something that is currently checked by csync and needs to be provided if we want to use SyncJournalDB there. Adjusted all call sites to also check the return value even though they could still just rely on rec.isValid(), but makes it more explicit as to what happens for database errors in those cases, if we ever want to gracefully handle them.
2017-09-13 20:02:38 +03:00
SyncJournalFileRecord record;
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("nonexistant"), &record));
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
QVERIFY(!record.isValid());
record._path = "foo";
Journal: 64bit inodes, fix storing uint64s generally In addition to using the right function when retrieving inodes this *also* fixes a more general bug ownsql had with storing uint64 values that didn't fit into an int64.
2017-12-11 16:47:49 +03:00
// Use a value that exceeds uint32 and isn't representable by the
// signed int being cast to uint64 either (like uint64::max would be)
record._inode = std::numeric_limits<quint32>::max() + 12ull;
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
record._modtime = dropMsecs(QDateTime::currentDateTime());
Unify item type enum Previously, there was csync_ftw_type_e and SyncFileItem::Type. Having two enums lead to a bug where Type::Unknown == Type::File that went unnoticed for a good while. This patch keeps only a single enum.
2017-12-14 17:08:53 +03:00
record._type = ItemTypeDirectory;
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
record._etag = "789789";
record._fileId = "abcd";
RemotePermissions: Fix empty vs null Fixes two bugs that appeared since the introduction of the struct: - when reading permissions from the journal, null ("") was read as empty-not-null - when reading permissinos from the server, empty ("") was read as null Addresses #4608
2018-08-15 13:16:46 +03:00
record._remotePerm = RemotePermissions::fromDbValue("RW");
SyncJournalDB: Add filesize column to metadata. * Alter table to include column. * Make get/set in SyncJournalDB store and load it. * Make csync recover the stat_t's size member from it.
2014-09-05 15:03:33 +04:00
record._fileSize = 213089055;
Compare the hash of files with identical mtime/size #5589 * For conflicts where mtime and size are identical: a) If there's no remote checksum, skip (unchanged) b) If there's a remote checksum that's a useful hash, create a PropagateDownload job and compute the local hash. If the hashes are identical, don't download the file and just update metadata. * Avoid exposing the existence of checksumTypeId beyond the database layer. This makes handling checksums easier in general because they can usually be treated as a single blob. This change was prompted by the difficulty of producing file_stat_t entries uniformly from PROPFINDs and the database.
2017-06-14 13:14:46 +03:00
record._checksumHeader = "MD5:mychecksum";
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
QVERIFY(_db.setFileRecord(record));
SyncJournalDB: Allow callers of getFileRecord if the query failed The current implementation would return the same value whether the query failed or if no row would be found. This is something that is currently checked by csync and needs to be provided if we want to use SyncJournalDB there. Adjusted all call sites to also check the return value even though they could still just rely on rec.isValid(), but makes it more explicit as to what happens for database errors in those cases, if we ever want to gracefully handle them.
2017-09-13 20:02:38 +03:00
SyncJournalFileRecord storedRecord;
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo"), &storedRecord));
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
QVERIFY(storedRecord == record);
Checksum: Don't lose it on metadata update #3735 Also improve tests.
2015-10-28 16:42:44 +03:00
// Update checksum
Compare the hash of files with identical mtime/size #5589 * For conflicts where mtime and size are identical: a) If there's no remote checksum, skip (unchanged) b) If there's a remote checksum that's a useful hash, create a PropagateDownload job and compute the local hash. If the hashes are identical, don't download the file and just update metadata. * Avoid exposing the existence of checksumTypeId beyond the database layer. This makes handling checksums easier in general because they can usually be treated as a single blob. This change was prompted by the difficulty of producing file_stat_t entries uniformly from PROPFINDs and the database.
2017-06-14 13:14:46 +03:00
record._checksumHeader = "Adler32:newchecksum";
_db.updateFileRecordChecksum("foo", "newchecksum", "Adler32");
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo"), &storedRecord));
Checksum: Don't lose it on metadata update #3735 Also improve tests.
2015-10-28 16:42:44 +03:00
QVERIFY(storedRecord == record);
// Update metadata
record._modtime = dropMsecs(QDateTime::currentDateTime().addDays(1));
Journal: 64bit inodes, fix storing uint64s generally In addition to using the right function when retrieving inodes this *also* fixes a more general bug ownsql had with storing uint64 values that didn't fit into an int64.
2017-12-11 16:47:49 +03:00
// try a value that only fits uint64, not int64
record._inode = std::numeric_limits<quint64>::max() - std::numeric_limits<quint32>::max() - 1;
Unify item type enum Previously, there was csync_ftw_type_e and SyncFileItem::Type. Having two enums lead to a bug where Type::Unknown == Type::File that went unnoticed for a good while. This patch keeps only a single enum.
2017-12-14 17:08:53 +03:00
record._type = ItemTypeFile;
Checksum: Don't lose it on metadata update #3735 Also improve tests.
2015-10-28 16:42:44 +03:00
record._etag = "789FFF";
record._fileId = "efg";
RemotePermissions: Fix empty vs null Fixes two bugs that appeared since the introduction of the struct: - when reading permissions from the journal, null ("") was read as empty-not-null - when reading permissinos from the server, empty ("") was read as null Addresses #4608
2018-08-15 13:16:46 +03:00
record._remotePerm = RemotePermissions::fromDbValue("NV");
Checksum: Don't lose it on metadata update #3735 Also improve tests.
2015-10-28 16:42:44 +03:00
record._fileSize = 289055;
Sync: optimize by removing setFileRecordMetadata Inh most case we already have a record from before, so avoid doing a useless lookup in the database. In owncloudpropagator.cpp, directories do not have a checksum so no need to call a function that preserves it
2018-11-06 12:30:33 +03:00
_db.setFileRecord(record);
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo"), &storedRecord));
Checksum: Don't lose it on metadata update #3735 Also improve tests.
2015-10-28 16:42:44 +03:00
QVERIFY(storedRecord == record);
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
QVERIFY(_db.deleteFileRecord("foo"));
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo"), &record));
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
QVERIFY(!record.isValid());
}
Checksum: Put checksum type into separate column #3735
2015-10-28 13:00:03 +03:00
void testFileRecordChecksum()
{
// Try with and without a checksum
{
SyncJournalFileRecord record;
record._path = "foo-checksum";
RemotePermissions: Fix empty vs null Fixes two bugs that appeared since the introduction of the struct: - when reading permissions from the journal, null ("") was read as empty-not-null - when reading permissinos from the server, empty ("") was read as null Addresses #4608
2018-08-15 13:16:46 +03:00
record._remotePerm = RemotePermissions::fromDbValue(" ");
Compare the hash of files with identical mtime/size #5589 * For conflicts where mtime and size are identical: a) If there's no remote checksum, skip (unchanged) b) If there's a remote checksum that's a useful hash, create a PropagateDownload job and compute the local hash. If the hashes are identical, don't download the file and just update metadata. * Avoid exposing the existence of checksumTypeId beyond the database layer. This makes handling checksums easier in general because they can usually be treated as a single blob. This change was prompted by the difficulty of producing file_stat_t entries uniformly from PROPFINDs and the database.
2017-06-14 13:14:46 +03:00
record._checksumHeader = "MD5:mychecksum";
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
record._modtime = Utility::qDateTimeToTime_t(QDateTime::currentDateTimeUtc());
Checksum: Put checksum type into separate column #3735
2015-10-28 13:00:03 +03:00
QVERIFY(_db.setFileRecord(record));
SyncJournalDB: Allow callers of getFileRecord if the query failed The current implementation would return the same value whether the query failed or if no row would be found. This is something that is currently checked by csync and needs to be provided if we want to use SyncJournalDB there. Adjusted all call sites to also check the return value even though they could still just rely on rec.isValid(), but makes it more explicit as to what happens for database errors in those cases, if we ever want to gracefully handle them.
2017-09-13 20:02:38 +03:00
SyncJournalFileRecord storedRecord;
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo-checksum"), &storedRecord));
Test syncjournaldb: Fix comparison of two QDateTime objects. Only compare full seconds as milliseconds may float.
2015-11-25 23:13:50 +03:00
QVERIFY(storedRecord._path == record._path);
QVERIFY(storedRecord._remotePerm == record._remotePerm);
Compare the hash of files with identical mtime/size #5589 * For conflicts where mtime and size are identical: a) If there's no remote checksum, skip (unchanged) b) If there's a remote checksum that's a useful hash, create a PropagateDownload job and compute the local hash. If the hashes are identical, don't download the file and just update metadata. * Avoid exposing the existence of checksumTypeId beyond the database layer. This makes handling checksums easier in general because they can usually be treated as a single blob. This change was prompted by the difficulty of producing file_stat_t entries uniformly from PROPFINDs and the database.
2017-06-14 13:14:46 +03:00
QVERIFY(storedRecord._checksumHeader == record._checksumHeader);
Test syncjournaldb: Fix comparison of two QDateTime objects. Only compare full seconds as milliseconds may float.
2015-11-25 23:13:50 +03:00
// qDebug()<< "OOOOO " << storedRecord._modtime.toTime_t() << record._modtime.toTime_t();
// Attention: compare time_t types here, as QDateTime seem to maintain
// milliseconds internally, which disappear in sqlite. Go for full seconds here.
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(storedRecord._modtime == record._modtime);
Checksum: Put checksum type into separate column #3735
2015-10-28 13:00:03 +03:00
QVERIFY(storedRecord == record);
}
{
SyncJournalFileRecord record;
record._path = "foo-nochecksum";
RemotePermissions: Fix empty vs null Fixes two bugs that appeared since the introduction of the struct: - when reading permissions from the journal, null ("") was read as empty-not-null - when reading permissinos from the server, empty ("") was read as null Addresses #4608
2018-08-15 13:16:46 +03:00
record._remotePerm = RemotePermissions();
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
record._modtime = Utility::qDateTimeToTime_t(QDateTime::currentDateTimeUtc());
SyncJournalTest: Use valid time for the tests.
2015-11-26 00:16:29 +03:00
Checksum: Put checksum type into separate column #3735
2015-10-28 13:00:03 +03:00
QVERIFY(_db.setFileRecord(record));
SyncJournalDB: Allow callers of getFileRecord if the query failed The current implementation would return the same value whether the query failed or if no row would be found. This is something that is currently checked by csync and needs to be provided if we want to use SyncJournalDB there. Adjusted all call sites to also check the return value even though they could still just rely on rec.isValid(), but makes it more explicit as to what happens for database errors in those cases, if we ever want to gracefully handle them.
2017-09-13 20:02:38 +03:00
SyncJournalFileRecord storedRecord;
Use SyncJournalDb in csync This gets rid of the csync_statedb sqlite layer and use the same code and same connection as the rest of the SyncEngine. Missing functions are added to SyncJournalDb and change a few minor things (like changing SyncJournalFileRecord::_modtime to be an int64 instead of a QDateTime, like it was in csync).
2017-09-14 16:50:13 +03:00
QVERIFY(_db.getFileRecord(QByteArrayLiteral("foo-nochecksum"), &storedRecord));
Checksum: Put checksum type into separate column #3735
2015-10-28 13:00:03 +03:00
QVERIFY(storedRecord == record);
}
}
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
void testDownloadInfo()
{
Enable the modernize-use-using check on clang-tidy Signed-off-by: Kevin Ottens <kevin.ottens@nextcloud.com>
2020-08-12 16:23:11 +03:00
using Info = SyncJournalDb::DownloadInfo;
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
Info record = _db.getDownloadInfo("nonexistant");
QVERIFY(!record._valid);
record._errorCount = 5;
record._etag = "ABCDEF";
record._valid = true;
record._tmpfile = "/tmp/foo";
_db.setDownloadInfo("foo", record);
Info storedRecord = _db.getDownloadInfo("foo");
QVERIFY(storedRecord == record);
_db.setDownloadInfo("foo", Info());
Info wipedRecord = _db.getDownloadInfo("foo");
QVERIFY(!wipedRecord._valid);
}
void testUploadInfo()
{
Use using instead of typedef Signed-off-by: Kevin Ottens <kevin.ottens@nextcloud.com>
2020-05-25 21:26:45 +03:00
using Info = SyncJournalDb::UploadInfo;
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
Info record = _db.getUploadInfo("nonexistant");
QVERIFY(!record._valid);
record._errorCount = 5;
record._chunk = 12;
record._transferid = 812974891;
record._size = 12894789147;
record._modtime = dropMsecs(QDateTime::currentDateTime());
record._valid = true;
_db.setUploadInfo("foo", record);
Info storedRecord = _db.getUploadInfo("foo");
QVERIFY(storedRecord == record);
_db.setUploadInfo("foo", Info());
Info wipedRecord = _db.getUploadInfo("foo");
QVERIFY(!wipedRecord._valid);
}
Add minor unittest for numeric id extraction #5933
2017-09-05 14:40:26 +03:00
void testNumericId()
{
SyncJournalFileRecord record;
// Typical 8-digit padded id
record._fileId = "00000001abcd";
QCOMPARE(record.numericFileId(), QByteArray("00000001"));
// When the numeric id overflows the 8-digit boundary
record._fileId = "123456789ocidblaabcd";
QCOMPARE(record.numericFileId(), QByteArray("123456789"));
}
Upload conflict files #4557 If the server has the 'uploadConflictFiles' capability conflict files will be uploaded instead of ignored. Uploaded conflict files have the following headers set during upload OC-Conflict: 1 OC-ConflictBaseFileId: 172489174instanceid OC-ConflictBaseMtime: 1235789213 OC-ConflictBaseEtag: myetag when the data is available. Downloads accept the same headers in return when downloading a conflict file. In the absence of server support clients will identify conflict files through the file name pattern and attempt to deduce the base fileid. Base etag and mtime can't be deduced though. The upload job for a new conflict file will be triggered directly from the job that created the conflict file now. No second sync run is necessary anymore. This commit does not yet introduce a 'username' like identifier that automatically gets added to conflict file filenames (to name the files foo_conflict-Fred-1345.txt instead of just foo_conflict-1345.txt).
2017-12-02 13:40:43 +03:00
void testConflictRecord()
{
ConflictRecord record;
record.path = "abc";
record.baseFileId = "def";
record.baseModtime = 1234;
record.baseEtag = "ghi";
QVERIFY(!_db.conflictRecord(record.path).isValid());
_db.setConflictRecord(record);
auto newRecord = _db.conflictRecord(record.path);
QVERIFY(newRecord.isValid());
QCOMPARE(newRecord.path, record.path);
QCOMPARE(newRecord.baseFileId, record.baseFileId);
QCOMPARE(newRecord.baseModtime, record.baseModtime);
QCOMPARE(newRecord.baseEtag, record.baseEtag);
_db.deleteConflictRecord(record.path);
QVERIFY(!_db.conflictRecord(record.path).isValid());
}
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
void testAvoidReadFromDbOnNextSync()
{
auto invalidEtag = QByteArray("_invalid_");
auto initialEtag = QByteArray("etag");
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
auto makeEntry = [&](const QByteArray &path, ItemType type) {
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
SyncJournalFileRecord record;
record._path = path;
record._type = type;
record._etag = initialEtag;
_db.setFileRecord(record);
};
auto getEtag = [&](const QByteArray &path) {
SyncJournalFileRecord record;
_db.getFileRecord(path, &record);
return record._etag;
};
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("foodir", ItemTypeDirectory);
makeEntry("otherdir", ItemTypeDirectory);
makeEntry("foo%", ItemTypeDirectory); // wildcards don't apply
makeEntry("foodi_", ItemTypeDirectory); // wildcards don't apply
makeEntry("foodir/file", ItemTypeFile);
makeEntry("foodir/subdir", ItemTypeDirectory);
makeEntry("foodir/subdir/file", ItemTypeFile);
makeEntry("foodir/otherdir", ItemTypeDirectory);
makeEntry("fo", ItemTypeDirectory); // prefix, but does not match
makeEntry("foodir/sub", ItemTypeDirectory); // prefix, but does not match
makeEntry("foodir/subdir/subsubdir", ItemTypeDirectory);
makeEntry("foodir/subdir/subsubdir/file", ItemTypeFile);
makeEntry("foodir/subdir/otherdir", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
Ensure local discovery on selective sync changes As far as I'm aware local discovery can be skipped on folders that are selective-sync blacklisted, so a local discovery is required when an entry is removed from the blacklist. Also rename avoidReadFromDbOnNextSync() -> schedulePathForRemoteDiscovery() since the old name might also imply it's not read from db in the local discovery - which is not the case. Use Folder:: schedulePathForLocalDiscovery() for that.
2019-02-13 16:18:54 +03:00
_db.schedulePathForRemoteDiscovery(QByteArray("foodir/subdir"));
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
// Direct effects of parent directories being set to _invalid_
QCOMPARE(getEtag("foodir"), invalidEtag);
QCOMPARE(getEtag("foodir/subdir"), invalidEtag);
QCOMPARE(getEtag("foodir/subdir/subsubdir"), initialEtag);
QCOMPARE(getEtag("foodir/file"), initialEtag);
QCOMPARE(getEtag("foodir/subdir/file"), initialEtag);
QCOMPARE(getEtag("foodir/subdir/subsubdir/file"), initialEtag);
QCOMPARE(getEtag("fo"), initialEtag);
QCOMPARE(getEtag("foo%"), initialEtag);
QCOMPARE(getEtag("foodi_"), initialEtag);
QCOMPARE(getEtag("otherdir"), initialEtag);
QCOMPARE(getEtag("foodir/otherdir"), initialEtag);
QCOMPARE(getEtag("foodir/sub"), initialEtag);
QCOMPARE(getEtag("foodir/subdir/otherdir"), initialEtag);
// Indirect effects: setFileRecord() calls filter etags
initialEtag = "etag2";
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("foodir", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
QCOMPARE(getEtag("foodir"), invalidEtag);
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("foodir/subdir", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
QCOMPARE(getEtag("foodir/subdir"), invalidEtag);
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("foodir/subdir/subsubdir", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
QCOMPARE(getEtag("foodir/subdir/subsubdir"), initialEtag);
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("fo", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
QCOMPARE(getEtag("fo"), initialEtag);
Fix tests to actually compile Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
2018-06-22 14:04:32 +03:00
makeEntry("foodir/sub", ItemTypeDirectory);
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
QCOMPARE(getEtag("foodir/sub"), initialEtag);
}
void testRecursiveDelete()
{
auto makeEntry = [&](const QByteArray &path) {
SyncJournalFileRecord record;
record._path = path;
_db.setFileRecord(record);
};
QByteArrayList elements;
elements
<< "foo"
<< "foo/file"
<< "bar"
<< "moo"
<< "moo/file"
<< "foo%bar"
<< "foo bla bar/file"
<< "fo_"
<< "fo_/file";
little loops optimization Signed-off-by: asapelkin <asapelkin0x01@ya.ru>
2019-10-07 00:10:26 +03:00
for (const auto& elem : elements)
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
makeEntry(elem);
auto checkElements = [&]() {
bool ok = true;
little loops optimization Signed-off-by: asapelkin <asapelkin0x01@ya.ru>
2019-10-07 00:10:26 +03:00
for (const auto& elem : elements) {
SyncJournal: Don't use LIKE with paths Paths can contain the wildcards % and _ and that would lead to odd behavior. This patch also clarifies the behavior of avoidReadFromDbOnNextSync() which previously dependend on whether "foo/bar" or "foo/bar/" was passed as input. Possibly affects #6322
2018-02-07 15:05:41 +03:00
SyncJournalFileRecord record;
_db.getFileRecord(elem, &record);
if (!record.isValid()) {
qWarning() << "Missing record: " << elem;
ok = false;
}
}
return ok;
};
_db.deleteFileRecord("moo", true);
elements.removeAll("moo");
elements.removeAll("moo/file");
QVERIFY(checkElements());
_db.deleteFileRecord("fo_", true);
elements.removeAll("fo_");
elements.removeAll("fo_/file");
QVERIFY(checkElements());
_db.deleteFileRecord("foo%bar", true);
elements.removeAll("foo%bar");
QVERIFY(checkElements());
}
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
void testPinState()
{
auto make = [&](const QByteArray &path, PinState state) {
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
_db.internalPinStates().setForPath(path, state);
auto pinState = _db.internalPinStates().rawForPath(path);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QVERIFY(pinState);
QCOMPARE(*pinState, state);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
};
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
auto get = [&](const QByteArray &path) -> PinState {
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
auto state = _db.internalPinStates().effectiveForPath(path);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
if (!state) {
QTest::qFail("couldn't read pin state", __FILE__, __LINE__);
return PinState::Inherited;
}
return *state;
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
};
Vfs: Add 'availability', a simplified, user-facing pin state #7111 The idea is that the user's question is "is this folder's data available offline?" and not "does this folder have AlwaysLocal pin state?". The the answers to the two questions can differ: an always-local folder can have subitems that are not always-local and are dehydrated. The new availability enum intends to describe the answer to the user's actual question and can be derived from pin states. If pin states aren't stored in the database the way of calculating availability will depend on the vfs plugin.
2019-04-03 11:53:04 +03:00
auto getRecursive = [&](const QByteArray &path) -> PinState {
auto state = _db.internalPinStates().effectiveForPathRecursive(path);
if (!state) {
QTest::qFail("couldn't read pin state", __FILE__, __LINE__);
return PinState::Inherited;
}
return *state;
};
Db: Add wiping of pin state for subtrees
2018-12-21 12:35:07 +03:00
auto getRaw = [&](const QByteArray &path) -> PinState {
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
auto state = _db.internalPinStates().rawForPath(path);
Db: Add wiping of pin state for subtrees
2018-12-21 12:35:07 +03:00
if (!state) {
QTest::qFail("couldn't read pin state", __FILE__, __LINE__);
return PinState::Inherited;
}
return *state;
};
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
_db.internalPinStates().wipeForPathAndBelow("");
auto list = _db.internalPinStates().rawList();
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
QCOMPARE(list->size(), 0);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
// Make a thrice-nested setup
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
make("", PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
make("local", PinState::AlwaysLocal);
make("online", PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
make("inherit", PinState::Inherited);
for (auto base : {"local/", "online/", "inherit/"}) {
make(QByteArray(base) + "inherit", PinState::Inherited);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
make(QByteArray(base) + "local", PinState::AlwaysLocal);
make(QByteArray(base) + "online", PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
for (auto base2 : {"local/", "online/", "inherit/"}) {
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
make(QByteArray(base) + base2 + "inherit", PinState::Inherited);
make(QByteArray(base) + base2 + "local", PinState::AlwaysLocal);
make(QByteArray(base) + base2 + "online", PinState::OnlineOnly);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
}
}
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
list = _db.internalPinStates().rawList();
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
QCOMPARE(list->size(), 4 + 9 + 27);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
// Baseline direct checks (the fallback for unset root pinstate is AlwaysLocal)
Vfs: Add 'availability', a simplified, user-facing pin state #7111 The idea is that the user's question is "is this folder's data available offline?" and not "does this folder have AlwaysLocal pin state?". The the answers to the two questions can differ: an always-local folder can have subitems that are not always-local and are dehydrated. The new availability enum intends to describe the answer to the user's actual question and can be derived from pin states. If pin states aren't stored in the database the way of calculating availability will depend on the vfs plugin.
2019-04-03 11:53:04 +03:00
QCOMPARE(get(""), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("local"), PinState::AlwaysLocal);
QCOMPARE(get("online"), PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("inherit"), PinState::AlwaysLocal);
QCOMPARE(get("nonexistant"), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("online/local"), PinState::AlwaysLocal);
QCOMPARE(get("local/online"), PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("inherit/local"), PinState::AlwaysLocal);
QCOMPARE(get("inherit/online"), PinState::OnlineOnly);
QCOMPARE(get("inherit/inherit"), PinState::AlwaysLocal);
QCOMPARE(get("inherit/nonexistant"), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
// Inheriting checks, level 1
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("local/inherit"), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("local/nonexistant"), PinState::AlwaysLocal);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("online/inherit"), PinState::OnlineOnly);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("online/nonexistant"), PinState::OnlineOnly);
// Inheriting checks, level 2
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("local/inherit/inherit"), PinState::AlwaysLocal);
QCOMPARE(get("local/local/inherit"), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("local/local/nonexistant"), PinState::AlwaysLocal);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("local/online/inherit"), PinState::OnlineOnly);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("local/online/nonexistant"), PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("online/inherit/inherit"), PinState::OnlineOnly);
QCOMPARE(get("online/local/inherit"), PinState::AlwaysLocal);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("online/local/nonexistant"), PinState::AlwaysLocal);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
QCOMPARE(get("online/online/inherit"), PinState::OnlineOnly);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
QCOMPARE(get("online/online/nonexistant"), PinState::OnlineOnly);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
Vfs: Add 'availability', a simplified, user-facing pin state #7111 The idea is that the user's question is "is this folder's data available offline?" and not "does this folder have AlwaysLocal pin state?". The the answers to the two questions can differ: an always-local folder can have subitems that are not always-local and are dehydrated. The new availability enum intends to describe the answer to the user's actual question and can be derived from pin states. If pin states aren't stored in the database the way of calculating availability will depend on the vfs plugin.
2019-04-03 11:53:04 +03:00
// Spot check the recursive variant
QCOMPARE(getRecursive(""), PinState::Inherited);
QCOMPARE(getRecursive("local"), PinState::Inherited);
QCOMPARE(getRecursive("online"), PinState::Inherited);
QCOMPARE(getRecursive("inherit"), PinState::Inherited);
QCOMPARE(getRecursive("online/local"), PinState::Inherited);
QCOMPARE(getRecursive("online/local/inherit"), PinState::AlwaysLocal);
QCOMPARE(getRecursive("inherit/inherit/inherit"), PinState::AlwaysLocal);
QCOMPARE(getRecursive("inherit/online/inherit"), PinState::OnlineOnly);
QCOMPARE(getRecursive("inherit/online/local"), PinState::AlwaysLocal);
make("local/local/local/local", PinState::AlwaysLocal);
QCOMPARE(getRecursive("local/local/local"), PinState::AlwaysLocal);
QCOMPARE(getRecursive("local/local/local/local"), PinState::AlwaysLocal);
vfs: Remove newFilesAreVirtual - use root PinState instead This unifies how to deal with pin states. Also enable reading a folders direct pin state vs its effective pin state.
2018-12-20 13:24:41 +03:00
// Check changing the root pin state
make("", PinState::OnlineOnly);
QCOMPARE(get("local"), PinState::AlwaysLocal);
QCOMPARE(get("online"), PinState::OnlineOnly);
QCOMPARE(get("inherit"), PinState::OnlineOnly);
QCOMPARE(get("nonexistant"), PinState::OnlineOnly);
make("", PinState::AlwaysLocal);
QCOMPARE(get("local"), PinState::AlwaysLocal);
QCOMPARE(get("online"), PinState::OnlineOnly);
QCOMPARE(get("inherit"), PinState::AlwaysLocal);
QCOMPARE(get("nonexistant"), PinState::AlwaysLocal);
Db: Add wiping of pin state for subtrees
2018-12-21 12:35:07 +03:00
// Wiping
QCOMPARE(getRaw("local/local"), PinState::AlwaysLocal);
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
_db.internalPinStates().wipeForPathAndBelow("local/local");
Db: Add wiping of pin state for subtrees
2018-12-21 12:35:07 +03:00
QCOMPARE(getRaw("local"), PinState::AlwaysLocal);
QCOMPARE(getRaw("local/local"), PinState::Inherited);
QCOMPARE(getRaw("local/local/local"), PinState::Inherited);
QCOMPARE(getRaw("local/local/online"), PinState::Inherited);
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
list = _db.internalPinStates().rawList();
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
QCOMPARE(list->size(), 4 + 9 + 27 - 4);
vfs: Allow (de-)hydrating the full sync folder
2019-01-08 14:24:15 +03:00
// Wiping everything
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
_db.internalPinStates().wipeForPathAndBelow("");
vfs: Allow (de-)hydrating the full sync folder
2019-01-08 14:24:15 +03:00
QCOMPARE(getRaw(""), PinState::Inherited);
QCOMPARE(getRaw("local"), PinState::Inherited);
QCOMPARE(getRaw("online"), PinState::Inherited);
PinStates cleanup - SyncJournalDB functions now behind internalPinStates() to avoid accidental usage, when nearly everyone should go through Vfs. - Rename Vfs::getPinState() to Vfs::pinState()
2019-01-29 12:53:47 +03:00
list = _db.internalPinStates().rawList();
vfs: Allow retrieving of pin state paths and flags
2019-01-08 17:15:17 +03:00
QCOMPARE(list->size(), 0);
vfs: Introduce PinState db storage #6815 The idea is to allow folders (and later maybe files?) to be - pinned to be available locally - pinned to be online only - inherit their pin from the parent Where this pinning only controls the default for new files. Subfolders may have a different pin state, and contained files may be hydrated or dehydrated based on user actions. This value is stored in a new 'flags' table. The idea is to store data there that doesn't necessarily exist for each metadata entry. The selective sync state could be migrated to this table.
2018-11-26 15:40:51 +03:00
}
Add SyncJournalDB autotests. There also was a bug in syncjournaldb: in some error conditions the sql query wasn't reset properly. We now always reset a query before calling bindValue.
2014-10-23 17:15:47 +04:00
private:
SyncJournalDb _db;
};
For tests we do not need a xserver running. Use for tests QTEST_GUILESS_MAIN and QTEST_APPLESS_MAIN.
2016-05-11 02:17:16 +03:00
QTEST_APPLESS_MAIN(TestSyncJournalDB)
Simplify the build of auto tests Remove all configure_files: - Move all tests to cpp files - Use the QTEST_MAIN macro instead of a generated main.cpp - Include test*.moc in the cpp to let CMAKE_AUTOMOC call moc - Pass info through add_definitions instead of generating oc_bin.h with them This makes sure that build errors points to the original test source file instead of the generated one in the build directory to be able to jump and fix errors directly from the IDE's error pane.
2016-03-30 18:58:15 +03:00
#include "testsyncjournaldb.moc"
Reference in a new issue Copy permalink