Add wp_mobile service layer with observable entity pattern

Cargo.toml

@@ -48,6 +48,7 @@ linkify = "0.10.0"
 parse_link_header = "0.4"
 paste = "1.0"
 proc-macro-crate = "3.4.0"
+rand = "0.8"
 proc-macro2 = "1.0"
 quote = "1.0"
 regex = "1.12"
@@ -57,6 +58,7 @@ rocket_dyn_templates = "0.2.0"
 roxmltree = "0.21"
 rstest = "0.26"
 rstest_reuse = "0.7.0"
+rusqlite = "0.37.0"
 rustls = "0.23.35"
 scraper = "0.24"
 semver = "1.0"

Makefile

@@ -208,6 +208,10 @@ test-kotlin-integration:
 	@# Help: Run Kotlin integration tests in test server.
 	docker exec -i wordpress /bin/bash < ./scripts/run-kotlin-integration-tests.sh
 
+runComposeDesktopApp:
+	@# Help: Run the Compose Multiplatform desktop application.
+	cd native/kotlin && ./gradlew :example:composeApp:run
+
 restore-test-server:
 	@# Help: Restore the test server from backup.
 	curl "http://localhost:4000/restore?db=true&plugins=true"

native/kotlin/api/kotlin/src/integrationTest/kotlin/IntegrationTestHelpers.kt

@@ -2,9 +2,16 @@ package rs.wordpress.api.kotlin
 
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import uniffi.wp_api.ParsedUrl
 import uniffi.wp_api.UserId
+import uniffi.wp_api.WpApiClientDelegate
+import uniffi.wp_api.WpApiMiddlewarePipeline
 import uniffi.wp_api.WpAuthenticationProvider
 import uniffi.wp_api.WpErrorCode
+import uniffi.wp_api.WpOrgSiteApiUrlResolver
+import uniffi.wp_mobile.MockPostService
+import uniffi.wp_mobile.WpSelfHostedService
+import rs.wordpress.cache.kotlin.WordPressApiCache
 
 const val FIRST_USER_ID: UserId = 1
 const val SECOND_USER_ID: UserId = 2
@@ -24,6 +31,52 @@ fun defaultApiClient(): WpApiClient {
     return WpApiClient(testCredentials.apiRootUrl, authProvider)
 }
 
+data class TestServiceContext(
+    val service: WpSelfHostedService,
+    val mockPostService: MockPostService
+)
+
+fun createTestServiceContext(): TestServiceContext {
+    // Create and migrate cache
+    val wordPressApiCache = WordPressApiCache()
+    wordPressApiCache.performMigrations()
+
+    val testCredentials = TestCredentials.INSTANCE
+
+    // Create auth provider
+    val authProvider = WpAuthenticationProvider.staticWithUsernameAndPassword(
+        username = testCredentials.adminUsername,
+        password = testCredentials.adminPassword
+    )
+
+    val apiRootUrl = testCredentials.apiRootUrl.toString()
+    // Extract site URL by removing /wp-json suffix
+    val siteUrl = apiRootUrl.removeSuffix("/wp-json")
+
+    // Create self-hosted service
+    val service = WpSelfHostedService(
+        siteUrl = siteUrl,
+        apiRoot = apiRootUrl,
+        apiUrlResolver = WpOrgSiteApiUrlResolver(apiRootUrl = ParsedUrl.parse(apiRootUrl)),
+        delegate = WpApiClientDelegate(
+            authProvider,
+            requestExecutor = WpRequestExecutor(),
+            middlewarePipeline = WpApiMiddlewarePipeline(emptyList()),
+            appNotifier = EmptyAppNotifier()
+        ),
+        cache = wordPressApiCache.cache
+    )
+
+    // Create mock post service with shared cache
+    val mockPostService = MockPostService(
+        wordPressApiCache.cache,
+        siteUrl,
+        apiRootUrl
+    )
+
+    return TestServiceContext(service, mockPostService)
+}
+
 fun <T> WpRequestResult<T>.assertSuccess() {
     assert(this is WpRequestResult.Success)
 }
@@ -44,4 +97,4 @@ fun restoreTestServer() {
     OkHttpClient().newCall(
         Request.Builder().url("http://localhost:4000/restore?db=true&plugins=true").build()
     ).execute()
-}
+}

native/kotlin/api/kotlin/src/integrationTest/kotlin/ObservableEntityTest.kt

@@ -0,0 +1,198 @@
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.parallel.Execution
+import org.junit.jupiter.api.parallel.ExecutionMode
+import rs.wordpress.api.kotlin.createTestServiceContext
+import rs.wordpress.cache.kotlin.getObservableEntityWithEditContext
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.assertEquals
+
+/**
+ * Tests for the Kotlin-specific ObservableEntity pattern.
+ *
+ * ObservableEntity is a platform-native wrapper that:
+ * - Wraps Entity<T> from Rust
+ * - Manages observers in Kotlin memory
+ * - Automatically receives database change notifications
+ * - Filters updates using Entity's is_relevant_update() method
+ */
+@Execution(ExecutionMode.CONCURRENT)
+class ObservableEntityTest {
+
+    @Test
+    fun `observable entity notifies observers when database updates`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        // Setup: Insert a test post
+        val postId = 42L
+        val entityId = mockPostService.insertMockPost(postId, "Original Title")
+
+        // Create observable entity and add observer
+        val observableEntity = postService.getObservableEntityWithEditContext(entityId)
+        val callCount = AtomicInteger(0)
+
+        observableEntity.addObserver {
+            callCount.incrementAndGet()
+        }
+
+        // Observer should not have been called yet
+        assertEquals(0, callCount.get())
+
+        // Update the post - should trigger observer
+        mockPostService.updateMockPost(postId, "Updated Title")
+
+        // Verify observer was called exactly once
+        assertEquals(1, callCount.get())
+
+        // Verify data was actually updated
+        val fullEntity = observableEntity.loadData()!!
+        assertEquals("Updated Title", fullEntity.data.title.rendered)
+    }
+
+    @Test
+    fun `observable entity supports multiple observers`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        val postId = 100L
+        val entityId = mockPostService.insertMockPost(postId, "Multi Observer Test")
+
+        val observableEntity = postService.getObservableEntityWithEditContext(entityId)
+
+        val observer1Calls = AtomicInteger(0)
+        val observer2Calls = AtomicInteger(0)
+
+        observableEntity.addObserver { observer1Calls.incrementAndGet() }
+        observableEntity.addObserver { observer2Calls.incrementAndGet() }
+
+        // Update should trigger both observers
+        mockPostService.updateMockPost(postId, "Updated")
+
+        assertEquals(1, observer1Calls.get())
+        assertEquals(1, observer2Calls.get())
+    }
+
+    @Test
+    fun `observable entity only fires for relevant updates`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        // Create two different posts
+        val post1Id = 200L
+        val post2Id = 201L
+        val entity1Id = mockPostService.insertMockPost(post1Id, "Post 1")
+        mockPostService.insertMockPost(post2Id, "Post 2")
+
+        // Create observable entity for post1
+        val observablePost1 = postService.getObservableEntityWithEditContext(entity1Id)
+        val post1Calls = AtomicInteger(0)
+        observablePost1.addObserver { post1Calls.incrementAndGet() }
+
+        // Update post2 - should NOT trigger post1's observer
+        mockPostService.updateMockPost(post2Id, "Post 2 Updated")
+        assertEquals(0, post1Calls.get(), "Observer should not fire for unrelated post")
+
+        // Update post1 - SHOULD trigger observer
+        mockPostService.updateMockPost(post1Id, "Post 1 Updated")
+        assertEquals(1, post1Calls.get(), "Observer should fire for relevant post")
+    }
+
+    @Test
+    fun `observers can be removed`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        val postId = 300L
+        val entityId = mockPostService.insertMockPost(postId, "Remove Test")
+
+        val observableEntity = postService.getObservableEntityWithEditContext(entityId)
+        val callCount = AtomicInteger(0)
+
+        val observer = { callCount.incrementAndGet(); Unit }
+        observableEntity.addObserver(observer)
+
+        // First update - should fire
+        mockPostService.updateMockPost(postId, "Update 1")
+        assertEquals(1, callCount.get())
+
+        // Remove observer
+        observableEntity.removeObserver(observer)
+
+        // Second update - should NOT fire
+        mockPostService.updateMockPost(postId, "Update 2")
+        assertEquals(1, callCount.get(), "Observer should not fire after removal")
+    }
+
+    @Test
+    fun `bulk insert posts and verify count`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        // Verify initial count is 0
+        val initialCount = postService.countEditContext()
+        assertEquals(0, initialCount)
+
+        // Generate and insert 50 posts
+        val postCount = 50u
+        val entityIds = mockPostService.generateAndInsertPosts(postCount)
+
+        // Verify the correct number of entity IDs were returned
+        assertEquals(postCount.toInt(), entityIds.size)
+
+        // Verify the count matches the number of posts inserted
+        val finalCount = postService.countEditContext()
+        assertEquals(postCount.toLong(), finalCount)
+    }
+
+    @Test
+    fun `stress test with random updates triggers observers`() = runTest {
+        val context = createTestServiceContext()
+        val postService = context.service.posts()
+        val mockPostService = context.mockPostService
+
+        // Generate a small set of posts for stress testing
+        val postCount = 5u
+        val entityIds = mockPostService.generateAndInsertPosts(postCount)
+
+        // Create observables for all posts and count notifications
+        val observedCount = AtomicInteger(0)
+        val observables = entityIds.map { entityId ->
+            postService.getObservableEntityWithEditContext(entityId).apply {
+                addObserver { observedCount.incrementAndGet() }
+            }
+        }
+
+        // Start random updates with 50ms delay
+        val handle = mockPostService.startRandomUpdates(entityIds, 0.05)
+
+        // Let it run for ~500ms (should get roughly 10 updates)
+        Thread.sleep(500)
+
+        // Stop the updates
+        handle.stop()
+
+        // Get the final counts
+        val updateCount = handle.updateCount()
+        val totalObserved = observedCount.get()
+
+        // Verify we got a reasonable number of updates
+        // Update count should be > 0 and roughly around 10 (500ms / 50ms)
+        assert(updateCount > 0u) { "Should have performed some updates" }
+        assert(updateCount >= 8u) { "Should have performed at least 8 updates in 500ms with 50ms delay" }
+
+        // Observed count should be close to update count
+        // It might be slightly less due to timing, but should be reasonably close
+        assert(totalObserved > 0) { "Should have observed some updates" }
+        assert(totalObserved.toULong() >= updateCount - 2u) {
+            "Observed count ($totalObserved) should be close to update count ($updateCount)"
+        }
+
+        println("Stress test completed: $updateCount updates, $totalObserved observed events")
+    }
+}

native/kotlin/api/kotlin/src/integrationTest/kotlin/UsersEndpointTest.kt

@@ -6,18 +6,12 @@ import uniffi.wp_api.SparseUserFieldWithEditContext
 import uniffi.wp_api.UserListParams
 import uniffi.wp_api.WpApiParamUsersHasPublishedPosts
 import uniffi.wp_api.WpErrorCode
-import uniffi.wp_mobile.wpMobileCrateWorks
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
 
 class UsersEndpointTest {
     private val client = defaultApiClient()
 
-    @Test
-    fun testThatWpMobileCrateWorks() = runTest {
-        assertEquals("foo is bar", wpMobileCrateWorks("bar"))
-    }
-
     @Test
     fun testUserListRequest() = runTest {
         val userList = client.request { requestBuilder ->

native/kotlin/api/kotlin/src/integrationTest/kotlin/WordPressApiCacheTest.kt

@@ -3,7 +3,6 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.parallel.Execution
 import org.junit.jupiter.api.parallel.ExecutionMode
 import rs.wordpress.cache.kotlin.WordPressApiCache
-import rs.wordpress.cache.kotlin.WordPressApiCacheDelegate
 import kotlin.test.assertEquals
 
 @Execution(ExecutionMode.CONCURRENT)
@@ -13,20 +12,4 @@ class WordPressApiCacheTest {
     fun testThatMigrationsWork() = runTest {
         assertEquals(6, WordPressApiCache().performMigrations())
     }
-
-    @Test
-    fun testBackgroundUpdateNotificationsWork() = runTest {
-        var updateCount = 0
-        val delegate = WordPressApiCacheDelegate(
-            callback = { updateHook ->
-                updateCount += 1
-            }
-        )
-
-        val cache = WordPressApiCache(delegate = delegate)
-        cache.startListeningForUpdates()
-
-        val migrationCount = cache.performMigrations()
-        assertEquals(updateCount, migrationCount)
-    }
 }