fix(quota): keep error context for user and add tests.

When a local file is blocked from uploading due to remote quota (HTTP 507) and the parent
folder is subsequently deleted on the server, checkErrorBlacklisting() in would overwrite
the deliberate CSYNC_INSTRUCTION_ERROR set by checkNewDeleteConflict() with a generic
CSYNC_INSTRUCTION_IGNORE so the user would loose the error message with the reason
for the permanence of some files.

Also add tests:
- confirms non-quota new files are still deleted when the parent folder is removed on the server.
- verifies that once the user remove the protected file locally, the next sync cleans up the
now empty server-deleted folder.
- same as above for a nested.

Signed-off-by: Camila Ayres <hello@camilasan.com>

Author: camilasan

src/libsync/discovery.cpp

@@ -2218,6 +2218,13 @@ int ProcessDirectoryJob::processSubJobs(int nbJobs)
                 // Do not remove a directory that has ignored files
                 qCInfo(lcDisco) << "Child ignored for a folder to remove" << _dirItem->_file << "direction" << _dirItem->_direction;
                 _dirItem->_instruction = CSYNC_INSTRUCTION_NONE;
+                // Invalidate the parent directory's etag so the next sync re-queries it from
+                // the server instead of using a ParentNotChanged cache hit.  Without this, a
+                // parent whose etag has not changed since the server-side deletion uses its DB
+                // record as a proxy for server state and keeps issuing NONE for this folder.
+                const auto slashPos = _dirItem->_file.lastIndexOf(QLatin1Char('/'));
+                const auto parentPath = slashPos >= 0 ? _dirItem->_file.left(slashPos) : QString();
+                _discoveryData->_statedb->schedulePathForRemoteDiscovery(parentPath.toUtf8());
             }
         }
         emit finished();

src/libsync/syncengine.cpp

@@ -143,6 +143,16 @@ bool SyncEngine::checkErrorBlacklisting(SyncFileItem &item)
 
     item._hasBlacklistEntry = true;
 
+    // Discovery already produced a deliberate error for items protected in checkNewDeleteConflict.
+    // Keep its instruction and message intact so the specific reason is displayed.
+    // Still show the quota notification if applicable.
+    if (item._instruction == CSYNC_INSTRUCTION_ERROR) {
+        if (entry._errorCategory == SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage) {
+            slotInsufficientRemoteStorage();
+        }
+        return true;
+    }
+
     // If duration has expired, it's not blacklisted anymore
     time_t now = Utility::qDateTimeToTime_t(QDateTime::currentDateTimeUtc());
     if (now >= entry._lastTryTime + entry._ignoreDuration) {

test/testsyncdelete.cpp

@@ -104,12 +104,9 @@ private slots:
         {
             auto item = completeSpy.findItem(QStringLiteral("A/quota_blocked.txt"));
             QVERIFY(item);
-            const bool isErrorItem = item->_instruction == CSYNC_INSTRUCTION_ERROR
-                || item->_instruction == CSYNC_INSTRUCTION_IGNORE; // BlacklistedError reuses IGNORE
-            QVERIFY(isErrorItem);
-            const bool isErrorStatus = item->_status == SyncFileItem::SoftError
-                || item->_status == SyncFileItem::BlacklistedError;
-            QVERIFY(isErrorStatus);
+            QCOMPARE(item->_instruction, CSYNC_INSTRUCTION_ERROR);
+            QVERIFY(item->_status == SyncFileItem::SoftError || item->_status == SyncFileItem::NormalError);
+            QVERIFY(!item->_errorString.contains(QStringLiteral("skipped due to earlier error")));
         }
     }