Folder: Keep files option after aboutToRemoveAllFiles should not clear selective...

We were removing the wholme journal db when the user wanted to keep all files,
But that would also remove the selective sync lists.
We should only remove the metadata table.

Issue #5484

diff --git a/src/gui/folder.cpp b/src/gui/folder.cpp
index 845b5b68dfba5ebd63828e225a984a479fb4aa7e..3bfb54cb0953923c2de6af6e69762e84ea25ef58 100644 (file)
--- a/src/gui/folder.cpp
+++ b/src/gui/folder.cpp
@@ -908,7 +908,7 @@ void Folder::slotAboutToRemoveAllFiles(SyncFileItem::Direction dir, bool *cancel
     }
     *cancel = msgBox.clickedButton() == keepBtn;
     if (*cancel) {
-        wipe();
+        journalDb()->clearFileTable();
         _lastEtag.clear();
         slotScheduleThisFolder();
     }

diff --git a/src/libsync/syncjournaldb.cpp b/src/libsync/syncjournaldb.cpp
index 7ee83db462a88313350863892be280f54f3642c6..43ef9b37aaf2e1637809e64b690476f4ed6767a5 100644 (file)
--- a/src/libsync/syncjournaldb.cpp
+++ b/src/libsync/syncjournaldb.cpp
@@ -1836,6 +1836,17 @@ void SyncJournalDb::setDataFingerprint(const QByteArray &dataFingerprint)
     }
 }
 
+void SyncJournalDb::clearFileTable()
+{
+    SqlQuery query(_db);
+    query.prepare("DELETE FROM metadata;");
+    if (!query.exec()) {
+        qWarning() << "SQL error in clearFileTable" << query.error();
+    } else {
+        qDebug() << query.lastQuery() << "(" << query.numRowsAffected() << " rows)";
+    }
+}
+
 void SyncJournalDb::commit(const QString& context, bool startTrans)
 {
     QMutexLocker lock(&_mutex);

diff --git a/src/libsync/syncjournaldb.h b/src/libsync/syncjournaldb.h
index fe00051a33aa52480b6cf292e988a67779b28d7d..cd45726449686b1c7d5a9323379fbd4030dc9617 100644 (file)
--- a/src/libsync/syncjournaldb.h
+++ b/src/libsync/syncjournaldb.h
@@ -173,6 +173,13 @@ public:
     void setDataFingerprint(const QByteArray &dataFingerprint);
     QByteArray dataFingerprint();
 
+    /**
+     * Delete any file entry. This will force the next sync to re-sync everything as if it was new,
+     * restoring everyfile on every remote. If a file is there both on the client and server side,
+     * it will be a conflict that will be automatically resolved if the file is the same.
+     */
+    void clearFileTable();
+
 private:
     bool updateDatabaseStructure();
     bool updateMetadataTableStructure();

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 16b4b658904d86a616c38b894a5a7087f10b917d..2f94501eeb6aa9f0e1e2df1cad17ec7995dc1e57 100644 (file)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -40,6 +40,7 @@ if(HAVE_QT5 AND NOT BUILD_WITH_QT4)
     owncloud_add_test(SyncFileStatusTracker "syncenginetestutils.h")
     owncloud_add_test(ChunkingNg "syncenginetestutils.h")
     owncloud_add_test(UploadReset "syncenginetestutils.h")
+    owncloud_add_test(AllFilesDeleted "syncenginetestutils.h")
     owncloud_add_test(FolderWatcher "${FolderWatcher_SRC}")
 
     if( UNIX AND NOT APPLE )

diff --git a/test/testallfilesdeleted.cpp b/test/testallfilesdeleted.cpp
new file mode 100644 (file)
index 0000000..d9356c8
--- /dev/null
+++ b/test/testallfilesdeleted.cpp
@@ -0,0 +1,118 @@
+/*
+ *    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 "syncenginetestutils.h"
+#include <syncengine.h>
+
+using namespace OCC;
+
+/*
+ * This test ensure that the SyncEngine::aboutToRemoveAllFiles is correctly called and that when
+ * we the user choose to remove all files SyncJournalDb::clearFileTable makes works as expected
+ */
+class TestAllFilesDeleted : public QObject
+{
+    Q_OBJECT
+
+private slots:
+
+    void testAllFilesDeletedKeep_data()
+    {
+        QTest::addColumn<bool>("deleteOnRemote");
+        QTest::newRow("local") << false;
+        QTest::newRow("remote") << true;
+
+    }
+
+    /*
+     * In this test, all files are deleted in the client, or the server, and we simulate
+     * that the users press "keep"
+     */
+    void testAllFilesDeletedKeep()
+    {
+        QFETCH(bool, deleteOnRemote);
+        FakeFolder fakeFolder{FileInfo::A12_B12_C12_S12()};
+
+        //Just set a blacklist so we can check it is still there. This directory does not exists but
+        // that does not matter for our purposes.
+        QStringList selectiveSyncBlackList = { "Q/" };
+        fakeFolder.syncEngine().journal()->setSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList,
+                                                                selectiveSyncBlackList);
+
+        auto initialState = fakeFolder.currentLocalState();
+        int aboutToRemoveAllFilesCalled = 0;
+        QObject::connect(&fakeFolder.syncEngine(), &SyncEngine::aboutToRemoveAllFiles,
+            [&](SyncFileItem::Direction dir, bool *cancel) {
+                QCOMPARE(aboutToRemoveAllFilesCalled, 0);
+                aboutToRemoveAllFilesCalled++;
+                QCOMPARE(dir, deleteOnRemote ? SyncFileItem::Down : SyncFileItem::Up);
+                *cancel = true;
+                fakeFolder.syncEngine().journal()->clearFileTable(); // That's what Folder is doing
+            });
+
+        auto &modifier = deleteOnRemote ? fakeFolder.remoteModifier() : fakeFolder.localModifier();
+        for (const auto &s : fakeFolder.currentRemoteState().children.keys())
+            modifier.remove(s);
+
+        QVERIFY(!fakeFolder.syncOnce()); // Should fail because we cancel the sync
+        QCOMPARE(aboutToRemoveAllFilesCalled, 1);
+
+        // Next sync should recover all files
+        QVERIFY(fakeFolder.syncOnce());
+        QCOMPARE(fakeFolder.currentLocalState(), initialState);
+        QCOMPARE(fakeFolder.currentRemoteState(), initialState);
+
+        // The selective sync blacklist should be not have been deleted.
+        bool ok = true;
+        QCOMPARE(fakeFolder.syncEngine().journal()->getSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList, &ok),
+                 selectiveSyncBlackList);
+    }
+
+    void testAllFilesDeletedDelete_data()
+    {
+        testAllFilesDeletedKeep_data();
+    }
+
+    /*
+     * This test is like the previous one but we simulate that the user presses "delete"
+     */
+    void testAllFilesDeletedDelete()
+    {
+        QFETCH(bool, deleteOnRemote);
+        FakeFolder fakeFolder{FileInfo::A12_B12_C12_S12()};
+
+        int aboutToRemoveAllFilesCalled = 0;
+        QObject::connect(&fakeFolder.syncEngine(), &SyncEngine::aboutToRemoveAllFiles,
+            [&](SyncFileItem::Direction dir, bool *cancel) {
+                QCOMPARE(aboutToRemoveAllFilesCalled, 0);
+                aboutToRemoveAllFilesCalled++;
+                QCOMPARE(dir, deleteOnRemote ? SyncFileItem::Down : SyncFileItem::Up);
+                *cancel = false;
+            });
+
+        auto &modifier = deleteOnRemote ? fakeFolder.remoteModifier() : fakeFolder.localModifier();
+        for (const auto &s : fakeFolder.currentRemoteState().children.keys())
+            modifier.remove(s);
+
+        QVERIFY(fakeFolder.syncOnce()); // Should succeed, and all files must then be deleted
+
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+        QCOMPARE(fakeFolder.currentLocalState().children.count(), 0);
+
+        // Try another sync to be sure.
+
+        QVERIFY(fakeFolder.syncOnce()); // Should succeed (doing nothing)
+        QCOMPARE(aboutToRemoveAllFilesCalled, 1); // should not have been called.
+
+        QCOMPARE(fakeFolder.currentLocalState(), fakeFolder.currentRemoteState());
+        QCOMPARE(fakeFolder.currentLocalState().children.count(), 0);
+    }
+};
+
+QTEST_GUILESS_MAIN(TestAllFilesDeleted)
+#include "testallfilesdeleted.moc"