mirror of
https://github.com/penpot/penpot.git
synced 2026-11-16 23:20:37 +00:00
* 🐛 Revoke websocket subscriptions when access is revoked GHSA-m53j-2766-6jqw. A websocket subscription was authorized once, when it opened, and that decision was trusted for the rest of the connection's life, so a member whose access was revoked kept receiving live file content as long as the tab stayed open. The revocation travels over the message bus instead of closing the socket from the mutation: the connection registry is local to one backend instance, while the RPC that revokes access runs on whichever instance received the request. Every instance re-verifies the subscriptions it owns with the same `has-read-permissions?` predicates that `:subscribe-file` and `:subscribe-team` authorize with, so a downgrade to viewer keeps its subscription and a non-member organization owner keeps read-only access. Two mechanisms cover each other: - Access-changing mutations announce after the write. delete-team- member, leave-team, update-team-member-role, delete-file, delete-project, move-files, move-project and delete-team announce. delete-share-link is deliberately excluded: a share-link visitor never passes the subscribe permission check, so there is no subscription to revoke. Team-wide changes publish one event per team; the watcher resolves the members itself, and both publishers defer through `db/after-commit` so the watcher never decides from pre-commit state. - Every relay re-checks access every 5 minutes by default (`subscription-revalidation-interval`), driven from the relay loop with `alts!` over the subscription channel and a one-shot tick channel, so a steady stream of edits cannot push the check away forever. Supporting changes: - The registry holds `:connections` and `:by-profile` in one atom, kept consistent by register/unregister in a single swap!; a profile lookup is one map access, and a profile whose last connection leaves is dropped from the index. - `close-file-subscription` and `close-team-subscription` announce the :leave-* message, close the relay channel and purge the bus subscription, and are idempotent. Closing the channel ends the relay loop and its re-check task. - The permission query the re-check uses filters soft-deleted files, projects and teams, matching its sibling queries. - A transient database error fails open: it logs and keeps the subscription; the next tick retries. - The revocation watcher's params schema declared the nitrate client as a bare keyword inside [:map ...], which malli resolved as a registry lookup and which took the whole system build down under enable-backend-asserts. It is now an explicit pair, optional because init-key yields nil with the admin-console flag off. The tests reproduce the leak against the real message bus, including the negative control for the interval re-check. The written records live in mem:backend/websocket-subscriptions. Closes #12155 AI-assisted-by: space-bunny-free AI-assisted-by: muse-spark-1.3-contributor * 🐛 Mirror the subscribe gates in the revocation re-checks Addresses the second review round on PR #12189 (pabloalba). The re-checks only asked whether the profile could read. The membership legs of sql:file-permissions filter soft-deleted rows since the F2 fix, but the organization-owner fallback grants read-only access over HTTP without looking at deleted_at, so a soft-deleted file or team kept an expelled org owner subscribed indefinitely. The re-checks now gate on existence as well: file-readable? and team-readable? require a live row (db/get*, non-throwing, soft-deleted rows excluded) plus the read permission, mirroring the :subscribe-file gates and extending them to teams. Both relays and revalidate-profile-subscriptions use them; the subscribe handlers keep their exact behavior. Also from the same review: - watcher-consumes-revocation-events-from-the-bus no longer races the command's after-commit announcement: it takes access away with a direct row delete and drives the watcher with a synthetic bus event, instead of deleting through the command and publishing a second notify-* that would mask a broken command announcement. - moving-a-project-closes-source-team-subscriptions pins the move-project e2e: the file subscription drops, the source-team subscription survives (membership unchanged). - soft-deleted-file/team-closes-org-owner-subscription cover the new gate with red-before/green-after tests. mem:backend/websocket-subscriptions updated. Closes #12155 AI-assisted-by: inkling-2-small-free * 🐛 Refuse dead teams in resolve-team-id (PR #12189 review) Second review round on PR #12189 (pabloalba). The file re-check added in 87ca7aca53 stops at the file row, but the organization-owner fallback grants read-only access to non-member org owners via Nitrate over HTTP, which knows nothing about Penpot soft-deletion. resolve-team-id resolved the team from unfiltered SQL, so an expelled org owner kept the file subscription open for an indefinitely soft-deleted file, project or team. Now both SQL lookups filter deleted_at, and resolve-team-id checks the team row itself (db/get*, which filters soft-deleted rows) for every caller — teams, projects and files alike. Also from the same review: - file-readable? now uses the same sql:get-minimal-file as the subscribe gate (non-throwing via throw-if-not-exists false), and team-readable? projects id and deleted-at, so db/get* can filter. - The test suite extracts the thrice-duplicated raw delete into delete-team-membership!; a sibling of the fail-open pin now redefs the existence probe to throw; memory and docstring aligned with the code. - docs/technical-guide/developer/architecture/backend.md attributed the websocket to notifications.clj; it now names app.http.websocket as the owner and notifications.clj as the revocation publisher. - mem:backend/auth-permissions-product-domains documents the fallback mechanism and the resolve-team-id contract. Closes #12155 AI-assisted-by: inkling-2-small-free * 🐛 Test resolve-team-id refusal and tidy review findings Third pass over PR #12189 after review-code on 225eb98de2. resolve-team-id now has a direct test: all three branches resolve while rows are live, and file, project and team soft-deletes each refuse their branch — the two new SQL predicates and the final team-row check are all pinned by it. From the same review: - failing-existence-check-keeps-the-subscription and the sibling a-failing-check-keeps-the-subscription are deleted: they could not distinguish a live relay from a dead one. The fail-open policy remains documented in the docstring and the memory; the memory no longer claims the pins exist. - team-readable? projects ::sql/columns like the rest of the backend; the fully-qualified keyword went away with the new alias. - The dead when-not guard in get-organization-owner-viewer-team is removed (resolve-team-id guarantees the row live); the let binding in resolve-team-id no longer shadows the destructured team-id. - docs/technical-guide names rpc/notifications.clj as the publisher and the tree lists the real top-level modules. Closes #12155 AI-assisted-by: inkling-2-small-free * 🐛 Make the revocation tests deterministic Third review round on PR #12189 (pabloalba). Both tests took access away through a command that announces, so the live watcher could close the subscriptions before the test looked: - revocation-closes-subscriptions-that-are-no-longer-authorized asserted an exact count of 2 closes after delete-team-member, and that count reads 0 whenever the watcher got there first. It now removes the member with delete-team-membership!, the raw row delete that publishes nothing, and asserts both subscriptions are still open before calling revalidate-profile-subscriptions. - team-event-closes-every-member-subscription ran delete-team and then published a second notify-team-permissions-changed, so a missing announcement in delete-team still passed. It now soft-deletes the team row (sql:team-members joins team_profile_rel and profile only, so the watcher still resolves every member), asserts nothing closed, and drives one synthetic team event. The command paths stay covered by the announce and end-to-end tests for delete-team-member and delete-team. The file split the reviewer suggested stays the optional follow-up, tracked outside this PR and waiting for the merge. Closes #12155 AI-assisted-by: deepseek-v4.1-flash
1239 lines
56 KiB
Clojure
1239 lines
56 KiB
Clojure
;; This Source Code Form is subject to the terms of the Mozilla Public
|
|
;; License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
;;
|
|
;; Copyright (c) KALEIDOS INC Sucursal en España SL
|
|
|
|
(ns backend-tests.http-websocket-test
|
|
(:require
|
|
[app.common.schema :as sm]
|
|
[app.common.time :as ct]
|
|
[app.common.uuid :as uuid]
|
|
[app.config :as cf]
|
|
[app.db :as db]
|
|
[app.http.websocket :as ws]
|
|
[app.msgbus :as mbus]
|
|
[app.nitrate :as nitrate]
|
|
[app.rpc :as-alias rpc]
|
|
[app.rpc.commands.files :as files]
|
|
[app.rpc.commands.teams :as teams]
|
|
[app.rpc.notifications :as ntf]
|
|
[app.util.websocket :as util-ws]
|
|
[backend-tests.helpers :as th]
|
|
[clojure.test :as t]
|
|
[promesa.exec.csp :as sp]))
|
|
|
|
(defn- with-clean-registry
|
|
"Runs `f` against an empty connection registry, restoring the previous
|
|
contents afterwards so tests cannot leak connections into each other."
|
|
[f]
|
|
(let [saved @ws/state]
|
|
(reset! ws/state {:connections {} :by-profile {}})
|
|
(try (f)
|
|
(finally (reset! ws/state saved)))))
|
|
|
|
(t/use-fixtures :once th/state-init)
|
|
(t/use-fixtures :each th/database-reset with-clean-registry)
|
|
|
|
(defn make-wsp
|
|
[profile-id state output-ch]
|
|
{::util-ws/id (uuid/next)
|
|
::util-ws/state state
|
|
::util-ws/output-ch output-ch
|
|
::ws/profile-id profile-id
|
|
::ws/session-id (uuid/next)})
|
|
|
|
(t/deftest subscribe-file-permission-check
|
|
(let [profile1 (th/create-profile* 1 {:is-active true})
|
|
profile2 (th/create-profile* 2 {:is-active true})
|
|
file (th/create-file* 1 {:profile-id (:id profile1)
|
|
:project-id (:default-project-id profile1)})
|
|
cfg th/*system*
|
|
state (atom {})
|
|
output-ch (sp/chan :buf (sp/dropping-buffer 64))]
|
|
|
|
(t/testing "rejects unauthorized user"
|
|
(let [wsp (make-wsp (:id profile2) state output-ch)]
|
|
(t/is (thrown-with-msg?
|
|
clojure.lang.ExceptionInfo
|
|
#"not found"
|
|
((get-method ws/handle-message :subscribe-file)
|
|
cfg wsp {:file-id (:id file)})))))
|
|
|
|
(t/testing "permission check passes for authorized user"
|
|
(t/is (nil? (files/check-read-permissions! cfg (:id profile1) (:id file)))))))
|
|
|
|
(t/deftest subscribe-team-permission-check
|
|
(let [profile1 (th/create-profile* 1 {:is-active true})
|
|
profile2 (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id profile1)})
|
|
cfg th/*system*
|
|
state (atom {})
|
|
output-ch (sp/chan :buf (sp/dropping-buffer 64))]
|
|
|
|
(t/testing "rejects unauthorized user"
|
|
(let [wsp (make-wsp (:id profile2) state output-ch)]
|
|
(t/is (thrown-with-msg?
|
|
clojure.lang.ExceptionInfo
|
|
#"not found"
|
|
((get-method ws/handle-message :subscribe-team)
|
|
cfg wsp {:team-id (:id team)})))))
|
|
|
|
(t/testing "permission check passes for authorized user"
|
|
(t/is (nil? (teams/check-read-permissions! cfg (:id profile1) (:id team)))))))
|
|
|
|
(defn- subscribed-topics
|
|
"Runs :subscribe-team for `profile-id` on `team-id` with `nitrate-call`
|
|
standing in for nitrate; returns the topics and the stored subscription."
|
|
[profile-id team-id nitrate-call]
|
|
(let [state (atom {})
|
|
output-ch (sp/chan :buf (sp/dropping-buffer 64))
|
|
wsp (make-wsp profile-id state output-ch)
|
|
calls (atom [])]
|
|
(with-redefs [nitrate/call nitrate-call
|
|
mbus/sub! (fn [_ & {:keys [topics]}]
|
|
(swap! calls conj topics))]
|
|
((get-method ws/handle-message :subscribe-team)
|
|
th/*system* wsp {:team-id team-id}))
|
|
(some-> @state ::ws/team-subscription :channel sp/close!)
|
|
{:topics @calls
|
|
:subscription (::ws/team-subscription @state)}))
|
|
|
|
(t/deftest subscribe-team-subscribes-to-team-organization
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
team-id (:id (th/create-team* 1 {:profile-id (:id profile)}))
|
|
org-id (uuid/next)]
|
|
|
|
(t/testing "adds the organization topic when the team has one"
|
|
(let [{:keys [topics subscription]}
|
|
(subscribed-topics (:id profile) team-id
|
|
(fn [_ method params]
|
|
(when (= :get-team-organization method)
|
|
{:id (:team-id params)
|
|
:organization {:id org-id}})))]
|
|
(t/is (= [[team-id org-id]] topics))
|
|
(t/is (= org-id (:organization-id subscription)))))
|
|
|
|
(t/testing "subscribes only to the team when it has no organization"
|
|
(let [{:keys [topics subscription]}
|
|
(subscribed-topics (:id profile) team-id (constantly nil))]
|
|
(t/is (= [[team-id]] topics))
|
|
(t/is (nil? (:organization-id subscription)))))
|
|
|
|
(t/testing "subscribes to the team when nitrate fails"
|
|
(let [{:keys [topics]}
|
|
(subscribed-topics (:id profile) team-id
|
|
(fn [& _] (throw (ex-info "nitrate down" {}))))]
|
|
(t/is (= [[team-id]] topics))))))
|
|
|
|
(t/deftest pointer-update-validates-file-id
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
file (th/create-file* 1 {:profile-id (:id profile)
|
|
:project-id (:default-project-id profile)})
|
|
cfg th/*system*
|
|
file-id (:id file)
|
|
sub-ch (sp/chan :buf (sp/dropping-buffer 64))
|
|
state (atom {::ws/file-subscription {:file-id file-id
|
|
:channel sub-ch
|
|
:topic file-id}})
|
|
output-ch (sp/chan :buf (sp/dropping-buffer 64))
|
|
wsp (make-wsp (:id profile) state output-ch)]
|
|
|
|
(t/testing "skips publish when file-id does not match subscription"
|
|
(let [wrong-msg {:type :pointer-update
|
|
:file-id (uuid/next)
|
|
:position {:x 10 :y 20}
|
|
:zoom 1.0}]
|
|
(t/is (nil?
|
|
((get-method ws/handle-message :pointer-update)
|
|
cfg wsp wrong-msg)))))
|
|
|
|
(t/testing "does nothing when no file subscription exists"
|
|
(let [empty-state (atom {})
|
|
empty-wsp (make-wsp (:id profile) empty-state output-ch)
|
|
msg {:type :pointer-update
|
|
:file-id file-id
|
|
:position {:x 10 :y 20}
|
|
:zoom 1.0}]
|
|
(t/is (nil?
|
|
((get-method ws/handle-message :pointer-update)
|
|
cfg empty-wsp msg)))))))
|
|
|
|
;; --- SUBSCRIPTION REVOCATION
|
|
;;
|
|
;; GHSA-m53j-2766-6jqw: a websocket subscription checks read permission
|
|
;; once, at subscribe time. Once the connection is subscribed to the
|
|
;; message-bus topic it keeps receiving live content for the rest of its
|
|
;; life, even after access is revoked.
|
|
|
|
(def ^:private revocation-timeout-ms
|
|
"How long to wait for a message that should never arrive. Long enough
|
|
to absorb the round trip through redis, short enough to keep the test
|
|
fast."
|
|
500)
|
|
|
|
(defn- poll-msg!
|
|
"Drains `ch` for up to `ms`, returning the first message whose `:type`
|
|
is `type`, or nil when none arrives.
|
|
|
|
Draining rather than reading a single message matters for the negative
|
|
assertions: a live subscription also carries presence traffic, so
|
|
\"no `:file-change` arrived\" is the property under test, not \"the
|
|
channel stayed empty\"."
|
|
[ch type ms]
|
|
(let [result (promise)
|
|
deadline (+ (System/currentTimeMillis) ms)]
|
|
(sp/go
|
|
(loop []
|
|
(let [remain (- deadline (System/currentTimeMillis))]
|
|
(when (pos? remain)
|
|
(let [[msg _] (sp/alts! [ch (sp/timeout-chan remain)])]
|
|
(if (= type (:type msg))
|
|
(deliver result msg)
|
|
(recur)))))))
|
|
(deref result (inc ms) nil)))
|
|
|
|
(defn- open-registered-connection
|
|
"Registers a connection for `profile-id` in the real registry, so the
|
|
revocation watcher can find it, and returns the pieces a test needs to
|
|
drive it and inspect what it did."
|
|
[profile-id]
|
|
(let [id (uuid/next)
|
|
output (sp/chan :buf (sp/dropping-buffer 64))
|
|
ws-state (atom {})
|
|
wsp (make-wsp profile-id ws-state output)]
|
|
(ws/register-connection id wsp)
|
|
{:id id :wsp wsp :state ws-state :output output}))
|
|
|
|
(defn- open-subscription!
|
|
"Opens a registered subscription for `profile-id` and returns the
|
|
output channel that receives whatever it forwards.
|
|
|
|
The connection goes through the real registry on purpose: these tests
|
|
assert the end-to-end path, where a mutation announces the change and
|
|
the watcher closes the subscription."
|
|
[handler profile-id params]
|
|
(let [{:keys [wsp output]} (open-registered-connection profile-id)]
|
|
((get-method ws/handle-message handler) th/*system* wsp params)
|
|
output))
|
|
|
|
(defn- wait-until
|
|
"Polls `pred` until it holds or `ms` elapses. Returns whether it held."
|
|
[pred ms]
|
|
(let [deadline (+ (System/currentTimeMillis) ms)]
|
|
(loop []
|
|
(cond
|
|
(pred) true
|
|
(>= (System/currentTimeMillis) deadline) false
|
|
:else (do (Thread/sleep 25) (recur))))))
|
|
|
|
(defn- subscribe
|
|
[{:keys [wsp] :as conn} handler params]
|
|
((get-method ws/handle-message handler) th/*system* wsp params)
|
|
conn)
|
|
|
|
(defn- subscribed-file [conn] (-> @(:state conn) ::ws/file-subscription :file-id))
|
|
(defn- subscribed-team [conn] (-> @(:state conn) ::ws/team-subscription :team-id))
|
|
|
|
(defn- publisher!
|
|
"Returns a fn that publishes `message` on `topic` through the system
|
|
msgbus, the same path `send-notifications!` uses."
|
|
[]
|
|
(let [msgbus (::mbus/msgbus th/*system*)]
|
|
(fn [topic message]
|
|
(mbus/pub! msgbus :topic topic :message message))))
|
|
|
|
;; --- CONNECTION REGISTRY
|
|
|
|
(t/deftest registry-indexes-connections-by-profile
|
|
(let [profile-a (uuid/next)
|
|
profile-b (uuid/next)
|
|
conn-a (uuid/next)
|
|
conn-b (uuid/next)
|
|
conn-c (uuid/next)]
|
|
|
|
(t/testing "a profile with no connections has an empty index"
|
|
(t/is (= #{} (ws/connections-for-profile profile-a))))
|
|
|
|
(ws/register-connection conn-a {::ws/profile-id profile-a})
|
|
(ws/register-connection conn-b {::ws/profile-id profile-a})
|
|
(ws/register-connection conn-c {::ws/profile-id profile-b})
|
|
|
|
(t/testing "connections are indexed under their profile"
|
|
(t/is (= #{conn-a conn-b} (ws/connections-for-profile profile-a)))
|
|
(t/is (= #{conn-c} (ws/connections-for-profile profile-b))))
|
|
|
|
(t/testing "connections are retrievable by id"
|
|
(t/is (= profile-a (::ws/profile-id (ws/get-connection conn-a))))
|
|
(t/is (nil? (ws/get-connection (uuid/next)))))
|
|
|
|
(t/testing "unregistering removes it from both the map and the index"
|
|
(ws/unregister-connection conn-b)
|
|
(t/is (= #{conn-a} (ws/connections-for-profile profile-a)))
|
|
(t/is (nil? (ws/get-connection conn-b))))
|
|
|
|
(t/testing "a profile whose last connection left is dropped from the index"
|
|
(ws/unregister-connection conn-a)
|
|
(t/is (= #{} (ws/connections-for-profile profile-a)))
|
|
(t/is (not (contains? (:by-profile @ws/state) profile-a)))
|
|
(t/is (= #{conn-c} (ws/connections-for-profile profile-b))))
|
|
|
|
(t/testing "unregistering an unknown connection is a no-op"
|
|
(ws/unregister-connection (uuid/next))
|
|
(t/is (= #{conn-c} (ws/connections-for-profile profile-b)))
|
|
(t/is (= conn-c (-> (:connections @ws/state) keys first))))))
|
|
|
|
(t/deftest close-file-subscription-drops-only-the-matching-file
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
file (th/create-file* 1 {:profile-id (:id profile)
|
|
:project-id (:default-project-id profile)})
|
|
other (th/create-file* 2 {:profile-id (:id profile)
|
|
:project-id (:default-project-id profile)})
|
|
output (sp/chan :buf (sp/dropping-buffer 64))
|
|
relay (sp/chan :buf (sp/dropping-buffer 64))
|
|
ws-state (atom {::ws/file-subscription
|
|
{:file-id (:id file)
|
|
:channel relay
|
|
:topic (:id file)}})
|
|
wsp (assoc (make-wsp (:id profile) ws-state output)
|
|
::ws/state ws-state)]
|
|
|
|
(t/testing "closing a file the connection is not subscribed to does nothing"
|
|
(with-redefs [mbus/pub! (fn [& _] (throw ::unexpected-publish))
|
|
mbus/purge! (fn [& _] (throw ::unexpected-purge))]
|
|
(t/is (nil? (ws/close-file-subscription th/*system* wsp (:id other))))
|
|
(t/is (some? (::ws/file-subscription @ws-state)))))
|
|
|
|
(t/testing "closing the subscribed file purges the bus"
|
|
(let [purged (atom [])]
|
|
(with-redefs [mbus/purge! (fn [_ chans] (swap! purged conj chans))]
|
|
(ws/close-file-subscription th/*system* wsp (:id file))
|
|
(t/is (= 1 (count @purged))))))
|
|
|
|
(t/testing "the relay channel is closed so the go-loop stops"
|
|
(t/is (nil? (sp/poll! relay)))
|
|
(t/is (true? (sp/closed? relay))))
|
|
|
|
(t/testing "the subscription is forgotten, so closing again is a no-op"
|
|
(t/is (nil? (::ws/file-subscription @ws-state)))
|
|
(with-redefs [mbus/pub! (fn [& _] (throw ::unexpected-publish))]
|
|
(t/is (nil? (ws/close-file-subscription th/*system* wsp (:id file))))))))
|
|
|
|
(t/deftest revoked-member-stops-receiving-file-changes
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
|
|
(let [project (th/create-project* 1 {:profile-id (:id editor)
|
|
:team-id (:id team)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project)})
|
|
file-id (:id file)
|
|
publish (publisher!)
|
|
change {:type :file-change
|
|
:file-id file-id
|
|
:revn 1
|
|
:changes [{:type :add :id (uuid/next)}]}]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id file-id}))
|
|
out (:output conn)]
|
|
|
|
(t/testing "member receives file changes before revocation"
|
|
(publish file-id change)
|
|
(t/is (some? (poll-msg! out :file-change
|
|
revocation-timeout-ms))))
|
|
|
|
(t/testing "owner removes the member from the team"
|
|
(let [result (th/command! {::th/type :delete-team-member
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)})]
|
|
(t/is (th/success? result))))
|
|
|
|
(t/testing "the mutation alone drops the subscription"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000)))
|
|
|
|
(t/testing "revoked member stops receiving file changes"
|
|
(publish file-id (assoc change :revn 2))
|
|
(t/is (nil? (poll-msg! out :file-change
|
|
revocation-timeout-ms))))))))
|
|
(t/deftest revoked-member-stops-receiving-library-changes
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
|
|
(let [team-id (:id team)
|
|
publish (publisher!)
|
|
change {:type :library-change
|
|
:team-id team-id
|
|
:file-id (uuid/next)
|
|
:revn 1
|
|
:changes [{:type :add :id (uuid/next)}]}]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-team {:team-id team-id}))
|
|
out (:output conn)]
|
|
|
|
(t/testing "member receives library changes before revocation"
|
|
(publish team-id change)
|
|
(t/is (some? (poll-msg! out :library-change
|
|
revocation-timeout-ms))))
|
|
|
|
(t/testing "member leaves the team"
|
|
(let [result (th/command! {::th/type :leave-team
|
|
::rpc/profile-id (:id editor)
|
|
:id team-id})]
|
|
(t/is (th/success? result))))
|
|
|
|
(t/testing "leaving drops the team subscription"
|
|
(t/is (wait-until #(nil? (subscribed-team conn)) 3000)))
|
|
|
|
(t/testing "revoked member stops receiving library changes"
|
|
(publish team-id (assoc change :revn 2))
|
|
(t/is (nil? (poll-msg! out :library-change
|
|
revocation-timeout-ms))))))))
|
|
(t/deftest role-downgrade-keeps-revocation-irrelevant
|
|
"A role change that does not remove read access must not be treated as
|
|
a revocation: `:viewer` can still read, so the subscription stays."
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
|
|
(let [project (th/create-project* 1 {:profile-id (:id editor)
|
|
:team-id (:id team)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project)})
|
|
file-id (:id file)
|
|
publish (publisher!)
|
|
change {:type :file-change :file-id file-id :revn 1 :changes []}
|
|
out (open-subscription! :subscribe-file (:id editor)
|
|
{:file-id file-id})]
|
|
|
|
(t/testing "editor is downgraded to viewer"
|
|
(let [result (th/command! {::th/type :update-team-member-role
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)
|
|
:role :viewer})]
|
|
(t/is (th/success? result))))
|
|
|
|
(t/testing "viewer keeps receiving file changes"
|
|
(publish file-id change)
|
|
(t/is (some? (poll-msg! out :file-change revocation-timeout-ms)))))))
|
|
|
|
;; --- REVOCATION WATCHER
|
|
;;
|
|
;; The registry is local to a backend instance while the message bus is
|
|
;; shared, so a revocation travels over the bus and each instance
|
|
;; re-verifies the connections it owns.
|
|
|
|
(defn- editor-in-team!
|
|
"Builds an owner, an editor with read access to `team`, and a project
|
|
and file inside it."
|
|
[owner-i editor-i]
|
|
(let [owner (th/create-profile* owner-i {:is-active true})
|
|
editor (th/create-profile* editor-i {:is-active true})
|
|
team (th/create-team* owner-i {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [project (th/create-project* owner-i {:profile-id (:id editor)
|
|
:team-id (:id team)})
|
|
file (th/create-file* owner-i {:profile-id (:id editor)
|
|
:project-id (:id project)})]
|
|
{:owner owner :editor editor :team team :file file})))
|
|
|
|
(defn- delete-team-membership!
|
|
"Takes `profile-id` out of `team-id` the way an external change would:
|
|
a direct row delete. Fires no command and publishes no announcement,
|
|
so no `db/after-commit` hook can race the test."
|
|
[team-id profile-id]
|
|
(db/exec! th/*system*
|
|
["delete from team_profile_rel where team_id = ? and profile_id = ?"
|
|
team-id profile-id]))
|
|
|
|
(t/deftest revocation-closes-subscriptions-that-are-no-longer-authorized
|
|
(let [{:keys [editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)})
|
|
(subscribe :subscribe-team {:team-id (:id team)}))]
|
|
|
|
(t/testing "both subscriptions are open before the revocation"
|
|
(t/is (= (:id file) (subscribed-file conn)))
|
|
(t/is (= (:id team) (subscribed-team conn))))
|
|
|
|
;; A direct row delete fires no command and publishes no
|
|
;; announcement, so the explicit revalidation below is the only
|
|
;; thing that can close these subscriptions and the count is
|
|
;; deterministic. A command would announce, and the live watcher
|
|
;; could close them before the count is taken.
|
|
(t/testing "the member is removed straight over SQL, so nothing announces it"
|
|
(delete-team-membership! (:id team) (:id editor))
|
|
(t/is (= (:id file) (subscribed-file conn)))
|
|
(t/is (= (:id team) (subscribed-team conn))))
|
|
|
|
(t/testing "revalidation closes the file and the team subscription"
|
|
(t/is (= 2 (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
|
|
(t/testing "nothing is left subscribed to relay content"
|
|
(t/is (nil? (subscribed-file conn)))
|
|
(t/is (nil? (subscribed-team conn))))
|
|
|
|
(t/testing "revalidating again is a no-op"
|
|
(t/is (zero? (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor))))))))
|
|
|
|
(t/deftest revocation-keeps-subscriptions-that-are-still-authorized
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)})
|
|
(subscribe :subscribe-team {:team-id (:id team)}))]
|
|
|
|
(t/testing "the editor is downgraded to viewer, which can still read"
|
|
(let [result (th/command! {::th/type :update-team-member-role
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)
|
|
:role :viewer})]
|
|
(t/is (th/success? result))))
|
|
|
|
(t/testing "revalidation closes nothing"
|
|
(t/is (zero? (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
|
|
(t/testing "both subscriptions survive"
|
|
(t/is (= (:id file) (subscribed-file conn)))
|
|
(t/is (= (:id team) (subscribed-team conn)))))))
|
|
|
|
(t/deftest revocation-leaves-other-profiles-alone
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)
|
|
other-owner (th/create-profile* 3 {:is-active true})
|
|
other-editor (th/create-profile* 4 {:is-active true})
|
|
other-team (th/create-team* 3 {:profile-id (:id other-owner)})]
|
|
(th/create-team-role* {:team-id (:id other-team)
|
|
:profile-id (:id other-editor)
|
|
:role :editor})
|
|
(let [other-file (th/create-file* 3 {:profile-id (:id other-editor)
|
|
:project-id (:default-project-id
|
|
other-editor)})]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
bystander (-> (open-registered-connection (:id other-editor))
|
|
(subscribe :subscribe-file {:file-id (:id other-file)}))]
|
|
|
|
(th/command! {::th/type :delete-team-member
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)})
|
|
|
|
(ws/revalidate-profile-subscriptions th/*system* (:id editor))
|
|
|
|
(t/testing "the revoked member's subscription is closed"
|
|
(t/is (nil? (subscribed-file conn))))
|
|
|
|
(t/testing "a member of another team keeps their subscription"
|
|
(t/is (= (:id other-file) (subscribed-file bystander))))
|
|
|
|
(t/testing "revalidating a profile with no connections is safe"
|
|
(t/is (zero? (ws/revalidate-profile-subscriptions
|
|
th/*system* (uuid/next)))))))))
|
|
|
|
(t/deftest watcher-consumes-revocation-events-from-the-bus
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
;; Access is taken away the way an external change would take
|
|
;; it: a direct row delete fires no command and publishes no
|
|
;; announcement, so the "still subscribed" check cannot race an
|
|
;; after-commit hook, and the command's own announcement cannot
|
|
;; mask a broken watcher.
|
|
(delete-team-membership! (:id team) (:id editor))
|
|
|
|
(t/testing "the event is not applied until it is announced"
|
|
(t/is (= (:id file) (subscribed-file conn))))
|
|
|
|
(ntf/notify-permissions-changed th/*system* (:id editor))
|
|
|
|
(t/testing "the watcher closes the subscription off the bus"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000))))))
|
|
|
|
(t/deftest internal-revocation-events-are-not-delivered-to-clients
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
id (uuid/next)
|
|
output (sp/chan :buf (sp/dropping-buffer 64))
|
|
wsp (assoc (make-wsp (:id profile) (atom {}) output)
|
|
::ws/id id)]
|
|
|
|
(ws/register-connection id wsp)
|
|
((get-method ws/handle-message :open) th/*system* wsp nil)
|
|
|
|
(t/testing "the client does receive its own profile traffic"
|
|
(mbus/pub! (::mbus/msgbus th/*system*)
|
|
:topic (:id profile)
|
|
:message {:type :notification :text "hello"})
|
|
(t/is (some? (poll-msg! output :notification revocation-timeout-ms))))
|
|
|
|
(t/testing "an internal revocation event never reaches the client"
|
|
(ntf/notify-permissions-changed th/*system* (:id profile))
|
|
(t/is (nil? (poll-msg! output :profile-permissions-changed
|
|
revocation-timeout-ms))))))
|
|
|
|
|
|
;; --- MUTATIONS THAT ANNOUNCE THE CHANGE
|
|
;;
|
|
;; The watcher only helps if the mutations that can revoke access
|
|
;; actually announce it. Each of these asserts the announcement reaches
|
|
;; the bus, and that a change which does not remove access announces
|
|
;; nothing harmful.
|
|
|
|
(defn- captured-events
|
|
"Runs `f` collecting the revocation events published on the internal
|
|
topic, while letting every other publish reach the real bus untouched."
|
|
[f]
|
|
(let [events (atom [])
|
|
real mbus/pub!]
|
|
(with-redefs [mbus/pub! (fn [bus & {:keys [topic message] :as opts}]
|
|
(when (= ntf/internal-revocation-topic topic)
|
|
(swap! events conj message))
|
|
(apply real bus (mapcat identity opts)))]
|
|
(f))
|
|
@events))
|
|
|
|
(defn- event-for
|
|
[events profile-id]
|
|
(first (filter #(= profile-id (:profile-id %)) events)))
|
|
|
|
(t/deftest removing-a-member-announces-the-revocation
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [events (captured-events
|
|
#(th/command! {::th/type :delete-team-member
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)}))]
|
|
(t/is (= {:type :profile-permissions-changed
|
|
:profile-id (:id editor)}
|
|
(event-for events (:id editor)))))))
|
|
|
|
(t/deftest a-role-change-announces-and-still-closes-nothing
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [project (th/create-project* 1 {:profile-id (:id editor)
|
|
:team-id (:id team)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project)})
|
|
events (captured-events
|
|
#(th/command! {::th/type :update-team-member-role
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)
|
|
:role :viewer}))]
|
|
|
|
(t/testing "the change is announced so subscriptions get re-checked"
|
|
(t/is (some? (event-for events (:id editor)))))
|
|
|
|
(t/testing "a viewer can still read, so the subscription survives"
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
(t/is (zero? (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor))))
|
|
(t/is (some? (subscribed-file conn))))))))
|
|
|
|
(t/deftest deleting-a-file-announces-to-the-whole-team
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [project (th/create-project* 1 {:profile-id (:id editor)
|
|
:team-id (:id team)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project)})
|
|
events (captured-events
|
|
#(th/command! {::th/type :delete-file
|
|
::rpc/profile-id (:id owner)
|
|
:id (:id file)}))]
|
|
|
|
;; One event per team: the watcher resolves the members itself, so
|
|
;; a large team cannot overflow the bounded publish buffers.
|
|
(t/is (= [{:type :team-permissions-changed
|
|
:team-id (:id team)}]
|
|
events)))))
|
|
|
|
(t/deftest deleting-a-team-announces-once
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [events (captured-events
|
|
#(th/command! {::th/type :delete-team
|
|
::rpc/profile-id (:id owner)
|
|
:id (:id team)}))]
|
|
(t/is (= [{:type :team-permissions-changed
|
|
:team-id (:id team)}]
|
|
events)))))
|
|
|
|
(t/deftest team-event-closes-every-member-subscription
|
|
(let [{:keys [editor team file]} (editor-in-team! 1 2)
|
|
other (th/create-profile* 3 {:is-active true})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id other)
|
|
:role :editor})
|
|
(let [other-project (th/create-project* 3 {:profile-id (:id other)
|
|
:team-id (:id team)})
|
|
other-file (th/create-file* 3 {:profile-id (:id other)
|
|
:project-id (:id other-project)})]
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
conn2 (-> (open-registered-connection (:id other))
|
|
(subscribe :subscribe-file {:file-id (:id other-file)}))]
|
|
|
|
;; Same shape as the watcher test above: a direct soft-delete
|
|
;; publishes nothing, so this test owns the fan-out of one event
|
|
;; and the announcement of `delete-team` is left to
|
|
;; `deleting-a-team-announces-once`. A second notify here would
|
|
;; make the test pass even if that announcement disappeared.
|
|
(db/update! th/*system* :team {:deleted-at (ct/now)} {:id (:id team)})
|
|
|
|
(t/testing "nothing closes until the event arrives"
|
|
(t/is (some? (subscribed-file conn)))
|
|
(t/is (some? (subscribed-file conn2))))
|
|
|
|
(t/testing "one team event reaches the watcher off the bus"
|
|
(ntf/notify-team-permissions-changed th/*system* (:id team))
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000))
|
|
(t/is (wait-until #(nil? (subscribed-file conn2)) 3000)))))))
|
|
|
|
(t/deftest rolled-back-revocation-announces-nothing
|
|
(let [editor (th/create-profile* 2 {:is-active true})
|
|
events (captured-events
|
|
#(try
|
|
(db/tx-run! th/*system*
|
|
(fn [_cfg]
|
|
(ntf/notify-permissions-changed th/*system* (:id editor))
|
|
(throw (ex-info "boom" {}))))
|
|
(catch clojure.lang.ExceptionInfo _)))]
|
|
(t/is (empty? events))))
|
|
|
|
(t/deftest leaving-a-team-announces-and-tells-only-the-leaver
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
other (th/create-profile* 3 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(th/create-team-role* {:team-id (:id team)
|
|
:profile-id (:id other)
|
|
:role :editor})
|
|
(let [published (atom [])
|
|
real mbus/pub!]
|
|
(with-redefs [mbus/pub! (fn [bus & args]
|
|
(let [opts (apply hash-map args)]
|
|
(swap! published conj opts))
|
|
(apply real bus args))]
|
|
(th/command! {::th/type :leave-team
|
|
::rpc/profile-id (:id editor)
|
|
:id (:id team)}))
|
|
|
|
(t/testing "the leaver is told they were removed, so the client leaves"
|
|
(let [msg (->> @published
|
|
(filter #(= (:id editor) (:topic %)))
|
|
(map :message)
|
|
first)]
|
|
(t/is (= :team-membership-change (:type msg)))
|
|
(t/is (= :removed (:change msg)))
|
|
(t/is (= (:id team) (:team-id msg)))))
|
|
|
|
(t/testing "no other member is told they were removed"
|
|
(t/is (empty? (filter #(= (:id other) (:topic %)) @published)))))))
|
|
|
|
(t/deftest deleting-a-share-link-announces-nothing
|
|
;; A share-link visitor never passes the websocket subscribe check:
|
|
;; `check-read-permissions!` is called without a share-id, and that
|
|
;; arity only considers team membership. There is no subscription to
|
|
;; revoke, so announcing would be noise.
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
file (th/create-file* 1 {:profile-id (:id owner)
|
|
:project-id (:default-project-id owner)})]
|
|
(th/command! {::th/type :create-share-link
|
|
::rpc/profile-id (:id owner)
|
|
:file-id (:id file)
|
|
:who-comment "none"
|
|
:who-inspect "none"
|
|
:pages #{}})
|
|
(let [link-id (:id (db/exec-one! th/*system*
|
|
["select id from share_link where file_id = ?"
|
|
(:id file)]))
|
|
events (captured-events
|
|
#(th/command! {::th/type :delete-share-link
|
|
::rpc/profile-id (:id owner)
|
|
:id link-id}))]
|
|
(t/is (some? link-id))
|
|
(t/is (empty? events)))))
|
|
|
|
;; --- PERIODIC REVALIDATION
|
|
;;
|
|
;; The announcement path is the primary mechanism. This interval is the
|
|
;; safety net for access changes that fire no command here, such as
|
|
;; Nitrate transferring the ownership of an organization, or rows
|
|
;; deleted straight over SQL.
|
|
|
|
(t/deftest revalidation-interval-defaults-to-five-minutes
|
|
(t/is (= (ct/duration {:minutes 5}) ws/default-revalidation-interval))
|
|
(t/is (= (ct/duration {:minutes 5}) (ws/revalidation-interval))))
|
|
|
|
(t/deftest revalidation-is-configurable
|
|
(with-redefs [cf/get (fn [k default] (if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:seconds 30})
|
|
default))]
|
|
(t/is (= (ct/duration {:seconds 30}) (ws/revalidation-interval)))))
|
|
|
|
(t/deftest interval-recheck-drops-a-subscription-without-any-announcement
|
|
(let [{:keys [editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(with-redefs [cf/get (fn [k default]
|
|
(if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:millis 150})
|
|
default))]
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
out (:output conn)]
|
|
|
|
(t/testing "the subscription is live at first"
|
|
(t/is (some? (subscribed-file conn))))
|
|
|
|
;; Access is taken away the way an external change would take
|
|
;; it: a direct row delete fires no command and publishes no
|
|
;; announcement, so the interval is the only thing that can
|
|
;; close the subscription.
|
|
(delete-team-membership! (:id team) (:id editor))
|
|
|
|
(t/testing "the interval re-check drops it anyway"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000)))
|
|
|
|
(t/testing "and nothing reaches the client afterwards"
|
|
(mbus/pub! (::mbus/msgbus th/*system*)
|
|
:topic (:id file)
|
|
:message {:type :file-change :file-id (:id file) :revn 9})
|
|
(t/is (nil? (poll-msg! out :file-change
|
|
revocation-timeout-ms))))))))
|
|
|
|
(t/deftest interval-recheck-keeps-a-subscription-that-still-holds
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(with-redefs [cf/get (fn [k default]
|
|
(if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:millis 150})
|
|
default))]
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
out (:output conn)]
|
|
|
|
(t/testing "a downgrade to viewer still allows reading"
|
|
(t/is (th/success? (th/command! {::th/type :update-team-member-role
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)
|
|
:role :viewer}))))
|
|
|
|
;; Wait for at least two interval ticks, so a re-check that
|
|
;; wrongly closed the subscription would have run.
|
|
(Thread/sleep 500)
|
|
|
|
(t/testing "the subscription survives the interval"
|
|
(t/is (some? (subscribed-file conn))))
|
|
|
|
(t/testing "and traffic still flows"
|
|
(mbus/pub! (::mbus/msgbus th/*system*)
|
|
:topic (:id file)
|
|
:message {:type :file-change :file-id (:id file) :revn 3})
|
|
(t/is (some? (poll-msg! out :file-change
|
|
revocation-timeout-ms))))))))
|
|
|
|
(t/deftest interval-recheck-covers-the-team-subscription-too
|
|
(let [{:keys [editor team]} (editor-in-team! 1 2)]
|
|
|
|
(with-redefs [cf/get (fn [k default]
|
|
(if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:millis 150})
|
|
default))]
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-team {:team-id (:id team)}))]
|
|
|
|
(t/is (some? (subscribed-team conn)))
|
|
|
|
;; Same external-change shape as above: no command, no
|
|
;; announcement, only the interval.
|
|
(delete-team-membership! (:id team) (:id editor))
|
|
|
|
(t/testing "the team subscription is dropped by the interval"
|
|
(t/is (wait-until #(nil? (subscribed-team conn)) 3000)))))))
|
|
|
|
(t/deftest a-false-check-closes-the-subscription
|
|
(let [{:keys [editor file]} (editor-in-team! 1 2)]
|
|
|
|
(with-redefs [cf/get (fn [k default]
|
|
(if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:millis 150})
|
|
default))]
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
(with-redefs [files/has-read-permissions? (fn [& _] false)]
|
|
(t/testing "a check that returns false closes it"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000))))))))
|
|
|
|
(t/deftest resubscribe-stops-previous-revalidation
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
file1 (th/create-file* 1 {:profile-id (:id profile)
|
|
:project-id (:default-project-id profile)})
|
|
file2 (th/create-file* 2 {:profile-id (:id profile)
|
|
:project-id (:default-project-id profile)})]
|
|
|
|
(with-redefs [cf/get (fn [k default]
|
|
(if (= :subscription-revalidation-interval k)
|
|
(ct/duration {:millis 150})
|
|
default))]
|
|
(let [counts (atom {})
|
|
real files/has-read-permissions?]
|
|
(with-redefs [files/has-read-permissions?
|
|
(fn [cfg pid fid]
|
|
(swap! counts update fid (fnil inc 0))
|
|
(real cfg pid fid))]
|
|
(let [conn (-> (open-registered-connection (:id profile))
|
|
(subscribe :subscribe-file {:file-id (:id file1)}))]
|
|
|
|
(t/testing "the first subscription is re-checked on the interval"
|
|
(t/is (wait-until #(pos? (get @counts (:id file1) 0)) 3000)))
|
|
|
|
(t/testing "resubscribing moves the relay to the new file"
|
|
(subscribe conn :subscribe-file {:file-id (:id file2)})
|
|
(t/is (wait-until #(>= (get @counts (:id file2) 0) 2) 3000)))
|
|
|
|
(t/testing "the previous subscription stops revalidating"
|
|
(let [old (get @counts (:id file1) 0)]
|
|
(Thread/sleep 400)
|
|
(t/is (= old (get @counts (:id file1) 0)))))))))))
|
|
|
|
;; --- EFFECT TESTS
|
|
;;
|
|
;; Announcing is not the same as revoking: these assert the subscription
|
|
;; actually drops and the content stops flowing.
|
|
|
|
(t/deftest deleting-a-file-closes-open-subscriptions
|
|
(let [{:keys [owner editor file]} (editor-in-team! 1 2)
|
|
publish (publisher!)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
out (:output conn)]
|
|
|
|
(th/command! {::th/type :delete-file
|
|
::rpc/profile-id (:id owner)
|
|
:id (:id file)})
|
|
|
|
(t/testing "the file subscription drops without any manual publish"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000)))
|
|
|
|
(t/testing "no file content reaches the client afterwards"
|
|
(publish (:id file) {:type :file-change :file-id (:id file) :revn 9})
|
|
(t/is (nil? (poll-msg! out :file-change revocation-timeout-ms)))))))
|
|
|
|
(t/deftest deleting-a-project-closes-open-subscriptions
|
|
(let [{:keys [owner editor file]} (editor-in-team! 1 2)
|
|
project-id (:project-id file)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))
|
|
out (:output conn)]
|
|
|
|
(th/command! {::th/type :delete-project
|
|
::rpc/profile-id (:id owner)
|
|
:id project-id})
|
|
|
|
(t/testing "the file subscription drops"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000)))
|
|
|
|
(t/testing "no file content reaches the client afterwards"
|
|
(mbus/pub! (::mbus/msgbus th/*system*)
|
|
:topic (:id file)
|
|
:message {:type :file-change :file-id (:id file) :revn 9})
|
|
(t/is (nil? (poll-msg! out :file-change revocation-timeout-ms)))))))
|
|
|
|
(t/deftest deleting-a-team-closes-open-subscriptions
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)})
|
|
(subscribe :subscribe-team {:team-id (:id team)}))]
|
|
|
|
(th/command! {::th/type :delete-team
|
|
::rpc/profile-id (:id owner)
|
|
:id (:id team)})
|
|
|
|
(t/testing "both subscriptions drop"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000))
|
|
(t/is (wait-until #(nil? (subscribed-team conn)) 3000))))))
|
|
|
|
(t/deftest moving-a-file-closes-source-team-subscriptions
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team-a (th/create-team* 1 {:profile-id (:id owner)})
|
|
team-b (th/create-team* 2 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team-a)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [project-a (th/create-project* 1 {:profile-id (:id owner)
|
|
:team-id (:id team-a)})
|
|
project-b (th/create-project* 2 {:profile-id (:id owner)
|
|
:team-id (:id team-b)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project-a)})
|
|
conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
(th/command! {::th/type :move-files
|
|
::rpc/profile-id (:id owner)
|
|
:ids #{(:id file)}
|
|
:project-id (:id project-b)})
|
|
|
|
(t/testing "a member left behind in the source team loses the subscription"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000))))))
|
|
|
|
(t/deftest moving-a-project-closes-source-team-subscriptions
|
|
(let [owner (th/create-profile* 1 {:is-active true})
|
|
editor (th/create-profile* 2 {:is-active true})
|
|
team-a (th/create-team* 1 {:profile-id (:id owner)})
|
|
team-b (th/create-team* 2 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id team-a)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [project-a (th/create-project* 1 {:profile-id (:id owner)
|
|
:team-id (:id team-a)})
|
|
project-b (th/create-project* 2 {:profile-id (:id owner)
|
|
:team-id (:id team-b)})
|
|
file (th/create-file* 1 {:profile-id (:id editor)
|
|
:project-id (:id project-a)})
|
|
conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)})
|
|
(subscribe :subscribe-team {:team-id (:id team-a)}))]
|
|
|
|
(th/command! {::th/type :move-project
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team-b)
|
|
:project-id (:id project-a)})
|
|
|
|
(t/testing "the file subscription drops: the file only lives in team-b now"
|
|
(t/is (wait-until #(nil? (subscribed-file conn)) 3000)))
|
|
|
|
(t/testing "the team subscription survives: the editor is still a member of team-a"
|
|
(t/is (= (:id team-a) (subscribed-team conn)))))))
|
|
|
|
(t/deftest close-team-subscription-is-idempotent
|
|
(let [profile (th/create-profile* 1 {:is-active true})
|
|
team (th/create-team* 1 {:profile-id (:id profile)})
|
|
other (th/create-team* 2 {:profile-id (:id profile)})
|
|
output (sp/chan :buf (sp/dropping-buffer 64))
|
|
relay (sp/chan :buf (sp/dropping-buffer 64))
|
|
ws-state (atom {::ws/team-subscription
|
|
{:team-id (:id team)
|
|
:channel relay
|
|
:topic (:id team)}})
|
|
wsp (assoc (make-wsp (:id profile) ws-state output)
|
|
::ws/state ws-state)]
|
|
|
|
(t/testing "closing a team the connection is not subscribed to does nothing"
|
|
(with-redefs [mbus/purge! (fn [& _] (throw ::unexpected-purge))]
|
|
(t/is (nil? (ws/close-team-subscription th/*system* wsp (:id other))))
|
|
(t/is (some? (::ws/team-subscription @ws-state)))))
|
|
|
|
(t/testing "closing the subscribed team purges the bus and the relay stops"
|
|
(let [purged (atom [])]
|
|
(with-redefs [mbus/purge! (fn [_ chans] (swap! purged conj chans))]
|
|
(ws/close-team-subscription th/*system* wsp (:id team))
|
|
(t/is (= 1 (count @purged)))))
|
|
(t/is (nil? (sp/poll! relay)))
|
|
(t/is (true? (sp/closed? relay))))
|
|
|
|
(t/testing "the subscription is forgotten, so closing again is a no-op"
|
|
(t/is (nil? (::ws/team-subscription @ws-state)))
|
|
(t/is (nil? (ws/close-team-subscription th/*system* wsp (:id team)))))))
|
|
|
|
(t/deftest losing-a-team-keeps-the-other-file-subscription
|
|
(let [{:keys [owner editor team]} (editor-in-team! 1 2)
|
|
other-team (th/create-team* 3 {:profile-id (:id owner)})]
|
|
(th/create-team-role* {:team-id (:id other-team)
|
|
:profile-id (:id editor)
|
|
:role :editor})
|
|
(let [other-project (th/create-project* 3 {:profile-id (:id editor)
|
|
:team-id (:id other-team)})
|
|
other-file (th/create-file* 3 {:profile-id (:id editor)
|
|
:project-id (:id other-project)})
|
|
conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-team {:team-id (:id team)})
|
|
(subscribe :subscribe-file {:file-id (:id other-file)}))]
|
|
|
|
(th/command! {::th/type :delete-team-member
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)})
|
|
|
|
(t/testing "the lost team subscription drops"
|
|
(t/is (wait-until #(nil? (subscribed-team conn)) 3000)))
|
|
|
|
(t/testing "the file subscription on the other team survives"
|
|
(t/is (some? (subscribed-file conn)))))))
|
|
|
|
;; The revocation watcher is the only integrant key here, so it is the
|
|
;; only one that compiles this schema at boot: a ref with no registered
|
|
;; schema crashes the boot with :malli.core/invalid-schema instead of
|
|
;; asserting. The test system builds the component, but assert-key only
|
|
;; runs its check with *assert* set, so pin the compilation here.
|
|
(t/deftest revocation-watcher-schema-resolves-every-ref
|
|
(t/testing "the schema compiles"
|
|
(t/is (sm/schema? (sm/schema @#'ws/schema:revocation-watcher))))
|
|
|
|
(t/testing "every ref the key injects is registered"
|
|
(t/is (= #{::db/pool ::mbus/msgbus}
|
|
(disj (set (sm/keys @#'ws/schema:revocation-watcher))
|
|
:app.nitrate/client))))
|
|
(t/testing "the nitrate client is optional, so a nil one passes"
|
|
(t/is (sm/valid? @#'ws/schema:revocation-watcher
|
|
{::db/pool (:app.db/pool th/*system*)
|
|
::mbus/msgbus (:app.msgbus/msgbus th/*system*)})))
|
|
(t/testing "a non-map nitrate client is rejected"
|
|
(t/is (not (sm/valid? @#'ws/schema:revocation-watcher
|
|
{::db/pool (:app.db/pool th/*system*)
|
|
::mbus/msgbus (:app.msgbus/msgbus th/*system*)
|
|
:app.nitrate/client "not-a-client"})))))
|
|
|
|
(t/deftest organization-owner-keeps-read-only-access
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
;; The admin-console flag is off in tests, so Nitrate never grants
|
|
;; this; stand in for an organization owner expelled from the team.
|
|
(with-redefs [nitrate/organization-owner-of-team? (fn [& _] true)]
|
|
(th/command! {::th/type :delete-team-member
|
|
::rpc/profile-id (:id owner)
|
|
:team-id (:id team)
|
|
:member-id (:id editor)})
|
|
|
|
(t/testing "revalidation closes nothing for an organization owner"
|
|
(t/is (zero? (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
|
|
(t/testing "the read-only subscription survives"
|
|
(t/is (some? (subscribed-file conn))))))))
|
|
|
|
(t/deftest soft-deleted-file-closes-org-owner-subscription
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
;; The admin-console flag is off in tests, so Nitrate never grants
|
|
;; this; stand in for an organization owner expelled from the team.
|
|
(with-redefs [nitrate/organization-owner-of-team? (fn [& _] true)]
|
|
;; Access is taken away the way an external change would take
|
|
;; it: a direct row soft-delete fires no command and publishes no
|
|
;; announcement. Membership SQL grants nothing through a deleted
|
|
;; file, but the org-owner fallback does not look at deleted_at,
|
|
;; so only the existence gate can close the subscription.
|
|
(db/update! th/*system* :file {:deleted-at (ct/now)} {:id (:id file)})
|
|
|
|
(t/testing "revalidation closes the subscription although Nitrate still grants read-only"
|
|
(t/is (= 1 (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
(t/testing "the read-only subscription is gone"
|
|
(t/is (nil? (subscribed-file conn))))))))
|
|
|
|
(t/deftest soft-deleted-team-closes-org-owner-subscription
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-team {:team-id (:id team)}))]
|
|
|
|
;; Same shape as the file case: the org-owner fallback grants
|
|
;; read-only access without looking at the team's deleted_at.
|
|
(with-redefs [nitrate/organization-owner-of-team? (fn [& _] true)]
|
|
(db/update! th/*system* :team {:deleted-at (ct/now)} {:id (:id team)})
|
|
|
|
(t/testing "revalidation closes the subscription although Nitrate still grants read-only"
|
|
(t/is (= 1 (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
(t/testing "the read-only subscription is gone"
|
|
(t/is (nil? (subscribed-team conn))))))))
|
|
|
|
(t/deftest soft-deleted-project-closes-org-owner-file-subscription
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
;; The admin-console flag is off in tests, so Nitrate never grants
|
|
;; this; stand in for an organization owner expelled from the team.
|
|
(with-redefs [nitrate/organization-owner-of-team? (fn [& _] true)]
|
|
;; A direct row soft-delete fires no command and publishes no
|
|
;; announcement. Membership SQL denies through a deleted project,
|
|
;; but the org-owner fallback resolves the team without any
|
|
;; deleted_at filter, so only the root fix can close the file
|
|
;; subscription.
|
|
(db/update! th/*system* :project {:deleted-at (ct/now)}
|
|
{:id (:project-id file)})
|
|
|
|
(t/testing "revalidation closes the file subscription although Nitrate still grants read-only"
|
|
(t/is (= 1 (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
(t/testing "the read-only subscription is gone"
|
|
(t/is (nil? (subscribed-file conn))))))))
|
|
|
|
(t/deftest soft-deleted-team-closes-org-owner-file-subscription
|
|
(let [{:keys [owner editor team file]} (editor-in-team! 1 2)]
|
|
|
|
(let [conn (-> (open-registered-connection (:id editor))
|
|
(subscribe :subscribe-file {:file-id (:id file)}))]
|
|
|
|
;; Same shape with the ancestor unavailable at the team level:
|
|
;; membership denies (t.deleted_at is null), the org-owner
|
|
;; fallback grants, and only resolve-team-id's team-row check
|
|
;; can close the file subscription.
|
|
(with-redefs [nitrate/organization-owner-of-team? (fn [& _] true)]
|
|
(db/update! th/*system* :team {:deleted-at (ct/now)} {:id (:id team)})
|
|
|
|
(t/testing "revalidation closes the file subscription although Nitrate still grants read-only"
|
|
(t/is (= 1 (ws/revalidate-profile-subscriptions
|
|
th/*system* (:id editor)))))
|
|
(t/testing "the read-only subscription is gone"
|
|
(t/is (nil? (subscribed-file conn))))))))
|