Add subscription smoketests that join on a view's primary key

Author: joshua-spacetime

crates/smoketests/modules/views-query/src/lib.rs

@@ -1,4 +1,4 @@
-use spacetimedb::{Query, ReducerContext, Table, ViewContext};
+use spacetimedb::{AnonymousViewContext, Query, ReducerContext, Table, ViewContext};
 
 #[spacetimedb::table(accessor = user, public)]
 pub struct User {
@@ -88,3 +88,21 @@ fn users_who_are_above_20_and_below_30(ctx: &ViewContext) -> impl Query<Person>
 fn users_who_are_above_eq_20_and_below_eq_30(ctx: &ViewContext) -> impl Query<Person> {
     ctx.from.person().r#where(|p| p.age.gte(20).and(p.age.lte(30)))
 }
+
+#[spacetimedb::view(accessor = anonymous_adult_people, public)]
+fn anonymous_adult_people(ctx: &AnonymousViewContext) -> impl Query<Person> {
+    ctx.from.person().r#where(|p| p.age.gte(20))
+}
+
+#[spacetimedb::view(accessor = online_users_identity_1, public)]
+fn online_users_identity_1(ctx: &ViewContext) -> impl Query<User> {
+    ctx.from.user().r#where(|u| u.online).filter(|u| u.identity.eq(1))
+}
+
+#[spacetimedb::view(accessor = users_whos_age_is_known_identity_1, public)]
+fn users_whos_age_is_known_identity_1(ctx: &ViewContext) -> impl Query<User> {
+    ctx.from
+        .user()
+        .left_semijoin(ctx.from.person(), |p, u| p.identity.eq(u.identity))
+        .filter(|u| u.identity.eq(1))
+}

crates/smoketests/modules/views-subscribe/src/lib.rs

@@ -1,23 +1,35 @@
-use spacetimedb::{Identity, ProcedureContext, ReducerContext, Table, ViewContext};
+use spacetimedb::{Identity, ProcedureContext, Query, ReducerContext, Table, ViewContext};
 
 #[spacetimedb::table(accessor = player_state)]
 pub struct PlayerState {
     #[primary_key]
     identity: Identity,
     #[unique]
     name: String,
+    online: bool,
 }
 
 #[spacetimedb::view(accessor = my_player, public)]
 pub fn my_player(ctx: &ViewContext) -> Option<PlayerState> {
     ctx.db.player_state().identity().find(ctx.sender())
 }
 
+#[spacetimedb::view(accessor = all_players, public)]
+pub fn all_players(ctx: &ViewContext) -> impl Query<PlayerState> {
+    ctx.from.player_state()
+}
+
+#[spacetimedb::view(accessor = online_players, public)]
+pub fn online_players(ctx: &ViewContext) -> impl Query<PlayerState> {
+    ctx.from.player_state().r#where(|row| row.online)
+}
+
 #[spacetimedb::reducer]
 pub fn insert_player(ctx: &ReducerContext, name: String) {
     ctx.db.player_state().insert(PlayerState {
         name,
         identity: ctx.sender(),
+        online: true,
     });
 }
 
@@ -28,6 +40,7 @@ pub fn insert_player_proc(ctx: &mut ProcedureContext, name: String) {
         tx.db.player_state().insert(PlayerState {
             name: name.clone(),
             identity: sender,
+            online: true,
         });
     });
 }

crates/smoketests/tests/smoketests/views.rs

@@ -1,4 +1,4 @@
-use serde_json::json;
+use serde_json::{json, Value};
 use spacetimedb_smoketests::{require_dotnet, require_pnpm, Smoketest};
 
 const TS_VIEWS_SUBSCRIBE_MODULE: &str = r#"import { schema, t, table } from "spacetimedb/server";
@@ -77,6 +77,30 @@ public static partial class Module
 }
 "#;
 
+fn project_inserts_and_deletes_for_view(events: Vec<Value>, view_name: &str) -> Vec<Value> {
+    events
+        .into_iter()
+        .map(|event| {
+            json!({
+                view_name: {
+                    "deletes": event[view_name]["deletes"]
+                        .as_array()
+                        .unwrap()
+                        .iter()
+                        .map(|row| json!({"name": row["name"]}))
+                        .collect::<Vec<_>>(),
+                    "inserts": event[view_name]["inserts"]
+                        .as_array()
+                        .unwrap()
+                        .iter()
+                        .map(|row| json!({"name": row["name"]}))
+                        .collect::<Vec<_>>()
+                }
+            })
+        })
+        .collect()
+}
+
 /// Tests that views populate the st_view_* system tables
 #[test]
 fn test_st_view_tables() {
@@ -404,24 +428,7 @@ fn test_subscribing_with_different_identities() {
     test.call("insert_player", &["Bob"]).unwrap();
     let events = sub.collect().unwrap();
 
-    let projection: Vec<serde_json::Value> = events
-        .into_iter()
-        .map(|event| {
-            let deletes = event["my_player"]["deletes"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            let inserts = event["my_player"]["inserts"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            json!({"my_player": {"deletes": deletes, "inserts": inserts}})
-        })
-        .collect();
+    let projection = project_inserts_and_deletes_for_view(events, "my_player");
 
     assert_eq!(
         serde_json::json!(projection),
@@ -500,26 +507,7 @@ fn test_procedure_triggers_subscription_updates() {
     let sub = test.subscribe_background(&["select * from my_player"], 1).unwrap();
     test.call("insert_player_proc", &["Alice"]).unwrap();
     let events = sub.collect().unwrap();
-
-    let projection: Vec<serde_json::Value> = events
-        .into_iter()
-        .map(|event| {
-            let deletes = event["my_player"]["deletes"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            let inserts = event["my_player"]["inserts"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            json!({"my_player": {"deletes": deletes, "inserts": inserts}})
-        })
-        .collect();
-
+    let projection = project_inserts_and_deletes_for_view(events, "my_player");
     assert_eq!(
         serde_json::json!(projection),
         serde_json::json!([
@@ -543,24 +531,7 @@ fn test_typescript_procedure_triggers_subscription_updates() {
     test.call("insert_player_proc", &["Alice"]).unwrap();
     let events = sub.collect().unwrap();
 
-    let projection: Vec<serde_json::Value> = events
-        .into_iter()
-        .map(|event| {
-            let deletes = event["my_player"]["deletes"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            let inserts = event["my_player"]["inserts"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .map(|row| json!({"name": row["name"]}))
-                .collect::<Vec<_>>();
-            json!({"my_player": {"deletes": deletes, "inserts": inserts}})
-        })
-        .collect();
+    let projection = project_inserts_and_deletes_for_view(events, "my_player");
 
     assert_eq!(
         serde_json::json!(projection),
@@ -609,3 +580,80 @@ fn test_csharp_query_builder_view_query() {
  1     | true"#,
     );
 }
+
+#[test]
+fn test_subscribe_join_with_view_on_primary_key_col() {
+    let test = Smoketest::builder().precompiled_module("views-subscribe").build();
+
+    test.call("insert_player_proc", &["Alice"]).unwrap();
+
+    let query =
+        "SELECT all_players.* FROM player_state JOIN all_players ON player_state.identity = all_players.identity";
+    let events = test.subscribe(&[query], 0).unwrap();
+    let projection = project_inserts_and_deletes_for_view(events, "all_players");
+
+    assert_eq!(
+        serde_json::json!(projection),
+        serde_json::json!([
+            {"all_players": {"deletes": [], "inserts": [{"name": "Alice"}]}}
+        ])
+    );
+}
+
+#[test]
+fn test_subscribe_join_two_views_on_primary_key_col() {
+    let test = Smoketest::builder().precompiled_module("views-query").build();
+
+    let query = "SELECT online_users.* \
+                 FROM online_users \
+                 JOIN users_whos_age_is_known \
+                 ON online_users.identity = users_whos_age_is_known.identity";
+    let events = test.subscribe(&[query], 0).unwrap();
+    let projection = project_inserts_and_deletes_for_view(events, "online_users");
+
+    assert_eq!(
+        serde_json::json!(projection),
+        serde_json::json!([
+            {"online_users": {"deletes": [], "inserts": [{"name": "Alice"}]}}
+        ])
+    );
+}
+
+#[test]
+fn test_subscribe_join_with_anonymous_view_on_primary_key_col() {
+    let test = Smoketest::builder().precompiled_module("views-query").build();
+
+    let query = "SELECT anonymous_adult_people.* \
+                 FROM person \
+                 JOIN anonymous_adult_people \
+                 ON person.identity = anonymous_adult_people.identity \
+                 WHERE anonymous_adult_people.identity = 1";
+    let events = test.subscribe(&[query], 0).unwrap();
+    let projection = project_inserts_and_deletes_for_view(events, "anonymous_adult_people");
+
+    assert_eq!(
+        serde_json::json!(projection),
+        serde_json::json!([
+            {"anonymous_adult_people": {"deletes": [], "inserts": [{"name": "Alice"}]}}
+        ])
+    );
+}
+
+#[test]
+fn test_subscribe_join_two_sender_views_with_filters_on_both_sides() {
+    let test = Smoketest::builder().precompiled_module("views-query").build();
+
+    let query = "SELECT online_users_identity_1.* \
+                 FROM online_users_identity_1 \
+                 JOIN users_whos_age_is_known_identity_1 \
+                 ON online_users_identity_1.identity = users_whos_age_is_known_identity_1.identity";
+    let events = test.subscribe(&[query], 0).unwrap();
+    let projection = project_inserts_and_deletes_for_view(events, "online_users_identity_1");
+
+    assert_eq!(
+        serde_json::json!(projection),
+        serde_json::json!([
+            {"online_users_identity_1": {"deletes": [], "inserts": [{"name": "Alice"}]}}
+        ])
+    );
+}