Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

GDGT-2558 move alerts management from EE to OSS (#75247)

Egor Grushincf2ba4502c8b
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index ebf776cc5d5..c5bc1c167ce 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -1397,6 +1397,7 @@
:uses #{analytics
analytics-interface
api
+ app-db
appearance
auth-identity
channel
@@ -1427,6 +1428,7 @@
:model/Dashboard
:model/DashboardCard
:model/DashboardTab
+ :model/TaskHistory
:model/User}}
oauth-server
@@ -3174,20 +3176,6 @@
util}
:model-imports #{:model/MetabotConversation :model/MetabotFeedback :model/MetabotMessage}}
- enterprise/notification-admin
- {:team "Gadget"
- :api #{metabase-enterprise.notification-admin.api}
- :uses #{api
- app-db
- models
- notification
- request
- util}
- :model-imports #{:model/Notification
- :model/NotificationHandler
- :model/NotificationRecipient
- :model/TaskHistory}}
-
enterprise/permission-debug
{:team "UX West"
:api #{metabase-enterprise.permission-debug.api}
diff --git a/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj b/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
index 17d56a2544a..9b068d27335 100644
--- a/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
+++ b/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
@@ -30,7 +30,6 @@
[metabase-enterprise.metabot-analytics.api]
[metabase-enterprise.metabot.api]
[metabase-enterprise.metabot.api.routes]
- [metabase-enterprise.notification-admin.api]
[metabase-enterprise.permission-debug.api]
[metabase-enterprise.remote-sync.api]
[metabase-enterprise.replacement.api]
@@ -133,7 +132,6 @@
"/logs" (premium-handler 'metabase-enterprise.advanced-config.api.logs :audit-app)
"/metabot" (premium-handler 'metabase-enterprise.metabot.api :metabot-v3)
"/metabot-analytics" (premium-handler metabase-enterprise.metabot-analytics.api/routes :audit-app)
- "/notifications" (premium-handler 'metabase-enterprise.notification-admin.api :audit-app)
"/permission_debug" (premium-handler metabase-enterprise.permission-debug.api/routes :advanced-permissions)
;; TODO (Ngoc 2026-03-25) -- use :transforms-advanced feature flag once it exists
"/transforms" (premium-handler metabase-enterprise.transforms.api/routes :transforms-python)
diff --git a/enterprise/backend/test/metabase_enterprise/notification_admin/api_test.clj b/enterprise/backend/test/metabase_enterprise/notification_admin/api_test.clj
deleted file mode 100644
index 50a77bb7e97..00000000000
--- a/enterprise/backend/test/metabase_enterprise/notification_admin/api_test.clj
+++ /dev/null
@@ -1,1638 +0,0 @@
-(ns metabase-enterprise.notification-admin.api-test
- (:require
- [clojure.test :refer :all]
- [java-time.api :as t]
- [metabase.test :as mt]
- [metabase.util :as u]
- [toucan2.core :as t2]))
-
-(deftest list-stub-returns-shape-test
- (testing "GET /api/ee/notifications returns :data + :total shape for superuser with :audit-app"
- (mt/with-premium-features #{:audit-app}
- (let [resp (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (contains? resp :data))
- (is (contains? resp :total))
- (is (sequential? (:data resp)))
- (is (integer? (:total resp)))))))
-
-(deftest requires-premium-feature-test
- (testing "GET /api/ee/notifications returns 402 without :audit-app premium feature"
- (mt/with-premium-features #{}
- (mt/assert-has-premium-feature-error
- "Audit app"
- (mt/user-http-request :crowberto :get 402 "ee/notifications")))))
-
-(deftest requires-superuser-test
- (testing "GET /api/ee/notifications returns 403 for non-superuser"
- (mt/with-premium-features #{:audit-app}
- (mt/user-http-request :rasta :get 403 "ee/notifications"))))
-
-(deftest list-returns-only-card-notifications-test
- (testing "GET /api/ee/notifications only returns :notification/card rows"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {ncard-id :id} {:card_id card-id}
- :model/Notification card-notif {:payload_type :notification/card
- :payload_id ncard-id
- :creator_id (mt/user->id :crowberto)}
- :model/Notification sys-notif {:payload_type :notification/system-event
- :creator_id (mt/user->id :crowberto)}]
- (let [{:keys [data total]} (mt/user-http-request :crowberto :get 200 "ee/notifications")
- ids (set (map :id data))]
- (is (contains? ids (:id card-notif)))
- (is (not (contains? ids (:id sys-notif))))
- (is (pos? total)))))))
-
-(deftest list-pagination-test
- (testing "limit + offset paginate the result"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification _n1 {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification _n2 {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}]
- (let [resp (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :limit 1 :offset 0)]
- (is (= 1 (count (:data resp))))
- (is (>= (:total resp) 2)))
- (let [resp (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :limit 100 :offset 0)]
- (is (>= (count (:data resp)) 2)))))))
-
-(deftest filter-by-active-test
- (testing "?active=true|false filters on the notification.active boolean; omitted = both"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification active-notif {:payload_type :notification/card
- :payload_id nc1
- :active true
- :creator_id (mt/user->id :crowberto)}
- :model/Notification archived-notif {:payload_type :notification/card
- :payload_id nc2
- :active false
- :creator_id (mt/user->id :crowberto)}]
- (testing "?active=true returns only active"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :active true)
- ids (set (map :id data))]
- (is (contains? ids (:id active-notif)))
- (is (not (contains? ids (:id archived-notif))))))
- (testing "?active=false returns only archived"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :active false)
- ids (set (map :id data))]
- (is (not (contains? ids (:id active-notif))))
- (is (contains? ids (:id archived-notif)))))
- (testing "omitting ?active returns both"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")
- ids (set (map :id data))]
- (is (contains? ids (:id active-notif)))
- (is (contains? ids (:id archived-notif)))))))))
-
-(deftest filter-by-owner-test
- (testing "creator_id filters to notifications owned by that user"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {user-a :id} {}
- :model/User {user-b :id} {}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification notif-a {:payload_type :notification/card
- :payload_id nc1
- :creator_id user-a}
- :model/Notification notif-b {:payload_type :notification/card
- :payload_id nc2
- :creator_id user-b}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :creator_id user-a)
- ids (set (map :id data))]
- (is (contains? ids (:id notif-a)))
- (is (not (contains? ids (:id notif-b)))))))))
-
-(deftest owner-includes-is-active-test
- (testing "the hydrated :creator map carries :is_active so FE can render the deactivated-owner state"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {active :id} {:is_active true}
- :model/User {deactivated :id} {:is_active false}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification {active-n :id} {:payload_type :notification/card
- :payload_id nc1
- :creator_id active}
- :model/Notification {deact-n :id} {:payload_type :notification/card
- :payload_id nc2
- :creator_id deactivated}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")
- by-id (into {} (map (juxt :id identity) data))]
- (is (=? {:creator {:id active :is_active true}} (by-id active-n)))
- (is (=? {:creator {:id deactivated :is_active false}} (by-id deact-n))))))))
-
-(deftest filter-by-owner-active-test
- (testing "?creator_active=true|false filters on the creator user's is_active flag"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {active :id} {:is_active true}
- :model/User {deactivated :id} {:is_active false}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification active-notif {:payload_type :notification/card
- :payload_id nc1
- :creator_id active}
- :model/Notification deact-notif {:payload_type :notification/card
- :payload_id nc2
- :creator_id deactivated}]
- (testing "creator_active=true keeps only notifications whose creator is active"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :creator_active true)
- ids (set (map :id data))]
- (is (contains? ids (:id active-notif)))
- (is (not (contains? ids (:id deact-notif))))))
- (testing "creator_active=false keeps only notifications whose creator is deactivated"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :creator_active false)
- ids (set (map :id data))]
- (is (contains? ids (:id deact-notif)))
- (is (not (contains? ids (:id active-notif))))))))))
-
-(deftest filter-by-card-test
- (testing "card_id filters to notifications whose notification_card.card_id matches"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {target-card :id} {}
- :model/Card {other-card :id} {}
- :model/NotificationCard {nc-target :id} {:card_id target-card}
- :model/NotificationCard {nc-other :id} {:card_id other-card}
- :model/Notification notif-target {:payload_type :notification/card
- :payload_id nc-target
- :creator_id (mt/user->id :crowberto)}
- :model/Notification notif-other {:payload_type :notification/card
- :payload_id nc-other
- :creator_id (mt/user->id :crowberto)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :card_id target-card)
- ids (set (map :id data))]
- (is (contains? ids (:id notif-target)))
- (is (not (contains? ids (:id notif-other)))))))))
-
-(deftest filter-by-channel-test
- (testing "channel filters to notifications with a matching handler channel_type"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification email-notif {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification slack-notif {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}
- :model/NotificationHandler _email-handler {:notification_id (:id email-notif)
- :channel_type :channel/email}
- :model/NotificationHandler _slack-handler {:notification_id (:id slack-notif)
- :channel_type :channel/slack}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :channel "channel/email")
- ids (set (map :id data))]
- (is (contains? ids (:id email-notif)))
- (is (not (contains? ids (:id slack-notif)))))))))
-
-(deftest filter-by-recipient-email-user-recipient-test
- (testing "recipient_email matches a user recipient via case-insensitive core_user.email"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {target-user :id
- target-email :email} {}
- :model/User {other-user :id} {}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification target-notif {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification other-notif {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}
- :model/NotificationHandler {target-handler :id} {:notification_id (:id target-notif)
- :channel_type :channel/email}
- :model/NotificationHandler {other-handler :id} {:notification_id (:id other-notif)
- :channel_type :channel/email}
- :model/NotificationRecipient _target-r {:notification_handler_id target-handler
- :type :notification-recipient/user
- :user_id target-user}
- :model/NotificationRecipient _other-r {:notification_handler_id other-handler
- :type :notification-recipient/user
- :user_id other-user}]
- (testing "exact (case-sensitive original)"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :recipient_email target-email)
- ids (set (map :id data))]
- (is (contains? ids (:id target-notif)))
- (is (not (contains? ids (:id other-notif))))))
- (testing "case-insensitive — uppercased query still matches a lowercased stored email"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :recipient_email (u/upper-case-en target-email))
- ids (set (map :id data))]
- (is (contains? ids (:id target-notif)))))))))
-
-(deftest filter-by-recipient-email-raw-value-test
- (testing "recipient_email also matches raw-value (external) recipients via the JSON details column"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification raw-notif {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification unrelated-notif {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}
- :model/NotificationHandler {raw-handler :id} {:notification_id (:id raw-notif)
- :channel_type :channel/email}
- :model/NotificationHandler {un-handler :id} {:notification_id (:id unrelated-notif)
- :channel_type :channel/email}
- :model/NotificationRecipient _raw-r {:notification_handler_id raw-handler
- :type :notification-recipient/raw-value
- :details {:value "[email protected]"}}
- :model/NotificationRecipient _other-raw {:notification_handler_id un-handler
- :type :notification-recipient/raw-value
- :details {:value "[email protected]"}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :recipient_email "[email protected]")
- ids (set (map :id data))]
- (is (contains? ids (:id raw-notif)))
- (is (not (contains? ids (:id unrelated-notif)))))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; Fuzzy ?query= search — matches card name + owner name/email only (recipients no longer)
-;; ---------------------------------------------------------------------------------------------
-
-(deftest query-matches-card-name-test
- (testing "?query= substring-matches the card name (case-insensitive)"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {sales :id} {:name "Sales report"}
- :model/Card {orders :id} {:name "Orders dashboard"}
- :model/NotificationCard {nc-sales :id} {:card_id sales}
- :model/NotificationCard {nc-orders :id} {:card_id orders}
- :model/Notification sales-n {:payload_type :notification/card
- :payload_id nc-sales
- :creator_id (mt/user->id :crowberto)}
- :model/Notification orders-n {:payload_type :notification/card
- :payload_id nc-orders
- :creator_id (mt/user->id :crowberto)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "SALES")
- ids (set (map :id data))]
- (is (contains? ids (:id sales-n)))
- (is (not (contains? ids (:id orders-n)))))))))
-
-(deftest query-matches-owner-name-test
- (testing "?query= substring-matches owner first/last/email"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {alice :id} {:first_name "Alice" :last_name "Stone"
- :email "[email protected]"}
- :model/User {bob :id} {:first_name "Bob" :last_name "Jones"
- :email "[email protected]"}
- :model/Card {card :id} {}
- :model/NotificationCard {nc-a :id} {:card_id card}
- :model/NotificationCard {nc-b :id} {:card_id card}
- :model/Notification alice-n {:payload_type :notification/card
- :payload_id nc-a
- :creator_id alice}
- :model/Notification bob-n {:payload_type :notification/card
- :payload_id nc-b
- :creator_id bob}]
- (testing "by first_name"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "alic")
- ids (set (map :id data))]
- (is (contains? ids (:id alice-n)))
- (is (not (contains? ids (:id bob-n))))))
- (testing "by last_name"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "stone")
- ids (set (map :id data))]
- (is (contains? ids (:id alice-n)))
- (is (not (contains? ids (:id bob-n))))))
- (testing "by email"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "bob@example")
- ids (set (map :id data))]
- (is (contains? ids (:id bob-n)))
- (is (not (contains? ids (:id alice-n))))))))))
-
-(deftest query-does-not-match-recipients-test
- (testing "?query= no longer descends into recipient emails or slack channels — only card + owner"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {recipient :id} {:email "[email protected]"}
- :model/Card {card :id} {:name "Innocuous card"}
- :model/NotificationCard {nc-user :id} {:card_id card}
- :model/NotificationCard {nc-raw :id} {:card_id card}
- :model/NotificationCard {nc-slack :id} {:card_id card}
- :model/Notification user-recipient-n {:payload_type :notification/card
- :payload_id nc-user
- :creator_id (mt/user->id :crowberto)}
- :model/Notification raw-recipient-n {:payload_type :notification/card
- :payload_id nc-raw
- :creator_id (mt/user->id :crowberto)}
- :model/Notification slack-recipient-n {:payload_type :notification/card
- :payload_id nc-slack
- :creator_id (mt/user->id :crowberto)}
- :model/NotificationHandler {h-user :id} {:notification_id (:id user-recipient-n)
- :channel_type :channel/email}
- :model/NotificationHandler {h-raw :id} {:notification_id (:id raw-recipient-n)
- :channel_type :channel/email}
- :model/NotificationHandler {h-slack :id} {:notification_id (:id slack-recipient-n)
- :channel_type :channel/slack}
- :model/NotificationRecipient _r-user {:notification_handler_id h-user
- :type :notification-recipient/user
- :user_id recipient}
- :model/NotificationRecipient _r-raw {:notification_handler_id h-raw
- :type :notification-recipient/raw-value
- :details {:value "[email protected]"}}
- :model/NotificationRecipient _r-slack {:notification_handler_id h-slack
- :type :notification-recipient/raw-value
- :details {:value "#fuzzy-channel"}}]
- (testing "user-recipient email is NOT matched by ?query="
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "unique-domain")
- ids (set (map :id data))]
- (is (not (contains? ids (:id user-recipient-n))))))
- (testing "raw-value email recipient is NOT matched by ?query="
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "fuzzy-target")
- ids (set (map :id data))]
- (is (not (contains? ids (:id raw-recipient-n))))))
- (testing "slack-channel raw-value recipient is NOT matched by ?query="
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "fuzzy-channel")
- ids (set (map :id data))]
- (is (not (contains? ids (:id slack-recipient-n))))))))))
-
-(deftest query-and-other-filters-and-together-test
- (testing "?query= AND'd with other filters; structured filters narrow the fuzzy result"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card :id} {:name "Quarterly fizzbuzz"}
- :model/NotificationCard {nc-a :id} {:card_id card}
- :model/NotificationCard {nc-b :id} {:card_id card}
- :model/Notification active-match {:payload_type :notification/card
- :payload_id nc-a
- :active true
- :creator_id (mt/user->id :crowberto)}
- :model/Notification archived-match {:payload_type :notification/card
- :payload_id nc-b
- :active false
- :creator_id (mt/user->id :crowberto)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :query "fizzbuzz"
- :active true)
- ids (set (map :id data))]
- (is (contains? ids (:id active-match)))
- (is (not (contains? ids (:id archived-match)))))))))
-
-(defn- find-row-by-id [data id]
- (some #(when (= id (:id %)) %) data))
-
-;; ---------------------------------------------------------------------------------------------
-;; :last_check / :last_send shape
-;; ---------------------------------------------------------------------------------------------
-
-(deftest last-send-from-channel-send-task-history-test
- (testing ":last_send reflects the latest channel-send task_history row (any outcome)"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-a :id} {:archived false}
- :model/Card {card-b :id} {:archived false}
- :model/NotificationCard {nc-a :id} {:card_id card-a}
- :model/NotificationCard {nc-b :id} {:card_id card-b}
- :model/Notification {n-sent :id} {:payload_type :notification/card
- :payload_id nc-a
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {n-unsent :id} {:payload_type :notification/card
- :payload_id nc-b
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-a
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _th {:task "channel-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"
- :notification_id (:id n-sent)}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")
- by-id (into {} (map (juxt :id identity) data))]
- (is (=? {:last_send {:at some?
- :status "successful"
- :error nil}}
- (by-id n-sent)))
- (is (=? {:last_send nil}
- (by-id n-unsent))))))))
-
-(deftest last-send-failing-channel-send-surfaces-status-and-error-test
- (testing ":last_send on the list shows :failing status AND the channel-send error message
- when the latest send-tick had a channel failure"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:message "SMTP connection refused"
- :channel_type "channel/email"
- :notification_id nid}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_send {:at some?
- :status "failing"
- :error "SMTP connection refused"}}
- (find-row-by-id data nid))))))))
-
-(deftest last-check-shape-success-test
- (testing ":last_check on a successful run reports status=successful with no error"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun _run {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check {:at some?
- :status "successful"
- :error nil}}
- (find-row-by-id data nid))))))))
-
-(deftest last-check-shape-failing-includes-error-test
- (testing ":last_check on a failed run reports status=failing and pulls the error from task_history"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _th {:task "notification-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:message "SMTP host unreachable"}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check {:at some?
- :status "failing"
- :error "SMTP host unreachable"}}
- (find-row-by-id data nid))))))))
-
-(deftest last-send-shape-failing-includes-error-test
- (testing ":last_send on the list endpoint surfaces the channel-send error message (not just status=failing)"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- ;; Outer notification-send succeeded; only the channel-send failed.
- :model/TaskHistory _ns-th {:task "notification-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:notification_id nid}}
- :model/TaskHistory _cs-th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:status :failed
- :message "Slack token invalid"
- :original-info {:channel_type "channel/slack"
- :notification_id nid}}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_send {:at some?
- :status "failing"
- :error "Slack token invalid"}}
- (find-row-by-id data nid))))))))
-
-(deftest last-check-abandoned-folds-into-failing-test
- (testing ":abandoned (heartbeat-killed) runs surface as last_check.status=failing"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun _run {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :abandoned
- :started_at (t/instant)
- :ended_at (t/instant)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check {:status "failing"}}
- (find-row-by-id data nid))))))))
-
-(deftest last-check-skips-in-flight-runs-test
- (testing "an :started in-flight run is invisible to the admin list — last_check stays nil"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun _run {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :started
- :started_at (t/instant)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check nil
- :last_send nil}
- (find-row-by-id data nid))))))))
-
-(deftest response-shape-includes-pagination-metadata-test
- (testing "GET / response shape echoes the {:data :total :limit :offset} pagination convention"
- (mt/with-premium-features #{:audit-app}
- (let [resp (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (contains? resp :data))
- (is (contains? resp :total))
- (is (contains? resp :limit))
- (is (contains? resp :offset))))))
-
-(deftest response-shape-does-not-include-counts-test
- (testing "GET / response does NOT include a :counts key — tab counts are dropped"
- (mt/with-premium-features #{:audit-app}
- (let [resp (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (not (contains? resp :counts)))))))
-
-(deftest filter-by-last-send-status-test
- (testing "?last_send_status=successful|failing filters by the latest channel-send outcome"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {success-card :id} {:archived false}
- :model/Card {fail-card :id} {:archived false}
- :model/Card {no-send-card :id} {:archived false}
- :model/NotificationCard {nc-success :id} {:card_id success-card}
- :model/NotificationCard {nc-fail :id} {:card_id fail-card}
- :model/NotificationCard {nc-no-send :id} {:card_id no-send-card}
- :model/Notification success-n {:payload_type :notification/card
- :payload_id nc-success
- :creator_id (mt/user->id :crowberto)}
- :model/Notification fail-n {:payload_type :notification/card
- :payload_id nc-fail
- :creator_id (mt/user->id :crowberto)}
- :model/Notification no-send-n {:payload_type :notification/card
- :payload_id nc-no-send
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {ok-run :id} {:run_type :alert
- :entity_type :card
- :entity_id success-card
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskRun {fail-run :id} {:run_type :alert
- :entity_type :card
- :entity_id fail-card
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- ;; channel-send rows drive the filter
- :model/TaskHistory _ok-th {:task "channel-send"
- :run_id ok-run
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"}}
- :model/TaskHistory _fail-th {:task "channel-send"
- :run_id fail-run
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"}}]
- (testing "successful"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :last_send_status "successful")
- ids (set (map :id data))]
- (is (contains? ids (:id success-n)))
- (is (not (contains? ids (:id fail-n))))
- (is (not (contains? ids (:id no-send-n))))))
- (testing "failing"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :last_send_status "failing")
- ids (set (map :id data))]
- (is (contains? ids (:id fail-n)))
- (is (not (contains? ids (:id success-n))))
- (is (not (contains? ids (:id no-send-n))))))))))
-
-(deftest filter-compound-test
- (testing "multiple filters AND together (active + owner_id)"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {target-user :id} {}
- :model/User {other-user :id} {}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/NotificationCard {nc3 :id} {:card_id card-id}
- :model/Notification matching {:payload_type :notification/card
- :payload_id nc1
- :active true
- :creator_id target-user}
- :model/Notification wrong-active {:payload_type :notification/card
- :payload_id nc2
- :active false
- :creator_id target-user}
- :model/Notification wrong-owner {:payload_type :notification/card
- :payload_id nc3
- :active true
- :creator_id other-user}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :active true
- :creator_id target-user)
- ids (set (map :id data))]
- (is (contains? ids (:id matching)))
- (is (not (contains? ids (:id wrong-active))))
- (is (not (contains? ids (:id wrong-owner)))))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; Sort
-;; ---------------------------------------------------------------------------------------------
-
-(deftest sort-by-last-send-test
- (testing "?sort_column=last_send orders rows by the latest channel-send started_at"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-old :id} {:archived false}
- :model/Card {card-new :id} {:archived false}
- :model/Card {card-never :id} {:archived false}
- :model/NotificationCard {nc-old :id} {:card_id card-old}
- :model/NotificationCard {nc-new :id} {:card_id card-new}
- :model/NotificationCard {nc-never :id} {:card_id card-never}
- :model/Notification {old-id :id} {:payload_type :notification/card
- :payload_id nc-old
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {new-id :id} {:payload_type :notification/card
- :payload_id nc-new
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {never-id :id} {:payload_type :notification/card
- :payload_id nc-never
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {old-run :id} {:run_type :alert
- :entity_type :card
- :entity_id card-old
- :status :success
- :started_at (t/minus (t/instant) (t/days 5))
- :ended_at (t/minus (t/instant) (t/days 5))}
- :model/TaskRun {new-run :id} {:run_type :alert
- :entity_type :card
- :entity_id card-new
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _old-th {:task "channel-send"
- :run_id old-run
- :status :success
- :started_at (t/minus (t/instant) (t/days 5))
- :ended_at (t/minus (t/instant) (t/days 5))
- :task_details {:channel_type "channel/email"}}
- :model/TaskHistory _new-th {:task "channel-send"
- :run_id new-run
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "last_send"
- :sort_direction "desc")
- ids (->> data (map :id) (filter #{old-id new-id never-id}) vec)]
- (is (= [new-id old-id never-id] ids)
- "newest-sent first, oldest-sent next, never-sent last (desc + null-trailing)"))))))
-
-(deftest sort-by-updated-at-test
- (testing "?sort_column=updated_at orders rows by notification.updated_at"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification n-older {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)
- :updated_at (t/minus (t/instant) (t/days 2))}
- :model/Notification n-newer {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)
- :updated_at (t/instant)}]
- (testing "desc puts newer first"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "updated_at"
- :sort_direction "desc")
- seen (->> data (map :id) (filter #{(:id n-older) (:id n-newer)}) vec)]
- (is (= [(:id n-newer) (:id n-older)] seen))))
- (testing "asc puts older first"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "updated_at"
- :sort_direction "asc")
- seen (->> data (map :id) (filter #{(:id n-older) (:id n-newer)}) vec)]
- (is (= [(:id n-older) (:id n-newer)] seen))))))))
-
-(deftest sort-rejects-unknown-column-test
- (testing "?sort_column=<unknown> is rejected with 400 by the malli enum"
- (mt/with-premium-features #{:audit-app}
- (mt/user-http-request :crowberto :get 400 "ee/notifications"
- :sort_column "name; DROP TABLE notification"))))
-
-(deftest default-sort-is-last-send-test
- (testing "default sort_column is :last_send (null-trailing desc), driven by channel-send rows"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-sent :id} {:archived false}
- :model/Card {card-unsent :id} {:archived false}
- :model/NotificationCard {nc-sent :id} {:card_id card-sent}
- :model/NotificationCard {nc-unsent :id} {:card_id card-unsent}
- :model/Notification {sent-id :id} {:payload_type :notification/card
- :payload_id nc-sent
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {unsent-id :id} {:payload_type :notification/card
- :payload_id nc-unsent
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-sent
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _th {:task "channel-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")
- ids (->> data (map :id) (filter #{sent-id unsent-id}) vec)]
- (is (= [sent-id unsent-id] ids)
- "notification with a last_send appears before the never-sent one under the default sort"))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; POST /bulk
-;; ---------------------------------------------------------------------------------------------
-
-(deftest bulk-archive-test
- (testing "POST /bulk with action=archive flips :active to false for each id"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification n1 {:payload_type :notification/card
- :payload_id nc1
- :active true
- :creator_id (mt/user->id :crowberto)}
- :model/Notification n2 {:payload_type :notification/card
- :payload_id nc2
- :active true
- :creator_id (mt/user->id :crowberto)}]
- (let [resp (mt/user-http-request :crowberto :post 200 "ee/notifications/bulk"
- {:notification_ids [(:id n1) (:id n2)]
- :action "archive"})]
- (is (= 2 (:updated resp)))
- (is (false? (t2/select-one-fn :active :model/Notification (:id n1))))
- (is (false? (t2/select-one-fn :active :model/Notification (:id n2))))
- (testing "publishes :event/notification-update per notification so the admin action is audited"
- (doseq [n [n1 n2]]
- (is (= {:topic :notification-update
- :user_id (mt/user->id :crowberto)
- :model "Notification"
- :model_id (:id n)
- :details {:previous {:active true}
- :new {:active false}}}
- (mt/latest-audit-log-entry :notification-update (:id n)))))))))))
-
-(deftest bulk-change-owner-test
- (testing "POST /bulk with action=change-creator sets :creator_id to creator_id for each id"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {new-owner :id} {}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/Notification n1 {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :rasta)}]
- (mt/user-http-request :crowberto :post 200 "ee/notifications/bulk"
- {:notification_ids [(:id n1)]
- :action "change-creator"
- :creator_id new-owner})
- (is (= new-owner (t2/select-one-fn :creator_id :model/Notification (:id n1))))))))
-
-(deftest bulk-change-owner-requires-owner-id-test
- (testing "POST /bulk with action=change-creator and no creator_id returns 400"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/Notification n1 {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}]
- (mt/user-http-request :crowberto :post 400 "ee/notifications/bulk"
- {:notification_ids [(:id n1)]
- :action "change-creator"})))))
-
-;; ---------------------------------------------------------------------------------------------
-;; Auth + feature-flag gating for POST /bulk (mirrors the GET triad above)
-;; ---------------------------------------------------------------------------------------------
-
-(deftest bulk-requires-premium-feature-test
- (testing "POST /api/ee/notifications/bulk returns 402 without :audit-app premium feature"
- (mt/with-premium-features #{}
- (mt/assert-has-premium-feature-error
- "Audit app"
- (mt/user-http-request :crowberto :post 402 "ee/notifications/bulk"
- {:notification_ids [1]
- :action "archive"})))))
-
-(deftest bulk-requires-superuser-test
- (testing "POST /api/ee/notifications/bulk returns 403 for non-superuser"
- (mt/with-premium-features #{:audit-app}
- (mt/user-http-request :rasta :post 403 "ee/notifications/bulk"
- {:notification_ids [1]
- :action "archive"}))))
-
-(deftest bulk-happy-path-test
- (testing "POST /api/ee/notifications/bulk returns 200 + :updated for superuser with premium"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification n {:payload_type :notification/card
- :payload_id nc
- :active true
- :creator_id (mt/user->id :crowberto)}]
- (let [resp (mt/user-http-request :crowberto :post 200 "ee/notifications/bulk"
- {:notification_ids [(:id n)]
- :action "archive"})]
- (is (= 1 (:updated resp))))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; GET /:id detail endpoint
-;; ---------------------------------------------------------------------------------------------
-
-(deftest detail-returns-notification-with-run-summaries-test
- (testing "GET /:id returns the hydrated notification with :last_check / :last_send slots and creator_id"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}]
- (is (=? {:id nid
- :creator_id (mt/user->id :crowberto)
- :last_check any?
- :last_send any?}
- (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))))))))
-
-(deftest detail-404-for-missing-id-test
- (testing "GET /:id returns 404 for a non-existent notification id"
- (mt/with-premium-features #{:audit-app}
- (let [max-id (or (t2/select-one-fn :id :model/Notification {:order-by [[:id :desc]]}) 0)]
- (mt/user-http-request :crowberto :get 404
- (str "ee/notifications/" (+ max-id 100000)))))))
-
-(deftest detail-404-for-non-card-notification-test
- (testing "GET /:id returns 404 when the notification exists but isn't a :notification/card"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Notification {nid :id} {:payload_type :notification/system-event
- :creator_id (mt/user->id :crowberto)}]
- (mt/user-http-request :crowberto :get 404 (str "ee/notifications/" nid))))))
-
-(deftest detail-requires-premium-feature-test
- (testing "GET /:id returns 402 without :audit-app premium feature"
- (mt/with-premium-features #{}
- (mt/assert-has-premium-feature-error
- "Audit app"
- (mt/user-http-request :crowberto :get 402 "ee/notifications/1")))))
-
-(deftest detail-requires-superuser-test
- (testing "GET /:id returns 403 for a non-superuser"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}]
- (mt/user-http-request :rasta :get 403 (str "ee/notifications/" nid))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; B. Ownerless filter
-;; ---------------------------------------------------------------------------------------------
-
-(deftest filter-by-ownerless-true-test
- (testing "?creatorless=true includes notifications with a deactivated creator and excludes active owners"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {active-user :id} {:is_active true}
- :model/User {deact-user :id} {:is_active false}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification active-owner-n {:payload_type :notification/card
- :payload_id nc1
- :creator_id active-user}
- :model/Notification deact-owner-n {:payload_type :notification/card
- :payload_id nc2
- :creator_id deact-user}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :creatorless true)
- ids (set (map :id data))]
- (is (contains? ids (:id deact-owner-n))
- "deactivated creator = ownerless")
- (is (not (contains? ids (:id active-owner-n)))
- "active owner is excluded"))))))
-
-(deftest filter-by-ownerless-false-test
- (testing "?creatorless=false includes only notifications with an active owner"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/User {active-user :id} {:is_active true}
- :model/User {deact-user :id} {:is_active false}
- :model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification active-owner-n {:payload_type :notification/card
- :payload_id nc1
- :creator_id active-user}
- :model/Notification deact-owner-n {:payload_type :notification/card
- :payload_id nc2
- :creator_id deact-user}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :creatorless false)
- ids (set (map :id data))]
- (is (contains? ids (:id active-owner-n))
- "active owner is included")
- (is (not (contains? ids (:id deact-owner-n)))
- "deactivated owner is excluded"))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; C. Multi-value channel filter
-;; ---------------------------------------------------------------------------------------------
-
-(deftest filter-by-channel-multi-value-test
- (testing "?channel= accepts multiple values (OR semantics across channel types)"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/NotificationCard {nc3 :id} {:card_id card-id}
- :model/Notification email-notif {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification slack-notif {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}
- :model/Notification other-notif {:payload_type :notification/card
- :payload_id nc3
- :creator_id (mt/user->id :crowberto)}
- :model/NotificationHandler _email-handler {:notification_id (:id email-notif)
- :channel_type :channel/email}
- :model/NotificationHandler _slack-handler {:notification_id (:id slack-notif)
- :channel_type :channel/slack}]
- (testing "single channel still works"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :channel "channel/email")
- ids (set (map :id data))]
- (is (contains? ids (:id email-notif)))
- (is (not (contains? ids (:id slack-notif))))
- (is (not (contains? ids (:id other-notif))))))
- (testing "multiple channels (vector) returns union"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :channel ["channel/email" "channel/slack"])
- ids (set (map :id data))]
- (is (contains? ids (:id email-notif)))
- (is (contains? ids (:id slack-notif)))
- (is (not (contains? ids (:id other-notif))))))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; D. New sort columns + default sort
-;; ---------------------------------------------------------------------------------------------
-
-(deftest sort-by-last-check-test
- (testing "?sort_column=last_check orders rows by the latest task_run started_at"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-old :id} {:archived false}
- :model/Card {card-new :id} {:archived false}
- :model/Card {card-never :id} {:archived false}
- :model/NotificationCard {nc-old :id} {:card_id card-old}
- :model/NotificationCard {nc-new :id} {:card_id card-new}
- :model/NotificationCard {nc-never :id} {:card_id card-never}
- :model/Notification {old-id :id} {:payload_type :notification/card
- :payload_id nc-old
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {new-id :id} {:payload_type :notification/card
- :payload_id nc-new
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {never-id :id} {:payload_type :notification/card
- :payload_id nc-never
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun _old-run {:run_type :alert
- :entity_type :card
- :entity_id card-old
- :status :failed
- :started_at (t/minus (t/instant) (t/days 5))
- :ended_at (t/minus (t/instant) (t/days 5))}
- :model/TaskRun _new-run {:run_type :alert
- :entity_type :card
- :entity_id card-new
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "last_check"
- :sort_direction "desc")
- ids (->> data (map :id) (filter #{old-id new-id never-id}) vec)]
- (is (= [new-id old-id never-id] ids)
- "newest-checked first, oldest-checked next, never-checked last (nulls trailing)"))))))
-
-(deftest sort-by-id-test
- (testing "?sort_column=id orders rows by notification.id"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc1 :id} {:card_id card-id}
- :model/NotificationCard {nc2 :id} {:card_id card-id}
- :model/Notification {n1 :id} {:payload_type :notification/card
- :payload_id nc1
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {n2 :id} {:payload_type :notification/card
- :payload_id nc2
- :creator_id (mt/user->id :crowberto)}]
- (testing "asc puts smaller id first"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "id"
- :sort_direction "asc")
- seen (->> data (map :id) (filter #{n1 n2}) vec)]
- (is (= [(min n1 n2) (max n1 n2)] seen))))
- (testing "desc puts larger id first"
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications"
- :sort_column "id"
- :sort_direction "desc")
- seen (->> data (map :id) (filter #{n1 n2}) vec)]
- (is (= [(max n1 n2) (min n1 n2)] seen))))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; E. check_history / send_history in the detail endpoint
-;; ---------------------------------------------------------------------------------------------
-
-(deftest detail-includes-check-history-test
- (testing "GET /:id includes :check_history — up to 10 most-recent terminal runs for THIS notification, newest first"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {r1 :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))}
- :model/TaskRun {r2 :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))}
- ;; notification-send rows with notification_id — required for per-notification filter
- :model/TaskHistory _th1 {:task "notification-send"
- :run_id r1
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))
- :task_details {:notification_id nid}}
- :model/TaskHistory _th2 {:task "notification-send"
- :run_id r2
- :status :failed
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:notification_id nid
- :message "Connection refused"}}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))
- check-history (:check_history resp)]
- (is (sequential? check-history))
- (is (= 2 (count check-history))
- "two terminal runs for this notification, newest first")
- (is (=? {:status "failing" :error "Connection refused"} (first check-history))
- "most-recent (the failed one) is first")
- (is (=? {:status "successful" :error nil} (second check-history))
- "older successful run is second"))))))
-
-(deftest detail-includes-send-history-test
- (testing "GET /:id includes :send_history — per-tick rollup, newest tick first, with :channels breakdown"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-ok :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))}
- :model/TaskRun {run-fail :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))}
- :model/TaskHistory _ok-th {:task "channel-send"
- :run_id run-ok
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))
- :task_details {:channel_type "channel/email"
- :notification_id nid}}
- :model/TaskHistory _fail-th {:task "channel-send"
- :run_id run-fail
- :status :failed
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:channel_type "channel/slack"
- :message "Slack token invalid"
- :notification_id nid}}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))
- send-history (:send_history resp)]
- (is (sequential? send-history))
- (is (= 2 (count send-history))
- "two ticks (one channel-send each)")
- (testing "most-recent tick (failed slack) is first"
- (is (=? {:status "failing"
- :error "Slack token invalid"
- :channels [{:channel_type "channel/slack"
- :status "failing"
- :error "Slack token invalid"}]}
- (first send-history))))
- (testing "older successful email tick is second"
- (is (=? {:status "successful"
- :error nil
- :channels [{:channel_type "channel/email"
- :status "successful"
- :error nil}]}
- (second send-history)))))))))
-
-(deftest detail-surfaces-history-when-task-details-failure-wrapped-test
- (testing "GET /:id surfaces last_check/last_send/error for ticks whose task_details is wrapped by with-task-history's failure handler"
- ;; Regression: `metabase.task_history/do-with-task-history` rewrites task_details on exception as
- ;; `{:status :failed :message ... :original-info <caller-task_details>}`. The per-notification
- ;; filter has to look in both the top level (success rows) and `:original-info` (failure rows),
- ;; or failing ticks silently disappear from the detail histories and `last_check`/`last_send`
- ;; come back nil — even though the list endpoint shows the notification as failing.
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- ;; notification-send: failure-wrapped (notification_id only under :original-info)
- :model/TaskHistory _ns-th {:task "notification-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:status :failed
- :message "Notification handler exploded"
- :original-info {:notification_id nid}}}
- ;; channel-send: failure-wrapped (channel_type + notification_id only under :original-info)
- :model/TaskHistory _cs-th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:status :failed
- :message "Slack token invalid"
- :original-info {:channel_type "channel/slack"
- :notification_id nid}}}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))]
- (testing "check_history surfaces the failed notification-send tick + its error"
- (is (=? [{:status "failing" :error "Notification handler exploded"}]
- (:check_history resp))))
- (testing "send_history surfaces the failed channel-send tick + its error and channel type"
- (is (=? [{:status "failing"
- :error "Slack token invalid"
- :channels [{:channel_type "channel/slack"
- :status "failing"
- :error "Slack token invalid"}]}]
- (:send_history resp))))
- (testing "last_check and last_send are derived from those histories"
- (is (=? {:status "failing" :error "Notification handler exploded"}
- (:last_check resp)))
- (is (=? {:status "failing" :error "Slack token invalid"}
- (:last_send resp)))))))))
-
-(deftest list-last-check-surfaces-channel-error-when-outer-send-succeeded-test
- (testing "list endpoint last_check.error surfaces the channel-send error when the outer notification-send succeeded but a channel failed"
- ;; Regression: `complete-task-run!` derives task_run.status as :failed when ANY child task is
- ;; not :success — so a tick where notification-send succeeded but a channel-send failed has
- ;; task_run.status = :failed. `error-by-run-id` must surface the channel-send's message in
- ;; that case (no notification-send failure row exists). If it filtered to notification-send
- ;; only, last_check would show status:failing error:nil for the Failing tab.
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- ;; Outer notification-send: succeeded
- :model/TaskHistory _ns-th {:task "notification-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:notification_id nid}}
- ;; Channel-send: failed (failure-wrapped task_details)
- :model/TaskHistory _cs-th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:status :failed
- :message "Slack token invalid"
- :original-info {:channel_type "channel/slack"
- :notification_id nid}}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check {:status "failing" :error "Slack token invalid"}}
- (find-row-by-id data nid))))))))
-
-(deftest list-last-check-prefers-outer-notification-send-error-test
- (testing "when both notification-send and channel-send failed in one run, last_check.error prefers the outer notification-send message"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _ns-th {:task "notification-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:message "Payload generation failed"}}
- :model/TaskHistory _cs-th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:message "Slack token invalid"}}]
- (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "ee/notifications")]
- (is (=? {:last_check {:status "failing" :error "Payload generation failed"}}
- (find-row-by-id data nid))
- "outer notification-send error wins over inner channel-send error"))))))
-
-(deftest detail-send-history-multi-channel-tick-test
- (testing "GET /:id: one tick with email+slack both succeeding → ONE send entry, status successful"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _email-th {:task "channel-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"
- :notification_id nid}}
- :model/TaskHistory _slack-th {:task "channel-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/slack"
- :notification_id nid}}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))
- send-history (:send_history resp)]
- (is (= 1 (count send-history))
- "two channels in the same tick collapse to ONE send entry")
- (is (=? {:status "successful"
- :error nil
- :channels [{:channel_type "channel/email" :status "successful"}
- {:channel_type "channel/slack" :status "successful"}]}
- (first send-history))))))))
-
-(deftest detail-send-history-mixed-channels-test
- (testing "GET /:id: one tick with email success + slack failure → failing, :channels shows both"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/TaskRun {run-id :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _email-th {:task "channel-send"
- :run_id run-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"
- :notification_id nid}}
- :model/TaskHistory _slack-th {:task "channel-send"
- :run_id run-id
- :status :failed
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/slack"
- :message "Rate limited"
- :notification_id nid}}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))
- entry (first (:send_history resp))]
- (is (= 1 (count (:send_history resp)))
- "two channels in the same tick → ONE send entry")
- (is (=? {:status "failing" :error "Rate limited"} entry))
- (is (= 2 (count (:channels entry)))
- "channels breakdown has one entry per channel-send row")
- (let [by-type (into {} (map (juxt :channel_type identity) (:channels entry)))]
- (is (=? {:status "successful"} (get by-type "channel/email")))
- (is (=? {:status "failing" :error "Rate limited"} (get by-type "channel/slack")))))))))
-
-(deftest detail-check-history-empty-when-no-runs-test
- (testing "GET /:id returns :check_history as empty vector when no terminal runs exist"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}]
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))]
- (is (= [] (:check_history resp)))
- (is (= [] (:send_history resp))))))))
-
-(deftest detail-check-history-respects-limit-test
- (testing "GET /:id returns at most 10 runs in :check_history"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}]
- ;; create 12 runs, each with a matching notification-send row so the per-notification filter passes
- (doseq [i (range 12)]
- (let [run-id (t2/insert-returning-pk! :model/TaskRun
- {:run_type "alert"
- :entity_type "card"
- :entity_id card-id
- :status "success"
- :started_at (t/minus (t/instant) (t/hours (inc i)))
- :ended_at (t/minus (t/instant) (t/hours (inc i)))
- :process_uuid "test"})]
- (t2/insert! :model/TaskHistory
- {:task "notification-send"
- :run_id run-id
- :status "success"
- :started_at (t/minus (t/instant) (t/hours (inc i)))
- :ended_at (t/minus (t/instant) (t/hours (inc i)))
- :task_details (str "{\"notification_id\":" nid "}")})))
- (let [resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))]
- (is (<= (count (:check_history resp)) 10)))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; F. creator_id (owner) cannot be reassigned via the public PUT endpoint — only via POST /bulk
-;; ---------------------------------------------------------------------------------------------
-
-(deftest put-creator-id-superuser-only-test
- (testing "PUT /api/notification/:id: superusers can reassign owner; non-superusers get a 400"
- (mt/with-temp [:model/Card {card-id :id} {}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :rasta)}]
- (testing "non-superuser (the current owner) is forbidden from reassigning (403 from mi/can-update?)"
- (let [notification (mt/user-http-request :rasta :get 200 (format "notification/%d" nid))]
- (mt/user-http-request :rasta :put 403 (format "notification/%d" nid)
- (assoc notification :creator_id (mt/user->id :lucky)))
- (is (= (mt/user->id :rasta)
- (t2/select-one-fn :creator_id :model/Notification nid))
- "owner unchanged after non-superuser attempt")))
- (testing "superuser can reassign owner"
- (let [notification (mt/user-http-request :crowberto :get 200 (format "notification/%d" nid))]
- (mt/user-http-request :crowberto :put 200 (format "notification/%d" nid)
- (assoc notification :creator_id (mt/user->id :lucky)))
- (is (= (mt/user->id :lucky)
- (t2/select-one-fn :creator_id :model/Notification nid))
- "owner reassigned after superuser PUT"))))))
-
-;; ---------------------------------------------------------------------------------------------
-;; Per-notification isolation — two notifications on the same card
-;; ---------------------------------------------------------------------------------------------
-
-(deftest detail-per-notification-isolation-test
- (testing "Two notifications on the same card each see only their own ticks in check_history and send_history"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- ;; Two distinct notifications sharing the same card
- :model/Notification {n1 :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {n2 :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- ;; tick-A: fires for n1 only
- :model/TaskRun {run-a :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))}
- :model/TaskHistory _ns-a {:task "notification-send"
- :run_id run-a
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))
- :task_details {:notification_id n1}}
- :model/TaskHistory _cs-a {:task "channel-send"
- :run_id run-a
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))
- :task_details {:channel_type "channel/email"
- :notification_id n1}}
- ;; tick-B: fires for n2 only
- :model/TaskRun {run-b :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))}
- :model/TaskHistory _ns-b {:task "notification-send"
- :run_id run-b
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:notification_id n2}}
- :model/TaskHistory _cs-b {:task "channel-send"
- :run_id run-b
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:channel_type "channel/slack"
- :notification_id n2}}]
- ;; suppress unused-var warnings
- (let [_ [run-a run-b]]
- (testing "detail for n1 sees only tick-A in check_history and send_history"
- (let [resp-n1 (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" n1))]
- (is (= 1 (count (:check_history resp-n1)))
- "n1 check_history has exactly 1 tick (tick-A)")
- (is (= 1 (count (:send_history resp-n1)))
- "n1 send_history has exactly 1 tick (tick-A)")
- (is (=? {:channels [{:channel_type "channel/email"}]}
- (first (:send_history resp-n1))))))
- (testing "detail for n2 sees only tick-B in check_history and send_history"
- (let [resp-n2 (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" n2))]
- (is (= 1 (count (:check_history resp-n2)))
- "n2 check_history has exactly 1 tick (tick-B)")
- (is (= 1 (count (:send_history resp-n2)))
- "n2 send_history has exactly 1 tick (tick-B)")
- (is (=? {:channels [{:channel_type "channel/slack"}]}
- (first (:send_history resp-n2)))))))))))
-
-(deftest detail-goal-not-met-tick-absent-from-send-history-test
- (testing "A tick where the goal was not met (no channel-send rows) appears in check_history but NOT send_history"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {nid :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- ;; tick-1: goal not met — notification-send row exists but no channel-send
- :model/TaskRun {run-skip :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))}
- :model/TaskHistory _ns-skip {:task "notification-send"
- :run_id run-skip
- :status :success
- :started_at (t/minus (t/instant) (t/hours 2))
- :ended_at (t/minus (t/instant) (t/hours 2))
- :task_details {:notification_id nid
- :skip_reason "goal-not-met"}}
- ;; tick-2: goal met — has channel-send
- :model/TaskRun {run-sent :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))}
- :model/TaskHistory _ns-sent {:task "notification-send"
- :run_id run-sent
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:notification_id nid}}
- :model/TaskHistory _cs-sent {:task "channel-send"
- :run_id run-sent
- :status :success
- :started_at (t/minus (t/instant) (t/hours 1))
- :ended_at (t/minus (t/instant) (t/hours 1))
- :task_details {:channel_type "channel/email"
- :notification_id nid}}]
- ;; suppress unused-var warnings
- (let [_ [run-skip run-sent]
- resp (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" nid))]
- (is (= 2 (count (:check_history resp)))
- "both ticks appear in check_history")
- (is (= 1 (count (:send_history resp)))
- "only the goal-met tick appears in send_history — goal-not-met tick is absent")
- (is (=? {:channels [{:channel_type "channel/email" :status "successful"}]}
- (first (:send_history resp)))))))))
-
-(deftest detail-last-check-and-last-send-derived-from-histories-test
- (testing "GET /:id: last_check and last_send are derived per-notification from histories, not from card-level join"
- (mt/with-premium-features #{:audit-app}
- (mt/with-temp [:model/Card {card-id :id} {:archived false}
- :model/NotificationCard {nc :id} {:card_id card-id}
- :model/Notification {n1 :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- :model/Notification {n2 :id} {:payload_type :notification/card
- :payload_id nc
- :creator_id (mt/user->id :crowberto)}
- ;; Only n2 has ever fired
- :model/TaskRun {run2 :id} {:run_type :alert
- :entity_type :card
- :entity_id card-id
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)}
- :model/TaskHistory _ns2 {:task "notification-send"
- :run_id run2
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:notification_id n2}}
- :model/TaskHistory _cs2 {:task "channel-send"
- :run_id run2
- :status :success
- :started_at (t/instant)
- :ended_at (t/instant)
- :task_details {:channel_type "channel/email"
- :notification_id n2}}]
- (let [_ run2
- resp-n1 (mt/user-http-request :crowberto :get 200 (str "ee/notifications/" n1))]
- (testing "n1 has nil last_check and nil last_send because it has never fired"
- (is (nil? (:last_check resp-n1))
- "n1 last_check is nil — the card-level task_run is for n2 only")
- (is (nil? (:last_send resp-n1))
- "n1 last_send is nil — the channel-send belongs to n2")))))))
diff --git a/frontend/src/metabase/admin/routes.tsx b/frontend/src/metabase/admin/routes.tsx
index 216b3df407f..e70c9688058 100644
--- a/frontend/src/metabase/admin/routes.tsx
+++ b/frontend/src/metabase/admin/routes.tsx
@@ -90,7 +90,6 @@ export const getRoutes = (
) => {
const state = store.getState();
const hasSimpleEmbedding = getTokenFeature(state, "embedding_simple");
- const hasAuditApp = getTokenFeature(state, "audit_app");
return (
<Route path="/admin" component={CanAccessSettings}>
@@ -327,9 +326,7 @@ export const getRoutes = (
)}
</Route>
<Route path="tasks">{getTasksRoutes()}</Route>
- {hasAuditApp && (
- <Route path="notifications">{getNotificationsRoutes()}</Route>
- )}
+ <Route path="notifications">{getNotificationsRoutes()}</Route>
<Route path="jobs" component={JobInfoApp}>
<ModalRoute
path=":jobKey"
diff --git a/frontend/src/metabase/admin/tools/components/ToolsApp.tsx b/frontend/src/metabase/admin/tools/components/ToolsApp.tsx
index 73da70bb91b..cb349bf6787 100644
--- a/frontend/src/metabase/admin/tools/components/ToolsApp.tsx
+++ b/frontend/src/metabase/admin/tools/components/ToolsApp.tsx
@@ -8,7 +8,6 @@ import {
type AdminNavItemProps,
AdminNavWrapper,
} from "metabase/admin/components/AdminNav";
-import { useHasTokenFeature } from "metabase/common/hooks";
import * as Urls from "metabase/urls";
type ToolsAppProps = {
@@ -17,8 +16,6 @@ type ToolsAppProps = {
};
export function ToolsApp({ location, children }: ToolsAppProps) {
- const hasAuditApp = useHasTokenFeature("audit_app");
-
return (
<AdminSettingsLayout
maw="100rem"
@@ -61,14 +58,12 @@ export function ToolsApp({ location, children }: ToolsAppProps) {
icon="database"
location={location}
/>
- {hasAuditApp && (
- <ToolsNavItem
- label={t`Alerts management`}
- path={Urls.adminToolsNotifications()}
- icon="bell"
- location={location}
- />
- )}
+ <ToolsNavItem
+ label={t`Alerts management`}
+ path={Urls.adminToolsNotifications()}
+ icon="bell"
+ location={location}
+ />
</AdminNavWrapper>
}
>
diff --git a/frontend/src/metabase/admin/tools/notifications/NotificationsAdminPage/NotificationsAdminPage.unit.spec.tsx b/frontend/src/metabase/admin/tools/notifications/NotificationsAdminPage/NotificationsAdminPage.unit.spec.tsx
index d8d6bf59e1b..b49c2b5f4b9 100644
--- a/frontend/src/metabase/admin/tools/notifications/NotificationsAdminPage/NotificationsAdminPage.unit.spec.tsx
+++ b/frontend/src/metabase/admin/tools/notifications/NotificationsAdminPage/NotificationsAdminPage.unit.spec.tsx
@@ -74,7 +74,7 @@ const setup = ({
cardDelay,
detailDelay,
}: SetupOpts = {}) => {
- fetchMock.get("path:/api/ee/notifications", (call) => {
+ fetchMock.get("path:/api/notification/admin", (call) => {
const params = new URL(call.url).searchParams;
if (
params.get("limit") === "1" &&
@@ -119,7 +119,7 @@ const setup = ({
const getListCalls = () =>
fetchMock.callHistory
- .calls("path:/api/ee/notifications")
+ .calls("path:/api/notification/admin")
.filter(
(call) =>
new URL(call.url).searchParams.get("limit") === String(PAGE_SIZE),
@@ -127,7 +127,7 @@ const getListCalls = () =>
const getBulkPosts = async () =>
(await findRequests("POST")).filter((request) =>
- request.url.includes("/api/ee/notifications/bulk"),
+ request.url.includes("/api/notification/admin/bulk"),
);
describe("NotificationsAdminPage", () => {
diff --git a/frontend/src/metabase/api/notification.ts b/frontend/src/metabase/api/notification.ts
index fea9922b88d..e40ec6172c3 100644
--- a/frontend/src/metabase/api/notification.ts
+++ b/frontend/src/metabase/api/notification.ts
@@ -104,7 +104,7 @@ export const notificationApi = Api.injectEndpoints({
>({
query: (params) => ({
method: "GET",
- url: "/api/ee/notifications",
+ url: "/api/notification/admin",
params: params ?? undefined,
}),
providesTags: (result) =>
@@ -118,7 +118,7 @@ export const notificationApi = Api.injectEndpoints({
>({
query: (body) => ({
method: "POST",
- url: "/api/ee/notifications/bulk",
+ url: "/api/notification/admin/bulk",
body,
}),
invalidatesTags: (_result, error, { notification_ids }) =>
@@ -135,7 +135,7 @@ export const notificationApi = Api.injectEndpoints({
>({
query: (id) => ({
method: "GET",
- url: `/api/ee/notifications/${id}`,
+ url: `/api/notification/admin/${id}`,
}),
providesTags: (result) =>
result ? provideAdminNotificationTags(result) : [],
diff --git a/frontend/test/__support__/server-mocks/notification.ts b/frontend/test/__support__/server-mocks/notification.ts
index bb95978ed4e..b86a0a6c05e 100644
--- a/frontend/test/__support__/server-mocks/notification.ts
+++ b/frontend/test/__support__/server-mocks/notification.ts
@@ -39,7 +39,7 @@ export const setupAdminListNotificationsEndpoint = (
offset: null,
...overrides,
};
- fetchMock.get("path:/api/ee/notifications", response);
+ fetchMock.get("path:/api/notification/admin", response);
};
export const setupAdminNotificationDetailEndpoint = (
@@ -47,7 +47,7 @@ export const setupAdminNotificationDetailEndpoint = (
options?: { delay?: number },
) => {
fetchMock.get(
- `path:/api/ee/notifications/${notification.id}`,
+ `path:/api/notification/admin/${notification.id}`,
notification,
options,
);
@@ -56,11 +56,11 @@ export const setupAdminNotificationDetailEndpoint = (
export const setupAdminNotificationDetailErrorEndpoint = (
id: NotificationId,
) => {
- fetchMock.get(`path:/api/ee/notifications/${id}`, { status: 500 });
+ fetchMock.get(`path:/api/notification/admin/${id}`, { status: 500 });
};
export const setupBulkNotificationActionEndpoint = (
response: { updated: number } = { updated: 1 },
) => {
- fetchMock.post("path:/api/ee/notifications/bulk", response);
+ fetchMock.post("path:/api/notification/admin/bulk", response);
};
diff --git a/src/metabase/notification/api.clj b/src/metabase/notification/api.clj
index c0628482bef..bbd351b2ba6 100644
--- a/src/metabase/notification/api.clj
+++ b/src/metabase/notification/api.clj
@@ -3,6 +3,7 @@
[metabase.api.macros :as api.macros]
[metabase.api.routes.common :as routes.common]
[metabase.api.util.handlers :as handlers]
+ [metabase.notification.api.admin]
[metabase.notification.api.notification]
[metabase.notification.api.unsubscribe]
[potemkin :as p]))
@@ -19,5 +20,6 @@
"`/api/notification` routes."
(handlers/routes
(handlers/route-map-handler
- {"/unsubscribe" 'metabase.notification.api.unsubscribe})
+ {"/unsubscribe" 'metabase.notification.api.unsubscribe
+ "/admin" (routes.common/+auth (api.macros/ns-handler 'metabase.notification.api.admin))})
(routes.common/+auth (api.macros/ns-handler 'metabase.notification.api.notification))))
diff --git a/enterprise/backend/src/metabase_enterprise/notification_admin/api.clj b/src/metabase/notification/api/admin.clj
similarity index 99%
rename from enterprise/backend/src/metabase_enterprise/notification_admin/api.clj
rename to src/metabase/notification/api/admin.clj
index dcf0b51e7d7..3b35c370952 100644
--- a/enterprise/backend/src/metabase_enterprise/notification_admin/api.clj
+++ b/src/metabase/notification/api/admin.clj
@@ -1,6 +1,6 @@
-(ns metabase-enterprise.notification-admin.api
- "Admin endpoints for notifications (card-type alerts). Gated behind the `:audit-app` feature flag
- and `check-superuser`. Each row carries `:last_check` (latest scheduler tick — any terminal
+(ns metabase.notification.api.admin
+ "Admin endpoints for notifications (card-type alerts). Gated behind `check-superuser`. Each row
+ carries `:last_check` (latest scheduler tick — any terminal
outcome) and `:last_send` (latest channel-send delivery attempt — any outcome, including
failures) computed from windowed subqueries; both expose `{at, error, status}`. The API surface
uses `creator_*` throughout — matching `notification.creator_id` and the hydrated `:creator` map,
@@ -29,7 +29,7 @@
[metabase.api.macros :as api.macros]
[metabase.app-db.core :as mdb]
[metabase.models.interface :as mi]
- [metabase.notification.api :as notification-api]
+ [metabase.notification.api.notification :as notification-api]
[metabase.notification.models :as models.notification]
[metabase.request.core :as request]
[metabase.util :as u]
diff --git a/test/metabase/notification/api/admin_test.clj b/test/metabase/notification/api/admin_test.clj
new file mode 100644
index 00000000000..e84da6c4c1a
--- /dev/null
+++ b/test/metabase/notification/api/admin_test.clj
@@ -0,0 +1,1558 @@
+(ns metabase.notification.api.admin-test
+ (:require
+ [clojure.test :refer :all]
+ [java-time.api :as t]
+ [metabase.test :as mt]
+ [metabase.util :as u]
+ [toucan2.core :as t2]))
+
+(deftest list-stub-returns-shape-test
+ (testing "GET /api/notification/admin returns :data + :total shape for superuser"
+ (let [resp (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (contains? resp :data))
+ (is (contains? resp :total))
+ (is (sequential? (:data resp)))
+ (is (integer? (:total resp))))))
+
+(deftest requires-superuser-test
+ (testing "GET /api/notification/admin returns 403 for non-superuser"
+ (mt/user-http-request :rasta :get 403 "notification/admin")))
+
+(deftest list-returns-only-card-notifications-test
+ (testing "GET /api/notification/admin only returns :notification/card rows"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {ncard-id :id} {:card_id card-id}
+ :model/Notification card-notif {:payload_type :notification/card
+ :payload_id ncard-id
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification sys-notif {:payload_type :notification/system-event
+ :creator_id (mt/user->id :crowberto)}]
+ (let [{:keys [data total]} (mt/user-http-request :crowberto :get 200 "notification/admin")
+ ids (set (map :id data))]
+ (is (contains? ids (:id card-notif)))
+ (is (not (contains? ids (:id sys-notif))))
+ (is (pos? total))))))
+
+(deftest list-pagination-test
+ (testing "limit + offset paginate the result"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification _n1 {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification _n2 {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}]
+ (let [resp (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :limit 1 :offset 0)]
+ (is (= 1 (count (:data resp))))
+ (is (>= (:total resp) 2)))
+ (let [resp (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :limit 100 :offset 0)]
+ (is (>= (count (:data resp)) 2))))))
+
+(deftest filter-by-active-test
+ (testing "?active=true|false filters on the notification.active boolean; omitted = both"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification active-notif {:payload_type :notification/card
+ :payload_id nc1
+ :active true
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification archived-notif {:payload_type :notification/card
+ :payload_id nc2
+ :active false
+ :creator_id (mt/user->id :crowberto)}]
+ (testing "?active=true returns only active"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :active true)
+ ids (set (map :id data))]
+ (is (contains? ids (:id active-notif)))
+ (is (not (contains? ids (:id archived-notif))))))
+ (testing "?active=false returns only archived"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :active false)
+ ids (set (map :id data))]
+ (is (not (contains? ids (:id active-notif))))
+ (is (contains? ids (:id archived-notif)))))
+ (testing "omitting ?active returns both"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")
+ ids (set (map :id data))]
+ (is (contains? ids (:id active-notif)))
+ (is (contains? ids (:id archived-notif))))))))
+
+(deftest filter-by-owner-test
+ (testing "creator_id filters to notifications owned by that user"
+ (mt/with-temp [:model/User {user-a :id} {}
+ :model/User {user-b :id} {}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification notif-a {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id user-a}
+ :model/Notification notif-b {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id user-b}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :creator_id user-a)
+ ids (set (map :id data))]
+ (is (contains? ids (:id notif-a)))
+ (is (not (contains? ids (:id notif-b))))))))
+
+(deftest owner-includes-is-active-test
+ (testing "the hydrated :creator map carries :is_active so FE can render the deactivated-owner state"
+ (mt/with-temp [:model/User {active :id} {:is_active true}
+ :model/User {deactivated :id} {:is_active false}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification {active-n :id} {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id active}
+ :model/Notification {deact-n :id} {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id deactivated}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")
+ by-id (into {} (map (juxt :id identity) data))]
+ (is (=? {:creator {:id active :is_active true}} (by-id active-n)))
+ (is (=? {:creator {:id deactivated :is_active false}} (by-id deact-n)))))))
+
+(deftest filter-by-owner-active-test
+ (testing "?creator_active=true|false filters on the creator user's is_active flag"
+ (mt/with-temp [:model/User {active :id} {:is_active true}
+ :model/User {deactivated :id} {:is_active false}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification active-notif {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id active}
+ :model/Notification deact-notif {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id deactivated}]
+ (testing "creator_active=true keeps only notifications whose creator is active"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :creator_active true)
+ ids (set (map :id data))]
+ (is (contains? ids (:id active-notif)))
+ (is (not (contains? ids (:id deact-notif))))))
+ (testing "creator_active=false keeps only notifications whose creator is deactivated"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :creator_active false)
+ ids (set (map :id data))]
+ (is (contains? ids (:id deact-notif)))
+ (is (not (contains? ids (:id active-notif)))))))))
+
+(deftest filter-by-card-test
+ (testing "card_id filters to notifications whose notification_card.card_id matches"
+ (mt/with-temp [:model/Card {target-card :id} {}
+ :model/Card {other-card :id} {}
+ :model/NotificationCard {nc-target :id} {:card_id target-card}
+ :model/NotificationCard {nc-other :id} {:card_id other-card}
+ :model/Notification notif-target {:payload_type :notification/card
+ :payload_id nc-target
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification notif-other {:payload_type :notification/card
+ :payload_id nc-other
+ :creator_id (mt/user->id :crowberto)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :card_id target-card)
+ ids (set (map :id data))]
+ (is (contains? ids (:id notif-target)))
+ (is (not (contains? ids (:id notif-other))))))))
+
+(deftest filter-by-channel-test
+ (testing "channel filters to notifications with a matching handler channel_type"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification email-notif {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification slack-notif {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}
+ :model/NotificationHandler _email-handler {:notification_id (:id email-notif)
+ :channel_type :channel/email}
+ :model/NotificationHandler _slack-handler {:notification_id (:id slack-notif)
+ :channel_type :channel/slack}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :channel "channel/email")
+ ids (set (map :id data))]
+ (is (contains? ids (:id email-notif)))
+ (is (not (contains? ids (:id slack-notif))))))))
+
+(deftest filter-by-recipient-email-user-recipient-test
+ (testing "recipient_email matches a user recipient via case-insensitive core_user.email"
+ (mt/with-temp [:model/User {target-user :id
+ target-email :email} {}
+ :model/User {other-user :id} {}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification target-notif {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification other-notif {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}
+ :model/NotificationHandler {target-handler :id} {:notification_id (:id target-notif)
+ :channel_type :channel/email}
+ :model/NotificationHandler {other-handler :id} {:notification_id (:id other-notif)
+ :channel_type :channel/email}
+ :model/NotificationRecipient _target-r {:notification_handler_id target-handler
+ :type :notification-recipient/user
+ :user_id target-user}
+ :model/NotificationRecipient _other-r {:notification_handler_id other-handler
+ :type :notification-recipient/user
+ :user_id other-user}]
+ (testing "exact (case-sensitive original)"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :recipient_email target-email)
+ ids (set (map :id data))]
+ (is (contains? ids (:id target-notif)))
+ (is (not (contains? ids (:id other-notif))))))
+ (testing "case-insensitive — uppercased query still matches a lowercased stored email"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :recipient_email (u/upper-case-en target-email))
+ ids (set (map :id data))]
+ (is (contains? ids (:id target-notif))))))))
+
+(deftest filter-by-recipient-email-raw-value-test
+ (testing "recipient_email also matches raw-value (external) recipients via the JSON details column"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification raw-notif {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification unrelated-notif {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}
+ :model/NotificationHandler {raw-handler :id} {:notification_id (:id raw-notif)
+ :channel_type :channel/email}
+ :model/NotificationHandler {un-handler :id} {:notification_id (:id unrelated-notif)
+ :channel_type :channel/email}
+ :model/NotificationRecipient _raw-r {:notification_handler_id raw-handler
+ :type :notification-recipient/raw-value
+ :details {:value "[email protected]"}}
+ :model/NotificationRecipient _other-raw {:notification_handler_id un-handler
+ :type :notification-recipient/raw-value
+ :details {:value "[email protected]"}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :recipient_email "[email protected]")
+ ids (set (map :id data))]
+ (is (contains? ids (:id raw-notif)))
+ (is (not (contains? ids (:id unrelated-notif))))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; Fuzzy ?query= search — matches card name + owner name/email only (recipients no longer)
+;; ---------------------------------------------------------------------------------------------
+
+(deftest query-matches-card-name-test
+ (testing "?query= substring-matches the card name (case-insensitive)"
+ (mt/with-temp [:model/Card {sales :id} {:name "Sales report"}
+ :model/Card {orders :id} {:name "Orders dashboard"}
+ :model/NotificationCard {nc-sales :id} {:card_id sales}
+ :model/NotificationCard {nc-orders :id} {:card_id orders}
+ :model/Notification sales-n {:payload_type :notification/card
+ :payload_id nc-sales
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification orders-n {:payload_type :notification/card
+ :payload_id nc-orders
+ :creator_id (mt/user->id :crowberto)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "SALES")
+ ids (set (map :id data))]
+ (is (contains? ids (:id sales-n)))
+ (is (not (contains? ids (:id orders-n))))))))
+
+(deftest query-matches-owner-name-test
+ (testing "?query= substring-matches owner first/last/email"
+ (mt/with-temp [:model/User {alice :id} {:first_name "Alice" :last_name "Stone"
+ :email "[email protected]"}
+ :model/User {bob :id} {:first_name "Bob" :last_name "Jones"
+ :email "[email protected]"}
+ :model/Card {card :id} {}
+ :model/NotificationCard {nc-a :id} {:card_id card}
+ :model/NotificationCard {nc-b :id} {:card_id card}
+ :model/Notification alice-n {:payload_type :notification/card
+ :payload_id nc-a
+ :creator_id alice}
+ :model/Notification bob-n {:payload_type :notification/card
+ :payload_id nc-b
+ :creator_id bob}]
+ (testing "by first_name"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "alic")
+ ids (set (map :id data))]
+ (is (contains? ids (:id alice-n)))
+ (is (not (contains? ids (:id bob-n))))))
+ (testing "by last_name"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "stone")
+ ids (set (map :id data))]
+ (is (contains? ids (:id alice-n)))
+ (is (not (contains? ids (:id bob-n))))))
+ (testing "by email"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "bob@example")
+ ids (set (map :id data))]
+ (is (contains? ids (:id bob-n)))
+ (is (not (contains? ids (:id alice-n)))))))))
+
+(deftest query-does-not-match-recipients-test
+ (testing "?query= no longer descends into recipient emails or slack channels — only card + owner"
+ (mt/with-temp [:model/User {recipient :id} {:email "[email protected]"}
+ :model/Card {card :id} {:name "Innocuous card"}
+ :model/NotificationCard {nc-user :id} {:card_id card}
+ :model/NotificationCard {nc-raw :id} {:card_id card}
+ :model/NotificationCard {nc-slack :id} {:card_id card}
+ :model/Notification user-recipient-n {:payload_type :notification/card
+ :payload_id nc-user
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification raw-recipient-n {:payload_type :notification/card
+ :payload_id nc-raw
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification slack-recipient-n {:payload_type :notification/card
+ :payload_id nc-slack
+ :creator_id (mt/user->id :crowberto)}
+ :model/NotificationHandler {h-user :id} {:notification_id (:id user-recipient-n)
+ :channel_type :channel/email}
+ :model/NotificationHandler {h-raw :id} {:notification_id (:id raw-recipient-n)
+ :channel_type :channel/email}
+ :model/NotificationHandler {h-slack :id} {:notification_id (:id slack-recipient-n)
+ :channel_type :channel/slack}
+ :model/NotificationRecipient _r-user {:notification_handler_id h-user
+ :type :notification-recipient/user
+ :user_id recipient}
+ :model/NotificationRecipient _r-raw {:notification_handler_id h-raw
+ :type :notification-recipient/raw-value
+ :details {:value "[email protected]"}}
+ :model/NotificationRecipient _r-slack {:notification_handler_id h-slack
+ :type :notification-recipient/raw-value
+ :details {:value "#fuzzy-channel"}}]
+ (testing "user-recipient email is NOT matched by ?query="
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "unique-domain")
+ ids (set (map :id data))]
+ (is (not (contains? ids (:id user-recipient-n))))))
+ (testing "raw-value email recipient is NOT matched by ?query="
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "fuzzy-target")
+ ids (set (map :id data))]
+ (is (not (contains? ids (:id raw-recipient-n))))))
+ (testing "slack-channel raw-value recipient is NOT matched by ?query="
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "fuzzy-channel")
+ ids (set (map :id data))]
+ (is (not (contains? ids (:id slack-recipient-n)))))))))
+
+(deftest query-and-other-filters-and-together-test
+ (testing "?query= AND'd with other filters; structured filters narrow the fuzzy result"
+ (mt/with-temp [:model/Card {card :id} {:name "Quarterly fizzbuzz"}
+ :model/NotificationCard {nc-a :id} {:card_id card}
+ :model/NotificationCard {nc-b :id} {:card_id card}
+ :model/Notification active-match {:payload_type :notification/card
+ :payload_id nc-a
+ :active true
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification archived-match {:payload_type :notification/card
+ :payload_id nc-b
+ :active false
+ :creator_id (mt/user->id :crowberto)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :query "fizzbuzz"
+ :active true)
+ ids (set (map :id data))]
+ (is (contains? ids (:id active-match)))
+ (is (not (contains? ids (:id archived-match))))))))
+
+(defn- find-row-by-id [data id]
+ (some #(when (= id (:id %)) %) data))
+
+;; ---------------------------------------------------------------------------------------------
+;; :last_check / :last_send shape
+;; ---------------------------------------------------------------------------------------------
+
+(deftest last-send-from-channel-send-task-history-test
+ (testing ":last_send reflects the latest channel-send task_history row (any outcome)"
+ (mt/with-temp [:model/Card {card-a :id} {:archived false}
+ :model/Card {card-b :id} {:archived false}
+ :model/NotificationCard {nc-a :id} {:card_id card-a}
+ :model/NotificationCard {nc-b :id} {:card_id card-b}
+ :model/Notification {n-sent :id} {:payload_type :notification/card
+ :payload_id nc-a
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {n-unsent :id} {:payload_type :notification/card
+ :payload_id nc-b
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-a
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _th {:task "channel-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"
+ :notification_id (:id n-sent)}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")
+ by-id (into {} (map (juxt :id identity) data))]
+ (is (=? {:last_send {:at some?
+ :status "successful"
+ :error nil}}
+ (by-id n-sent)))
+ (is (=? {:last_send nil}
+ (by-id n-unsent)))))))
+
+(deftest last-send-failing-channel-send-surfaces-status-and-error-test
+ (testing ":last_send on the list shows :failing status AND the channel-send error message
+ when the latest send-tick had a channel failure"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:message "SMTP connection refused"
+ :channel_type "channel/email"
+ :notification_id nid}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_send {:at some?
+ :status "failing"
+ :error "SMTP connection refused"}}
+ (find-row-by-id data nid)))))))
+
+(deftest last-check-shape-success-test
+ (testing ":last_check on a successful run reports status=successful with no error"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun _run {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check {:at some?
+ :status "successful"
+ :error nil}}
+ (find-row-by-id data nid)))))))
+
+(deftest last-check-shape-failing-includes-error-test
+ (testing ":last_check on a failed run reports status=failing and pulls the error from task_history"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _th {:task "notification-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:message "SMTP host unreachable"}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check {:at some?
+ :status "failing"
+ :error "SMTP host unreachable"}}
+ (find-row-by-id data nid)))))))
+
+(deftest last-send-shape-failing-includes-error-test
+ (testing ":last_send on the list endpoint surfaces the channel-send error message (not just status=failing)"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ ;; Outer notification-send succeeded; only the channel-send failed.
+ :model/TaskHistory _ns-th {:task "notification-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:notification_id nid}}
+ :model/TaskHistory _cs-th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:status :failed
+ :message "Slack token invalid"
+ :original-info {:channel_type "channel/slack"
+ :notification_id nid}}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_send {:at some?
+ :status "failing"
+ :error "Slack token invalid"}}
+ (find-row-by-id data nid)))))))
+
+(deftest last-check-abandoned-folds-into-failing-test
+ (testing ":abandoned (heartbeat-killed) runs surface as last_check.status=failing"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun _run {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :abandoned
+ :started_at (t/instant)
+ :ended_at (t/instant)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check {:status "failing"}}
+ (find-row-by-id data nid)))))))
+
+(deftest last-check-skips-in-flight-runs-test
+ (testing "an :started in-flight run is invisible to the admin list — last_check stays nil"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun _run {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :started
+ :started_at (t/instant)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check nil
+ :last_send nil}
+ (find-row-by-id data nid)))))))
+
+(deftest response-shape-includes-pagination-metadata-test
+ (testing "GET / response shape echoes the {:data :total :limit :offset} pagination convention"
+ (let [resp (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (contains? resp :data))
+ (is (contains? resp :total))
+ (is (contains? resp :limit))
+ (is (contains? resp :offset)))))
+
+(deftest response-shape-does-not-include-counts-test
+ (testing "GET / response does NOT include a :counts key — tab counts are dropped"
+ (let [resp (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (not (contains? resp :counts))))))
+
+(deftest filter-by-last-send-status-test
+ (testing "?last_send_status=successful|failing filters by the latest channel-send outcome"
+ (mt/with-temp [:model/Card {success-card :id} {:archived false}
+ :model/Card {fail-card :id} {:archived false}
+ :model/Card {no-send-card :id} {:archived false}
+ :model/NotificationCard {nc-success :id} {:card_id success-card}
+ :model/NotificationCard {nc-fail :id} {:card_id fail-card}
+ :model/NotificationCard {nc-no-send :id} {:card_id no-send-card}
+ :model/Notification success-n {:payload_type :notification/card
+ :payload_id nc-success
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification fail-n {:payload_type :notification/card
+ :payload_id nc-fail
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification no-send-n {:payload_type :notification/card
+ :payload_id nc-no-send
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {ok-run :id} {:run_type :alert
+ :entity_type :card
+ :entity_id success-card
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskRun {fail-run :id} {:run_type :alert
+ :entity_type :card
+ :entity_id fail-card
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ ;; channel-send rows drive the filter
+ :model/TaskHistory _ok-th {:task "channel-send"
+ :run_id ok-run
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"}}
+ :model/TaskHistory _fail-th {:task "channel-send"
+ :run_id fail-run
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"}}]
+ (testing "successful"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :last_send_status "successful")
+ ids (set (map :id data))]
+ (is (contains? ids (:id success-n)))
+ (is (not (contains? ids (:id fail-n))))
+ (is (not (contains? ids (:id no-send-n))))))
+ (testing "failing"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :last_send_status "failing")
+ ids (set (map :id data))]
+ (is (contains? ids (:id fail-n)))
+ (is (not (contains? ids (:id success-n))))
+ (is (not (contains? ids (:id no-send-n)))))))))
+
+(deftest filter-compound-test
+ (testing "multiple filters AND together (active + owner_id)"
+ (mt/with-temp [:model/User {target-user :id} {}
+ :model/User {other-user :id} {}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/NotificationCard {nc3 :id} {:card_id card-id}
+ :model/Notification matching {:payload_type :notification/card
+ :payload_id nc1
+ :active true
+ :creator_id target-user}
+ :model/Notification wrong-active {:payload_type :notification/card
+ :payload_id nc2
+ :active false
+ :creator_id target-user}
+ :model/Notification wrong-owner {:payload_type :notification/card
+ :payload_id nc3
+ :active true
+ :creator_id other-user}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :active true
+ :creator_id target-user)
+ ids (set (map :id data))]
+ (is (contains? ids (:id matching)))
+ (is (not (contains? ids (:id wrong-active))))
+ (is (not (contains? ids (:id wrong-owner))))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; Sort
+;; ---------------------------------------------------------------------------------------------
+
+(deftest sort-by-last-send-test
+ (testing "?sort_column=last_send orders rows by the latest channel-send started_at"
+ (mt/with-temp [:model/Card {card-old :id} {:archived false}
+ :model/Card {card-new :id} {:archived false}
+ :model/Card {card-never :id} {:archived false}
+ :model/NotificationCard {nc-old :id} {:card_id card-old}
+ :model/NotificationCard {nc-new :id} {:card_id card-new}
+ :model/NotificationCard {nc-never :id} {:card_id card-never}
+ :model/Notification {old-id :id} {:payload_type :notification/card
+ :payload_id nc-old
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {new-id :id} {:payload_type :notification/card
+ :payload_id nc-new
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {never-id :id} {:payload_type :notification/card
+ :payload_id nc-never
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {old-run :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-old
+ :status :success
+ :started_at (t/minus (t/instant) (t/days 5))
+ :ended_at (t/minus (t/instant) (t/days 5))}
+ :model/TaskRun {new-run :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-new
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _old-th {:task "channel-send"
+ :run_id old-run
+ :status :success
+ :started_at (t/minus (t/instant) (t/days 5))
+ :ended_at (t/minus (t/instant) (t/days 5))
+ :task_details {:channel_type "channel/email"}}
+ :model/TaskHistory _new-th {:task "channel-send"
+ :run_id new-run
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "last_send"
+ :sort_direction "desc")
+ ids (->> data (map :id) (filter #{old-id new-id never-id}) vec)]
+ (is (= [new-id old-id never-id] ids)
+ "newest-sent first, oldest-sent next, never-sent last (desc + null-trailing)")))))
+
+(deftest sort-by-updated-at-test
+ (testing "?sort_column=updated_at orders rows by notification.updated_at"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification n-older {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)
+ :updated_at (t/minus (t/instant) (t/days 2))}
+ :model/Notification n-newer {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)
+ :updated_at (t/instant)}]
+ (testing "desc puts newer first"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "updated_at"
+ :sort_direction "desc")
+ seen (->> data (map :id) (filter #{(:id n-older) (:id n-newer)}) vec)]
+ (is (= [(:id n-newer) (:id n-older)] seen))))
+ (testing "asc puts older first"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "updated_at"
+ :sort_direction "asc")
+ seen (->> data (map :id) (filter #{(:id n-older) (:id n-newer)}) vec)]
+ (is (= [(:id n-older) (:id n-newer)] seen)))))))
+
+(deftest sort-rejects-unknown-column-test
+ (testing "?sort_column=<unknown> is rejected with 400 by the malli enum"
+ (mt/user-http-request :crowberto :get 400 "notification/admin"
+ :sort_column "name; DROP TABLE notification")))
+
+(deftest default-sort-is-last-send-test
+ (testing "default sort_column is :last_send (null-trailing desc), driven by channel-send rows"
+ (mt/with-temp [:model/Card {card-sent :id} {:archived false}
+ :model/Card {card-unsent :id} {:archived false}
+ :model/NotificationCard {nc-sent :id} {:card_id card-sent}
+ :model/NotificationCard {nc-unsent :id} {:card_id card-unsent}
+ :model/Notification {sent-id :id} {:payload_type :notification/card
+ :payload_id nc-sent
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {unsent-id :id} {:payload_type :notification/card
+ :payload_id nc-unsent
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-sent
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _th {:task "channel-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")
+ ids (->> data (map :id) (filter #{sent-id unsent-id}) vec)]
+ (is (= [sent-id unsent-id] ids)
+ "notification with a last_send appears before the never-sent one under the default sort")))))
+
+;; ---------------------------------------------------------------------------------------------
+;; POST /bulk
+;; ---------------------------------------------------------------------------------------------
+
+(deftest bulk-archive-test
+ (testing "POST /bulk with action=archive flips :active to false for each id"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification n1 {:payload_type :notification/card
+ :payload_id nc1
+ :active true
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification n2 {:payload_type :notification/card
+ :payload_id nc2
+ :active true
+ :creator_id (mt/user->id :crowberto)}]
+ (mt/with-premium-features #{:audit-app}
+ (let [resp (mt/user-http-request :crowberto :post 200 "notification/admin/bulk"
+ {:notification_ids [(:id n1) (:id n2)]
+ :action "archive"})]
+ (is (= 2 (:updated resp)))
+ (is (false? (t2/select-one-fn :active :model/Notification (:id n1))))
+ (is (false? (t2/select-one-fn :active :model/Notification (:id n2))))
+ (testing "publishes :event/notification-update per notification so the admin action is audited"
+ (doseq [n [n1 n2]]
+ (is (= {:topic :notification-update
+ :user_id (mt/user->id :crowberto)
+ :model "Notification"
+ :model_id (:id n)
+ :details {:previous {:active true}
+ :new {:active false}}}
+ (mt/latest-audit-log-entry :notification-update (:id n)))))))))))
+
+(deftest bulk-change-owner-test
+ (testing "POST /bulk with action=change-creator sets :creator_id to creator_id for each id"
+ (mt/with-temp [:model/User {new-owner :id} {}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/Notification n1 {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :rasta)}]
+ (mt/user-http-request :crowberto :post 200 "notification/admin/bulk"
+ {:notification_ids [(:id n1)]
+ :action "change-creator"
+ :creator_id new-owner})
+ (is (= new-owner (t2/select-one-fn :creator_id :model/Notification (:id n1)))))))
+
+(deftest bulk-change-owner-requires-owner-id-test
+ (testing "POST /bulk with action=change-creator and no creator_id returns 400"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/Notification n1 {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}]
+ (mt/user-http-request :crowberto :post 400 "notification/admin/bulk"
+ {:notification_ids [(:id n1)]
+ :action "change-creator"}))))
+
+;; ---------------------------------------------------------------------------------------------
+;; Auth + feature-flag gating for POST /bulk (mirrors the GET triad above)
+;; ---------------------------------------------------------------------------------------------
+(deftest bulk-requires-superuser-test
+ (testing "POST /api/notification/admin/bulk returns 403 for non-superuser"
+ (mt/user-http-request :rasta :post 403 "notification/admin/bulk"
+ {:notification_ids [1]
+ :action "archive"})))
+
+(deftest bulk-happy-path-test
+ (testing "POST /api/notification/admin/bulk returns 200 + :updated for superuser"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification n {:payload_type :notification/card
+ :payload_id nc
+ :active true
+ :creator_id (mt/user->id :crowberto)}]
+ (let [resp (mt/user-http-request :crowberto :post 200 "notification/admin/bulk"
+ {:notification_ids [(:id n)]
+ :action "archive"})]
+ (is (= 1 (:updated resp)))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; GET /:id detail endpoint
+;; ---------------------------------------------------------------------------------------------
+
+(deftest detail-returns-notification-with-run-summaries-test
+ (testing "GET /:id returns the hydrated notification with :last_check / :last_send slots and creator_id"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}]
+ (is (=? {:id nid
+ :creator_id (mt/user->id :crowberto)
+ :last_check any?
+ :last_send any?}
+ (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid)))))))
+
+(deftest detail-404-for-missing-id-test
+ (testing "GET /:id returns 404 for a non-existent notification id"
+ (let [max-id (or (t2/select-one-fn :id :model/Notification {:order-by [[:id :desc]]}) 0)]
+ (mt/user-http-request :crowberto :get 404
+ (str "notification/admin/" (+ max-id 100000))))))
+
+(deftest detail-404-for-non-card-notification-test
+ (testing "GET /:id returns 404 when the notification exists but isn't a :notification/card"
+ (mt/with-temp [:model/Notification {nid :id} {:payload_type :notification/system-event
+ :creator_id (mt/user->id :crowberto)}]
+ (mt/user-http-request :crowberto :get 404 (str "notification/admin/" nid)))))
+
+(deftest detail-requires-superuser-test
+ (testing "GET /:id returns 403 for a non-superuser"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}]
+ (mt/user-http-request :rasta :get 403 (str "notification/admin/" nid)))))
+
+;; ---------------------------------------------------------------------------------------------
+;; B. Ownerless filter
+;; ---------------------------------------------------------------------------------------------
+
+(deftest filter-by-ownerless-true-test
+ (testing "?creatorless=true includes notifications with a deactivated creator and excludes active owners"
+ (mt/with-temp [:model/User {active-user :id} {:is_active true}
+ :model/User {deact-user :id} {:is_active false}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification active-owner-n {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id active-user}
+ :model/Notification deact-owner-n {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id deact-user}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :creatorless true)
+ ids (set (map :id data))]
+ (is (contains? ids (:id deact-owner-n))
+ "deactivated creator = ownerless")
+ (is (not (contains? ids (:id active-owner-n)))
+ "active owner is excluded")))))
+
+(deftest filter-by-ownerless-false-test
+ (testing "?creatorless=false includes only notifications with an active owner"
+ (mt/with-temp [:model/User {active-user :id} {:is_active true}
+ :model/User {deact-user :id} {:is_active false}
+ :model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification active-owner-n {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id active-user}
+ :model/Notification deact-owner-n {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id deact-user}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :creatorless false)
+ ids (set (map :id data))]
+ (is (contains? ids (:id active-owner-n))
+ "active owner is included")
+ (is (not (contains? ids (:id deact-owner-n)))
+ "deactivated owner is excluded")))))
+
+;; ---------------------------------------------------------------------------------------------
+;; C. Multi-value channel filter
+;; ---------------------------------------------------------------------------------------------
+
+(deftest filter-by-channel-multi-value-test
+ (testing "?channel= accepts multiple values (OR semantics across channel types)"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/NotificationCard {nc3 :id} {:card_id card-id}
+ :model/Notification email-notif {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification slack-notif {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification other-notif {:payload_type :notification/card
+ :payload_id nc3
+ :creator_id (mt/user->id :crowberto)}
+ :model/NotificationHandler _email-handler {:notification_id (:id email-notif)
+ :channel_type :channel/email}
+ :model/NotificationHandler _slack-handler {:notification_id (:id slack-notif)
+ :channel_type :channel/slack}]
+ (testing "single channel still works"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :channel "channel/email")
+ ids (set (map :id data))]
+ (is (contains? ids (:id email-notif)))
+ (is (not (contains? ids (:id slack-notif))))
+ (is (not (contains? ids (:id other-notif))))))
+ (testing "multiple channels (vector) returns union"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :channel ["channel/email" "channel/slack"])
+ ids (set (map :id data))]
+ (is (contains? ids (:id email-notif)))
+ (is (contains? ids (:id slack-notif)))
+ (is (not (contains? ids (:id other-notif)))))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; D. New sort columns + default sort
+;; ---------------------------------------------------------------------------------------------
+
+(deftest sort-by-last-check-test
+ (testing "?sort_column=last_check orders rows by the latest task_run started_at"
+ (mt/with-temp [:model/Card {card-old :id} {:archived false}
+ :model/Card {card-new :id} {:archived false}
+ :model/Card {card-never :id} {:archived false}
+ :model/NotificationCard {nc-old :id} {:card_id card-old}
+ :model/NotificationCard {nc-new :id} {:card_id card-new}
+ :model/NotificationCard {nc-never :id} {:card_id card-never}
+ :model/Notification {old-id :id} {:payload_type :notification/card
+ :payload_id nc-old
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {new-id :id} {:payload_type :notification/card
+ :payload_id nc-new
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {never-id :id} {:payload_type :notification/card
+ :payload_id nc-never
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun _old-run {:run_type :alert
+ :entity_type :card
+ :entity_id card-old
+ :status :failed
+ :started_at (t/minus (t/instant) (t/days 5))
+ :ended_at (t/minus (t/instant) (t/days 5))}
+ :model/TaskRun _new-run {:run_type :alert
+ :entity_type :card
+ :entity_id card-new
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "last_check"
+ :sort_direction "desc")
+ ids (->> data (map :id) (filter #{old-id new-id never-id}) vec)]
+ (is (= [new-id old-id never-id] ids)
+ "newest-checked first, oldest-checked next, never-checked last (nulls trailing)")))))
+
+(deftest sort-by-id-test
+ (testing "?sort_column=id orders rows by notification.id"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc1 :id} {:card_id card-id}
+ :model/NotificationCard {nc2 :id} {:card_id card-id}
+ :model/Notification {n1 :id} {:payload_type :notification/card
+ :payload_id nc1
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {n2 :id} {:payload_type :notification/card
+ :payload_id nc2
+ :creator_id (mt/user->id :crowberto)}]
+ (testing "asc puts smaller id first"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "id"
+ :sort_direction "asc")
+ seen (->> data (map :id) (filter #{n1 n2}) vec)]
+ (is (= [(min n1 n2) (max n1 n2)] seen))))
+ (testing "desc puts larger id first"
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin"
+ :sort_column "id"
+ :sort_direction "desc")
+ seen (->> data (map :id) (filter #{n1 n2}) vec)]
+ (is (= [(max n1 n2) (min n1 n2)] seen)))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; E. check_history / send_history in the detail endpoint
+;; ---------------------------------------------------------------------------------------------
+
+(deftest detail-includes-check-history-test
+ (testing "GET /:id includes :check_history — up to 10 most-recent terminal runs for THIS notification, newest first"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {r1 :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))}
+ :model/TaskRun {r2 :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))}
+ ;; notification-send rows with notification_id — required for per-notification filter
+ :model/TaskHistory _th1 {:task "notification-send"
+ :run_id r1
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))
+ :task_details {:notification_id nid}}
+ :model/TaskHistory _th2 {:task "notification-send"
+ :run_id r2
+ :status :failed
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:notification_id nid
+ :message "Connection refused"}}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))
+ check-history (:check_history resp)]
+ (is (sequential? check-history))
+ (is (= 2 (count check-history))
+ "two terminal runs for this notification, newest first")
+ (is (=? {:status "failing" :error "Connection refused"} (first check-history))
+ "most-recent (the failed one) is first")
+ (is (=? {:status "successful" :error nil} (second check-history))
+ "older successful run is second")))))
+
+(deftest detail-includes-send-history-test
+ (testing "GET /:id includes :send_history — per-tick rollup, newest tick first, with :channels breakdown"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-ok :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))}
+ :model/TaskRun {run-fail :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))}
+ :model/TaskHistory _ok-th {:task "channel-send"
+ :run_id run-ok
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))
+ :task_details {:channel_type "channel/email"
+ :notification_id nid}}
+ :model/TaskHistory _fail-th {:task "channel-send"
+ :run_id run-fail
+ :status :failed
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:channel_type "channel/slack"
+ :message "Slack token invalid"
+ :notification_id nid}}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))
+ send-history (:send_history resp)]
+ (is (sequential? send-history))
+ (is (= 2 (count send-history))
+ "two ticks (one channel-send each)")
+ (testing "most-recent tick (failed slack) is first"
+ (is (=? {:status "failing"
+ :error "Slack token invalid"
+ :channels [{:channel_type "channel/slack"
+ :status "failing"
+ :error "Slack token invalid"}]}
+ (first send-history))))
+ (testing "older successful email tick is second"
+ (is (=? {:status "successful"
+ :error nil
+ :channels [{:channel_type "channel/email"
+ :status "successful"
+ :error nil}]}
+ (second send-history))))))))
+
+(deftest detail-surfaces-history-when-task-details-failure-wrapped-test
+ (testing "GET /:id surfaces last_check/last_send/error for ticks whose task_details is wrapped by with-task-history's failure handler"
+ ;; Regression: `metabase.task_history/do-with-task-history` rewrites task_details on exception as
+ ;; `{:status :failed :message ... :original-info <caller-task_details>}`. The per-notification
+ ;; filter has to look in both the top level (success rows) and `:original-info` (failure rows),
+ ;; or failing ticks silently disappear from the detail histories and `last_check`/`last_send`
+ ;; come back nil — even though the list endpoint shows the notification as failing.
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ ;; notification-send: failure-wrapped (notification_id only under :original-info)
+ :model/TaskHistory _ns-th {:task "notification-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:status :failed
+ :message "Notification handler exploded"
+ :original-info {:notification_id nid}}}
+ ;; channel-send: failure-wrapped (channel_type + notification_id only under :original-info)
+ :model/TaskHistory _cs-th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:status :failed
+ :message "Slack token invalid"
+ :original-info {:channel_type "channel/slack"
+ :notification_id nid}}}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))]
+ (testing "check_history surfaces the failed notification-send tick + its error"
+ (is (=? [{:status "failing" :error "Notification handler exploded"}]
+ (:check_history resp))))
+ (testing "send_history surfaces the failed channel-send tick + its error and channel type"
+ (is (=? [{:status "failing"
+ :error "Slack token invalid"
+ :channels [{:channel_type "channel/slack"
+ :status "failing"
+ :error "Slack token invalid"}]}]
+ (:send_history resp))))
+ (testing "last_check and last_send are derived from those histories"
+ (is (=? {:status "failing" :error "Notification handler exploded"}
+ (:last_check resp)))
+ (is (=? {:status "failing" :error "Slack token invalid"}
+ (:last_send resp))))))))
+
+(deftest list-last-check-surfaces-channel-error-when-outer-send-succeeded-test
+ (testing "list endpoint last_check.error surfaces the channel-send error when the outer notification-send succeeded but a channel failed"
+ ;; Regression: `complete-task-run!` derives task_run.status as :failed when ANY child task is
+ ;; not :success — so a tick where notification-send succeeded but a channel-send failed has
+ ;; task_run.status = :failed. `error-by-run-id` must surface the channel-send's message in
+ ;; that case (no notification-send failure row exists). If it filtered to notification-send
+ ;; only, last_check would show status:failing error:nil for the Failing tab.
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ ;; Outer notification-send: succeeded
+ :model/TaskHistory _ns-th {:task "notification-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:notification_id nid}}
+ ;; Channel-send: failed (failure-wrapped task_details)
+ :model/TaskHistory _cs-th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:status :failed
+ :message "Slack token invalid"
+ :original-info {:channel_type "channel/slack"
+ :notification_id nid}}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check {:status "failing" :error "Slack token invalid"}}
+ (find-row-by-id data nid)))))))
+
+(deftest list-last-check-prefers-outer-notification-send-error-test
+ (testing "when both notification-send and channel-send failed in one run, last_check.error prefers the outer notification-send message"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _ns-th {:task "notification-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:message "Payload generation failed"}}
+ :model/TaskHistory _cs-th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:message "Slack token invalid"}}]
+ (let [{:keys [data]} (mt/user-http-request :crowberto :get 200 "notification/admin")]
+ (is (=? {:last_check {:status "failing" :error "Payload generation failed"}}
+ (find-row-by-id data nid))
+ "outer notification-send error wins over inner channel-send error")))))
+
+(deftest detail-send-history-multi-channel-tick-test
+ (testing "GET /:id: one tick with email+slack both succeeding → ONE send entry, status successful"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _email-th {:task "channel-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"
+ :notification_id nid}}
+ :model/TaskHistory _slack-th {:task "channel-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/slack"
+ :notification_id nid}}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))
+ send-history (:send_history resp)]
+ (is (= 1 (count send-history))
+ "two channels in the same tick collapse to ONE send entry")
+ (is (=? {:status "successful"
+ :error nil
+ :channels [{:channel_type "channel/email" :status "successful"}
+ {:channel_type "channel/slack" :status "successful"}]}
+ (first send-history)))))))
+
+(deftest detail-send-history-mixed-channels-test
+ (testing "GET /:id: one tick with email success + slack failure → failing, :channels shows both"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/TaskRun {run-id :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _email-th {:task "channel-send"
+ :run_id run-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"
+ :notification_id nid}}
+ :model/TaskHistory _slack-th {:task "channel-send"
+ :run_id run-id
+ :status :failed
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/slack"
+ :message "Rate limited"
+ :notification_id nid}}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))
+ entry (first (:send_history resp))]
+ (is (= 1 (count (:send_history resp)))
+ "two channels in the same tick → ONE send entry")
+ (is (=? {:status "failing" :error "Rate limited"} entry))
+ (is (= 2 (count (:channels entry)))
+ "channels breakdown has one entry per channel-send row")
+ (let [by-type (into {} (map (juxt :channel_type identity) (:channels entry)))]
+ (is (=? {:status "successful"} (get by-type "channel/email")))
+ (is (=? {:status "failing" :error "Rate limited"} (get by-type "channel/slack"))))))))
+
+(deftest detail-check-history-empty-when-no-runs-test
+ (testing "GET /:id returns :check_history as empty vector when no terminal runs exist"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}]
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))]
+ (is (= [] (:check_history resp)))
+ (is (= [] (:send_history resp)))))))
+
+(deftest detail-check-history-respects-limit-test
+ (testing "GET /:id returns at most 10 runs in :check_history"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}]
+ ;; create 12 runs, each with a matching notification-send row so the per-notification filter passes
+ (doseq [i (range 12)]
+ (let [run-id (t2/insert-returning-pk! :model/TaskRun
+ {:run_type "alert"
+ :entity_type "card"
+ :entity_id card-id
+ :status "success"
+ :started_at (t/minus (t/instant) (t/hours (inc i)))
+ :ended_at (t/minus (t/instant) (t/hours (inc i)))
+ :process_uuid "test"})]
+ (t2/insert! :model/TaskHistory
+ {:task "notification-send"
+ :run_id run-id
+ :status "success"
+ :started_at (t/minus (t/instant) (t/hours (inc i)))
+ :ended_at (t/minus (t/instant) (t/hours (inc i)))
+ :task_details (str "{\"notification_id\":" nid "}")})))
+ (let [resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))]
+ (is (<= (count (:check_history resp)) 10))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; F. creator_id (owner) cannot be reassigned via the public PUT endpoint — only via POST /bulk
+;; ---------------------------------------------------------------------------------------------
+
+(deftest put-creator-id-superuser-only-test
+ (testing "PUT /api/notification/:id: superusers can reassign owner; non-superusers get a 400"
+ (mt/with-temp [:model/Card {card-id :id} {}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :rasta)}]
+ (testing "non-superuser (the current owner) is forbidden from reassigning (403 from mi/can-update?)"
+ (let [notification (mt/user-http-request :rasta :get 200 (format "notification/%d" nid))]
+ (mt/user-http-request :rasta :put 403 (format "notification/%d" nid)
+ (assoc notification :creator_id (mt/user->id :lucky)))
+ (is (= (mt/user->id :rasta)
+ (t2/select-one-fn :creator_id :model/Notification nid))
+ "owner unchanged after non-superuser attempt")))
+ (testing "superuser can reassign owner"
+ (let [notification (mt/user-http-request :crowberto :get 200 (format "notification/%d" nid))]
+ (mt/user-http-request :crowberto :put 200 (format "notification/%d" nid)
+ (assoc notification :creator_id (mt/user->id :lucky)))
+ (is (= (mt/user->id :lucky)
+ (t2/select-one-fn :creator_id :model/Notification nid))
+ "owner reassigned after superuser PUT"))))))
+
+;; ---------------------------------------------------------------------------------------------
+;; Per-notification isolation — two notifications on the same card
+;; ---------------------------------------------------------------------------------------------
+
+(deftest detail-per-notification-isolation-test
+ (testing "Two notifications on the same card each see only their own ticks in check_history and send_history"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ ;; Two distinct notifications sharing the same card
+ :model/Notification {n1 :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {n2 :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ ;; tick-A: fires for n1 only
+ :model/TaskRun {run-a :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))}
+ :model/TaskHistory _ns-a {:task "notification-send"
+ :run_id run-a
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))
+ :task_details {:notification_id n1}}
+ :model/TaskHistory _cs-a {:task "channel-send"
+ :run_id run-a
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))
+ :task_details {:channel_type "channel/email"
+ :notification_id n1}}
+ ;; tick-B: fires for n2 only
+ :model/TaskRun {run-b :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))}
+ :model/TaskHistory _ns-b {:task "notification-send"
+ :run_id run-b
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:notification_id n2}}
+ :model/TaskHistory _cs-b {:task "channel-send"
+ :run_id run-b
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:channel_type "channel/slack"
+ :notification_id n2}}]
+ ;; suppress unused-var warnings
+ (let [_ [run-a run-b]]
+ (testing "detail for n1 sees only tick-A in check_history and send_history"
+ (let [resp-n1 (mt/user-http-request :crowberto :get 200 (str "notification/admin/" n1))]
+ (is (= 1 (count (:check_history resp-n1)))
+ "n1 check_history has exactly 1 tick (tick-A)")
+ (is (= 1 (count (:send_history resp-n1)))
+ "n1 send_history has exactly 1 tick (tick-A)")
+ (is (=? {:channels [{:channel_type "channel/email"}]}
+ (first (:send_history resp-n1))))))
+ (testing "detail for n2 sees only tick-B in check_history and send_history"
+ (let [resp-n2 (mt/user-http-request :crowberto :get 200 (str "notification/admin/" n2))]
+ (is (= 1 (count (:check_history resp-n2)))
+ "n2 check_history has exactly 1 tick (tick-B)")
+ (is (= 1 (count (:send_history resp-n2)))
+ "n2 send_history has exactly 1 tick (tick-B)")
+ (is (=? {:channels [{:channel_type "channel/slack"}]}
+ (first (:send_history resp-n2))))))))))
+
+(deftest detail-goal-not-met-tick-absent-from-send-history-test
+ (testing "A tick where the goal was not met (no channel-send rows) appears in check_history but NOT send_history"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {nid :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ ;; tick-1: goal not met — notification-send row exists but no channel-send
+ :model/TaskRun {run-skip :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))}
+ :model/TaskHistory _ns-skip {:task "notification-send"
+ :run_id run-skip
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 2))
+ :ended_at (t/minus (t/instant) (t/hours 2))
+ :task_details {:notification_id nid
+ :skip_reason "goal-not-met"}}
+ ;; tick-2: goal met — has channel-send
+ :model/TaskRun {run-sent :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))}
+ :model/TaskHistory _ns-sent {:task "notification-send"
+ :run_id run-sent
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:notification_id nid}}
+ :model/TaskHistory _cs-sent {:task "channel-send"
+ :run_id run-sent
+ :status :success
+ :started_at (t/minus (t/instant) (t/hours 1))
+ :ended_at (t/minus (t/instant) (t/hours 1))
+ :task_details {:channel_type "channel/email"
+ :notification_id nid}}]
+ ;; suppress unused-var warnings
+ (let [_ [run-skip run-sent]
+ resp (mt/user-http-request :crowberto :get 200 (str "notification/admin/" nid))]
+ (is (= 2 (count (:check_history resp)))
+ "both ticks appear in check_history")
+ (is (= 1 (count (:send_history resp)))
+ "only the goal-met tick appears in send_history — goal-not-met tick is absent")
+ (is (=? {:channels [{:channel_type "channel/email" :status "successful"}]}
+ (first (:send_history resp))))))))
+
+(deftest detail-last-check-and-last-send-derived-from-histories-test
+ (testing "GET /:id: last_check and last_send are derived per-notification from histories, not from card-level join"
+ (mt/with-temp [:model/Card {card-id :id} {:archived false}
+ :model/NotificationCard {nc :id} {:card_id card-id}
+ :model/Notification {n1 :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ :model/Notification {n2 :id} {:payload_type :notification/card
+ :payload_id nc
+ :creator_id (mt/user->id :crowberto)}
+ ;; Only n2 has ever fired
+ :model/TaskRun {run2 :id} {:run_type :alert
+ :entity_type :card
+ :entity_id card-id
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)}
+ :model/TaskHistory _ns2 {:task "notification-send"
+ :run_id run2
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:notification_id n2}}
+ :model/TaskHistory _cs2 {:task "channel-send"
+ :run_id run2
+ :status :success
+ :started_at (t/instant)
+ :ended_at (t/instant)
+ :task_details {:channel_type "channel/email"
+ :notification_id n2}}]
+ (let [_ run2
+ resp-n1 (mt/user-http-request :crowberto :get 200 (str "notification/admin/" n1))]
+ (testing "n1 has nil last_check and nil last_send because it has never fired"
+ (is (nil? (:last_check resp-n1))
+ "n1 last_check is nil — the card-level task_run is for n2 only")
+ (is (nil? (:last_send resp-n1))
+ "n1 last_send is nil — the channel-send belongs to n2"))))))