Enhance test coverage in SyncServiceTest by adding new cases for device registration, deactivation, and removal, including error propagation for unauthorized access and database exceptions. Update TEST_COVERAGE_ACTION_PLAN.md to reflect these improvements. Extend MetadataUseCaseTest with advanced search and metadata retrieval tests, and enhance PluginsViewModelTest with success and error handling scenarios. Revise StringsTest to ensure all languages have consistent string values for various UI elements.

Author: efraespada

backend/core/sync/src/test/kotlin/com/vaultstadio/core/domain/service/SyncServiceTest.kt

@@ -15,6 +15,7 @@ import com.vaultstadio.core.domain.model.SyncConflict
 import com.vaultstadio.core.domain.model.SyncDevice
 import com.vaultstadio.core.domain.model.SyncRequest
 import com.vaultstadio.core.domain.repository.SyncRepository
+import com.vaultstadio.domain.common.exception.AuthorizationException
 import com.vaultstadio.domain.common.exception.DatabaseException
 import com.vaultstadio.domain.common.exception.InvalidOperationException
 import com.vaultstadio.domain.common.exception.ItemNotFoundException
@@ -275,6 +276,86 @@ class SyncServiceTest {
         result.onLeft { err -> assertTrue(err is DatabaseException) }
     }
 
+    @Test
+    fun `registerDevice should propagate error when updateDevice returns Left on reactivate`() = runTest {
+        val userId = "user-1"
+        val now = Clock.System.now()
+        val existingDevice = SyncDevice(
+            id = "existing-id",
+            userId = userId,
+            deviceId = "device-123",
+            deviceName = "Old Name",
+            deviceType = DeviceType.DESKTOP_MAC,
+            isActive = false,
+            createdAt = now,
+            updatedAt = now,
+        )
+        val input = RegisterDeviceInput(
+            deviceId = "device-123",
+            deviceName = "New Name",
+            deviceType = DeviceType.DESKTOP_MAC,
+        )
+        coEvery { syncRepository.findDeviceByUserAndId(userId, input.deviceId) } returns existingDevice.right()
+        coEvery { syncRepository.updateDevice(any()) } returns DatabaseException("update failed").left()
+
+        val result = service.registerDevice(input, userId)
+
+        assertTrue(result.isLeft())
+        result.onLeft { err -> assertTrue(err is DatabaseException) }
+    }
+
+    @Test
+    fun `deactivateDevice should return AuthorizationException when device belongs to another user`() = runTest {
+        val userId = "user-1"
+        val otherUserId = "user-2"
+        val now = Clock.System.now()
+        val otherUserDevice = SyncDevice(
+            id = "dev-1",
+            userId = otherUserId,
+            deviceId = "device-1",
+            deviceName = "Other Device",
+            deviceType = DeviceType.DESKTOP_MAC,
+            isActive = true,
+            createdAt = now,
+            updatedAt = now,
+        )
+        coEvery { syncRepository.findDeviceByUserAndId(userId, "device-1") } returns otherUserDevice.right()
+
+        val result = service.deactivateDevice("device-1", userId)
+
+        assertTrue(result.isLeft())
+        result.onLeft { err ->
+            assertTrue(err is AuthorizationException)
+            assertTrue(err.message!!.contains("Not authorized to deactivate"))
+        }
+    }
+
+    @Test
+    fun `removeDevice should return AuthorizationException when device belongs to another user`() = runTest {
+        val userId = "user-1"
+        val otherUserId = "user-2"
+        val now = Clock.System.now()
+        val otherUserDevice = SyncDevice(
+            id = "dev-1",
+            userId = otherUserId,
+            deviceId = "device-1",
+            deviceName = "Other Device",
+            deviceType = DeviceType.DESKTOP_MAC,
+            isActive = true,
+            createdAt = now,
+            updatedAt = now,
+        )
+        coEvery { syncRepository.findDeviceByUserAndId(userId, "device-1") } returns otherUserDevice.right()
+
+        val result = service.removeDevice("device-1", userId)
+
+        assertTrue(result.isLeft())
+        result.onLeft { err ->
+            assertTrue(err is AuthorizationException)
+            assertTrue(err.message!!.contains("Not authorized to remove"))
+        }
+    }
+
     @Test
     fun `listDevices should propagate error when repository returns Left`() = runTest {
         val userId = "user-1"
@@ -335,6 +416,50 @@ class SyncServiceTest {
         }
     }
 
+    @Test
+    fun `deactivateDevice should succeed when device found and repository returns Right`() = runTest {
+        val userId = "user-1"
+        val now = Clock.System.now()
+        val device = SyncDevice(
+            id = "dev-1",
+            userId = userId,
+            deviceId = "device-1",
+            deviceName = "Laptop",
+            deviceType = DeviceType.DESKTOP_MAC,
+            isActive = true,
+            createdAt = now,
+            updatedAt = now,
+        )
+        coEvery { syncRepository.findDeviceByUserAndId(userId, "device-1") } returns device.right()
+        coEvery { syncRepository.deactivateDevice("dev-1") } returns Unit.right()
+
+        val result = service.deactivateDevice("device-1", userId)
+
+        assertTrue(result.isRight())
+    }
+
+    @Test
+    fun `removeDevice should succeed when device found and repository returns Right`() = runTest {
+        val userId = "user-1"
+        val now = Clock.System.now()
+        val device = SyncDevice(
+            id = "dev-1",
+            userId = userId,
+            deviceId = "device-1",
+            deviceName = "Laptop",
+            deviceType = DeviceType.DESKTOP_MAC,
+            isActive = true,
+            createdAt = now,
+            updatedAt = now,
+        )
+        coEvery { syncRepository.findDeviceByUserAndId(userId, "device-1") } returns device.right()
+        coEvery { syncRepository.removeDevice("dev-1") } returns Unit.right()
+
+        val result = service.removeDevice("device-1", userId)
+
+        assertTrue(result.isRight())
+    }
+
     @Test
     fun `sync should return ItemNotFoundException when device not found`() = runTest {
         val userId = "user-1"
@@ -475,6 +600,45 @@ class SyncServiceTest {
         }
     }
 
+    @Test
+    fun `resolveConflict should propagate when repository resolveConflict returns Left`() = runTest {
+        val conflictId = "conflict-1"
+        val userId = "user-1"
+        val now = Clock.System.now()
+        val localChange = SyncChange(
+            id = "local-1",
+            itemId = "item-1",
+            changeType = ChangeType.MODIFY,
+            userId = userId,
+            timestamp = now,
+            cursor = 100,
+        )
+        val remoteChange = SyncChange(
+            id = "remote-1",
+            itemId = "item-1",
+            changeType = ChangeType.MODIFY,
+            userId = userId,
+            timestamp = now,
+            cursor = 101,
+        )
+        val pendingConflict = SyncConflict(
+            id = conflictId,
+            itemId = "item-1",
+            localChange = localChange,
+            remoteChange = remoteChange,
+            conflictType = ConflictType.EDIT_CONFLICT,
+            createdAt = now,
+        )
+        coEvery { syncRepository.findConflict(conflictId) } returns pendingConflict.right()
+        coEvery { syncRepository.resolveConflict(conflictId, ConflictResolution.KEEP_REMOTE, any()) } returns
+            DatabaseException("db error").left()
+
+        val result = service.resolveConflict(conflictId, ConflictResolution.KEEP_REMOTE, userId)
+
+        assertTrue(result.isLeft())
+        result.onLeft { err -> assertTrue(err is DatabaseException) }
+    }
+
     @Test
     fun `pruneOldData should return sum of pruned changes and conflicts`() = runTest {
         coEvery { syncRepository.pruneChanges(any()) } returns 10.right()

docs/development/TEST_COVERAGE_ACTION_PLAN.md

@@ -94,7 +94,12 @@ Frontend coverage is a single report for **composeApp** (desktop JVM tests); it
 
 ---
 
-**Recent coverage improvements:** **Applied (continuation 2026-02-22):** **Backend core (share):** **ShareServiceTest** (GetSharesTests) extended with `should propagate when shareRepository findByCreatedBy returns Left for getSharesByUser`, **getSharesSharedWithUser** – `should get shares shared with user`, `should propagate when shareRepository findSharedWithUser returns Left`. —
+**Recent coverage improvements:** **Applied (continuation 2026-02-22):** **Backend core (sync):** **SyncServiceTest** extended with `deactivateDevice should succeed when device found and repository returns Right`, `removeDevice should succeed when device found and repository returns Right`. **Frontend composeApp:** **PluginsViewModelTest** extended with `loadPlugins_success_setsPlugins`, `loadPlugins_error_setsError`. —
+**Applied (continuation 2026-02-22):** **Backend core (sync):** **SyncServiceTest** extended with `resolveConflict should propagate when repository resolveConflict returns Left`. **Frontend i18n (core/resources):** **StringsTest** extended with **allLanguages_haveCommonBackAndCommonRetry**. —
+**Applied (continuation 2026-02-22):** **Backend core (sync):** **SyncServiceTest** extended with `registerDevice should propagate error when updateDevice returns Left on reactivate`, `deactivateDevice should return AuthorizationException when device belongs to another user`, `removeDevice should return AuthorizationException when device belongs to another user`. **Frontend i18n (core/resources):** **StringsTest** extended with **allLanguages_haveActionRestoreAndActionNew**. —
+**Applied (continuation 2026-02-22):** **Frontend i18n (core/resources):** **StringsTest** extended with **allLanguages_haveShareTitle**, **allLanguages_haveNavRecentAndNavStarred**, **allLanguages_haveVersionTitleAndSyncTitle**, **allLanguages_haveActivityNoActivity** (all 7 languages non-empty for share, nav recent/starred, version/sync titles, activity empty state). —
+**Applied (continuation 2026-02-22):** **Frontend composeApp (domain.usecase.metadata):** **MetadataUseCaseTest** extended with **AdvancedSearchUseCaseTest** (invoke returns repository advancedSearch result, invoke propagates error), **GetImageMetadataUseCaseTest** (invoke returns repository getImageMetadata result, invoke propagates error), **GetVideoMetadataUseCaseTest** (invoke returns repository getVideoMetadata result, invoke propagates error), **GetDocumentMetadataUseCaseTest** (invoke returns repository getDocumentMetadata result, invoke propagates error). FakeMetadataRepository now has configurable advancedSearchResult, getImageMetadataResult, getVideoMetadataResult, getDocumentMetadataResult. Covers all metadata use cases (GetSearchSuggestions, SearchByMetadata, GetFileMetadata, AdvancedSearch, GetImageMetadata, GetVideoMetadata, GetDocumentMetadata). —
+**Applied (continuation 2026-02-22):** **Backend core (share):** **ShareServiceTest** (GetSharesTests) extended with `should propagate when shareRepository findByCreatedBy returns Left for getSharesByUser`, **getSharesSharedWithUser** – `should get shares shared with user`, `should propagate when shareRepository findSharedWithUser returns Left`. —
 **Applied (continuation 2026-02-22):** **Backend core (share):** **ShareServiceTest** (AccessShareTests) extended with `should propagate when shareRepository findByToken returns Left`, `should propagate when storageItemRepository findById returns Left for accessShare`. —
 **Applied (continuation 2026-02-22):** **Backend core (share):** **ShareServiceTest** (CreateShareTests) extended with `should propagate when shareRepository create returns Left`. **Frontend i18n (core/resources):** **StringsTest** extended with **allLanguages_haveActionShare**. —
 **Applied (continuation 2026-02-22):** **Backend core (share):** **ShareServiceTest** (GetShareTests) extended with `should propagate when shareRepository findById returns Left`. **Frontend i18n (core/resources):** **StringsTest** extended with **allLanguages_haveActionDownload**. —

frontend/composeApp/src/test/kotlin/com/vaultstadio/app/domain/usecase/metadata/MetadataUseCaseTest.kt

@@ -1,12 +1,17 @@
 /**
- * Unit tests for metadata use cases (GetSearchSuggestions, SearchByMetadata).
+ * Unit tests for metadata use cases (GetSearchSuggestions, SearchByMetadata, GetFileMetadata,
+ * AdvancedSearch, GetImageMetadata, GetVideoMetadata, GetDocumentMetadata).
  * Uses a fake MetadataRepository to avoid platform/DI.
  */
 
 package com.vaultstadio.app.domain.usecase.metadata
 
+import com.vaultstadio.app.data.metadata.usecase.AdvancedSearchUseCaseImpl
+import com.vaultstadio.app.data.metadata.usecase.GetDocumentMetadataUseCaseImpl
 import com.vaultstadio.app.data.metadata.usecase.GetFileMetadataUseCaseImpl
+import com.vaultstadio.app.data.metadata.usecase.GetImageMetadataUseCaseImpl
 import com.vaultstadio.app.data.metadata.usecase.GetSearchSuggestionsUseCaseImpl
+import com.vaultstadio.app.data.metadata.usecase.GetVideoMetadataUseCaseImpl
 import com.vaultstadio.app.data.metadata.usecase.SearchByMetadataUseCaseImpl
 import com.vaultstadio.app.domain.metadata.MetadataRepository
 import com.vaultstadio.app.domain.metadata.model.DocumentMetadata
@@ -15,8 +20,10 @@ import com.vaultstadio.app.domain.metadata.model.ImageMetadata
 import com.vaultstadio.app.domain.metadata.model.MetadataSearchResult
 import com.vaultstadio.app.domain.metadata.model.VideoMetadata
 import com.vaultstadio.app.domain.result.Result
+import com.vaultstadio.app.domain.storage.model.ItemType
 import com.vaultstadio.app.domain.storage.model.PaginatedResponse
 import com.vaultstadio.app.domain.storage.model.StorageItem
+import com.vaultstadio.app.domain.storage.model.Visibility
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.Instant
 import kotlin.test.Test
@@ -50,21 +57,50 @@ private fun testFileMetadata(
     extractedBy = emptyList(),
 )
 
+private fun testStorageItem(
+    id: String = "item-1",
+    name: String = "doc.pdf",
+) = StorageItem(
+    id = id,
+    name = name,
+    path = "/docs/$name",
+    type = ItemType.FILE,
+    parentId = "parent-1",
+    size = 1024L,
+    mimeType = "application/pdf",
+    visibility = Visibility.PRIVATE,
+    isStarred = false,
+    isTrashed = false,
+    createdAt = testInstant,
+    updatedAt = testInstant,
+    metadata = null,
+)
+
 private class FakeMetadataRepository(
     var getSearchSuggestionsResult: Result<List<String>> = Result.success(emptyList()),
     var searchByMetadataResult: Result<PaginatedResponse<MetadataSearchResult>> = Result.success(
         PaginatedResponse(emptyList(), 0L, 0, 50, 0, false),
     ),
     var getFileMetadataResult: Result<FileMetadata> = Result.success(testFileMetadata()),
+    var advancedSearchResult: Result<PaginatedResponse<StorageItem>> = Result.success(
+        PaginatedResponse(emptyList(), 0L, 0, 50, 0, false),
+    ),
+    var getImageMetadataResult: Result<ImageMetadata> = Result.success(ImageMetadata(width = 1920, height = 1080)),
+    var getVideoMetadataResult: Result<VideoMetadata> = Result.success(
+        VideoMetadata(width = 1280, height = 720, duration = 120.0),
+    ),
+    var getDocumentMetadataResult: Result<DocumentMetadata> = Result.success(
+        DocumentMetadata(title = "Test", author = "Author", pageCount = 10),
+    ),
 ) : MetadataRepository {
 
     override suspend fun getFileMetadata(itemId: String): Result<FileMetadata> = getFileMetadataResult
 
-    override suspend fun getImageMetadata(itemId: String): Result<ImageMetadata> = stubResult()
+    override suspend fun getImageMetadata(itemId: String): Result<ImageMetadata> = getImageMetadataResult
 
-    override suspend fun getVideoMetadata(itemId: String): Result<VideoMetadata> = stubResult()
+    override suspend fun getVideoMetadata(itemId: String): Result<VideoMetadata> = getVideoMetadataResult
 
-    override suspend fun getDocumentMetadata(itemId: String): Result<DocumentMetadata> = stubResult()
+    override suspend fun getDocumentMetadata(itemId: String): Result<DocumentMetadata> = getDocumentMetadataResult
 
     override suspend fun advancedSearch(
         query: String,
@@ -76,7 +112,7 @@ private class FakeMetadataRepository(
         toDate: Instant?,
         limit: Int,
         offset: Int,
-    ): Result<PaginatedResponse<StorageItem>> = stubResult()
+    ): Result<PaginatedResponse<StorageItem>> = advancedSearchResult
 
     override suspend fun searchByMetadata(
         key: String,
@@ -157,3 +193,96 @@ class GetFileMetadataUseCaseTest {
         assertNull(result.getOrNull())
     }
 }
+
+class AdvancedSearchUseCaseTest {
+
+    @Test
+    fun invoke_returnsRepositoryAdvancedSearchResult() = runTest {
+        val items = listOf(testStorageItem("i1", "photo.jpg"), testStorageItem("i2", "doc.pdf"))
+        val paged = PaginatedResponse(items, 2L, 0, 50, 2, false)
+        val repo = FakeMetadataRepository(advancedSearchResult = Result.success(paged))
+        val useCase = AdvancedSearchUseCaseImpl(repo)
+        val result = useCase("query", searchContent = true, fileTypes = listOf("image"), limit = 50, offset = 0)
+        assertTrue(result.isSuccess())
+        assertEquals(2, result.getOrNull()?.items?.size)
+        assertEquals("photo.jpg", result.getOrNull()?.items?.get(0)?.name)
+    }
+
+    @Test
+    fun invoke_propagatesError() = runTest {
+        val repo = FakeMetadataRepository(advancedSearchResult = Result.error("UNAUTHORIZED", "Not logged in"))
+        val useCase = AdvancedSearchUseCaseImpl(repo)
+        val result = useCase("q")
+        assertTrue(result.isError())
+        assertNull(result.getOrNull())
+    }
+}
+
+class GetImageMetadataUseCaseTest {
+
+    @Test
+    fun invoke_returnsRepositoryGetImageMetadataResult() = runTest {
+        val meta = ImageMetadata(width = 1920, height = 1080, cameraMake = "Canon", cameraModel = "EOS R5")
+        val repo = FakeMetadataRepository(getImageMetadataResult = Result.success(meta))
+        val useCase = GetImageMetadataUseCaseImpl(repo)
+        val result = useCase("item-1")
+        assertTrue(result.isSuccess())
+        assertEquals(1920, result.getOrNull()?.width)
+        assertEquals("Canon", result.getOrNull()?.cameraMake)
+    }
+
+    @Test
+    fun invoke_propagatesError() = runTest {
+        val repo = FakeMetadataRepository(getImageMetadataResult = Result.error("NOT_FOUND", "Item not found"))
+        val useCase = GetImageMetadataUseCaseImpl(repo)
+        val result = useCase("missing")
+        assertTrue(result.isError())
+        assertNull(result.getOrNull())
+    }
+}
+
+class GetVideoMetadataUseCaseTest {
+
+    @Test
+    fun invoke_returnsRepositoryGetVideoMetadataResult() = runTest {
+        val meta = VideoMetadata(width = 1920, height = 1080, duration = 90.5, title = "Clip")
+        val repo = FakeMetadataRepository(getVideoMetadataResult = Result.success(meta))
+        val useCase = GetVideoMetadataUseCaseImpl(repo)
+        val result = useCase("video-1")
+        assertTrue(result.isSuccess())
+        assertEquals(1920, result.getOrNull()?.width)
+        assertEquals(90.5, result.getOrNull()?.duration)
+    }
+
+    @Test
+    fun invoke_propagatesError() = runTest {
+        val repo = FakeMetadataRepository(getVideoMetadataResult = Result.error("NOT_FOUND", "Item not found"))
+        val useCase = GetVideoMetadataUseCaseImpl(repo)
+        val result = useCase("missing")
+        assertTrue(result.isError())
+        assertNull(result.getOrNull())
+    }
+}
+
+class GetDocumentMetadataUseCaseTest {
+
+    @Test
+    fun invoke_returnsRepositoryGetDocumentMetadataResult() = runTest {
+        val meta = DocumentMetadata(title = "Report", author = "Jane", pageCount = 42, wordCount = 5000)
+        val repo = FakeMetadataRepository(getDocumentMetadataResult = Result.success(meta))
+        val useCase = GetDocumentMetadataUseCaseImpl(repo)
+        val result = useCase("doc-1")
+        assertTrue(result.isSuccess())
+        assertEquals("Report", result.getOrNull()?.title)
+        assertEquals(42, result.getOrNull()?.pageCount)
+    }
+
+    @Test
+    fun invoke_propagatesError() = runTest {
+        val repo = FakeMetadataRepository(getDocumentMetadataResult = Result.error("NOT_FOUND", "Item not found"))
+        val useCase = GetDocumentMetadataUseCaseImpl(repo)
+        val result = useCase("missing")
+        assertTrue(result.isError())
+        assertNull(result.getOrNull())
+    }
+}