Support querying event sequences via iterators or streams.

These filters are meant to be used with, respectively, `Iterator::filter_map` and `StreamExt::filter_map`. The two operations are conceptually the same - they pass an item from the underlying sequence to a function that returns an option, drops the values for which the function returns `None`, and yields the value inside of `Some` in the resulting sequence.

However, `Iterator::filter_map` takes a function from the iterator elements to `Option<T>`. `StreamExt::filter_map` takes a function from the iterator elements to _a `Future` whose output is `Option<T>`_. As such, you can't easily use functions designed for one use case, for the other. You need an adapter - conventionally, `futures::ready`, if you have a non-async function and need an async one.

This provides two sets of sequence filters:

* `crate::test::fixtures::event` contains functions which return `Option` directly, and which are intended for use with `Iterator::filter_map`.
* `crate::test::fixtures::event::stream` contains lifted versions that return a `Future`, and which are intended for use with `StreamExt::filter_map`.

The lifting is done purely manually. I spent a lot of time writing clever-er versions before deciding on this; those were fun to write, but hell to read and not meaningfully better, and this is test support code, so we want it to be dumb and obvious. Complexity for the sake of intellectual satisfaction is a huge antifeature in this context.

1 files changed, 74 insertions, 0 deletions

diff --git a/src/test/fixtures/event/mod.rs b/src/test/fixtures/event/mod.rs
new file mode 100644
index 0000000..691cdeb
--- /dev/null
+++ b/src/test/fixtures/event/mod.rs
@@ -0,0 +1,74 @@
+use crate::event::Event;
+
+pub mod stream;
+
+pub fn channel(event: Event) -> Option<crate::channel::Event> {
+    match event {
+        Event::Channel(channel) => Some(channel),
+        _ => None,
+    }
+}
+
+pub fn message(event: Event) -> Option<crate::message::Event> {
+    match event {
+        Event::Message(event) => Some(event),
+        _ => None,
+    }
+}
+
+pub fn user(event: Event) -> Option<crate::user::Event> {
+    match event {
+        Event::User(event) => Some(event),
+        _ => None,
+    }
+}
+
+pub mod channel {
+    use crate::channel::{Event, event};
+
+    pub fn created(event: Event) -> Option<event::Created> {
+        match event {
+            Event::Created(event) => Some(event),
+            Event::Deleted(_) => None,
+        }
+    }
+
+    pub fn deleted(event: Event) -> Option<event::Deleted> {
+        match event {
+            Event::Deleted(event) => Some(event),
+            Event::Created(_) => None,
+        }
+    }
+}
+
+pub mod message {
+    use crate::message::{Event, event};
+
+    pub fn sent(event: Event) -> Option<event::Sent> {
+        match event {
+            Event::Sent(event) => Some(event),
+            Event::Deleted(_) => None,
+        }
+    }
+
+    pub fn deleted(event: Event) -> Option<event::Deleted> {
+        match event {
+            Event::Deleted(event) => Some(event),
+            Event::Sent(_) => None,
+        }
+    }
+}
+
+pub mod user {
+    use crate::user::{Event, event};
+
+    // This could be defined as `-> event::Created`. However, I want the interface to be consistent
+    // with the event stream transformers for other types, and we'd have to refactor the return type
+    // to `-> Option<event::Created>` the instant users sprout a second event, anyways.
+    #[allow(clippy::unnecessary_wraps)]
+    pub fn created(event: Event) -> Option<event::Created> {
+        match event {
+            Event::Created(event) => Some(event),
+        }
+    }
+}