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

This commit is contained in:
venture
2026-09-23 00:25:27 +02:00
parent d89c0d03c9
commit 22286aa2b1
21 changed files with 655 additions and 80 deletions
@@ -1,5 +1,6 @@
package com.kazier.mobile.auth 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.ApiClient
import com.kazier.mobile.data.remote.dto.UserDto import com.kazier.mobile.data.remote.dto.UserDto
import com.kazier.mobile.domain.ActiveUserStore import com.kazier.mobile.domain.ActiveUserStore
@@ -28,6 +29,7 @@ class SessionManager @Inject constructor(
private val activeUserStore: ActiveUserStore, private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider, private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore, private val localModeStore: LocalModeStore,
private val pendingOperationDao: PendingOperationDao,
private val apiClient: ApiClient, private val apiClient: ApiClient,
) { ) {
@@ -50,16 +52,28 @@ class SessionManager @Inject constructor(
suspend fun save(token: String, user: UserDto, expiresAt: Long? = null) = suspend fun save(token: String, user: UserDto, expiresAt: Long? = null) =
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
val previousUserId = activeUserStore.get()
tokenStore.save(token, user, expiresAt) tokenStore.save(token, user, expiresAt)
activeUserStore.set(user.id) activeUserStore.set(user.id)
localModeStore.clear() localModeStore.clear()
tokenProvider.current = token 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) { suspend fun clear() = withContext(Dispatchers.IO) {
tokenStore.clear() tokenStore.clear()
activeUserStore.clear() activeUserStore.clear()
tokenProvider.current = null 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, FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
], ],
version = 13, version = 14,
exportSchema = false, exportSchema = false,
) )
abstract class AppDatabase : RoomDatabase() { abstract class AppDatabase : RoomDatabase() {
@@ -15,6 +15,15 @@ interface FileDao {
@Query("SELECT * FROM files ORDER BY name ASC") @Query("SELECT * FROM files ORDER BY name ASC")
suspend fun getAll(): List<FileEntity> 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") @Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC")
fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>> fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>>
@@ -18,6 +18,14 @@ interface FolderDao {
@Query("SELECT * FROM folders ORDER BY name ASC") @Query("SELECT * FROM folders ORDER BY name ASC")
suspend fun getAll(): List<FolderEntity> 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. */ /** 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") @Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC")
suspend fun getCreatedInApp(): List<FolderEntity> suspend fun getCreatedInApp(): List<FolderEntity>
@@ -38,14 +38,17 @@ interface PendingOperationDao {
/** /**
* Invalidation en cascade : un `create_resource` définitivement échoué rend * Invalidation en cascade : un `create_resource` définitivement échoué rend
* fautives toutes les ops en attente qui ciblent la même ressource, ainsi * fautives toutes les ops en attente qui ciblent la même ressource, ainsi
* que les creates enfants (autre `resource_id`, liés via * que les creates enfants (autre `resource_id`, liés via la colonne
* `payload.parentResourceId` — le walk émet parent avant enfant, cf. C6). * `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(""" @Query("""
UPDATE pending_operations SET status = 'failed', updated_at = :now UPDATE pending_operations SET status = 'failed', updated_at = :now
WHERE status = 'pending' AND ( WHERE status = 'pending' AND (
resource_id = :resourceId 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) suspend fun failDescendants(resourceId: String, now: Long)
@@ -137,11 +140,43 @@ interface PendingOperationDao {
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'") @Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'")
suspend fun countPending(): Int 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 * Abandon de la file non poussée (C5) : supprime les ops `pending` et
* ressource ? L'antichambre outbox est alors la source de vérité du * `failed` — jamais les `synced`. Au changement de compte (sign-out, ou
* placement : ni le refresh serveur ni le walk SAF ne doivent écraser le * login d'un autre user), rejouer la file de A sous le token de B
* `folder_resource_id` local avant que le serveur ait accusé le move. * 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(""" @Query("""
SELECT COUNT(*) FROM pending_operations SELECT COUNT(*) FROM pending_operations
@@ -24,6 +24,7 @@ import androidx.room.PrimaryKey
Index(value = ["status"]), Index(value = ["status"]),
Index(value = ["resource_id"]), Index(value = ["resource_id"]),
Index(value = ["resource_id", "operation", "status"]), Index(value = ["resource_id", "operation", "status"]),
Index(value = ["parent_resource_id"]),
], ],
) )
data class PendingOperationEntity( data class PendingOperationEntity(
@@ -45,6 +46,15 @@ data class PendingOperationEntity(
val operation: String, val operation: String,
@ColumnInfo(name = "payload") @ColumnInfo(name = "payload")
val payload: String, 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") @ColumnInfo(name = "status")
val status: String = PendingOpStatus.PENDING, val status: String = PendingOpStatus.PENDING,
@ColumnInfo(name = "attempts") @ColumnInfo(name = "attempts")
@@ -99,6 +99,14 @@ object Migrations {
db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0") 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 // Backlog = déjà traité : la file de review ne contient que les
// fichiers découverts après l'activation de la fonctionnalité. // 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") 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( 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 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 // 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é // 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. // 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) } val existing = input.resourceId?.let { folderDao.getByResourceId(it) }
?: input.uri?.let { folderDao.getByUri(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 // Garde pending-move (M1) : un snapshot SAF périmé ne revert jamais un
// reparent/merge en cours de push. // reparent/merge en cours de push.
val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId) val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId)
@@ -58,6 +58,9 @@ class OutboxRepository @Inject constructor(
resourceType = resourceType, resourceType = resourceType,
operation = operation, operation = operation,
payload = payloadAdapter.toJson(payload), 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, status = PendingOpStatus.PENDING,
createdAt = now, createdAt = now,
updatedAt = now, updatedAt = now,
@@ -163,6 +166,27 @@ class OutboxRepository @Inject constructor(
suspend fun hasCreateOperationAnyType(resourceId: String): Boolean = suspend fun hasCreateOperationAnyType(resourceId: String): Boolean =
pendingOperationDao.countCreateOperationsAnyType(resourceId) > 0 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 * 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 * 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 = suspend fun hasPendingMoveOperation(resourceId: String): Boolean =
pendingOperationDao.countPendingMoveOperations(resourceId) > 0 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é ? * Un `move_resource` (pending ou synced) a-t-il jamais été journalisé ?
* Utilisé par la réconciliation du walk : une ligne en transition physique * 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 { private suspend fun deleteInCloud(file: FileEntity): Boolean {
var ok = false var ok = false
runCatching { 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") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
ok = true ok = true
@@ -100,34 +104,75 @@ class FileDeleter @Inject constructor(
} }
/** /**
* Suppression complète : physique + cloud. * Suppression complète : journal d'abord, physique ensuite (C4).
* Transaction atomique : SAF delete + markMissing + outbox. *
* 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 { private suspend fun deleteFull(file: FileEntity): Boolean {
val uri = file.uri val uri = file.uri
return if (uri != null) { return if (uri != null) {
runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onSuccess { deleted ->
if (deleted) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
if (outboxRepository.hasCreateOperation(file.resourceId)) { outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") 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) Timber.d("deleted full %s", uri)
thumbnailStore.delete(file.resourceId) thumbnailStore.delete(file.resourceId)
} else { } else {
Timber.w("deleteDocument returned false for %s", uri) Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
} }
}.onFailure { e -> deleted
Timber.w(e, "deleteDocument failed for %s", uri)
}.getOrDefault(false)
} else { } else {
// Cloud-only : outbox uniquement. // Cloud-only : outbox uniquement.
deleteInCloud(file) 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 { private suspend fun deleteInCloud(folder: FolderEntity): Boolean {
var ok = false var ok = false
runCatching { runCatching {
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { outboxRepository.cancelPendingCreates(folder.resourceId)
if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) {
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") outboxRepository.enqueueDeleteResource(folder.resourceId, "folder")
} }
ok = true ok = true
@@ -102,43 +103,88 @@ class FolderDeleter @Inject constructor(
return ok 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 { private suspend fun deleteFull(folder: FolderEntity): Boolean {
val uri = folder.uri val uri = folder.uri
if (uri != null) { if (uri != null) {
val tree = collectDescendants(folder.resourceId) val tree = collectDescendants(folder.resourceId)
if (deleteTreePhysically(folder, tree)) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
treeMarkMissing(folder, tree, now) treeMarkMissing(folder, tree, now)
} }
return if (deleteTreePhysically(folder, tree)) {
tree.files.forEach { thumbnailStore.delete(it.resourceId) } tree.files.forEach { thumbnailStore.delete(it.resourceId) }
Timber.d("deleted folder full %s", uri) 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. // Cloud-only : outbox uniquement.
return deleteInCloud(folder) 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. */ /** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */
private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) { private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) {
for (file in tree.files) { for (file in tree.files) {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
if (outboxRepository.hasCreateOperation(file.resourceId)) { outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
} }
for (desc in tree.folders) { for (desc in tree.folders) {
folderRepository.markMissing(desc.resourceId, now) folderRepository.markMissing(desc.resourceId, now)
if (outboxRepository.hasCreateOperationAnyType(desc.resourceId)) { outboxRepository.cancelPendingCreates(desc.resourceId)
if (outboxRepository.hasSyncedCreateOperationAnyType(desc.resourceId)) {
outboxRepository.enqueueDeleteResource(desc.resourceId, "folder") outboxRepository.enqueueDeleteResource(desc.resourceId, "folder")
} }
} }
folderRepository.markMissing(folder.resourceId, now) folderRepository.markMissing(folder.resourceId, now)
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { outboxRepository.cancelPendingCreates(folder.resourceId)
if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) {
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") outboxRepository.enqueueDeleteResource(folder.resourceId, "folder")
} }
} }
@@ -41,32 +41,39 @@ class SafFileDeleter @Inject constructor(
private val resolver: ContentResolver get() = context.contentResolver 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 { suspend fun delete(file: FileEntity): Boolean {
val uri = file.uri ?: return false val uri = file.uri ?: return false
return withContext(Dispatchers.IO) { return withContext(Dispatchers.IO) {
runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onSuccess { deleted ->
if (deleted) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
// Gate « processed » : si le fichier n'a jamais été poussé // Gate « processed » + annulation (M19) : si le fichier
// (create_resource absent), le serveur n'en sait rien — // n'a jamais été poussé (create encore pending), on
// un delete_resource serait du bruit. On ne le journalise // annule le create au lieu d'un delete bruit ; le
// que pour les ressources déjà synchronisées. // delete n'est journalisé que si le serveur connaît
if (outboxRepository.hasCreateOperation(file.resourceId)) { // déjà la ressource (create synced).
outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") 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) Timber.d("deleted %s", uri)
thumbnailStore.delete(file.resourceId) thumbnailStore.delete(file.resourceId)
} else { } else {
Timber.w("deleteDocument returned false for %s", uri) Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
} }
}.onFailure { e -> deleted
Timber.w(e, "deleteDocument failed for %s", uri)
}.getOrDefault(false)
} }
} }
} }
@@ -130,21 +130,30 @@ class DeviceSync @Inject constructor(
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
for (folder in folderRepository.getAll()) { for (folder in folderRepository.getAll()) {
val folderUri = folder.uri 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) 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++ missing++
} }
} }
for (file in fileRepository.getAll()) { for (file in fileRepository.getAll()) {
val fileUri = file.uri 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 // source de vérité du placement : on ne masque jamais une ligne
// en transition vers une autre arborescence physique (le // en transition vers une autre arborescence physique (le
// snapshot peut être périmé par rapport au move en cours). // 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 && 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) fileRepository.markMissing(file.resourceId, now)
outboxRepository.cancelPendingCreates(file.resourceId)
missing++ 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.ApiClient
import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.features.ocr.OcrAutoWorker import com.kazier.mobile.features.ocr.OcrAutoWorker
import dagger.assisted.Assisted import dagger.assisted.Assisted
import dagger.assisted.AssistedInject 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? = private fun parentResourceIdOf(op: PendingOperationEntity): String? =
runCatching { payloadAdapter.fromJson(op.payload) } op.parentResourceId ?: runCatching { payloadAdapter.fromJson(op.payload) }
.getOrNull()?.get(PARENT_RESOURCE_ID_KEY) as? String .getOrNull()?.get(OutboxRepository.PARENT_PAYLOAD_KEY) as? String
companion object { companion object {
const val NAME = "outbox_sync" const val NAME = "outbox_sync"
@@ -278,8 +279,6 @@ class OutboxSyncWorker @AssistedInject constructor(
private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L
/** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */ /** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */
private const val CASCADE_SCAN_LIMIT = 10_000 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. * 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.SaveFolderInput
import com.kazier.mobile.data.repository.ShareRepository import com.kazier.mobile.data.repository.ShareRepository
import com.kazier.mobile.features.ocr.OcrAutoWorker 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.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CancellationException
@@ -49,6 +51,8 @@ class SyncViewModel @Inject constructor(
private val folderRepository: FolderRepository, private val folderRepository: FolderRepository,
private val pendingOperationDao: PendingOperationDao, private val pendingOperationDao: PendingOperationDao,
private val shareRepository: ShareRepository, private val shareRepository: ShareRepository,
private val fileDeleter: FileDeleter,
private val folderDeleter: FolderDeleter,
@ApplicationContext private val appContext: Context, @ApplicationContext private val appContext: Context,
) : ViewModel() { ) : ViewModel() {
@@ -110,6 +114,16 @@ class SyncViewModel @Inject constructor(
OutboxSyncWorker.enqueue(appContext) OutboxSyncWorker.enqueue(appContext)
// OCR auto : uploader les octets des fichiers récemment promus (local-cloud). // OCR auto : uploader les octets des fichiers récemment promus (local-cloud).
OcrAutoWorker.enqueue(appContext) 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") } .onFailure { e -> Timber.w(e, "syncAll failed, retrying later") }
// Hydrate les ressources partagées depuis le snapshot serveur. // Hydrate les ressources partagées depuis le snapshot serveur.
@@ -143,6 +157,14 @@ class SyncViewModel @Inject constructor(
) )
val result = deviceSync.syncRoot(saved.resourceId) val result = deviceSync.syncRoot(saved.resourceId)
Timber.d("syncRoot %s", result) 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) { } catch (e: CancellationException) {
throw e throw e
} catch (e: Exception) { } catch (e: Exception) {
@@ -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.FileRepository
import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput 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.FileDeleter
import com.kazier.mobile.features.saf.FileMover import com.kazier.mobile.features.saf.FileMover
import com.kazier.mobile.features.saf.SafFolderCreator import com.kazier.mobile.features.saf.SafFolderCreator
@@ -54,7 +54,7 @@ class FolderDetailViewModel @Inject constructor(
private val safFolderCreator: SafFolderCreator, private val safFolderCreator: SafFolderCreator,
private val fileMover: FileMover, private val fileMover: FileMover,
private val fileDeleter: FileDeleter, private val fileDeleter: FileDeleter,
private val deviceIdentity: DeviceIdentity, private val activeUserStore: ActiveUserStore,
@ApplicationContext private val context: Context, @ApplicationContext private val context: Context,
) : ViewModel() { ) : ViewModel() {
@@ -156,7 +156,7 @@ class FolderDetailViewModel @Inject constructor(
val folder = _uiState.value.folder val folder = _uiState.value.folder
val shareable = folder != null && val shareable = folder != null &&
tokenProvider.current != null && tokenProvider.current != null &&
(folder.ownerId == null || folder.ownerId == deviceIdentity.getOrCreate()) (folder.ownerId == null || folder.ownerId == activeUserStore.get())
_uiState.update { it.copy(canShare = shareable) } _uiState.update { it.copy(canShare = shareable) }
} }
} }
@@ -15,7 +15,7 @@ import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.repository.FileRepository import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput 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.FileMover
import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.features.saf.FolderDeleter import com.kazier.mobile.features.saf.FolderDeleter
@@ -49,7 +49,7 @@ class FolderListViewModel @Inject constructor(
private val fileMover: FileMover, private val fileMover: FileMover,
private val fileDeleter: FileDeleter, private val fileDeleter: FileDeleter,
private val folderDeleter: FolderDeleter, private val folderDeleter: FolderDeleter,
private val deviceIdentity: DeviceIdentity, private val activeUserStore: ActiveUserStore,
@ApplicationContext private val context: Context, @ApplicationContext private val context: Context,
) : ViewModel() { ) : ViewModel() {
@@ -191,7 +191,8 @@ class FolderListViewModel @Inject constructor(
/** /**
* Un dossier est partageable quand l'utilisateur est connecté et que ce * 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 à * 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` * Pas de gate `syncStatus` : un dossier `local` a son `create_resource`
* enqueued avant le `share` dans le même outbox — le serveur applique la * 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 { private suspend fun isShareable(folder: FolderEntity): Boolean {
if (tokenProvider.current == null) return false if (tokenProvider.current == null) return false
val deviceUserId = deviceIdentity.getOrCreate() val currentUserId = activeUserStore.get()
return folder.ownerId == null || folder.ownerId == deviceUserId return folder.ownerId == null || folder.ownerId == currentUserId
} }
suspend fun isShareableFolder(folder: FolderEntity): Boolean = isShareable(folder) suspend fun isShareableFolder(folder: FolderEntity): Boolean = isShareable(folder)
@@ -288,7 +289,7 @@ class FolderListViewModel @Inject constructor(
title = trimmed, title = trimmed,
body = body, body = body,
folderResourceId = targetId, folderResourceId = targetId,
ownerId = deviceIdentity.getOrCreate(), ownerId = activeUserStore.get(),
) )
}.onFailure { }.onFailure {
_uiState.update { it.copy(createError = context.getString(R.string.new_folder_error)) } _uiState.update { it.copy(createError = context.getString(R.string.new_folder_error)) }
@@ -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"
}
}
@@ -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.TokenProvider
import com.kazier.mobile.auth.TokenStore import com.kazier.mobile.auth.TokenStore
import com.kazier.mobile.data.local.AppDatabase 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.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
@@ -78,6 +80,7 @@ class Auth401Test {
ActiveUserStore(db.userPreferenceDao()), ActiveUserStore(db.userPreferenceDao()),
tokenProvider, tokenProvider,
LocalModeStore(db.userPreferenceDao()), LocalModeStore(db.userPreferenceDao()),
db.pendingOperationDao(),
apiClient, apiClient,
) )
} }
@@ -129,8 +132,7 @@ class Auth401Test {
} }
@Test @Test
fun `401_login_ne_purge_pas`() = runBlocking { fun `401_login_ne_purge_pas`() = runBlocking { seed()
seed()
val error = runCatching { apiClient.login("alice", "mauvais-mdp", "device-1") }.exceptionOrNull() val error = runCatching { apiClient.login("alice", "mauvais-mdp", "device-1") }.exceptionOrNull()
assertNotNull(error) assertNotNull(error)
assertEquals("UNAUTHORIZED", (error as ApiException).code) assertEquals("UNAUTHORIZED", (error as ApiException).code)
@@ -139,6 +141,69 @@ class Auth401Test {
assertEquals("tok-abc", tokenStore.getToken()) 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 class FakeTokenStore : TokenStore {
private var token: String? = null private var token: String? = null
private var user: UserDto? = null private var user: UserDto? = null