You are a constitutional council ranking individual git commits for ownership allocation. Compare these two commits. Decide which contributed more lasting value to the project. Judge substance, not spectacle: - Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise. - Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one. - Do not favor a side merely because its patch is longer or noisier. - Weight what the change does for the project, not the contributor's name. Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."} The explanation must cite concrete differences in the patches (1-3 sentences). Side A — contributor: tommy-mor Side A — commit message: [5db58b98] Improve vote pair selection for spanning trees and rank refinement. Prefer attaching unranked items to established components before comparing isolates, then zip down adjacent rank-centrality pairs once the pool is fully connected, skipping pairs that already have votes. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/server/src/pair.rs b/server/src/pair.rs index 54b5d2417e9dba04ed8df422156e274c2b2f76b2..c14de4b0502c8b5a17cddf3746077739d56e03e0 100644 --- a/server/src/pair.rs +++ b/server/src/pair.rs @@ -3,13 +3,21 @@ //! Pair selection prefers **bridge** votes — comparisons between items in //! different connected components of the voted-pairs graph — so the pool //! merges into one ranking group before refining within it. +//! +//! Among unvoted bridges, prefer merging established voted components, then +//! attaching a never-voted child to an established component, and only then +//! comparing two never-voted children (so the voted graph grows as one tree). +//! +//! Once every pool child sits in one voted component, refinement **zips** down +//! the rank-centrality order: prefer 1 vs 2, then 2 vs 3, and so on, skipping +//! pairs that already have a vote. use rand::seq::SliceRandom; use std::collections::{HashMap, HashSet}; use crate::{ path_types::ItemId, - ranking::connected_components_from_voted_pairs, + ranking::{connected_components_from_voted_pairs, ranked_items}, reducer::{GlobalTree, GroupState}, }; @@ -28,36 +36,77 @@ fn pair_is_voted(group: &GroupState, a: &ItemId, b: &ItemId) -> bool { group.voted_pairs.contains(&(i, j)) } -/// Component id per pool item: voted-pairs graph components plus one id per -/// never-voted child. -fn component_ids(group: &GroupState, pool: &[ItemId]) -> HashMap { +/// Voted-pairs layout for pool items: component id per item plus which ids are +/// multi-node voted components (ranked groups in the UI). +struct ComponentLayout { + ids: HashMap, + established: HashSet, +} + +fn component_layout(group: &GroupState, pool: &[ItemId]) -> ComponentLayout { let n = group.idx_to_item.len(); let (comps, isolates) = connected_components_from_voted_pairs(n, group.voted_pairs.iter().copied()); - let mut out: HashMap = HashMap::new(); + let mut established = HashSet::new(); + let mut ids: HashMap = HashMap::new(); for (comp_idx, comp) in comps.iter().enumerate() { + if comp.len() >= 2 { + established.insert(comp_idx); + } for &idx in comp { if idx < n { - out.insert(group.idx_to_item[idx].clone(), comp_idx); + ids.insert(group.idx_to_item[idx].clone(), comp_idx); } } } let mut next = comps.len(); for &idx in &isolates { if idx < n { - out.insert(group.idx_to_item[idx].clone(), next); + ids.insert(group.idx_to_item[idx].clone(), next); next += 1; } } for item in pool { - out.entry(item.clone()).or_insert_with(|| { + ids.entry(item.clone()).or_insert_with(|| { let id = next; next += 1; id }); } - out + ComponentLayout { ids, established } +} + +/// Every pool child shares one multi-node voted component (spanning tree phase done). +fn pool_fully_connected(layout: &ComponentLayout, pool: &[ItemId]) -> bool { + if pool.len() < 2 { + return false; + } + let mut comp_id = None; + for item in pool { + let Some(id) = layout.ids.get(item) else { + return false; + }; + if !layout.established.contains(id) { + return false; + } + match comp_id { + None => comp_id = Some(*id), + Some(expected) if expected == *id => {} + _ => return false, + } + } + comp_id.is_some() +} + +/// Pool children that appear in `group`, sorted best rank first. +fn ranked_pool_order(group: &GroupState, pool: &[ItemId]) -> Vec { + let pool_set: HashSet<_> = pool.iter().collect(); + ranked_items(group) + .into_iter() + .map(|r| r.item) + .filter(|id| pool_set.contains(id)) + .collect() } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -72,19 +121,108 @@ enum PairPriority { WithinVoted = 3, } -fn pair_priority( +/// Tie-break among unvoted bridge pairs. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +enum BridgeSubPriority { + /// Both endpoints lie in established (multi-node) voted components. + MergeEstablished = 0, + /// One established component member and one never-voted child. + AttachIsolate = 1, + /// Two never-voted children (separate singleton components). + IsolatePair = 2, +} + +/// Tie-break among within-component pairs once the pool is one connected group. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +struct WithinSubPriority { + /// 1 = adjacent ranks (i vs i+1); larger = farther apart in the order. + rank_gap: usize, + /// min rank index of the two — zip from the top (1 vs 2 before 2 vs 3). + zip_index: usize, +} + +const WITHIN_SUB_WORST: WithinSubPriority = WithinSubPriority { + rank_gap: usize::MAX, + zip_index: usize::MAX, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +struct PairSortKey { + priority: PairPriority, + bridge_sub: BridgeSubPriority, + within_sub: WithinSubPriority, +} + +fn item_in_established(layout: &ComponentLayout, item: &ItemId) -> bool { + layout + .ids + .get(item) + .is_some_and(|id| layout.established.contains(id)) +} + +fn bridge_sub_priority(layout: &ComponentLayout, a: &ItemId, b: &ItemId) -> BridgeSubPriority { + let a_est = item_in_established(layout, a); + let b_est = item_in_established(layout, b); + match (a_est, b_est) { + (true, true) => BridgeSubPriority::MergeEstablished, + (true, false) | (false, true) => BridgeSubPriority::AttachIsolate, + (false, false) => BridgeSubPriority::IsolatePair, + } +} + +fn within_sub_priority( + group: &GroupState, + pool: &[ItemId], + layout: &ComponentLayout, + a: &ItemId, + b: &ItemId, +) -> WithinSubPriority { + if !pool_fully_connected(layout, pool) { + return WITHIN_SUB_WORST; + } + let order = ranked_pool_order(group, pool); + let (Some(i), Some(j)) = (order.iter().position(|x| x == a), order.iter().position(|x| x == b)) + else { + return WITHIN_SUB_WORST; + }; + WithinSubPriority { + rank_gap: i.abs_diff(j), + zip_index: i.min(j), + } +} + +fn pair_sort_key( group: &GroupState, - components: &HashMap, + pool: &[ItemId], + layout: &ComponentLayout, a: &ItemId, b: &ItemId, -) -> PairPriority { +) -> PairSortKey { let voted = pair_is_voted(group, a, b); - let bridge = components.get(a) != components.get(b); - match (bridge, voted) { + let bridge = layout.ids.get(a) != layout.ids.get(b); + let priority = match (bridge, voted) { (true, false) => PairPriority::BridgeUnvoted, (false, false) => PairPriority::WithinUnvoted, (true, true) => PairPriority::BridgeVoted, (false, true) => PairPriority::WithinVoted, + }; + let bridge_sub = if priority == PairPriority::BridgeUnvoted { + bridge_sub_priority(layout, a, b) + } else { + BridgeSubPriority::MergeEstablished + }; + let within_sub = if matches!( + priority, + PairPriority::WithinUnvoted | PairPriority::WithinVoted + ) { + within_sub_priority(group, pool, layout, a, b) + } else { + WITHIN_SUB_WORST + }; + PairSortKey { + priority, + bridge_sub, + within_sub, } } @@ -109,9 +247,12 @@ fn candidate_pairs(pool: &[ItemId], exclude: Option<(&ItemId, &ItemId)>) -> Vec< /// Pick the next pair to vote on within `pool`. /// -/// 1. Prefer unvoted **bridge** pairs (connect separate ranking components). -/// 2. Then unvoted within-component pairs (refinement). -/// 3. Then already-voted pairs (re-compare). +/// 1. Prefer unvoted **bridge** pairs (connect separate ranking components), +/// with sub-priority: merge established components, attach an isolate to +/// established, then compare two isolates. +/// 2. Then unvoted within-component pairs; when the pool is one connected group, +/// prefer adjacent ranks (1 vs 2, 2 vs 3, …) in order, skipping voted pairs. +/// 3. Then already-voted pairs (re-compare), with the same zip ordering. pub fn suggest_next_pair_in_pool( group: &GroupState, pool: &[ItemId], @@ -121,15 +262,15 @@ pub fn suggest_next_pair_in_pool( if candidates.is_empty() { return None; } - let components = component_ids(group, pool); + let layout = component_layout(group, pool); let best = candidates .iter() - .map(|(a, b)| (pair_priority(group, &components, a, b), (a, b))) - .min_by_key(|(p, _)| *p)? + .map(|(a, b)| (pair_sort_key(group, pool, &layout, a, b), (a, b))) + .min_by_key(|(k, _)| *k)? .0; let best_pairs: Vec<(ItemId, ItemId)> = candidates .into_iter() - .filter(|(a, b)| pair_priority(group, &components, a, b) == best) + .filter(|(a, b)| pair_sort_key(group, pool, &layout, a, b) == best) .collect(); best_pairs.choose(&mut rand::thread_rng()).cloned() } @@ -303,6 +444,38 @@ mod tests { assert!(from_ab && from_cd, "expected bridge pair, got {:?}", chosen); } + #[test] + fn suggest_prefers_attach_over_isolate_pair_among_many_unranked() { + let parent = ItemId::parse("reddit.com/r/rust").unwrap(); + let mut tree = seed_children( + &parent, + &[ + "reddit.com/r/rust/a", + "reddit.com/r/rust/b", + "reddit.com/r/rust/c", + "reddit.com/r/rust/d", + "reddit.com/r/rust/e", + ], + ); + let ab = + VoteData::from_recorded(1, "reddit.com/r/rust/a", "reddit.com/r/rust/b", 2, 1).unwrap(); + tree.apply_vote(&parent, ab); + let group = tree.get(&parent).unwrap().local_ranking.clone(); + let pool = children_of(&tree, &parent); + let pair = suggest_next_pair_in_pool(&group, &pool, None).unwrap(); + let chosen = pair_set(&pair); + let from_ab = + chosen.contains("reddit.com/r/rust/a") || chosen.contains("reddit.com/r/rust/b"); + let from_cde = chosen.contains("reddit.com/r/rust/c") + || chosen.contains("reddit.com/r/rust/d") + || chosen.contains("reddit.com/r/rust/e"); + assert!( + from_ab && from_cde, + "expected ranked+unranked attach, got {:?}", + chosen + ); + } + #[test] fn suggest_connects_isolate_to_existing_component() { let parent = ItemId::parse("reddit.com/r/rust").unwrap(); @@ -325,6 +498,65 @@ mod tests { assert!(chosen.contains("reddit.com/r/rust/a") || chosen.contains("reddit.com/r/rust/b")); } + #[test] + fn suggest_zips_adjacent_ranks_when_tree_complete() { + let parent = ItemId::parse("reddit.com/r/rust").unwrap(); + let mut tree = seed_children( + &parent, + &[ + "reddit.com/r/rust/a", + "reddit.com/r/rust/b", + "reddit.com/r/rust/c", + ], + ); + // Star at a connects all three; b-c is the only unvoted adjacent pair left. + for (a, b, l, r) in [ + ("reddit.com/r/rust/a", "reddit.com/r/rust/b", 3, 1), + ("reddit.com/r/rust/a", "reddit.com/r/rust/c", 2, 1), + ] { + let v = VoteData::from_recorded(1, a, b, l, r).unwrap(); + tree.apply_vote(&parent, v); + } + let group = tree.get(&parent).unwrap().local_ranking.clone(); + let pool = children_of(&tree, &parent); + let pair = suggest_next_pair_in_pool(&group, &pool, None).unwrap(); + let chosen = pair_set(&pair); + // a-b and a-c voted; b-c is the only unvoted adjacent pair in rank order. + assert!(chosen.contains("reddit.com/r/rust/b")); + assert!(chosen.contains("reddit.com/r/rust/c")); + } + + #[test] + fn suggest_zip_prefers_1v2_before_2v3_when_both_unvoted() { + let parent = ItemId::parse("reddit.com/r/rust").unwrap(); + let mut tree = seed_children( + &parent, + &[ + "reddit.com/r/rust/a", + "reddit.com/r/rust/b", + "reddit.com/r/rust/c", + "reddit.com/r/rust/d", + ], + ); + // Hub at c connects all four; leave rank-adjacent a-b and b-c unvoted. + for (a, b, l, r) in [ + ("reddit.com/r/rust/c", "reddit.com/r/rust/d", 3, 1), + ("reddit.com/r/rust/b", "reddit.com/r/rust/c", 2, 1), + ("reddit.com/r/rust/a", "reddit.com/r/rust/c", 2, 1), + ] { + let v = VoteData::from_recorded(1, a, b, l, r).unwrap(); + tree.apply_vote(&parent, v); + } + let group = tree.get(&parent).unwrap().local_ranking.clone(); + let pool = children_of(&tree, &parent); + assert!(pool_fully_connected(&component_layout(&group, &pool), &pool)); + let pair = suggest_next_pair_in_pool(&group, &pool, None).unwrap(); + let chosen = pair_set(&pair); + // Top adjacent unvoted edge should be a-b (zip index 0), not b-c (index 1). + assert!(chosen.contains("reddit.com/r/rust/a")); + assert!(chosen.contains("reddit.com/r/rust/b")); + } + #[test] fn resolve_pair_picks_from_pool() { let parent = ItemId::parse("reddit.com/r/rust").unwrap(); Side B — contributor: tommy-mor Side B — commit message: [9acdf18a] feat: add RoomList RPC command and CLI room list subcommand Returns all rooms the authenticated principal has a grant in. Includes integration tests proving per-user isolation: users only see rooms they have been explicitly granted, not all rooms in the system. Co-Authored-By: Claude Sonnet 4.6 Side B — unified diff (full patch): diff --git a/bb.edn b/bb.edn index f7c53eb2d5def514a8f2c480ac420416205db14e..8dc6a5be7321de198cbb5939842a33b8c5d52625 100644 --- a/bb.edn +++ b/bb.edn @@ -47,16 +47,18 @@ "RUST_LOG" "info"})})))} test - {:doc "Full test suite: integration + auth + grants + invites" + {:doc "Full test suite: integration + auth + grants + invites + room-list" :requires ([test.integration :as integration] [test.auth :as auth] [test.grants :as grants] - [test.invites :as invites]) + [test.invites :as invites] + [test.room-list :as room-list]) :task (do (integration/integration) (auth/auth-test) (grants/grants-test) - (invites/invites-test))} + (invites/invites-test) + (room-list/room-list-test))} walkthrough-fixture {:doc "Run local server + mock OAuth + seeded walkthrough data for manual browser demos" diff --git a/cli/src/main.rs b/cli/src/main.rs index 69492cb5417a0a19c38f8cacbeadd103bd905b6f..b008cf377bb360aaae666d2dfd4b5e13dedb204a 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -219,6 +219,12 @@ enum RoomCmd { #[arg(long)] json: bool, }, + /// List rooms the authenticated user has access to + List { + /// Output as JSON for agent parsing + #[arg(long)] + json: bool, + }, } #[derive(Subcommand, Debug)] @@ -1319,6 +1325,38 @@ async fn main() -> Result<()> { _ => return Err(anyhow!("unexpected RPC result")), } } + RoomCmd::List { json } => { + let client = http_client()?; + let bearer = effective_bearer().ok_or_else(|| { + anyhow!( + "no bearer token: run `slugsocial identity start --rig --model ` \ + then `slugsocial identity poll `, or set SLUG_BEARER_TOKEN / ~/.config/slugsocial/token" + ) + })?; + let batch = send_rpc( + &client, + base, + Some(&bearer), + vec![RpcCommand::RoomList], + ) + .await?; + match rpc_line_ok(&batch.results[0])? { + RpcResult::RoomList(resp) => { + if json { + println!("{}", serde_json::to_string_pretty(&resp)?); + } else { + if resp.rooms.is_empty() { + println!("no rooms"); + } else { + for room in &resp.rooms { + println!("{room}"); + } + } + } + } + _ => return Err(anyhow!("unexpected RPC result")), + } + } }, Command::Healthz { json } => { diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs index ed4800e7cbdeaf04e72192c191e71354e603c1fe..f1ee6d35b95a1a28490823e907b8f4dc5c091b94 100644 --- a/server/src/api/rpc.rs +++ b/server/src/api/rpc.rs @@ -1345,6 +1345,25 @@ pub async fn handle_rpc_batch( } } } + RpcCommand::RoomList => { + let principal = { + let reduced = state.reduced.read().await; + verify_bearer_principal(&headers, &*reduced) + }; + match principal { + Err((_, m)) => line_err(m, None), + Ok(principal) => { + let reduced = state.reduced.read().await; + let rooms: Vec = reduced + .grants + .iter() + .filter(|(_, members)| members.contains_key(&principal)) + .map(|(room, _)| room.clone()) + .collect(); + line_ok(RpcResult::RoomList(RoomListResponse { rooms })) + } + } + } RpcCommand::RoomRevoke { room, username, diff --git a/test/room_list.clj b/test/room_list.clj new file mode 100644 index 0000000000000000000000000000000000000000..a089a722ac8d5f822f47d5511a46f671d61d46cf --- /dev/null +++ b/test/room_list.clj @@ -0,0 +1,158 @@ +(ns test.room-list + "Room list integration test: list rooms user has access to via POST /api/v0/rpc. + + Covers: + - user with no rooms -> empty list + - user with one room -> list contains that room + - user with multiple rooms -> list contains all rooms" + (:require [babashka.fs :as fs] + [cheshire.core :as json] + [clojure.set :as set] + [test.common :as common] + [test.oauth :as oauth])) + +(def ^:private counts (atom {:pass 0 :fail 0})) + +(defn- assert! [pred msg] + (common/test-assert! counts pred msg)) + +(defn- bearer [token] {"Authorization" (str "Bearer " token)}) + +(defn- rpc-batch! [base-url token cmds] + (let [resp (oauth/http-post-json (str base-url "/api/v0/rpc") cmds :headers (bearer token))] + {:status (:status resp) + :parsed (json/parse-string (:body resp) false)})) + +(defn- rpc-line-ok? [parsed] + (true? (get-in parsed ["results" 0 "ok"]))) + +(defn- register-user! [base-url session-agent username] + (oauth/complete-registration! base-url + :agent session-agent + :username username + :assert! (fn [pred msg] (assert! pred msg)))) + +(defn room-list-test [& _args] + (println "\n━━━ room list integration check ━━━\n") + (reset! counts {:pass 0 :fail 0}) + + (println "building server binary…") + (common/letlocals + (bind build (common/run-cargo-build-release! ["slugsocial-server"])) + (assert! (zero? (:exit build)) "cargo build succeeds") + (bind server-bin "target/release/slugsocial-server") + + (bind tmp-dir (str (fs/create-temp-dir {:prefix "slug-room-list-"}))) + (bind slug-port (common/pick-port)) + (bind google-port (common/pick-port)) + (bind base-url (str "http://127.0.0.1:" slug-port)) + (bind google-url (str "http://127.0.0.1:" google-port)) + + (bind !server (atom nil)) + (bind !google (atom nil)) + + (bind server-env (common/slug-server-env tmp-dir base-url google-url slug-port)) + (try + (println (str "starting mock google on :" google-port)) + (reset! !google (oauth/start-mock-google google-port + :google-users ["google-user-alice" + "google-user-bob" + "google-user-carol"])) + + (println (str "starting server on :" slug-port)) + (reset! !server (common/start-server server-bin server-env)) + (assert! (common/wait-for-server base-url 10000) "server responds to /healthz") + + (println "\nregistering alice, bob, carol…") + (let [alice-token (register-user! base-url + "00000000-0000-0000-0000-000000000001:test:local/dev" + "alice") + bob-token (register-user! base-url + "00000000-0000-0000-0000-000000000002:test:local/dev" + "bob") + carol-token (register-user! base-url + "00000000-0000-0000-0000-000000000003:test:local/dev" + "carol") + + ;; Alice creates two private rooms + _ (println "\nalice creates two rooms…") + room-id-1 (-> (rpc-batch! base-url alice-token [{"RoomCreate" {"slug" "alice-room-one"}}]) + (get-in [:parsed "results" 0 "result" "RoomCreated" "room_id"])) + _ (assert! (some? room-id-1) "alice room-one created") + room-id-2 (-> (rpc-batch! base-url alice-token [{"RoomCreate" {"slug" "alice-room-two"}}]) + (get-in [:parsed "results" 0 "result" "RoomCreated" "room_id"])) + _ (assert! (some? room-id-2) "alice room-two created") + + ;; Carol creates her own room + _ (println "carol creates her own room…") + carol-room (-> (rpc-batch! base-url carol-token [{"RoomCreate" {"slug" "carol-room"}}]) + (get-in [:parsed "results" 0 "result" "RoomCreated" "room_id"])) + _ (assert! (some? carol-room) "carol room created")] + + ;; --- isolation: alice only sees her rooms, not carol's --- + (println "\nalice sees her 2 rooms but not carol's…") + (let [rooms (-> (rpc-batch! base-url alice-token ["RoomList"]) + (get-in [:parsed "results" 0 "result" "RoomList" "rooms"]) + set)] + (assert! (= #{room-id-1 room-id-2} rooms) + "alice sees exactly her 2 rooms") + (assert! (not (contains? rooms carol-room)) + "alice does NOT see carol's room")) + + ;; --- isolation: carol only sees her room, not alice's --- + (println "carol sees only her room…") + (let [rooms (-> (rpc-batch! base-url carol-token ["RoomList"]) + (get-in [:parsed "results" 0 "result" "RoomList" "rooms"]) + set)] + (assert! (= #{carol-room} rooms) + "carol sees exactly her own room") + (assert! (not (contains? rooms room-id-1)) + "carol does NOT see alice's room-one") + (assert! (not (contains? rooms room-id-2)) + "carol does NOT see alice's room-two")) + + ;; --- bob sees nothing yet: alice has 3 rooms total but bob is in none --- + (println "bob (no grants) sees no rooms despite 3 existing…") + (let [rooms (-> (rpc-batch! base-url bob-token ["RoomList"]) + (get-in [:parsed "results" 0 "result" "RoomList" "rooms"]))] + (assert! (zero? (count rooms)) + "bob sees 0 rooms even though 3 exist in the system")) + + ;; --- partial grant: alice grants bob room-one only --- + (println "\nalice grants bob view on room-one only…") + (assert! (rpc-line-ok? (:parsed (rpc-batch! base-url alice-token + [{"RoomGrant" {"room" room-id-1 + "username" "bob" + "capabilities" ["view"]}}]))) + "grant ok") + + ;; bob sees room-one but NOT room-two or carol's room + (println "bob sees room-one but not room-two or carol's room…") + (let [rooms (-> (rpc-batch! base-url bob-token ["RoomList"]) + (get-in [:parsed "results" 0 "result" "RoomList" "rooms"]) + set)] + (assert! (= #{room-id-1} rooms) + "bob sees exactly room-one") + (assert! (not (contains? rooms room-id-2)) + "bob does NOT see alice's room-two (not granted)") + (assert! (not (contains? rooms carol-room)) + "bob does NOT see carol's room (not granted)")) + + ;; alice's view is unchanged + (println "alice's view unchanged after granting bob…") + (let [rooms (-> (rpc-batch! base-url alice-token ["RoomList"]) + (get-in [:parsed "results" 0 "result" "RoomList" "rooms"]) + set)] + (assert! (= #{room-id-1 room-id-2} rooms) + "alice still sees exactly her 2 rooms after granting bob"))) + + (finally + (when-some [s @!server] (common/kill-server s)) + (when-some [g @!google] ((:stop-fn g))) + (fs/delete-tree tmp-dir))) + + (bind {pass :pass fail :fail} @counts) + (if (zero? fail) + (println (str "\n" common/ansi-green "━━━ " pass " room list checks passed ━━━" common/ansi-reset "\n")) + (do (println (str "\n" common/ansi-red "━━━ " fail " room list checks FAILED ━━━" common/ansi-reset "\n")) + (System/exit 1))))) diff --git a/test/runner.clj b/test/runner.clj index b5c5f1f839d51487e4dee00952c2339b586b7a97..365372a7d11ab7968aa981f9b246543e25decfea 100644 --- a/test/runner.clj +++ b/test/runner.clj @@ -4,13 +4,15 @@ [test.auth :as auth] [test.grants :as grants] [test.invites :as invites] + [test.room-list :as room-list] [test.browser-sse :as browser-sse])) (defn run-core! [] (integration/integration) (auth/auth-test) (grants/grants-test) - (invites/invites-test)) + (invites/invites-test) + (room-list/room-list-test)) (defn -main [& args] (if (= ["browser-sse"] (vec args)) diff --git a/types/src/lib.rs b/types/src/lib.rs index bb8586f1734f77d95598a9294bdb0de2d55bf715..341fff7be7f9b28abc79c738d84804f743ce5657 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -260,6 +260,11 @@ pub struct RoomAuditResponse { pub grants: Vec, } +#[derive(Debug, Serialize, Deserialize)] +pub struct RoomListResponse { + pub rooms: Vec, +} + #[derive(Debug, Serialize, Deserialize)] #[serde(transparent)] pub struct RpcBatch(pub Vec); @@ -342,6 +347,8 @@ pub enum RpcCommand { RoomAudit { room: String, }, + /// List rooms the authenticated principal has access to. + RoomList, GetGlobalRank { room: String, #[serde(default)] @@ -419,6 +426,7 @@ pub enum RpcResult { max_uses: usize, }, RoomAudit(RoomAuditResponse), + RoomList(RoomListResponse), GrantOk {}, GlobalRank(GlobalRankResponse), Pair(PairResponse),