fix(quota): emit storage notification on quota flag and simplify blacklist rename

Gate the discovery-time storage full notification on _isQuotaError instead
of a faked 507, so the same-sync first-detection case (no blacklist entry,
no HTTP request) still notifies the user.

Collapse renameErrorBlacklistPaths to a single category-scoped UPDATE that
returns numRowsAffected, removing the extra COUNT query and the mismatch
where the UPDATE moved non-quota entries.

Assisted-by: Claude Code:claude-opus-4-8
Signed-off-by: Camila Ayres <hello@camilasan.com>

Author: camilasan

src/common/preparedsqlquerymanager.h

@@ -99,7 +99,6 @@ class OCSYNC_EXPORT PreparedSqlQueryManager
         FolderUpdateInvalidEncryptionStatus,
         FileUpdateInvalidEncryptionStatus,
         HasFileIdQuery,
-        RenameErrorBlacklistCountQuery,
         RenameErrorBlacklistUpdateQuery,
 
         PreparedQueryCount

src/common/syncjournaldb.cpp

@@ -2178,38 +2178,26 @@ bool SyncJournalDb::renameErrorBlacklistPaths(const QString &from, const QString
         return false;
     }
 
-    const auto countQuery = _queryManager.get(PreparedSqlQueryManager::RenameErrorBlacklistCountQuery, 
-                                            QByteArrayLiteral("SELECT COUNT(*) FROM blacklist "
-                                                            "WHERE errorCategory = ?1 "
-                                                            "AND (path = ?2 OR (path > (?2 || '/') AND path < (?2 || '0')))"),
-                                            _db);
-    if (!countQuery) {
+    // Move the exact folder entry and all entries whose path starts with "from/".
+    // Uses the same range trick as IS_PREFIX_PATH_OR_EQUAL: '/' + 1 == '0'.
+    // Scoped to quota entries so the returned count reflects only protected files.
+    const auto query = _queryManager.get(PreparedSqlQueryManager::RenameErrorBlacklistUpdateQuery,
+                                        QByteArrayLiteral("UPDATE blacklist "
+                                                        "SET path = ?2 || substr(path, length(?1) + 1) "
+                                                        "WHERE errorCategory = ?3 "
+                                                        "AND (path == ?1 OR (path > (?1 || '/') AND path < (?1 || '0')))"),
+                                        _db);
+    if (!query) {
         return false;
     }
-
-    countQuery->bindValue(1, SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage);
-    countQuery->bindValue(2, from);
-
-    const bool hasQuotaEntries = countQuery->exec() && countQuery->next().hasData && countQuery->intValue(0) > 0;
-    if (hasQuotaEntries) {
-        // Update the exact folder entry and all entries whose path starts with "from/".
-        // Uses the same range trick as IS_PREFIX_PATH_OR_EQUAL: '/' + 1 == '0'.
-        const auto query = _queryManager.get(PreparedSqlQueryManager::RenameErrorBlacklistUpdateQuery,
-                                            QByteArrayLiteral("UPDATE blacklist "
-                                                            "SET path = ?2 || substr(path, length(?1) + 1) "
-                                                            "WHERE path == ?1 OR (path > (?1 || '/') AND path < (?1 || '0'))"),
-                                            _db);
-        if (!query) {
-            return false;
-        }
-        query->bindValue(1, from);
-        query->bindValue(2, to);
-        if (!query->exec()) {
-            sqlFail(QStringLiteral("renameErrorBlacklistPaths"), *query);
-        }
+    query->bindValue(1, from);
+    query->bindValue(2, to);
+    query->bindValue(3, SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage);
+    if (!query->exec()) {
+        return sqlFail(QStringLiteral("renameErrorBlacklistPaths"), *query);
     }
 
-    return hasQuotaEntries;
+    return query->numRowsAffected() > 0;
 }
 
 bool SyncJournalDb::deleteStaleErrorBlacklistEntries(const QSet<QString> &keep)

src/libsync/syncengine.cpp

@@ -487,7 +487,7 @@ void OCC::SyncEngine::slotItemDiscovered(const OCC::SyncFileItemPtr &item)
     // when a blacklist entry already exists; in the same sync as the folder deletion there is no
     // entry yet, so we check here unconditionally.
     if (item->_instruction == CSYNC_INSTRUCTION_ERROR
-        && item->_httpErrorCode == 507) {
+        && item->_isQuotaError) {
         slotInsufficientRemoteStorage();
     }
 

test/testsyncdelete.cpp

@@ -215,6 +215,7 @@ private slots:
         fakeFolder.localModifier().insert(QStringLiteral("A/big_file.txt"), 100); // 100 > 50
 
         ItemCompletedSpy completeSpy(fakeFolder);
+        QSignalSpy storageSpy(&fakeFolder.syncEngine(), &SyncEngine::syncError);
         fakeFolder.syncOnce();
 
         // big_file.txt was never uploaded but exceeds the last known quota.
@@ -232,6 +233,14 @@ private slots:
             QCOMPARE(item->_instruction, CSYNC_INSTRUCTION_ERROR);
             QVERIFY(item->_status == SyncFileItem::SoftError || item->_status == SyncFileItem::NormalError);
         }
+
+        // The storage full notification must fire even though no upload was attempted
+        // and there is no blacklist entry yet for the file.
+        const bool hadStorageNotification = std::any_of(storageSpy.begin(), storageSpy.end(),
+            [](const QList<QVariant> &args) {
+                return args.at(1).value<ErrorCategory>() == ErrorCategory::InsufficientRemoteStorage;
+            });
+        QVERIFY(hadStorageNotification);
     }
 
     // Files blocked from upload because of quota errors must follow their parent folder through