rust client view test

Author: joshua-spacetime

modules/sdk-test-cs/Lib.cs

@@ -2060,10 +2060,24 @@ public static void insert_user(ReducerContext ctx, string name, Identity identit
         ctx.Db.users.Insert(new Users { name = name, identity = identity });
     }
 
-    [SpacetimeDB.View(Name = "my_user", Public = true)]
-    public static Users? MyUser(ViewContext ctx)
+    [SpacetimeDB.Table(Name = "player")]
+    public partial struct Player
     {
-        return ctx.Db.users.identity.Find(ctx.Sender) as Users;
+        [PrimaryKey]
+        public Identity identity;
+        public string name;
+    }
+
+    [SpacetimeDB.Reducer]
+    public static void insert_player(ReducerContext ctx, string name, Identity identity)
+    {
+        ctx.Db.player.Insert(new Player { name = name, identity = identity });
+    }
+
+    [SpacetimeDB.View(Name = "my_player", Public = true)]
+    public static Player? MyPlayer(ViewContext ctx)
+    {
+        return (Player?)ctx.Db.player.identity.Find(ctx.Sender);
     }
 
     [SpacetimeDB.Table(Name = "indexed_simple_enum", Public = true)]

modules/sdk-test/src/lib.rs

@@ -796,9 +796,22 @@ fn insert_user(ctx: &ReducerContext, name: String, identity: Identity) -> anyhow
     Ok(())
 }
 
-#[spacetimedb::view(name = my_user, public)]
-fn my_user(ctx: &ViewContext) -> Option<Users> {
-    ctx.db.users().identity().find(ctx.sender)
+#[spacetimedb::table(name = player)]
+struct Player {
+    #[primary_key]
+    identity: Identity,
+    name: String,
+}
+
+#[spacetimedb::reducer]
+fn insert_player(ctx: &ReducerContext, name: String, identity: Identity) -> anyhow::Result<()> {
+    ctx.db.player().insert(Player { name, identity });
+    Ok(())
+}
+
+#[spacetimedb::view(name = my_player, public)]
+fn my_player(ctx: &ViewContext) -> Option<Player> {
+    ctx.db.player().identity().find(ctx.sender)
 }
 
 #[spacetimedb::table(name = indexed_simple_enum, public)]

sdks/rust/tests/test-client/src/main.rs

@@ -129,6 +129,7 @@ fn main() {
         "two-different-compression-algos" => exec_two_different_compression_algos(),
         "test-parameterized-subscription" => test_parameterized_subscription(),
         "test-rls-subscription" => test_rls_subscription(),
+        "test-client-specific-view" => test_client_specific_view(),
         "pk-simple-enum" => exec_pk_simple_enum(),
         "indexed-simple-enum" => exec_indexed_simple_enum(),
 
@@ -2471,6 +2472,59 @@ fn test_rls_subscription() {
     ctr_for_test.wait_for_all();
 }
 
+/// The same test as [`test_rls_subscription`], but with views instead of rls
+fn test_client_specific_view() {
+    let ctr_for_test = TestCounter::new();
+    let ctr_for_subs = TestCounter::new();
+    let sub_0 = Some(ctr_for_subs.add_test("sub_0"));
+    let sub_1 = Some(ctr_for_subs.add_test("sub_1"));
+    let ins_0 = Some(ctr_for_test.add_test("insert_0"));
+    let ins_1 = Some(ctr_for_test.add_test("insert_1"));
+
+    fn subscribe_and_update(
+        test_name: &str,
+        user_name: &str,
+        waiters: [Arc<TestCounter>; 2],
+        senders: [Option<ResultRecorder>; 2],
+    ) {
+        let [ctr_for_test, ctr_for_subs] = waiters;
+        let [mut record_sub, mut record_ins] = senders;
+        let user_name = user_name.to_owned();
+        let expected_name = user_name.to_owned();
+        connect_with_then(&ctr_for_test, test_name, |builder| builder, {
+            move |ctx| {
+                let sender = ctx.identity();
+                let expected_identity = sender;
+                subscribe_these_then(ctx, &["SELECT * FROM my_player"], move |ctx| {
+                    put_result(&mut record_sub, Ok(()));
+                    // Wait to insert until both client connections have been made
+                    ctr_for_subs.wait_for_all();
+                    ctx.reducers.insert_player(user_name, sender).unwrap();
+                });
+                ctx.db.my_player().on_insert(move |_, player| {
+                    assert_eq!(player.name, expected_name);
+                    assert_eq!(player.identity, expected_identity);
+                    put_result(&mut record_ins, Ok(()));
+                });
+            }
+        });
+    }
+
+    subscribe_and_update(
+        "client_0",
+        "Alice",
+        [ctr_for_test.clone(), ctr_for_subs.clone()],
+        [sub_0, ins_0],
+    );
+    subscribe_and_update(
+        "client_1",
+        "Bob",
+        [ctr_for_test.clone(), ctr_for_subs.clone()],
+        [sub_1, ins_1],
+    );
+    ctr_for_test.wait_for_all();
+}
+
 fn exec_pk_simple_enum() {
     let test_counter: Arc<TestCounter> = TestCounter::new();
     let mut updated = Some(test_counter.add_test("updated"));