refactor: Add LifeCycle

Author: tomphp

src/commands/update/lifecycle.rs

@@ -0,0 +1,91 @@
+use super::event::Event;
+use uuid;
+use uuid::Uuid;
+
+pub struct LifeCycle {
+    id: Uuid,
+    file_name: String,
+}
+
+impl LifeCycle {
+    pub(crate) fn new(file_name: &str) -> Self {
+        Self {
+            id: Uuid::new_v4(),
+            file_name: file_name.to_string(),
+        }
+    }
+
+    pub(crate) fn start(&self) -> Event {
+        Event::Started(self.id, self.file_name.clone())
+    }
+
+    pub(crate) const fn succeed(&self) -> Event {
+        Event::Succeeded(self.id)
+    }
+
+    pub(crate) fn fail(&self, reason: &str) -> Event {
+        Event::Failed(self.id, reason.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Event;
+    use super::*;
+
+    #[test]
+    fn start_returns_a_started_event() {
+        let life_cycle = LifeCycle::new("file.txt");
+        assert!(
+            matches!(life_cycle.start(), Event::Started(_, file_name) if file_name == "file.txt")
+        );
+    }
+
+    #[test]
+    fn succeed_returns_a_succeed_event() {
+        let life_cycle = LifeCycle::new("file.txt");
+        assert!(matches!(life_cycle.succeed(), Event::Succeeded(_)));
+    }
+
+    #[test]
+    fn fail_returns_a_fail_event() {
+        let life_cycle = LifeCycle::new("file.txt");
+        assert!(
+            matches!(life_cycle.fail("error message"), Event::Failed(_, reason) if reason == "error message")
+        );
+    }
+
+    #[test]
+    #[allow(clippy::panic)]
+    fn new_returns_instances_with_unique_ids() {
+        let life_cycle1 = LifeCycle::new("file1.txt");
+        let life_cycle2 = LifeCycle::new("file2.txt");
+        match (life_cycle1.start(), life_cycle2.start()) {
+            (Event::Started(id1, _), Event::Started(id2, _)) => {
+                assert_ne!(id1, id2);
+            }
+            _ => panic!("Unexpected events returned from start()"),
+        }
+    }
+
+    #[test]
+    #[allow(clippy::panic)]
+    fn ids_are_consistent_within_a_lifecycle() {
+        let life_cycle = LifeCycle::new("file.txt");
+        let started = life_cycle.start();
+        let succeeded = life_cycle.succeed();
+        let failed = life_cycle.fail("error");
+
+        match (started, succeeded, failed) {
+            (
+                Event::Started(start_id, _),
+                Event::Succeeded(succeed_id),
+                Event::Failed(failed_id, _),
+            ) => {
+                assert_eq!(start_id, succeed_id);
+                assert_eq!(start_id, failed_id);
+            }
+            _ => panic!("Unexpected events returned from start()"),
+        }
+    }
+}

src/commands/update/mod.rs

@@ -1,8 +1,10 @@
 mod command;
 mod event;
+mod lifecycle;
 mod state;
 mod updater;
 
 pub use command::Command;
 pub use event::{Event, Stream as EventStream};
+pub use lifecycle::LifeCycle;
 pub use updater::Updater;

src/location_types/cargo/location.rs

@@ -3,10 +3,9 @@ use std::process::{Child, Command, ExitStatus, Stdio};
 
 use anyhow::anyhow;
 use async_stream::stream;
-use uuid::Uuid;
 
 use crate::commands::update;
-use crate::commands::update::Updater;
+use crate::commands::update::{LifeCycle, Updater};
 
 pub struct Location;
 
@@ -19,17 +18,17 @@ impl Location {
 impl Updater for Location {
     fn update(&self, version: String) -> update::EventStream {
         Box::pin(stream! {
-            let toml_id = Uuid::new_v4();
-            let lock_id = Uuid::new_v4();
-            yield update::Event::Started(toml_id, "Cargo.toml".to_string());
+            let toml_life_cycle = LifeCycle::new("Cargo.toml");
+            yield toml_life_cycle.start();
             match update_cargo_version(&version) {
                 Ok(()) => {
-                  yield update::Event::Succeeded(toml_id);
-                  yield update::Event::Started(lock_id, "Cargo.lock".to_string());
-                  yield update::Event::Succeeded(lock_id);
+                  yield toml_life_cycle.succeed();
+                  let lock_life_cycle = LifeCycle::new("Cargo.lock");
+                  yield lock_life_cycle.start();
+                  yield lock_life_cycle.succeed();
                 }
                 Err(err) => {
-                    yield update::Event::Failed(toml_id, err.to_string());
+                    yield toml_life_cycle.fail(&err.to_string())
                 }
             }
         })

src/location_types/string_pattern/location.rs

@@ -1,9 +1,8 @@
 use std::path::Path;
 
 use async_stream::stream;
-use uuid::Uuid;
 
-use crate::commands::update::{Event, EventStream, Updater};
+use crate::commands::update::{EventStream, LifeCycle, Updater};
 
 use super::config::Config;
 use super::pattern::Pattern;
@@ -25,11 +24,11 @@ impl Updater for Location {
         let config = self.config.clone();
 
         Box::pin(stream! {
-            let id = Uuid::new_v4();
-            yield Event::Started(id, config.file.clone());
+            let life_cycle = LifeCycle::new(&config.file);
+            yield life_cycle.start();
             match replace_version(&config, &version) {
-                Ok(()) => yield Event::Succeeded(id),
-                Err(err) => yield Event::Failed(id, err.to_string()),
+                Ok(()) => yield life_cycle.succeed(),
+                Err(err) => yield life_cycle.fail(&err.to_string()),
             }
         })
     }