From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from gate001.proxmox.com (gate001.proxmox.com [IPv6:2a0f:8001:1:32::40]) by lore.proxmox.com (Postfix) with ESMTPS id A602F1FF0C0 for ; Wed, 18 Nov 2026 10:50:04 +0100 (CET) Received: from gate001.proxmox.com (localhost.localdomain [127.0.0.1]) by gate001.proxmox.com (Proxmox) with ESMTP id 47D8321C3E; Wed, 18 Nov 2026 10:45:07 +0100 (CET) From: Lukas Wagner To: pve-devel@lists.proxmox.com Subject: [PATCH proxmox v2 11/63] notify: move `send`, `test_target` and `Bus` to new `send` module Date: Wed, 18 Nov 2026 10:42:55 +0100 Message-ID: <20261118094348.273646-12-l.wagner@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261118094348.273646-1-l.wagner@proxmox.com> References: <20261118094348.273646-1-l.wagner@proxmox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1794995036217 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.189 Adjusted score from AWL reputation of From: address DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment (newer systems) RCVD_IN_DNSWL_MED -2.3 Sender listed at https://www.dnswl.org/, medium trust SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record Message-ID-Hash: KJ6KM3UDKVUWM7LQDPVVU62XANACKURE X-Message-ID-Hash: KJ6KM3UDKVUWM7LQDPVVU62XANACKURE X-MailFrom: l.wagner@proxmox.com X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; loop; banned-address; emergency; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header X-Mailman-Version: 3.3.10 Precedence: list List-Id: Proxmox VE development discussion List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: lib.rs has grown quite large, so moving functionality to smaller submodules is appropriate. This also makes it easier to feature-gate these functions/types with a single directive in lib.rs. Signed-off-by: Lukas Wagner --- proxmox-notify/src/api/common.rs | 47 +--- proxmox-notify/src/lib.rs | 374 +---------------------------- proxmox-notify/src/send.rs | 393 +++++++++++++++++++++++++++++++ 3 files changed, 398 insertions(+), 416 deletions(-) create mode 100644 proxmox-notify/src/send.rs diff --git a/proxmox-notify/src/api/common.rs b/proxmox-notify/src/api/common.rs index 56a9797a9..a31cbaea8 100644 --- a/proxmox-notify/src/api/common.rs +++ b/proxmox-notify/src/api/common.rs @@ -1,51 +1,6 @@ use proxmox_http_error::HttpError; -use super::http_err; -use crate::{Bus, Config, Context, Error, Notification}; - -/// Send a notification to a given target. -/// -/// The caller is responsible for any needed permission checks. -/// Returns an `anyhow::Error` in case of an error. -pub fn send( - context: &Context, - config: &Config, - notification: &Notification, -) -> Result<(), HttpError> { - let bus = Bus::from_config(config).map_err(|err| { - http_err!( - INTERNAL_SERVER_ERROR, - "Could not instantiate notification bus: {err}" - ) - })?; - - bus.send(context, notification); - - Ok(()) -} - -/// Test target (group or single endpoint) identified by its `name`. -/// -/// The caller is responsible for any needed permission checks. -/// Returns an `anyhow::Error` if sending via the endpoint failed. -pub fn test_target(context: &Context, config: &Config, endpoint: &str) -> Result<(), HttpError> { - let bus = Bus::from_config(config).map_err(|err| { - http_err!( - INTERNAL_SERVER_ERROR, - "Could not instantiate notification bus: {err}" - ) - })?; - - bus.test_target(context, endpoint) - .map_err(|err| match err { - Error::TargetDoesNotExist(endpoint) => { - http_err!(NOT_FOUND, "endpoint '{endpoint}' does not exist") - } - _ => http_err!(INTERNAL_SERVER_ERROR, "Could not test target: {err}"), - })?; - - Ok(()) -} +use crate::Config; /// Return all entities (targets, groups, filters) that are linked to the entity. /// For instance, if a group 'grp1' contains the targets 'a', 'b' and 'c', diff --git a/proxmox-notify/src/lib.rs b/proxmox-notify/src/lib.rs index c74e7e1a9..2061d9150 100644 --- a/proxmox-notify/src/lib.rs +++ b/proxmox-notify/src/lib.rs @@ -7,8 +7,7 @@ use std::str::FromStr; use serde::{Deserialize, Serialize}; use serde_json::Value; -use serde_json::json; -use tracing::{error, info}; +use tracing::error; use proxmox_config_digest::ConfigDigest; use proxmox_schema::api; @@ -24,6 +23,9 @@ pub mod endpoints; pub mod renderer; pub mod schema; +#[cfg(feature = "send-impl")] +pub mod send; + #[cfg(feature = "api-types")] pub mod api_types; @@ -33,11 +35,6 @@ pub use error::Error; pub use context::Context; pub use context::ContextImpl; -use endpoints::Endpoint; - -use crate::api_types::MATCHER_TYPENAME; -use crate::api_types::MatcherConfig; - #[api()] #[derive(Clone, Debug, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd)] #[serde(rename_all = "kebab-case")] @@ -307,366 +304,3 @@ impl Config { &self.digest } } - -/// Notification bus - distributes notifications to all registered endpoints -// The reason for the split between `Config` and this struct is to make testing with mocked -// endpoints a bit easier. -#[derive(Default)] -pub struct Bus { - endpoints: HashMap>, - matchers: Vec, -} - -macro_rules! parse_endpoints_with_private_config { - ($config:ident, $public_config:ty, $private_config:ty, $endpoint_type:ident, $type_name:expr) => { - (|| -> Result>, Error> { - let mut endpoints = Vec::>::new(); - - let configs: Vec<$public_config> = $config - .config - .convert_to_typed_array($type_name) - .map_err(|err| Error::ConfigDeserialization(err.into()))?; - - for config in configs { - match $config.private_config.sections.get(&config.name) { - Some((section_type_name, private_config)) => { - if $type_name != section_type_name { - error!( - "Could not instantiate endpoint '{name}': \ - private config has wrong type", - name = config.name - ); - } - let private_config = <$private_config>::deserialize(private_config) - .map_err(|err| Error::ConfigDeserialization(err.into()))?; - - endpoints.push(Box::new($endpoint_type { - config, - private_config: private_config.clone(), - })); - } - None => error!( - "Could not instantiate endpoint '{name}': \ - private config does not exist", - name = config.name - ), - } - } - - Ok(endpoints) - })() - }; -} - -macro_rules! parse_endpoints_without_private_config { - ($config:ident, $public_config:ty, $endpoint_type:ident, $type_name:expr) => { - (|| -> Result>, Error> { - let mut endpoints = Vec::>::new(); - - let configs: Vec<$public_config> = $config - .config - .convert_to_typed_array($type_name) - .map_err(|err| Error::ConfigDeserialization(err.into()))?; - - for config in configs { - endpoints.push(Box::new($endpoint_type { config })); - } - - Ok(endpoints) - })() - }; -} - -impl Bus { - /// Instantiate notification bus from a given configuration. - pub fn from_config(config: &Config) -> Result { - let mut endpoints = HashMap::new(); - - // Instantiate endpoints - use crate::api_types::{SENDMAIL_TYPENAME, SendmailConfig}; - use endpoints::sendmail::SendmailEndpoint; - endpoints.extend( - parse_endpoints_without_private_config!( - config, - SendmailConfig, - SendmailEndpoint, - SENDMAIL_TYPENAME - )? - .into_iter() - .map(|e| (e.name().into(), e)), - ); - - use crate::api_types::{GOTIFY_TYPENAME, GotifyConfig, GotifyPrivateConfig}; - use crate::endpoints::gotify::GotifyEndpoint; - - endpoints.extend( - parse_endpoints_with_private_config!( - config, - GotifyConfig, - GotifyPrivateConfig, - GotifyEndpoint, - GOTIFY_TYPENAME - )? - .into_iter() - .map(|e| (e.name().into(), e)), - ); - - use crate::api_types::{SMTP_TYPENAME, SmtpConfig, SmtpPrivateConfig}; - use endpoints::smtp::SmtpEndpoint; - - endpoints.extend( - parse_endpoints_with_private_config!( - config, - SmtpConfig, - SmtpPrivateConfig, - SmtpEndpoint, - SMTP_TYPENAME - )? - .into_iter() - .map(|e| (e.name().into(), e)), - ); - - use crate::api_types::{WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig}; - use endpoints::webhook::WebhookEndpoint; - endpoints.extend( - parse_endpoints_with_private_config!( - config, - WebhookConfig, - WebhookPrivateConfig, - WebhookEndpoint, - WEBHOOK_TYPENAME - )? - .into_iter() - .map(|e| (e.name().into(), e)), - ); - - let matchers = config - .config - .convert_to_typed_array(MATCHER_TYPENAME) - .map_err(|err| Error::ConfigDeserialization(err.into()))?; - - Ok(Bus { - endpoints, - matchers, - }) - } - - #[cfg(test)] - pub(crate) fn add_endpoint(&mut self, endpoint: Box) { - self.endpoints.insert(endpoint.name().to_string(), endpoint); - } - - #[cfg(test)] - pub fn add_matcher(&mut self, filter: MatcherConfig) { - self.matchers.push(filter) - } - - /// Send a notification. Notification matchers will determine which targets will receive - /// the notification. - /// - /// Any errors will not be returned but only logged. - pub fn send(&self, context: &Context, notification: &Notification) { - let targets = api_types::check_matches(self.matchers.as_slice(), notification); - - for target in targets { - if let Some(endpoint) = self.endpoints.get(target) { - let name = endpoint.name(); - - if endpoint.disabled() { - // Skip this target if it is disabled - info!("skipping disabled target '{name}'"); - continue; - } - - match endpoint.send(context, notification) { - Ok(_) => { - info!("notified via target `{name}`"); - } - Err(e) => { - // Only log on errors, do not propagate fail to the caller. - error!("could not notify via target `{name}`: {e}"); - } - } - } else { - error!("could not notify via target '{target}', it does not exist"); - } - } - } - - /// Send a test notification to a target (endpoint or group). - /// - /// In contrast to the `send` function, this function will return - /// any errors to the caller. - pub fn test_target(&self, context: &Context, target: &str) -> Result<(), Error> { - let notification = Notification { - metadata: Metadata { - severity: Severity::Info, - // TODO: what fields would make sense for test notifications? - additional_fields: Default::default(), - timestamp: proxmox_time::epoch_i64(), - }, - content: Content::Template { - template_name: "test".to_string(), - data: json!({ "target": target }), - }, - id: Uuid::generate(), - }; - - if let Some(endpoint) = self.endpoints.get(target) { - endpoint.send(context, ¬ification)?; - } else { - return Err(Error::target_does_not_exist(target)); - } - - Ok(()) - } -} - -#[cfg(test)] -mod tests { - use std::{cell::RefCell, rc::Rc}; - - use proxmox_match_expression::Expression; - - use crate::{ - api_types::{expression::NotificationMatcher, severity::SeverityMatcher}, - context::{Context, test}, - }; - - use super::*; - - #[derive(Default, Clone)] - struct MockEndpoint { - name: &'static str, - // Needs to be an Rc so that we can clone MockEndpoint before - // passing it to Bus, while still retaining a handle to the Vec - messages: Rc>>, - } - - impl Endpoint for MockEndpoint { - fn send(&self, _context: &Context, message: &Notification) -> Result<(), Error> { - self.messages.borrow_mut().push(message.clone()); - - Ok(()) - } - - fn name(&self) -> &str { - self.name - } - - fn disabled(&self) -> bool { - false - } - } - - impl MockEndpoint { - fn new(name: &'static str) -> Self { - Self { - name, - ..Default::default() - } - } - - fn messages(&self) -> Vec { - self.messages.borrow().clone() - } - } - - fn expression_to_string(expression: Expression) -> String { - serde_json::to_string(&expression).unwrap() - } - - #[test] - fn test_add_mock_endpoint() -> Result<(), Error> { - let context = test::test_context(); - let mock = MockEndpoint::new("endpoint"); - - let mut bus = Bus::default(); - bus.add_endpoint(Box::new(mock.clone())); - - let matcher = MatcherConfig { - target: vec!["endpoint".into()], - expression: Some(expression_to_string(Expression::Constant(true))), - ..Default::default() - }; - - bus.add_matcher(matcher); - - // Send directly to endpoint - bus.send( - &context, - &Notification::from_template( - Severity::Info, - "test", - Default::default(), - Default::default(), - ), - ); - let messages = mock.messages(); - assert_eq!(messages.len(), 1); - - Ok(()) - } - - #[test] - fn test_multiple_endpoints_with_different_matchers() -> Result<(), Error> { - let context = test::test_context(); - - let endpoint1 = MockEndpoint::new("mock1"); - let endpoint2 = MockEndpoint::new("mock2"); - - let mut bus = Bus::default(); - - bus.add_endpoint(Box::new(endpoint1.clone())); - bus.add_endpoint(Box::new(endpoint2.clone())); - - bus.add_matcher(MatcherConfig { - name: "matcher1".into(), - expression: Some(expression_to_string( - SeverityMatcher { - severities: vec![Severity::Error, Severity::Warning], - } - .into(), - )), - target: vec!["mock1".into()], - ..Default::default() - }); - - bus.add_matcher(MatcherConfig { - name: "matcher2".into(), - expression: Some(expression_to_string( - SeverityMatcher { - severities: vec![Severity::Error], - } - .into(), - )), - target: vec!["mock2".into()], - ..Default::default() - }); - - let send_with_severity = |severity| { - let notification = Notification::from_template( - severity, - "test", - Default::default(), - Default::default(), - ); - - bus.send(&context, ¬ification); - }; - - send_with_severity(Severity::Info); - assert_eq!(endpoint1.messages().len(), 0); - assert_eq!(endpoint2.messages().len(), 0); - - send_with_severity(Severity::Warning); - assert_eq!(endpoint1.messages().len(), 1); - assert_eq!(endpoint2.messages().len(), 0); - - send_with_severity(Severity::Error); - assert_eq!(endpoint1.messages().len(), 2); - assert_eq!(endpoint2.messages().len(), 1); - - Ok(()) - } -} diff --git a/proxmox-notify/src/send.rs b/proxmox-notify/src/send.rs new file mode 100644 index 000000000..3ef63aa8c --- /dev/null +++ b/proxmox-notify/src/send.rs @@ -0,0 +1,393 @@ +use std::collections::HashMap; + +use proxmox_uuid::Uuid; +use serde::Deserialize; +use serde_json::json; +use tracing::{error, info}; + +use crate::api_types::{GOTIFY_TYPENAME, GotifyConfig, GotifyPrivateConfig}; +use crate::api_types::{MATCHER_TYPENAME, MatcherConfig}; +use crate::api_types::{SENDMAIL_TYPENAME, SendmailConfig}; +use crate::api_types::{SMTP_TYPENAME, SmtpConfig, SmtpPrivateConfig}; +use crate::api_types::{WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig}; +use crate::endpoints::Endpoint; +use crate::endpoints::gotify::GotifyEndpoint; +use crate::endpoints::sendmail::SendmailEndpoint; +use crate::endpoints::smtp::SmtpEndpoint; +use crate::endpoints::webhook::WebhookEndpoint; +use crate::{Config, Content, Context, Error, Metadata, Notification, Severity}; + +/// Send a notification to a given target. +/// +/// The caller is responsible for any needed permission checks. +/// Returns an `anyhow::Error` in case of an error. +pub fn send(context: &Context, config: &Config, notification: &Notification) -> Result<(), Error> { + let bus = Bus::from_config(config)?; + bus.send(context, notification); + + Ok(()) +} + +/// Test target (group or single endpoint) identified by its `name`. +/// +/// The caller is responsible for any needed permission checks. +/// Returns an `anyhow::Error` if sending via the endpoint failed. +pub fn test_target(context: &Context, config: &Config, endpoint: &str) -> Result<(), Error> { + let bus = Bus::from_config(config)?; + bus.test_target(context, endpoint)?; + + Ok(()) +} + +/// Notification bus - distributes notifications to all registered endpoints +// The reason for the split between `Config` and this struct is to make testing with mocked +// endpoints a bit easier. +#[derive(Default)] +struct Bus { + endpoints: HashMap>, + matchers: Vec, +} + +macro_rules! parse_endpoints_with_private_config { + ($config:ident, $public_config:ty, $private_config:ty, $endpoint_type:ident, $type_name:expr) => { + (|| -> Result>, Error> { + let mut endpoints = Vec::>::new(); + + let configs: Vec<$public_config> = $config + .config + .convert_to_typed_array($type_name) + .map_err(|err| Error::ConfigDeserialization(err.into()))?; + + for config in configs { + match $config.private_config.sections.get(&config.name) { + Some((section_type_name, private_config)) => { + if $type_name != section_type_name { + error!( + "Could not instantiate endpoint '{name}': \ + private config has wrong type", + name = config.name + ); + } + let private_config = <$private_config>::deserialize(private_config) + .map_err(|err| Error::ConfigDeserialization(err.into()))?; + + endpoints.push(Box::new($endpoint_type { + config, + private_config: private_config.clone(), + })); + } + None => error!( + "Could not instantiate endpoint '{name}': \ + private config does not exist", + name = config.name + ), + } + } + + Ok(endpoints) + })() + }; +} + +macro_rules! parse_endpoints_without_private_config { + ($config:ident, $public_config:ty, $endpoint_type:ident, $type_name:expr) => { + (|| -> Result>, Error> { + let mut endpoints = Vec::>::new(); + + let configs: Vec<$public_config> = $config + .config + .convert_to_typed_array($type_name) + .map_err(|err| Error::ConfigDeserialization(err.into()))?; + + for config in configs { + endpoints.push(Box::new($endpoint_type { config })); + } + + Ok(endpoints) + })() + }; +} + +impl Bus { + /// Instantiate notification bus from a given configuration. + pub fn from_config(config: &Config) -> Result { + let mut endpoints = HashMap::new(); + + // Instantiate endpoints + endpoints.extend( + parse_endpoints_without_private_config!( + config, + SendmailConfig, + SendmailEndpoint, + SENDMAIL_TYPENAME + )? + .into_iter() + .map(|e| (e.name().into(), e)), + ); + + endpoints.extend( + parse_endpoints_with_private_config!( + config, + GotifyConfig, + GotifyPrivateConfig, + GotifyEndpoint, + GOTIFY_TYPENAME + )? + .into_iter() + .map(|e| (e.name().into(), e)), + ); + + endpoints.extend( + parse_endpoints_with_private_config!( + config, + SmtpConfig, + SmtpPrivateConfig, + SmtpEndpoint, + SMTP_TYPENAME + )? + .into_iter() + .map(|e| (e.name().into(), e)), + ); + + endpoints.extend( + parse_endpoints_with_private_config!( + config, + WebhookConfig, + WebhookPrivateConfig, + WebhookEndpoint, + WEBHOOK_TYPENAME + )? + .into_iter() + .map(|e| (e.name().into(), e)), + ); + + let matchers = config + .config + .convert_to_typed_array(MATCHER_TYPENAME) + .map_err(|err| Error::ConfigDeserialization(err.into()))?; + + Ok(Bus { + endpoints, + matchers, + }) + } + + #[cfg(test)] + pub(crate) fn add_endpoint(&mut self, endpoint: Box) { + self.endpoints.insert(endpoint.name().to_string(), endpoint); + } + + #[cfg(test)] + pub(crate) fn add_matcher(&mut self, filter: MatcherConfig) { + self.matchers.push(filter) + } + + /// Send a notification. Notification matchers will determine which targets will receive + /// the notification. + /// + /// Any errors will not be returned but only logged. + pub fn send(&self, context: &Context, notification: &Notification) { + let targets = crate::api_types::check_matches(self.matchers.as_slice(), notification); + + for target in targets { + if let Some(endpoint) = self.endpoints.get(target) { + let name = endpoint.name(); + + if endpoint.disabled() { + // Skip this target if it is disabled + info!("skipping disabled target '{name}'"); + continue; + } + + match endpoint.send(context, notification) { + Ok(_) => { + info!("notified via target `{name}`"); + } + Err(e) => { + // Only log on errors, do not propagate fail to the caller. + error!("could not notify via target `{name}`: {e}"); + } + } + } else { + error!("could not notify via target '{target}', it does not exist"); + } + } + } + + /// Send a test notification to a target (endpoint or group). + /// + /// In contrast to the `send` function, this function will return + /// any errors to the caller. + pub fn test_target(&self, context: &Context, target: &str) -> Result<(), Error> { + let notification = Notification { + metadata: Metadata { + severity: Severity::Info, + // TODO: what fields would make sense for test notifications? + additional_fields: Default::default(), + timestamp: proxmox_time::epoch_i64(), + }, + content: Content::Template { + template_name: "test".to_string(), + data: json!({ "target": target }), + }, + id: Uuid::generate(), + }; + + if let Some(endpoint) = self.endpoints.get(target) { + endpoint.send(context, ¬ification)?; + } else { + return Err(Error::target_does_not_exist(target)); + } + + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use std::{cell::RefCell, rc::Rc}; + + use proxmox_match_expression::Expression; + + use crate::{ + api_types::{expression::NotificationMatcher, severity::SeverityMatcher}, + context::{Context, test}, + }; + + use super::*; + + #[derive(Default, Clone)] + struct MockEndpoint { + name: &'static str, + // Needs to be an Rc so that we can clone MockEndpoint before + // passing it to Bus, while still retaining a handle to the Vec + messages: Rc>>, + } + + impl Endpoint for MockEndpoint { + fn send(&self, _context: &Context, message: &Notification) -> Result<(), Error> { + self.messages.borrow_mut().push(message.clone()); + + Ok(()) + } + + fn name(&self) -> &str { + self.name + } + + fn disabled(&self) -> bool { + false + } + } + + impl MockEndpoint { + fn new(name: &'static str) -> Self { + Self { + name, + ..Default::default() + } + } + + fn messages(&self) -> Vec { + self.messages.borrow().clone() + } + } + + fn expression_to_string(expression: Expression) -> String { + serde_json::to_string(&expression).unwrap() + } + + #[test] + fn test_add_mock_endpoint() -> Result<(), Error> { + let context = test::test_context(); + let mock = MockEndpoint::new("endpoint"); + + let mut bus = Bus::default(); + bus.add_endpoint(Box::new(mock.clone())); + + let matcher = MatcherConfig { + target: vec!["endpoint".into()], + expression: Some(expression_to_string(Expression::Constant(true))), + ..Default::default() + }; + + bus.add_matcher(matcher); + + // Send directly to endpoint + bus.send( + &context, + &Notification::from_template( + Severity::Info, + "test", + Default::default(), + Default::default(), + ), + ); + let messages = mock.messages(); + assert_eq!(messages.len(), 1); + + Ok(()) + } + + #[test] + fn test_multiple_endpoints_with_different_matchers() -> Result<(), Error> { + let context = test::test_context(); + + let endpoint1 = MockEndpoint::new("mock1"); + let endpoint2 = MockEndpoint::new("mock2"); + + let mut bus = Bus::default(); + + bus.add_endpoint(Box::new(endpoint1.clone())); + bus.add_endpoint(Box::new(endpoint2.clone())); + + bus.add_matcher(MatcherConfig { + name: "matcher1".into(), + expression: Some(expression_to_string( + SeverityMatcher { + severities: vec![Severity::Error, Severity::Warning], + } + .into(), + )), + target: vec!["mock1".into()], + ..Default::default() + }); + + bus.add_matcher(MatcherConfig { + name: "matcher2".into(), + expression: Some(expression_to_string( + SeverityMatcher { + severities: vec![Severity::Error], + } + .into(), + )), + target: vec!["mock2".into()], + ..Default::default() + }); + + let send_with_severity = |severity| { + let notification = Notification::from_template( + severity, + "test", + Default::default(), + Default::default(), + ); + + bus.send(&context, ¬ification); + }; + + send_with_severity(Severity::Info); + assert_eq!(endpoint1.messages().len(), 0); + assert_eq!(endpoint2.messages().len(), 0); + + send_with_severity(Severity::Warning); + assert_eq!(endpoint1.messages().len(), 1); + assert_eq!(endpoint2.messages().len(), 0); + + send_with_severity(Severity::Error); + assert_eq!(endpoint1.messages().len(), 2); + assert_eq!(endpoint2.messages().len(), 1); + + Ok(()) + } +} -- 2.47.3