fix mobile audit review: ownership, outbox purge, delete gates, journal-first sweep, parent link column
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Failing after 6m39s
CI / test-backend (push) Successful in 1m19s
CI / test-mobile (push) Successful in 8m18s
CI / build-backend (push) Successful in 43s
CI / docker (push) Successful in 8s
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Failing after 6m39s
CI / test-backend (push) Successful in 1m19s
CI / test-mobile (push) Successful in 8m18s
CI / build-backend (push) Successful in 43s
CI / docker (push) Successful in 8s
This commit is contained in:
@@ -1,5 +1,6 @@
|
||||
package com.kazier.mobile.auth
|
||||
|
||||
import com.kazier.mobile.data.local.dao.PendingOperationDao
|
||||
import com.kazier.mobile.data.remote.ApiClient
|
||||
import com.kazier.mobile.data.remote.dto.UserDto
|
||||
import com.kazier.mobile.domain.ActiveUserStore
|
||||
@@ -28,6 +29,7 @@ class SessionManager @Inject constructor(
|
||||
private val activeUserStore: ActiveUserStore,
|
||||
private val tokenProvider: TokenProvider,
|
||||
private val localModeStore: LocalModeStore,
|
||||
private val pendingOperationDao: PendingOperationDao,
|
||||
private val apiClient: ApiClient,
|
||||
) {
|
||||
|
||||
@@ -50,16 +52,28 @@ class SessionManager @Inject constructor(
|
||||
|
||||
suspend fun save(token: String, user: UserDto, expiresAt: Long? = null) =
|
||||
withContext(Dispatchers.IO) {
|
||||
val previousUserId = activeUserStore.get()
|
||||
tokenStore.save(token, user, expiresAt)
|
||||
activeUserStore.set(user.id)
|
||||
localModeStore.clear()
|
||||
tokenProvider.current = token
|
||||
// Changement de compte sans sign-out explicite (login de B par
|
||||
// dessus la session de A) : même purge que `clear()` — la file de
|
||||
// A ne doit pas partir sous le token de B. Premier login
|
||||
// (`previousUserId == null`, éventuel travail du mode local) et
|
||||
// re-login du même compte : file conservée.
|
||||
if (previousUserId != null && previousUserId != user.id) {
|
||||
pendingOperationDao.deleteUnpushed()
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun clear() = withContext(Dispatchers.IO) {
|
||||
tokenStore.clear()
|
||||
activeUserStore.clear()
|
||||
tokenProvider.current = null
|
||||
// Sign-out explicite : la file non poussée est abandonnée (C5, voir
|
||||
// `deleteUnpushed`). Les ops `synced` survivent comme tombstones.
|
||||
pendingOperationDao.deleteUnpushed()
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -33,7 +33,7 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity
|
||||
FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
|
||||
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
|
||||
],
|
||||
version = 13,
|
||||
version = 14,
|
||||
exportSchema = false,
|
||||
)
|
||||
abstract class AppDatabase : RoomDatabase() {
|
||||
|
||||
@@ -15,6 +15,15 @@ interface FileDao {
|
||||
@Query("SELECT * FROM files ORDER BY name ASC")
|
||||
suspend fun getAll(): List<FileEntity>
|
||||
|
||||
/**
|
||||
* Repasse C4 : lignes déjà journalisées (`exists = 0`) dont les octets
|
||||
* sont peut-être encore sur le disque (journal-first, crash ou refus SAF
|
||||
* entre la transaction et la suppression physique). Borné pour ne jamais
|
||||
* bloquer un tick de sync.
|
||||
*/
|
||||
@Query("SELECT * FROM files WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
|
||||
suspend fun getMissingWithUri(limit: Int): List<FileEntity>
|
||||
|
||||
@Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC")
|
||||
fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>>
|
||||
|
||||
|
||||
@@ -18,6 +18,14 @@ interface FolderDao {
|
||||
@Query("SELECT * FROM folders ORDER BY name ASC")
|
||||
suspend fun getAll(): List<FolderEntity>
|
||||
|
||||
/**
|
||||
* Repasse C4 (dossiers) : voir `FileDao.getMissingWithUri`. Un dossier
|
||||
* n'est re-supprimé physiquement que si toute sa descendance Room est
|
||||
* aussi `exists = 0` (jamais de suppression d'un arbre encore vivant).
|
||||
*/
|
||||
@Query("SELECT * FROM folders WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
|
||||
suspend fun getMissingWithUri(limit: Int): List<FolderEntity>
|
||||
|
||||
/** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */
|
||||
@Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC")
|
||||
suspend fun getCreatedInApp(): List<FolderEntity>
|
||||
|
||||
+42
-7
@@ -38,14 +38,17 @@ interface PendingOperationDao {
|
||||
/**
|
||||
* Invalidation en cascade : un `create_resource` définitivement échoué rend
|
||||
* fautives toutes les ops en attente qui ciblent la même ressource, ainsi
|
||||
* que les creates enfants (autre `resource_id`, liés via
|
||||
* `payload.parentResourceId` — le walk émet parent avant enfant, cf. C6).
|
||||
* que les creates enfants (autre `resource_id`, liés via la colonne
|
||||
* `parent_resource_id` — le walk émet parent avant enfant, cf. C6).
|
||||
* Le repli `LIKE` sur le payload ne sert que les lignes pré-v14 sans
|
||||
* colonne renseignée.
|
||||
*/
|
||||
@Query("""
|
||||
UPDATE pending_operations SET status = 'failed', updated_at = :now
|
||||
WHERE status = 'pending' AND (
|
||||
resource_id = :resourceId
|
||||
OR payload LIKE '%"parentResourceId":"' || :resourceId || '"%'
|
||||
OR parent_resource_id = :resourceId
|
||||
OR (parent_resource_id IS NULL AND payload LIKE '%"parentResourceId":"' || :resourceId || '"%')
|
||||
)
|
||||
""")
|
||||
suspend fun failDescendants(resourceId: String, now: Long)
|
||||
@@ -137,11 +140,43 @@ interface PendingOperationDao {
|
||||
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'")
|
||||
suspend fun countPending(): Int
|
||||
|
||||
/** Compteur diagnostique par statut (tests, badge « liste des sync »). */
|
||||
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = :status")
|
||||
suspend fun countByStatus(status: String): Int
|
||||
|
||||
/**
|
||||
* Une op `move_resource` encore en attente de push existe-t-elle pour cette
|
||||
* ressource ? L'antichambre outbox est alors la source de vérité du
|
||||
* placement : ni le refresh serveur ni le walk SAF ne doivent écraser le
|
||||
* `folder_resource_id` local avant que le serveur ait accusé le move.
|
||||
* Abandon de la file non poussée (C5) : supprime les ops `pending` et
|
||||
* `failed` — jamais les `synced`. Au changement de compte (sign-out, ou
|
||||
* login d'un autre user), rejouer la file de A sous le token de B
|
||||
* appliquerait ses mutations dans le scope de B (`NOT_FOUND`,
|
||||
* `NAME_CONFLICT`, voire créations croisées). Les ops `synced` sont
|
||||
* conservées : ce sont des tombstones (C3) fondant les gates
|
||||
* delete/create et le backfill — elles ne sont plus jamais sélectionnées
|
||||
* (`selectPending` ne lit que `pending`) donc sans risque de rejeu.
|
||||
*/
|
||||
@Query("DELETE FROM pending_operations WHERE status IN ('pending', 'failed')")
|
||||
suspend fun deleteUnpushed(): Int
|
||||
|
||||
/**
|
||||
* Un `delete_resource` est-il encore en attente de push pour cette
|
||||
* ressource ? Le walk SAF ne doit alors jamais la ressusciter (`exists =
|
||||
* 1`) : l'intention de suppression est déjà journalisée (ordre
|
||||
* journal-first, C4) et la repasse physique va suivre. Sans ce garde, le
|
||||
* walk réimporterait une ressource que le serveur s'apprête à supprimer.
|
||||
*/
|
||||
@Query("""
|
||||
SELECT COUNT(*) FROM pending_operations
|
||||
WHERE resource_id = :resourceId
|
||||
AND operation = 'delete_resource'
|
||||
AND status = 'pending'
|
||||
""")
|
||||
suspend fun countPendingDeleteOperations(resourceId: String): Int
|
||||
|
||||
/**
|
||||
* Un `move_resource` est-il encore en attente de push ? Tant que l'op est
|
||||
* pendante, le `folder_resource_id` local reflète la cible future : ni le
|
||||
* refresh serveur (qui renvoie l'ancien dossier) ni le walk SAF (snapshot
|
||||
* périmé) ne doivent l'écraser.
|
||||
*/
|
||||
@Query("""
|
||||
SELECT COUNT(*) FROM pending_operations
|
||||
|
||||
+10
@@ -24,6 +24,7 @@ import androidx.room.PrimaryKey
|
||||
Index(value = ["status"]),
|
||||
Index(value = ["resource_id"]),
|
||||
Index(value = ["resource_id", "operation", "status"]),
|
||||
Index(value = ["parent_resource_id"]),
|
||||
],
|
||||
)
|
||||
data class PendingOperationEntity(
|
||||
@@ -45,6 +46,15 @@ data class PendingOperationEntity(
|
||||
val operation: String,
|
||||
@ColumnInfo(name = "payload")
|
||||
val payload: String,
|
||||
/**
|
||||
* Lien parent→enfant dénormalisé (P8) : `resource_id` du dossier parent
|
||||
* pour un `create_resource` avec parent (les enfants portent un autre
|
||||
* `resource_id`). Évite de parser le JSON du payload (`LIKE`) pour la
|
||||
* cascade d'invalidation — robuste au format de sérialisation Moshi.
|
||||
* NULL pour les ops sans parent et les lignes pré-v14 (repli LIKE).
|
||||
*/
|
||||
@ColumnInfo(name = "parent_resource_id")
|
||||
val parentResourceId: String? = null,
|
||||
@ColumnInfo(name = "status")
|
||||
val status: String = PendingOpStatus.PENDING,
|
||||
@ColumnInfo(name = "attempts")
|
||||
|
||||
+25
-1
@@ -99,6 +99,14 @@ object Migrations {
|
||||
db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0")
|
||||
// Backlog = déjà traité : la file de review ne contient que les
|
||||
// fichiers découverts après l'activation de la fonctionnalité.
|
||||
//
|
||||
// Décision M11 (documentée, assumée) : aucun `create_resource`
|
||||
// rétroactif n'est journalisé pour ce backlog — ces fichiers ne
|
||||
// seront jamais poussés vers le serveur (ni vizibles en review).
|
||||
// Un backfill applicatif créerait des doublons serveur pour les
|
||||
// ressources déjà connues par d'autres chemins (scan, second
|
||||
// device) sans moyen fiable de les distinguer : la perte silencieuse
|
||||
// du backlog pré-v6 est préférée à une résurrection massive.
|
||||
db.execSQL("UPDATE `files` SET `processed` = 1")
|
||||
}
|
||||
}
|
||||
@@ -222,7 +230,23 @@ object Migrations {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* P8 : colonne `parent_resource_id` dénormalisée (cascade sans parsing
|
||||
* JSON). Les lignes pré-v14 gardent NULL et restent couvertes par le repli
|
||||
* `LIKE` de `failDescendants` — pas de backfill (le `json_extract`
|
||||
* SQLite n'est pas garanti sur tous les niveaux d'API).
|
||||
*/
|
||||
private val MIGRATION_13_14 = object : Migration(13, 14) {
|
||||
override fun migrate(db: SupportSQLiteDatabase) {
|
||||
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `parent_resource_id` TEXT")
|
||||
db.execSQL(
|
||||
"CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` " +
|
||||
"ON `pending_operations` (`parent_resource_id`)",
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
val ALL: Array<Migration> = arrayOf(
|
||||
MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13,
|
||||
MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, MIGRATION_13_14,
|
||||
)
|
||||
}
|
||||
@@ -186,6 +186,14 @@ class FileRepository @Inject constructor(
|
||||
|
||||
val category = computeCategory(input.mimeType, input.extension).dbValue
|
||||
|
||||
// Garde anti-résurrection (C4) : un `delete_resource` déjà journalisé
|
||||
// (ordre journal-first) interdit de réimporter la ressource — le
|
||||
// serveur s'apprête à la supprimer et la repasse physique va suivre.
|
||||
if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) {
|
||||
if (existing.exists != 0) fileDao.markMissing(existing.resourceId, now)
|
||||
return existing.copy(exists = 0, updatedAt = now)
|
||||
}
|
||||
|
||||
// Un `move_resource` encore en attente fait de la cible outbox la
|
||||
// source de vérité du placement : un snapshot SAF périmé (walk lancé
|
||||
// avant le move) ne doit pas ré-attribuer le dossier à l'ancien parent.
|
||||
|
||||
@@ -114,6 +114,12 @@ class FolderRepository @Inject constructor(
|
||||
val existing = input.resourceId?.let { folderDao.getByResourceId(it) }
|
||||
?: input.uri?.let { folderDao.getByUri(it) }
|
||||
|
||||
// Garde anti-résurrection (C4) : voir `FileRepository.saveLocalFile`.
|
||||
if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) {
|
||||
if (existing.exists != 0) folderDao.markMissing(existing.resourceId, now)
|
||||
return existing.copy(exists = 0, updatedAt = now)
|
||||
}
|
||||
|
||||
// Garde pending-move (M1) : un snapshot SAF périmé ne revert jamais un
|
||||
// reparent/merge en cours de push.
|
||||
val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId)
|
||||
|
||||
@@ -58,6 +58,9 @@ class OutboxRepository @Inject constructor(
|
||||
resourceType = resourceType,
|
||||
operation = operation,
|
||||
payload = payloadAdapter.toJson(payload),
|
||||
// Lien parent→enfant dénormalisé pour la cascade (P8) —
|
||||
// même clé que le payload JSON ci-dessous.
|
||||
parentResourceId = payload[PARENT_PAYLOAD_KEY] as? String,
|
||||
status = PendingOpStatus.PENDING,
|
||||
createdAt = now,
|
||||
updatedAt = now,
|
||||
@@ -163,6 +166,27 @@ class OutboxRepository @Inject constructor(
|
||||
suspend fun hasCreateOperationAnyType(resourceId: String): Boolean =
|
||||
pendingOperationDao.countCreateOperationsAnyType(resourceId) > 0
|
||||
|
||||
/**
|
||||
* Le serveur connaît-il déjà ce fichier (create `synced`) ? Gate delete
|
||||
* précis (M19) : après [cancelPendingCreates], un `delete_resource` n'est
|
||||
* émis que dans ce cas — jamais pour une ressource que le serveur n'a
|
||||
* jamais vue (ni bruit create-puis-delete, ni `NOT_FOUND`).
|
||||
*/
|
||||
suspend fun hasSyncedCreateOperation(resourceId: String): Boolean =
|
||||
pendingOperationDao.countSyncedCreateOperations(resourceId) > 0
|
||||
|
||||
/** Variante dossiers de [hasSyncedCreateOperation]. */
|
||||
suspend fun hasSyncedCreateOperationAnyType(resourceId: String): Boolean =
|
||||
pendingOperationDao.countSyncedCreateOperationsAnyType(resourceId) > 0
|
||||
|
||||
/**
|
||||
* Annulation (M19) : supprime les `create_resource` encore `pending` pour
|
||||
* cette ressource qui disparaît localement avant que le serveur l'ait
|
||||
* connue. Retourne le nombre d'ops annulées.
|
||||
*/
|
||||
suspend fun cancelPendingCreates(resourceId: String): Int =
|
||||
pendingOperationDao.deletePendingCreates(resourceId)
|
||||
|
||||
/**
|
||||
* Un `move_resource` est-il encore en attente de push ? Tant que l'op est
|
||||
* pendante, le `folder_resource_id` local reflète la cible future : ni le
|
||||
@@ -172,6 +196,23 @@ class OutboxRepository @Inject constructor(
|
||||
suspend fun hasPendingMoveOperation(resourceId: String): Boolean =
|
||||
pendingOperationDao.countPendingMoveOperations(resourceId) > 0
|
||||
|
||||
/**
|
||||
* Un `delete_resource` est-il encore en attente de push ? Garde
|
||||
* anti-résurrection du walk (C4, voir DAO) : une ressource dont la
|
||||
* suppression est journalisée ne doit plus être réimportée.
|
||||
*/
|
||||
suspend fun hasPendingDeleteOperation(resourceId: String): Boolean =
|
||||
pendingOperationDao.countPendingDeleteOperations(resourceId) > 0
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Clé du lien parent→enfant, à la fois dans le payload JSON
|
||||
* `create_resource` (protocole, lu par `OutboxSyncWorker`) et dans la
|
||||
* colonne dénormalisée `parent_resource_id` (cascade SQL).
|
||||
*/
|
||||
const val PARENT_PAYLOAD_KEY = "parentResourceId"
|
||||
}
|
||||
|
||||
/**
|
||||
* Un `move_resource` (pending ou synced) a-t-il jamais été journalisé ?
|
||||
* Utilisé par la réconciliation du walk : une ligne en transition physique
|
||||
|
||||
@@ -88,7 +88,11 @@ class FileDeleter @Inject constructor(
|
||||
private suspend fun deleteInCloud(file: FileEntity): Boolean {
|
||||
var ok = false
|
||||
runCatching {
|
||||
if (outboxRepository.hasCreateOperation(file.resourceId)) {
|
||||
// Jamais poussé (create encore pending) : annulation (M19), pas
|
||||
// de delete — le serveur n'a rien à oublier. Poussé (synced) :
|
||||
// `delete_resource`, le serveur connaît la ressource.
|
||||
outboxRepository.cancelPendingCreates(file.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(file.resourceId, "file")
|
||||
}
|
||||
ok = true
|
||||
@@ -100,34 +104,75 @@ class FileDeleter @Inject constructor(
|
||||
}
|
||||
|
||||
/**
|
||||
* Suppression complète : physique + cloud.
|
||||
* Transaction atomique : SAF delete + markMissing + outbox.
|
||||
* Suppression complète : journal d'abord, physique ensuite (C4).
|
||||
*
|
||||
* Ordre crash-safe : la transaction Room (`exists = 0` + annulation du
|
||||
* create pending + éventuel `delete_resource`) est committée AVANT la
|
||||
* suppression SAF — un kill entre les deux ne perd plus le journal, le
|
||||
* serveur est toujours notifié. Si la suppression physique échoue (ou si
|
||||
* le kill survient juste après), la ligne reste `exists = 0` avec son
|
||||
* `uri` : la repasse [sweepPendingPhysicalDeletes] retentera le
|
||||
* `deleteDocument` au prochain tick (le walk peut la ressusciter
|
||||
* entre-temps, elle sera re-marquée sans nouveau journal — convergence).
|
||||
*/
|
||||
private suspend fun deleteFull(file: FileEntity): Boolean {
|
||||
val uri = file.uri
|
||||
return if (uri != null) {
|
||||
runCatching {
|
||||
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
|
||||
}.onSuccess { deleted ->
|
||||
if (deleted) {
|
||||
val now = System.currentTimeMillis()
|
||||
appDatabase.withTransaction {
|
||||
fileRepository.markMissing(file.resourceId, now)
|
||||
if (outboxRepository.hasCreateOperation(file.resourceId)) {
|
||||
outboxRepository.cancelPendingCreates(file.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(file.resourceId, "file")
|
||||
}
|
||||
}
|
||||
val deleted = runCatching {
|
||||
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
|
||||
}.onFailure { e ->
|
||||
Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri)
|
||||
}.getOrDefault(false)
|
||||
if (deleted) {
|
||||
Timber.d("deleted full %s", uri)
|
||||
thumbnailStore.delete(file.resourceId)
|
||||
} else {
|
||||
Timber.w("deleteDocument returned false for %s", uri)
|
||||
Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
|
||||
}
|
||||
}.onFailure { e ->
|
||||
Timber.w(e, "deleteDocument failed for %s", uri)
|
||||
}.getOrDefault(false)
|
||||
deleted
|
||||
} else {
|
||||
// Cloud-only : outbox uniquement.
|
||||
deleteInCloud(file)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Repasse C4 : retente la suppression physique des lignes déjà
|
||||
* journalisées (`exists = 0`, `uri` présente) dont les octets ont survécu
|
||||
* (kill entre journal et SAF, refus du provider). Bornée ([SWEEP_LIMIT])
|
||||
* et best-effort — appelée à chaque tick de sync et après chaque import.
|
||||
* Retourne le nombre d'octets effectivement supprimés.
|
||||
*/
|
||||
suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int {
|
||||
var swept = 0
|
||||
val stale = try {
|
||||
appDatabase.fileDao().getMissingWithUri(limit)
|
||||
} catch (e: Exception) {
|
||||
Timber.w(e, "sweep: lecture impossible")
|
||||
return 0
|
||||
}
|
||||
for (file in stale) {
|
||||
val uri = file.uri ?: continue
|
||||
val deleted = runCatching {
|
||||
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
|
||||
}.getOrDefault(false)
|
||||
if (deleted) {
|
||||
thumbnailStore.delete(file.resourceId)
|
||||
swept++
|
||||
}
|
||||
}
|
||||
return swept
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val SWEEP_LIMIT = 50
|
||||
}
|
||||
}
|
||||
|
||||
@@ -91,7 +91,8 @@ class FolderDeleter @Inject constructor(
|
||||
private suspend fun deleteInCloud(folder: FolderEntity): Boolean {
|
||||
var ok = false
|
||||
runCatching {
|
||||
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) {
|
||||
outboxRepository.cancelPendingCreates(folder.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder")
|
||||
}
|
||||
ok = true
|
||||
@@ -102,43 +103,88 @@ class FolderDeleter @Inject constructor(
|
||||
return ok
|
||||
}
|
||||
|
||||
/** Suppression complète : physique + cloud. Transaction atomique Room. */
|
||||
/**
|
||||
* Suppression complète : journal d'abord, physique ensuite (C4).
|
||||
*
|
||||
* Même contrat crash-safe que `FileDeleter.deleteFull` : la transaction
|
||||
* Room (`exists = 0` sur tout l'arbre + annulation des creates pending +
|
||||
* `delete_resource` là où le serveur connaît déjà la ressource) est
|
||||
* committée AVANT la suppression SAF. Un kill entre les deux ne perd plus
|
||||
* le journal ; si le physique échoue, [sweepPendingPhysicalDeletes]
|
||||
* retentera au prochain tick (le walk ne ressuscite plus les lignes sous
|
||||
* `delete_resource` pending — garde anti-résurrection).
|
||||
*/
|
||||
private suspend fun deleteFull(folder: FolderEntity): Boolean {
|
||||
val uri = folder.uri
|
||||
if (uri != null) {
|
||||
val tree = collectDescendants(folder.resourceId)
|
||||
if (deleteTreePhysically(folder, tree)) {
|
||||
val now = System.currentTimeMillis()
|
||||
appDatabase.withTransaction {
|
||||
treeMarkMissing(folder, tree, now)
|
||||
}
|
||||
return if (deleteTreePhysically(folder, tree)) {
|
||||
tree.files.forEach { thumbnailStore.delete(it.resourceId) }
|
||||
Timber.d("deleted folder full %s", uri)
|
||||
return true
|
||||
true
|
||||
} else {
|
||||
Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
|
||||
false
|
||||
}
|
||||
Timber.w("deleteDocument returned false for %s", uri)
|
||||
return false
|
||||
}
|
||||
// Cloud-only : outbox uniquement.
|
||||
return deleteInCloud(folder)
|
||||
}
|
||||
|
||||
/**
|
||||
* Repasse C4 (dossiers) : retente la suppression physique des arbres déjà
|
||||
* journalisés (`exists = 0`, `uri` présente). Un dossier n'est retenté que
|
||||
* si toute sa descendance Room est aussi `exists = 0` — jamais de
|
||||
* suppression d'un arbre encore vivant. Bornée ([SWEEP_LIMIT]).
|
||||
* Retourne le nombre d'arbres effectivement supprimés.
|
||||
*/
|
||||
suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int {
|
||||
var swept = 0
|
||||
val stale = try {
|
||||
appDatabase.folderDao().getMissingWithUri(limit)
|
||||
} catch (e: Exception) {
|
||||
Timber.w(e, "sweep folders: lecture impossible")
|
||||
return 0
|
||||
}
|
||||
for (folder in stale) {
|
||||
val tree = collectDescendants(folder.resourceId)
|
||||
val alive = tree.files.any { it.exists != 0 } || tree.folders.any { it.exists != 0 }
|
||||
if (alive) continue
|
||||
if (deleteTreePhysically(folder, tree)) {
|
||||
tree.files.forEach { thumbnailStore.delete(it.resourceId) }
|
||||
swept++
|
||||
}
|
||||
}
|
||||
return swept
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val SWEEP_LIMIT = 50
|
||||
}
|
||||
|
||||
/** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */
|
||||
private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) {
|
||||
for (file in tree.files) {
|
||||
fileRepository.markMissing(file.resourceId, now)
|
||||
if (outboxRepository.hasCreateOperation(file.resourceId)) {
|
||||
outboxRepository.cancelPendingCreates(file.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(file.resourceId, "file")
|
||||
}
|
||||
}
|
||||
for (desc in tree.folders) {
|
||||
folderRepository.markMissing(desc.resourceId, now)
|
||||
if (outboxRepository.hasCreateOperationAnyType(desc.resourceId)) {
|
||||
outboxRepository.cancelPendingCreates(desc.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperationAnyType(desc.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(desc.resourceId, "folder")
|
||||
}
|
||||
}
|
||||
folderRepository.markMissing(folder.resourceId, now)
|
||||
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) {
|
||||
outboxRepository.cancelPendingCreates(folder.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -41,32 +41,39 @@ class SafFileDeleter @Inject constructor(
|
||||
|
||||
private val resolver: ContentResolver get() = context.contentResolver
|
||||
|
||||
/**
|
||||
* Suppression review (swipe ✗) : journal d'abord, physique ensuite (C4 —
|
||||
* même contrat que `FileDeleter.deleteFull`, la repasse
|
||||
* `FileDeleter.sweepPendingPhysicalDeletes` couvrant aussi ces lignes).
|
||||
*/
|
||||
suspend fun delete(file: FileEntity): Boolean {
|
||||
val uri = file.uri ?: return false
|
||||
return withContext(Dispatchers.IO) {
|
||||
runCatching {
|
||||
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
|
||||
}.onSuccess { deleted ->
|
||||
if (deleted) {
|
||||
val now = System.currentTimeMillis()
|
||||
appDatabase.withTransaction {
|
||||
fileRepository.markMissing(file.resourceId, now)
|
||||
// Gate « processed » : si le fichier n'a jamais été poussé
|
||||
// (create_resource absent), le serveur n'en sait rien —
|
||||
// un delete_resource serait du bruit. On ne le journalise
|
||||
// que pour les ressources déjà synchronisées.
|
||||
if (outboxRepository.hasCreateOperation(file.resourceId)) {
|
||||
// Gate « processed » + annulation (M19) : si le fichier
|
||||
// n'a jamais été poussé (create encore pending), on
|
||||
// annule le create au lieu d'un delete bruit ; le
|
||||
// delete n'est journalisé que si le serveur connaît
|
||||
// déjà la ressource (create synced).
|
||||
outboxRepository.cancelPendingCreates(file.resourceId)
|
||||
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
|
||||
outboxRepository.enqueueDeleteResource(file.resourceId, "file")
|
||||
}
|
||||
}
|
||||
val deleted = runCatching {
|
||||
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
|
||||
}.onFailure { e ->
|
||||
Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri)
|
||||
}.getOrDefault(false)
|
||||
if (deleted) {
|
||||
Timber.d("deleted %s", uri)
|
||||
thumbnailStore.delete(file.resourceId)
|
||||
} else {
|
||||
Timber.w("deleteDocument returned false for %s", uri)
|
||||
Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
|
||||
}
|
||||
}.onFailure { e ->
|
||||
Timber.w(e, "deleteDocument failed for %s", uri)
|
||||
}.getOrDefault(false)
|
||||
deleted
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -130,21 +130,30 @@ class DeviceSync @Inject constructor(
|
||||
val now = System.currentTimeMillis()
|
||||
for (folder in folderRepository.getAll()) {
|
||||
val folderUri = folder.uri
|
||||
if (folder.exists != 0 && folderUri != null && isChildOf(folderUri, rootUri) && folderUri !in seen) {
|
||||
if (folder.exists != 0 && folderUri != null && isChildOf(folderUri, rootUri) && folderUri !in seen &&
|
||||
!outboxRepository.hasPendingMoveOperation(folder.resourceId)
|
||||
) {
|
||||
folderRepository.markMissing(folder.resourceId, now)
|
||||
// Disparu avant push : annule le create pending (M19) —
|
||||
// le serveur ne doit ni le créer ni l'oublier.
|
||||
outboxRepository.cancelPendingCreates(folder.resourceId)
|
||||
missing++
|
||||
}
|
||||
}
|
||||
for (file in fileRepository.getAll()) {
|
||||
val fileUri = file.uri
|
||||
// Un `move_resource` (pending ou synced) fait de l'outbox la
|
||||
// Un `move_resource` encore `pending` fait de l'outbox la
|
||||
// source de vérité du placement : on ne masque jamais une ligne
|
||||
// en transition vers une autre arborescence physique (le
|
||||
// snapshot peut être périmé par rapport au move en cours).
|
||||
// Un move déjà `synced` ne protège plus : si le fichier a
|
||||
// ensuite disparu du disque, c'est une vraie suppression
|
||||
// (sinon fantôme `exists = 1` éternel, M4).
|
||||
if (file.exists != 0 && fileUri != null && isChildOf(fileUri, rootUri) && fileUri !in seen &&
|
||||
!outboxRepository.hasMoveOperation(file.resourceId)
|
||||
!outboxRepository.hasPendingMoveOperation(file.resourceId)
|
||||
) {
|
||||
fileRepository.markMissing(file.resourceId, now)
|
||||
outboxRepository.cancelPendingCreates(file.resourceId)
|
||||
missing++
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,6 +23,7 @@ import com.kazier.mobile.data.local.entity.PendingOperationType
|
||||
import com.kazier.mobile.data.remote.ApiClient
|
||||
import com.kazier.mobile.data.remote.ApiException
|
||||
import com.kazier.mobile.data.remote.dto.SyncOpDto
|
||||
import com.kazier.mobile.data.repository.OutboxRepository
|
||||
import com.kazier.mobile.features.ocr.OcrAutoWorker
|
||||
import dagger.assisted.Assisted
|
||||
import dagger.assisted.AssistedInject
|
||||
@@ -267,10 +268,10 @@ class OutboxSyncWorker @AssistedInject constructor(
|
||||
}
|
||||
}
|
||||
|
||||
/** Lien parent→enfant porté par le payload (`create_resource` avec parent). */
|
||||
/** Lien parent→enfant : colonne dénormalisée, repli parsing JSON (lignes pré-v14). */
|
||||
private fun parentResourceIdOf(op: PendingOperationEntity): String? =
|
||||
runCatching { payloadAdapter.fromJson(op.payload) }
|
||||
.getOrNull()?.get(PARENT_RESOURCE_ID_KEY) as? String
|
||||
op.parentResourceId ?: runCatching { payloadAdapter.fromJson(op.payload) }
|
||||
.getOrNull()?.get(OutboxRepository.PARENT_PAYLOAD_KEY) as? String
|
||||
|
||||
companion object {
|
||||
const val NAME = "outbox_sync"
|
||||
@@ -278,8 +279,6 @@ class OutboxSyncWorker @AssistedInject constructor(
|
||||
private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L
|
||||
/** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */
|
||||
private const val CASCADE_SCAN_LIMIT = 10_000
|
||||
/** Clé du lien parent→enfant dans le payload `create_resource`. */
|
||||
private const val PARENT_RESOURCE_ID_KEY = "parentResourceId"
|
||||
|
||||
/**
|
||||
* Enregistre (idempotent) le worker avec contrainte réseau + backoff.
|
||||
|
||||
@@ -12,6 +12,8 @@ import com.kazier.mobile.data.repository.FolderRepository
|
||||
import com.kazier.mobile.data.repository.SaveFolderInput
|
||||
import com.kazier.mobile.data.repository.ShareRepository
|
||||
import com.kazier.mobile.features.ocr.OcrAutoWorker
|
||||
import com.kazier.mobile.features.saf.FileDeleter
|
||||
import com.kazier.mobile.features.saf.FolderDeleter
|
||||
import dagger.hilt.android.lifecycle.HiltViewModel
|
||||
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||
import kotlinx.coroutines.CancellationException
|
||||
@@ -49,6 +51,8 @@ class SyncViewModel @Inject constructor(
|
||||
private val folderRepository: FolderRepository,
|
||||
private val pendingOperationDao: PendingOperationDao,
|
||||
private val shareRepository: ShareRepository,
|
||||
private val fileDeleter: FileDeleter,
|
||||
private val folderDeleter: FolderDeleter,
|
||||
@ApplicationContext private val appContext: Context,
|
||||
) : ViewModel() {
|
||||
|
||||
@@ -110,6 +114,16 @@ class SyncViewModel @Inject constructor(
|
||||
OutboxSyncWorker.enqueue(appContext)
|
||||
// OCR auto : uploader les octets des fichiers récemment promus (local-cloud).
|
||||
OcrAutoWorker.enqueue(appContext)
|
||||
// Repasse C4 : les suppressions journalisées dont les
|
||||
// octets ont survécu (crash entre journal et SAF).
|
||||
runCatching {
|
||||
fileDeleter.sweepPendingPhysicalDeletes() +
|
||||
folderDeleter.sweepPendingPhysicalDeletes()
|
||||
}.onSuccess { swept ->
|
||||
if (swept > 0) Timber.d("sweep: %d suppressions physiques rattrapées", swept)
|
||||
}.onFailure { e ->
|
||||
Timber.w(e, "sweep failed, retrying later")
|
||||
}
|
||||
}
|
||||
.onFailure { e -> Timber.w(e, "syncAll failed, retrying later") }
|
||||
// Hydrate les ressources partagées depuis le snapshot serveur.
|
||||
@@ -143,6 +157,14 @@ class SyncViewModel @Inject constructor(
|
||||
)
|
||||
val result = deviceSync.syncRoot(saved.resourceId)
|
||||
Timber.d("syncRoot %s", result)
|
||||
// Même drain qu'après `syncAll` (M7) : le `create_resource` de
|
||||
// la racine ne doit pas dormir jusqu'au prochain tick.
|
||||
OutboxSyncWorker.enqueue(appContext)
|
||||
OcrAutoWorker.enqueue(appContext)
|
||||
runCatching {
|
||||
fileDeleter.sweepPendingPhysicalDeletes() +
|
||||
folderDeleter.sweepPendingPhysicalDeletes()
|
||||
}.onFailure { e -> Timber.w(e, "sweep failed, retrying later") }
|
||||
} catch (e: CancellationException) {
|
||||
throw e
|
||||
} catch (e: Exception) {
|
||||
|
||||
+3
-3
@@ -11,7 +11,7 @@ import com.kazier.mobile.data.local.entity.FolderEntity
|
||||
import com.kazier.mobile.data.repository.FileRepository
|
||||
import com.kazier.mobile.data.repository.FolderRepository
|
||||
import com.kazier.mobile.data.repository.SaveFolderInput
|
||||
import com.kazier.mobile.domain.DeviceIdentity
|
||||
import com.kazier.mobile.domain.ActiveUserStore
|
||||
import com.kazier.mobile.features.saf.FileDeleter
|
||||
import com.kazier.mobile.features.saf.FileMover
|
||||
import com.kazier.mobile.features.saf.SafFolderCreator
|
||||
@@ -54,7 +54,7 @@ class FolderDetailViewModel @Inject constructor(
|
||||
private val safFolderCreator: SafFolderCreator,
|
||||
private val fileMover: FileMover,
|
||||
private val fileDeleter: FileDeleter,
|
||||
private val deviceIdentity: DeviceIdentity,
|
||||
private val activeUserStore: ActiveUserStore,
|
||||
@ApplicationContext private val context: Context,
|
||||
) : ViewModel() {
|
||||
|
||||
@@ -156,7 +156,7 @@ class FolderDetailViewModel @Inject constructor(
|
||||
val folder = _uiState.value.folder
|
||||
val shareable = folder != null &&
|
||||
tokenProvider.current != null &&
|
||||
(folder.ownerId == null || folder.ownerId == deviceIdentity.getOrCreate())
|
||||
(folder.ownerId == null || folder.ownerId == activeUserStore.get())
|
||||
_uiState.update { it.copy(canShare = shareable) }
|
||||
}
|
||||
}
|
||||
|
||||
+7
-6
@@ -15,7 +15,7 @@ import com.kazier.mobile.data.remote.ApiException
|
||||
import com.kazier.mobile.data.repository.FileRepository
|
||||
import com.kazier.mobile.data.repository.FolderRepository
|
||||
import com.kazier.mobile.data.repository.SaveFolderInput
|
||||
import com.kazier.mobile.domain.DeviceIdentity
|
||||
import com.kazier.mobile.domain.ActiveUserStore
|
||||
import com.kazier.mobile.features.saf.FileMover
|
||||
import com.kazier.mobile.features.saf.FileDeleter
|
||||
import com.kazier.mobile.features.saf.FolderDeleter
|
||||
@@ -49,7 +49,7 @@ class FolderListViewModel @Inject constructor(
|
||||
private val fileMover: FileMover,
|
||||
private val fileDeleter: FileDeleter,
|
||||
private val folderDeleter: FolderDeleter,
|
||||
private val deviceIdentity: DeviceIdentity,
|
||||
private val activeUserStore: ActiveUserStore,
|
||||
@ApplicationContext private val context: Context,
|
||||
) : ViewModel() {
|
||||
|
||||
@@ -191,7 +191,8 @@ class FolderListViewModel @Inject constructor(
|
||||
/**
|
||||
* Un dossier est partageable quand l'utilisateur est connecté et que ce
|
||||
* n'est pas une ressource reçue en partage : `ownerId` absent ou égal à
|
||||
* l'identité du device (les lignes hydratées portent l'utilisateur réel).
|
||||
* l'utilisateur connecté (`owner_id` Room = `user_id`, jamais le device —
|
||||
* les lignes hydratées du snapshot portent le vrai propriétaire).
|
||||
*
|
||||
* Pas de gate `syncStatus` : un dossier `local` a son `create_resource`
|
||||
* enqueued avant le `share` dans le même outbox — le serveur applique la
|
||||
@@ -199,8 +200,8 @@ class FolderListViewModel @Inject constructor(
|
||||
*/
|
||||
private suspend fun isShareable(folder: FolderEntity): Boolean {
|
||||
if (tokenProvider.current == null) return false
|
||||
val deviceUserId = deviceIdentity.getOrCreate()
|
||||
return folder.ownerId == null || folder.ownerId == deviceUserId
|
||||
val currentUserId = activeUserStore.get()
|
||||
return folder.ownerId == null || folder.ownerId == currentUserId
|
||||
}
|
||||
|
||||
suspend fun isShareableFolder(folder: FolderEntity): Boolean = isShareable(folder)
|
||||
@@ -288,7 +289,7 @@ class FolderListViewModel @Inject constructor(
|
||||
title = trimmed,
|
||||
body = body,
|
||||
folderResourceId = targetId,
|
||||
ownerId = deviceIdentity.getOrCreate(),
|
||||
ownerId = activeUserStore.get(),
|
||||
)
|
||||
}.onFailure {
|
||||
_uiState.update { it.copy(createError = context.getString(R.string.new_folder_error)) }
|
||||
|
||||
+124
@@ -0,0 +1,124 @@
|
||||
package com.kazier.mobile.data.local.dao
|
||||
|
||||
import android.content.Context
|
||||
import androidx.room.Room
|
||||
import androidx.test.core.app.ApplicationProvider
|
||||
import com.squareup.moshi.Moshi
|
||||
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
|
||||
import com.kazier.mobile.data.local.AppDatabase
|
||||
import com.kazier.mobile.data.local.entity.PendingOpStatus
|
||||
import com.kazier.mobile.data.local.entity.PendingOperationEntity
|
||||
import com.kazier.mobile.data.local.entity.PendingOperationType
|
||||
import com.kazier.mobile.data.repository.OutboxRepository
|
||||
import com.kazier.mobile.domain.DeviceIdentity
|
||||
import com.kazier.mobile.domain.GenerateId
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
/**
|
||||
* P8 : le lien parent→enfant de la cascade est dénormalisé en colonne
|
||||
* `parent_resource_id` (robuste au format Moshi), avec repli `LIKE` sur le
|
||||
* payload pour les lignes pré-v14.
|
||||
*/
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [34])
|
||||
class ParentLinkCascadeTest {
|
||||
|
||||
private lateinit var db: AppDatabase
|
||||
private lateinit var opsDao: PendingOperationDao
|
||||
private lateinit var outboxRepository: OutboxRepository
|
||||
|
||||
@Before
|
||||
fun setUp() {
|
||||
val context = ApplicationProvider.getApplicationContext<Context>()
|
||||
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
|
||||
.allowMainThreadQueries()
|
||||
.build()
|
||||
opsDao = db.pendingOperationDao()
|
||||
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
|
||||
val generateId = GenerateId()
|
||||
outboxRepository = OutboxRepository(
|
||||
opsDao,
|
||||
generateId,
|
||||
DeviceIdentity(db.userPreferenceDao(), generateId),
|
||||
moshi,
|
||||
)
|
||||
}
|
||||
|
||||
@After
|
||||
fun tearDown() {
|
||||
db.close()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun enqueue_remplit_la_colonne_parent() = runTest {
|
||||
outboxRepository.enqueueCreateResource(
|
||||
resourceId = CHILD,
|
||||
resourceType = "folder",
|
||||
name = "Enfant",
|
||||
parentResourceId = PARENT,
|
||||
)
|
||||
|
||||
val rows = opsDao.selectPending(10).filter { it.resourceId == CHILD }
|
||||
assertEquals(1, rows.size)
|
||||
assertEquals("la colonne dénormalisée porte le parent", PARENT, rows[0].parentResourceId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun cascade_via_colonne_sans_lien_json() = runTest {
|
||||
// Payload volontairement vide : seul `parent_resource_id` lie l'enfant.
|
||||
opsDao.insert(
|
||||
op(resourceId = CHILD, parentResourceId = PARENT, payload = "{}"),
|
||||
)
|
||||
|
||||
opsDao.failDescendants(PARENT, NOW)
|
||||
|
||||
// La ligne est passée `failed` : elle n'est plus `pending`.
|
||||
assertEquals(0, opsDao.countByStatus(PendingOpStatus.PENDING))
|
||||
assertEquals(
|
||||
"l'enfant est invalidé par la colonne, sans parsing JSON",
|
||||
1,
|
||||
opsDao.countByStatus(PendingOpStatus.FAILED),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun repli_like_pour_lignes_pre_v14_sans_colonne() = runTest {
|
||||
opsDao.insert(
|
||||
op(
|
||||
resourceId = CHILD,
|
||||
parentResourceId = null,
|
||||
payload = """{"name":"Enfant","parentResourceId":"$PARENT"}""",
|
||||
),
|
||||
)
|
||||
|
||||
opsDao.failDescendants(PARENT, NOW)
|
||||
|
||||
assertEquals(1, opsDao.countByStatus(PendingOpStatus.FAILED))
|
||||
}
|
||||
|
||||
private fun op(resourceId: String, parentResourceId: String?, payload: String) =
|
||||
PendingOperationEntity(
|
||||
operationId = resourceId,
|
||||
resourceId = resourceId,
|
||||
resourceType = "folder",
|
||||
operation = PendingOperationType.CREATE_RESOURCE,
|
||||
payload = payload,
|
||||
parentResourceId = parentResourceId,
|
||||
status = PendingOpStatus.PENDING,
|
||||
createdAt = NOW,
|
||||
updatedAt = NOW,
|
||||
)
|
||||
|
||||
private companion object {
|
||||
const val NOW = 1_700_000_000_000L
|
||||
const val PARENT = "11111111111111111111111111111111"
|
||||
const val CHILD = "22222222222222222222222222222222"
|
||||
}
|
||||
}
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
package com.kazier.mobile.data.local.migration
|
||||
|
||||
import android.content.Context
|
||||
import androidx.sqlite.db.SupportSQLiteDatabase
|
||||
import androidx.sqlite.db.SupportSQLiteOpenHelper
|
||||
import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
|
||||
import androidx.test.core.app.ApplicationProvider
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.robolectric.RobolectricTestRunner
|
||||
import org.robolectric.annotation.Config
|
||||
|
||||
/**
|
||||
* P8 : la migration 13→14 ajoute `parent_resource_id` + son index sans
|
||||
* toucher aux lignes existantes (NULL → repli LIKE). Une coquille SQL ici
|
||||
* briquerait l'app au démarrage après update : on rejoue la migration sur
|
||||
* une table v13 minimale et on vérifie schéma + données.
|
||||
*/
|
||||
@RunWith(RobolectricTestRunner::class)
|
||||
@Config(sdk = [34])
|
||||
class Migration13To14Test {
|
||||
|
||||
@Test
|
||||
fun migration_ajoute_la_colonne_et_l_index_en_preservant_les_lignes() {
|
||||
val context = ApplicationProvider.getApplicationContext<Context>()
|
||||
val helper = FrameworkSQLiteOpenHelperFactory().create(
|
||||
SupportSQLiteOpenHelper.Configuration.builder(context)
|
||||
.name(null)
|
||||
.callback(V13Callback())
|
||||
.build(),
|
||||
)
|
||||
val db = helper.writableDatabase
|
||||
db.execSQL(
|
||||
"INSERT INTO `pending_operations` " +
|
||||
"(`device_id`, `operation_id`, `resource_id`, `operation`, `payload`, `status`, `created_at`, `updated_at`) " +
|
||||
"VALUES ('d1', 'op1', 'r1', 'create_resource', '{\"a\":1}', 'pending', 1, 1)",
|
||||
)
|
||||
|
||||
val migration = Migrations.ALL.first { it.startVersion == 13 && it.endVersion == 14 }
|
||||
migration.migrate(db)
|
||||
|
||||
// Colonne présente et NULL sur les lignes préexistantes.
|
||||
val columns = mutableListOf<String>()
|
||||
db.query("PRAGMA table_info(`pending_operations`)").use { cursor ->
|
||||
val nameIdx = cursor.getColumnIndexOrThrow("name")
|
||||
while (cursor.moveToNext()) columns += cursor.getString(nameIdx)
|
||||
}
|
||||
assertTrue(columns.contains("parent_resource_id"))
|
||||
db.query("SELECT `parent_resource_id` FROM `pending_operations`").use { cursor ->
|
||||
assertTrue(cursor.moveToFirst())
|
||||
assertTrue(cursor.isNull(0))
|
||||
}
|
||||
// Index présent.
|
||||
var indexFound = false
|
||||
db.query("PRAGMA index_list(`pending_operations`)").use { cursor ->
|
||||
val nameIdx = cursor.getColumnIndexOrThrow("name")
|
||||
while (cursor.moveToNext()) {
|
||||
if (cursor.getString(nameIdx) == "index_pending_operations_parent_resource_id") {
|
||||
indexFound = true
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue("index parent_resource_id manquant", indexFound)
|
||||
// Données intactes.
|
||||
db.query("SELECT `operation_id`, `status` FROM `pending_operations`").use { cursor ->
|
||||
assertTrue(cursor.moveToFirst())
|
||||
assertEquals("op1", cursor.getString(0))
|
||||
assertEquals("pending", cursor.getString(1))
|
||||
}
|
||||
helper.close()
|
||||
}
|
||||
|
||||
/** Schéma v13 minimal de `pending_operations` (sans `parent_resource_id`). */
|
||||
private class V13Callback : SupportSQLiteOpenHelper.Callback(13) {
|
||||
override fun onCreate(db: SupportSQLiteDatabase) {
|
||||
db.execSQL(
|
||||
"CREATE TABLE `pending_operations` (" +
|
||||
"`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
|
||||
"`device_id` TEXT, " +
|
||||
"`operation_id` TEXT NOT NULL, " +
|
||||
"`ref_type` TEXT, " +
|
||||
"`ref_id` INTEGER, " +
|
||||
"`resource_id` TEXT, " +
|
||||
"`resource_type` TEXT, " +
|
||||
"`operation` TEXT NOT NULL, " +
|
||||
"`payload` TEXT NOT NULL, " +
|
||||
"`status` TEXT NOT NULL, " +
|
||||
"`attempts` INTEGER NOT NULL DEFAULT 0, " +
|
||||
"`created_at` INTEGER NOT NULL, " +
|
||||
"`updated_at` INTEGER NOT NULL)",
|
||||
)
|
||||
}
|
||||
|
||||
override fun onUpgrade(
|
||||
db: SupportSQLiteDatabase,
|
||||
oldVersion: Int,
|
||||
newVersion: Int,
|
||||
) = Unit
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,8 @@ import com.kazier.mobile.auth.SessionManager
|
||||
import com.kazier.mobile.auth.TokenProvider
|
||||
import com.kazier.mobile.auth.TokenStore
|
||||
import com.kazier.mobile.data.local.AppDatabase
|
||||
import com.kazier.mobile.data.local.entity.PendingOpStatus
|
||||
import com.kazier.mobile.data.local.entity.PendingOperationType
|
||||
import com.kazier.mobile.data.remote.dto.ApiEnvelope
|
||||
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
|
||||
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
|
||||
@@ -78,6 +80,7 @@ class Auth401Test {
|
||||
ActiveUserStore(db.userPreferenceDao()),
|
||||
tokenProvider,
|
||||
LocalModeStore(db.userPreferenceDao()),
|
||||
db.pendingOperationDao(),
|
||||
apiClient,
|
||||
)
|
||||
}
|
||||
@@ -129,8 +132,7 @@ class Auth401Test {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `401_login_ne_purge_pas`() = runBlocking {
|
||||
seed()
|
||||
fun `401_login_ne_purge_pas`() = runBlocking { seed()
|
||||
val error = runCatching { apiClient.login("alice", "mauvais-mdp", "device-1") }.exceptionOrNull()
|
||||
assertNotNull(error)
|
||||
assertEquals("UNAUTHORIZED", (error as ApiException).code)
|
||||
@@ -139,6 +141,69 @@ class Auth401Test {
|
||||
assertEquals("tok-abc", tokenStore.getToken())
|
||||
}
|
||||
|
||||
// --- C5 : pas de replay cross-account ------------------------------------
|
||||
|
||||
@Test
|
||||
fun `signOut_purge_pending_et_failed_conserve_synced`() = runBlocking {
|
||||
seed()
|
||||
val ops = db.pendingOperationDao()
|
||||
ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING))
|
||||
ops.insert(op("b", PendingOperationType.MOVE_RESOURCE, PendingOpStatus.FAILED))
|
||||
ops.insert(op("c", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.SYNCED))
|
||||
|
||||
sessionManager.clear()
|
||||
|
||||
assertNull(tokenProvider.current)
|
||||
assertEquals("pending purgé", 0, ops.countByStatus(PendingOpStatus.PENDING))
|
||||
assertEquals("failed purgé", 0, ops.countByStatus(PendingOpStatus.FAILED))
|
||||
assertEquals("les tombstones synced survivent", 1, ops.countByStatus(PendingOpStatus.SYNCED))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login_autre_compte_purge_la_file`() = runBlocking {
|
||||
sessionManager.save("tok-a", UserDto(id = "user-a", username = "alice"), null)
|
||||
val ops = db.pendingOperationDao()
|
||||
ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING))
|
||||
|
||||
sessionManager.save("tok-b", UserDto(id = "user-b", username = "bob"), null)
|
||||
|
||||
assertEquals("la file de A ne part pas sous le token de B", 0, ops.countPending())
|
||||
assertEquals("user-b", ActiveUserStore(db.userPreferenceDao()).get())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `relogin_meme_compte_conserve_la_file`() = runBlocking {
|
||||
sessionManager.save("tok-a1", UserDto(id = "user-a", username = "alice"), null)
|
||||
val ops = db.pendingOperationDao()
|
||||
ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING))
|
||||
|
||||
sessionManager.save("tok-a2", UserDto(id = "user-a", username = "alice"), null)
|
||||
|
||||
assertEquals("un simple renouvellement de token ne perd rien", 1, ops.countPending())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `premier_login_conserve_le_travail_local`() = runBlocking {
|
||||
val ops = db.pendingOperationDao()
|
||||
ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING))
|
||||
|
||||
sessionManager.save("tok-a", UserDto(id = "user-a", username = "alice"), null)
|
||||
|
||||
assertEquals("le travail du mode local est poussé après login", 1, ops.countPending())
|
||||
}
|
||||
|
||||
private fun op(resourceId: String, operation: String, status: String) =
|
||||
com.kazier.mobile.data.local.entity.PendingOperationEntity(
|
||||
operationId = resourceId,
|
||||
resourceId = "r".repeat(32),
|
||||
resourceType = "file",
|
||||
operation = operation,
|
||||
payload = "{}",
|
||||
status = status,
|
||||
createdAt = 1L,
|
||||
updatedAt = 1L,
|
||||
)
|
||||
|
||||
private class FakeTokenStore : TokenStore {
|
||||
private var token: String? = null
|
||||
private var user: UserDto? = null
|
||||
|
||||
Reference in New Issue
Block a user