Auto merge of #359 - pietroalbini:failure, r=pietroalbini

Migrate from error-chain to failure

Author: bors

Cargo.lock

@@ -61,6 +61,7 @@ chrono-humanize = "0.0.11"
 csv = "1.0.2"
 rusoto_credential = "0.13.0"
 nix = "0.11.0"
+failure = "0.1.3"
 
 [dev-dependencies]
 assert_cmd = "0.10.1"

Cargo.toml

@@ -1,8 +1,9 @@
+use actions::experiments::ExperimentError;
 use chrono::Utc;
 use config::Config;
 use db::{Database, QueryUtils};
-use errors::*;
 use experiments::{CapLints, CrateSelect, Experiment, GitHubIssue, Mode, Status};
+use prelude::*;
 use toolchain::Toolchain;
 
 pub struct CreateExperiment {
@@ -31,15 +32,15 @@ impl CreateExperiment {
         }
     }
 
-    pub fn apply(self, db: &Database, config: &Config) -> Result<()> {
+    pub fn apply(self, db: &Database, config: &Config) -> Fallible<()> {
         // Ensure no duplicate experiments are created
         if Experiment::exists(db, &self.name)? {
-            return Err(ErrorKind::ExperimentAlreadyExists(self.name).into());
+            return Err(ExperimentError::AlreadyExists(self.name).into());
         }
 
         // Ensure no experiment with duplicate toolchains is created
         if self.toolchains[0] == self.toolchains[1] {
-            return Err(ErrorKind::DuplicateToolchains.into());
+            return Err(ExperimentError::DuplicateToolchains.into());
         }
 
         let crates = ::crates::lists::get_crates(self.crates, db, config)?;
@@ -74,16 +75,18 @@ impl CreateExperiment {
             }
 
             Ok(())
-        })
+        })?;
+
+        Ok(())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::CreateExperiment;
+    use actions::ExperimentError;
     use config::Config;
     use db::Database;
-    use errors::*;
     use experiments::{CapLints, CrateSelect, Experiment, GitHubIssue, Mode, Status};
     use toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
 
@@ -154,10 +157,10 @@ mod tests {
         }.apply(&db, &config)
         .unwrap_err();
 
-        match err.kind() {
-            ErrorKind::DuplicateToolchains => {}
-            other => panic!("received unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::DuplicateToolchains)
+        );
     }
 
     #[test]
@@ -191,9 +194,9 @@ mod tests {
         }.apply(&db, &config)
         .unwrap_err();
 
-        match err.kind() {
-            ErrorKind::ExperimentAlreadyExists(name) => assert_eq!(name, "foo"),
-            other => panic!("received unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::AlreadyExists("foo".into()))
+        );
     }
 }

src/actions/experiments/create.rs

@@ -1,16 +1,17 @@
+use actions::experiments::ExperimentError;
 use config::Config;
 use db::{Database, QueryUtils};
-use errors::*;
 use experiments::Experiment;
+use prelude::*;
 
 pub struct DeleteExperiment {
     pub name: String,
 }
 
 impl DeleteExperiment {
-    pub fn apply(self, db: &Database, _config: &Config) -> Result<()> {
+    pub fn apply(self, db: &Database, _config: &Config) -> Fallible<()> {
         if !Experiment::exists(db, &self.name)? {
-            return Err(ErrorKind::ExperimentNotFound(self.name).into());
+            return Err(ExperimentError::NotFound(self.name).into());
         }
 
         // This will also delete all the data related to this experiment, thanks to the foreign
@@ -24,10 +25,9 @@ impl DeleteExperiment {
 #[cfg(test)]
 mod tests {
     use super::DeleteExperiment;
-    use actions::CreateExperiment;
+    use actions::{CreateExperiment, ExperimentError};
     use config::Config;
     use db::Database;
-    use errors::*;
     use experiments::Experiment;
 
     #[test]
@@ -40,10 +40,10 @@ mod tests {
         }.apply(&db, &config)
         .unwrap_err();
 
-        match err.kind() {
-            ErrorKind::ExperimentNotFound(name) => assert_eq!(name, "dummy"),
-            other => panic!("unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::NotFound("dummy".into()))
+        );
     }
 
     #[test]

src/actions/experiments/delete.rs

@@ -1,7 +1,8 @@
+use actions::experiments::ExperimentError;
 use config::Config;
 use db::{Database, QueryUtils};
-use errors::*;
 use experiments::{CapLints, CrateSelect, Experiment, Mode, Status};
+use prelude::*;
 use toolchain::Toolchain;
 
 pub struct EditExperiment {
@@ -26,18 +27,18 @@ impl EditExperiment {
         }
     }
 
-    pub fn apply(mut self, db: &Database, config: &Config) -> Result<bool> {
+    pub fn apply(mut self, db: &Database, config: &Config) -> Fallible<bool> {
         let mut ex = match Experiment::get(db, &self.name)? {
             Some(ex) => ex,
-            None => return Err(ErrorKind::ExperimentNotFound(self.name).into()),
+            None => return Err(ExperimentError::NotFound(self.name).into()),
         };
 
         // Ensure no change is made to running or complete experiments
         if ex.status != Status::Queued {
-            return Err(ErrorKind::CanEditOnlyQueuedExperiments.into());
+            return Err(ExperimentError::CanOnlyEditQueuedExperiments.into());
         }
 
-        db.transaction(|t| {
+        Ok(db.transaction(|t| {
             let mut has_changed = false;
 
             // Try to update both toolchains
@@ -47,7 +48,7 @@ impl EditExperiment {
 
                     // Ensure no duplicate toolchain is inserted
                     if ex.toolchains[0] == ex.toolchains[1] {
-                        return Err(ErrorKind::DuplicateToolchains.into());
+                        return Err(ExperimentError::DuplicateToolchains.into());
                     }
 
                     let changes = t.execute(
@@ -123,17 +124,16 @@ impl EditExperiment {
             }
 
             Ok(has_changed)
-        })
+        })?)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::EditExperiment;
-    use actions::CreateExperiment;
+    use actions::{CreateExperiment, ExperimentError};
     use config::Config;
     use db::Database;
-    use errors::*;
     use experiments::{CapLints, CrateSelect, Experiment, Mode, Status};
     use toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
 
@@ -217,10 +217,10 @@ mod tests {
         edit.toolchains[1] = Some(MAIN_TOOLCHAIN.clone());
 
         let err = edit.apply(&db, &config).unwrap_err();
-        match err.kind() {
-            ErrorKind::DuplicateToolchains => {}
-            other => panic!("received unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::DuplicateToolchains)
+        );
     }
 
     #[test]
@@ -233,10 +233,10 @@ mod tests {
         let err = EditExperiment::dummy("foo")
             .apply(&db, &config)
             .unwrap_err();
-        match err.kind() {
-            ErrorKind::ExperimentNotFound(name) => assert_eq!(name, "foo"),
-            other => panic!("received unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::NotFound("foo".into()))
+        );
     }
 
     #[test]
@@ -255,9 +255,9 @@ mod tests {
         let err = EditExperiment::dummy("foo")
             .apply(&db, &config)
             .unwrap_err();
-        match err.kind() {
-            ErrorKind::CanEditOnlyQueuedExperiments => {}
-            other => panic!("received unexpected error: {}", other),
-        }
+        assert_eq!(
+            err.downcast_ref(),
+            Some(&ExperimentError::CanOnlyEditQueuedExperiments)
+        );
     }
 }

src/actions/experiments/edit.rs

@@ -5,3 +5,16 @@ mod edit;
 pub use self::create::CreateExperiment;
 pub use self::delete::DeleteExperiment;
 pub use self::edit::EditExperiment;
+
+#[derive(Debug, Fail)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+pub enum ExperimentError {
+    #[fail(display = "experiment '{}' not found", _0)]
+    NotFound(String),
+    #[fail(display = "experiment '{}' already exists", _0)]
+    AlreadyExists(String),
+    #[fail(display = "duplicate toolchains provided")]
+    DuplicateToolchains,
+    #[fail(display = "it's only possible to edit queued experiments")]
+    CanOnlyEditQueuedExperiments,
+}

src/actions/experiments/mod.rs

@@ -1,7 +1,7 @@
 use config::Config;
 use crates::lists::{GitHubList, List, LocalList, RegistryList};
 use db::Database;
-use errors::*;
+use prelude::*;
 
 pub struct UpdateLists {
     pub github: bool,
@@ -20,7 +20,7 @@ impl Default for UpdateLists {
 }
 
 impl UpdateLists {
-    pub fn apply(self, db: &Database, _config: &Config) -> Result<()> {
+    pub fn apply(self, db: &Database, _config: &Config) -> Fallible<()> {
         if self.github {
             info!("updating GitHub repositories list");
             GitHubList::default().update(db)?;