nexus-acto-rs 0.4.2

A Rust crate for Actors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

#[cfg(test)]
mod tests {
  use std::sync::{Arc, RwLock};

  use crate::log::log::{LogLevel, Logger};
  use crate::log::log_event::LogEvent;
  use crate::log::log_event_stream::{publish_to_stream, subscribe_stream, unsubscribe_stream, LogEventStream};
  use crate::log::log_field::LogField;

  #[tokio::test]
  async fn test_logger_with() {
    let event_stream = LogEventStream::new();
    let base = Logger::new(event_stream, LogLevel::Debug, "").with_fields([LogField::string("first", "value")]);
    let l = base.with_fields([LogField::string("second", "value")]);

    assert_eq!(
      vec![LogField::string("first", "value"), LogField::string("second", "value")],
      l.get_context()
    );
  }

  #[tokio::test]
  async fn test_off_level_two_fields() {
    let event_stream = LogEventStream::new();
    let l = Logger::new(event_stream, LogLevel::Min, "");
    l.debug_with_fields("foo", [LogField::i32("bar", 32), LogField::bool("fum", false)])
      .await;
  }

  #[tokio::test]
  async fn test_off_level_only_context() {
    let event_stream = LogEventStream::new();
    let l = Logger::new(event_stream, LogLevel::Min, "")
      .with_fields([LogField::i32("bar", 32), LogField::bool("fum", false)]);
    l.debug("foo").await;
  }

  #[tokio::test]
  async fn test_debug_level_only_context_one_subscriber() {
    let event_stream = LogEventStream::new();
    let _s1 = subscribe_stream(&event_stream, |_: LogEvent| async {}).await;

    let l = Logger::new(event_stream, LogLevel::Debug, "")
      .with_fields([LogField::i32("bar", 32), LogField::bool("fum", false)]);
    l.debug("foo").await;

    unsubscribe_stream(&_s1).await;
  }

  #[tokio::test]
  async fn test_debug_level_only_context_multiple_subscribers() {
    let event_stream = LogEventStream::new();
    let _s1 = subscribe_stream(&event_stream, |_: LogEvent| async {}).await;
    let _s2 = subscribe_stream(&event_stream, |_: LogEvent| async {}).await;

    let l = Logger::new(event_stream, LogLevel::Debug, "")
      .with_fields([LogField::i32("bar", 32), LogField::bool("fum", false)]);
    l.debug("foo").await;

    unsubscribe_stream(&_s1).await;
    unsubscribe_stream(&_s2).await;
  }

  #[tokio::test]
  async fn test_subscribe_and_publish() {
    let event_stream = LogEventStream::new();
    let received = Arc::new(RwLock::new(Vec::new()));
    let received_clone = Arc::clone(&received);

    let sub = subscribe_stream(&event_stream, move |evt: LogEvent| {
      let received_clone = received_clone.clone();
      async move {
        received_clone.write().unwrap().push(evt.message.clone());
      }
    })
    .await;

    publish_to_stream(&event_stream, LogEvent::new(LogLevel::Info, "Test message".to_string())).await;

    assert_eq!(received.read().unwrap().len(), 1);
    assert_eq!(received.read().unwrap()[0], "Test message");

    unsubscribe_stream(&sub).await;
  }

  #[tokio::test]
  async fn test_min_level_filtering() {
    let event_stream = LogEventStream::new();
    let received = Arc::new(RwLock::new(Vec::new()));
    let received_clone = Arc::clone(&received);

    let sub = subscribe_stream(&event_stream, move |evt: LogEvent| {
      let received_clone = received_clone.clone();
      async move {
        received_clone.write().unwrap().push(evt.message.clone());
      }
    })
    .await
    .with_min_level(LogLevel::Warn);

    publish_to_stream(&event_stream, LogEvent::new(LogLevel::Info, "Info message".to_string())).await;
    publish_to_stream(&event_stream, LogEvent::new(LogLevel::Warn, "Warn message".to_string())).await;
    publish_to_stream(
      &event_stream,
      LogEvent::new(LogLevel::Error, "Error message".to_string()),
    )
    .await;

    assert_eq!(received.read().unwrap().len(), 2);
    assert_eq!(received.read().unwrap()[0], "Warn message");
    assert_eq!(received.read().unwrap()[1], "Error message");

    unsubscribe_stream(&sub).await;
  }
}