Add post deletion support to service layer with enhanced stress testing (#1033)

* Add `delete_by_entity_id` to PostRepository and optimize `delete_by_post_id`

Improved post deletion in the repository layer with better performance
and support for entity-based deletion.

Changes:
- Add `delete_by_entity_id` method that accepts an `EntityId` parameter
- Optimize `delete_by_post_id` to remove wasteful full post SELECT query
- `delete_by_entity_id` performs lightweight SELECT for just the post ID, then delegates to `delete_by_post_id`
- All deletion logic now centralized in `delete_by_post_id`
- Add unit tests: `test_repository_delete_by_entity_id` and `test_delete_by_entity_id_deletes_terms` in main test module
- Add constraint test: `test_delete_by_entity_id_non_existent_returns_zero` in posts_constraint_tests.rs
- Both methods automatically clean up associated term relationships

* Add delete methods to PostService with unit tests

Expose post deletion functionality in the service layer for both
entity-based and post ID-based deletion.

Changes:
- Add `delete_by_entity_id` method to `PostService`
- Add `delete_by_post_id` method to `PostService`
- Both methods return `u64` for uniffi compatibility (converts from repository `usize`)
- Both methods automatically clean up associated term relationships via repository layer
- Add comprehensive unit tests: `test_delete_by_entity_id`, `test_delete_by_post_id`, `test_delete_by_entity_id_non_existent_returns_zero`, and `test_delete_by_post_id_non_existent_returns_zero`
- Tests follow consistent pattern: setup via repository/helpers, actions via service layer, verification via repository

* Enhance stress test with delete/insert operations and refactor

Enhanced `start_comprehensive_stress_test` to support random updates,
deletes, and inserts with configurable operation weights. Refactored
for better maintainability and eliminated unnecessary mutations.

Changes:
- Add `StressTestConfig` struct to reduce function parameters from 9 to 3
- Add `StressTestOperation` enum for type-safe operation selection (Update, Delete, Insert)
- Add weighted random operation selection based on configurable weights
- Extract helper functions: `stress_test_batch_update`, `stress_test_batch_delete`, `stress_test_batch_insert`
- Refactor `create_test_post` to accept all parameters (title, slug, link, content)
- Remove `create_temp_post` method in favor of standalone `create_test_post`
- Eliminate mutations when creating new posts (all parameters passed during construction)
- Convert imperative for loops to functional style using `.iter().for_each()`
- Optimize counter increments to batch-level instead of per-item

* Add separate counters for inserts and deletes in stress test

Track and display individual operation counts (updates, inserts, deletes)
in the stress test UI for better observability.

Changes:
- Add `insert_counter` and `delete_counter` to `StressTestHandle` in Rust
- Add `insert_count()` and `delete_count()` methods to expose counters
- Update stress test to increment appropriate counter for each operation type
- Add `totalInserts` and `totalDeletes` StateFlows in Kotlin ViewModel
- Add coroutine to poll operation counters every 100ms from handle
- Update UI to display: "Updates: X | Inserts: Y | Deletes: Z"
- Add "Total Operations" line showing sum of all operations

* make fmt-rust

* Randomize post status during stress test updates

Add status randomization to batch updates, cycling through Draft,
Pending, Publish, and Future statuses to better simulate real-world
database changes.

Author: oguzkocer

native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/stresstest/StressTestScreen.kt

@@ -29,6 +29,8 @@ import rs.wordpress.example.shared.ui.components.PostCard
 fun StressTestScreen(viewModel: StressTestViewModel = koinInject()) {
     val posts by viewModel.posts.collectAsState()
     val totalUpdates by viewModel.totalUpdates.collectAsState()
+    val totalInserts by viewModel.totalInserts.collectAsState()
+    val totalDeletes by viewModel.totalDeletes.collectAsState()
     val isRunning by viewModel.isRunning.collectAsState()
     val performanceMetrics by viewModel.performanceMetrics.collectAsState()
     val listState = rememberLazyListState()
@@ -51,7 +53,8 @@ fun StressTestScreen(viewModel: StressTestViewModel = koinInject()) {
                     )
                     Spacer(modifier = Modifier.height(8.dp))
                     Text(text = "Total Posts: ${posts.size}")
-                    Text(text = "Total Updates: $totalUpdates")
+                    Text(text = "Updates: $totalUpdates | Inserts: $totalInserts | Deletes: $totalDeletes")
+                    Text(text = "Total Operations: ${totalUpdates + totalInserts + totalDeletes}")
                     Text(text = "Status: ${if (isRunning) "Running" else "Stopped"}")
 
                     performanceMetrics?.let { metrics ->

native/kotlin/example/composeApp/src/commonMain/kotlin/rs/wordpress/example/shared/ui/stresstest/StressTestViewModel.kt

@@ -39,6 +39,12 @@ class StressTestViewModel(
     private val _totalUpdates = MutableStateFlow(0L)
     val totalUpdates: StateFlow<Long> = _totalUpdates.asStateFlow()
 
+    private val _totalInserts = MutableStateFlow(0L)
+    val totalInserts: StateFlow<Long> = _totalInserts.asStateFlow()
+
+    private val _totalDeletes = MutableStateFlow(0L)
+    val totalDeletes: StateFlow<Long> = _totalDeletes.asStateFlow()
+
     private val _isRunning = MutableStateFlow(false)
     val isRunning: StateFlow<Boolean> = _isRunning.asStateFlow()
 
@@ -132,9 +138,6 @@ class StressTestViewModel(
 
                 // Update performance metrics
                 updatePerformanceMetrics(loadDuration, totalLatency)
-
-                // Increment total updates counter
-                _totalUpdates.value += 1
             }
         }
 
@@ -145,14 +148,32 @@ class StressTestViewModel(
         // Start comprehensive stress test with:
         // - 10-100ms delay between batches (variable timing)
         // - 1-20 posts per batch (variable batch size)
+        // - 50% updates, 25% deletes, 25% inserts (operation weights)
         stressTestHandle = mockPostService.startComprehensiveStressTest(
             entityIds,
-            minDelayMs = 10u,
-            maxDelayMs = 100u,
-            minBatchSize = 1u,
-            maxBatchSize = 20u
+            uniffi.wp_mobile.StressTestConfig(
+                minDelayMs = 10u,
+                maxDelayMs = 100u,
+                minBatchSize = 1u,
+                maxBatchSize = 20u,
+                updateWeight = 50u,
+                deleteWeight = 25u,
+                insertWeight = 25u
+            )
         )
-        println("Comprehensive stress test started with ObservableCollection!")
+        println("Comprehensive stress test started with ObservableCollection (updates/deletes/inserts)!")
+
+        // Poll operation counters from the stress test handle
+        viewModelScope.launch(Dispatchers.Default) {
+            while (_isRunning.value) {
+                stressTestHandle?.let { handle ->
+                    _totalUpdates.value = handle.updateCount().toLong()
+                    _totalInserts.value = handle.insertCount().toLong()
+                    _totalDeletes.value = handle.deleteCount().toLong()
+                }
+                kotlinx.coroutines.delay(100) // Poll every 100ms
+            }
+        }
     }
 
     private fun updatePerformanceMetrics(loadDuration: Long, totalLatency: Long) {
@@ -203,6 +224,9 @@ class StressTestViewModel(
     }
 
     fun onCleared() {
+        // Stop the running flag to stop polling
+        _isRunning.value = false
+
         // Stop background updates
         stressTestHandle?.stop()
 

native/swift/Example/Example/ExampleApp.swift

@@ -42,10 +42,15 @@ struct ExampleApp: App {
 
         self.handle = mockService.startComprehensiveStressTest(
             entityIds: ids,
-            minDelayMs: 100,
-            maxDelayMs: 2000,
-            minBatchSize: 100,
-            maxBatchSize: 1000
+            config: StressTestConfig(
+                minDelayMs: 100,
+                maxDelayMs: 2000,
+                minBatchSize: 100,
+                maxBatchSize: 1000,
+                updateWeight: 50,
+                deleteWeight: 25,
+                insertWeight: 25
+            )
         )
     }
 

native/swift/Tests/wordpress-api-cache/WordPressApiCacheTests.swift

@@ -62,10 +62,15 @@ actor Test {
                 group.addTask {
                     _ = mockService.startComprehensiveStressTest(
                         entityIds: ids,
-                        minDelayMs: 1,
-                        maxDelayMs: 1000,
-                        minBatchSize: 100,
-                        maxBatchSize: 1000
+                        config: StressTestConfig(
+                            minDelayMs: 1,
+                            maxDelayMs: 1000,
+                            minBatchSize: 100,
+                            maxBatchSize: 1000,
+                            updateWeight: 50,
+                            deleteWeight: 25,
+                            insertWeight: 25
+                        )
                     )
                 }
             }