Use claim to simplify assertions

Cargo.toml

@@ -88,6 +88,7 @@ toml = "0.5"
 url = "2.1"
 
 [dev-dependencies]
+claim = "0.4.0"
 conduit-test = "0.9.0-alpha.3"
 diesel_migrations = { version = "1.3.0", features = ["postgres"] }
 hyper-tls = "0.4"

src/config.rs

@@ -187,5 +187,5 @@ fn parse_traffic_patterns_splits_on_comma_and_looks_for_equal_sign() {
     let patterns_2 = parse_traffic_patterns(pattern_string_2).collect::<Vec<_>>();
     assert_eq!(vec![("Baz", "QUX")], patterns_2);
 
-    assert!(parse_traffic_patterns(pattern_string_3).next().is_none());
+    assert_none!(parse_traffic_patterns(pattern_string_3).next());
 }

src/email.rs

@@ -141,12 +141,12 @@ mod tests {
             "test",
             "test",
         );
-        assert!(result.is_err());
+        assert_err!(result);
     }
 
     #[test]
     fn sending_to_valid_email_succeeds() {
         let result = send_email("someone@example.com", "test", "test");
-        assert!(result.is_ok());
+        assert_ok!(result);
     }
 }

src/lib.rs

@@ -7,6 +7,9 @@
 #![warn(clippy::all, rust_2018_idioms)]
 #![warn(missing_debug_implementations, missing_copy_implementations)]
 
+#[cfg(test)]
+#[macro_use]
+extern crate claim;
 #[macro_use]
 extern crate derive_deref;
 #[macro_use]

src/models/krate.rs

@@ -564,7 +564,7 @@ mod tests {
             repository: None,
             max_upload_size: None,
         };
-        assert!(krate.validate().is_err());
+        assert_err!(krate.validate());
     }
 
     #[test]

src/models/token.rs

@@ -133,14 +133,12 @@ mod tests {
             last_used_at: Some(NaiveDate::from_ymd(2017, 1, 6).and_hms(14, 23, 12)),
         };
         let json = serde_json::to_string(&tok).unwrap();
-        assert!(json
+        assert_some!(json
             .as_str()
-            .find(r#""created_at":"2017-01-06T14:23:11+00:00""#)
-            .is_some());
-        assert!(json
+            .find(r#""created_at":"2017-01-06T14:23:11+00:00""#));
+        assert_some!(json
             .as_str()
-            .find(r#""last_used_at":"2017-01-06T14:23:12+00:00""#)
-            .is_some());
+            .find(r#""last_used_at":"2017-01-06T14:23:12+00:00""#));
     }
 
     #[test]
@@ -154,13 +152,11 @@ mod tests {
             last_used_at: Some(NaiveDate::from_ymd(2017, 1, 6).and_hms(14, 23, 12)),
         };
         let json = serde_json::to_string(&tok).unwrap();
-        assert!(json
+        assert_some!(json
             .as_str()
-            .find(r#""created_at":"2017-01-06T14:23:11+00:00""#)
-            .is_some());
-        assert!(json
+            .find(r#""created_at":"2017-01-06T14:23:11+00:00""#));
+        assert_some!(json
             .as_str()
-            .find(r#""last_used_at":"2017-01-06T14:23:12+00:00""#)
-            .is_some());
+            .find(r#""last_used_at":"2017-01-06T14:23:12+00:00""#));
     }
 }

src/tests/all.rs

@@ -1,5 +1,7 @@
 #![warn(clippy::all, rust_2018_idioms)]
 
+#[macro_use]
+extern crate claim;
 #[macro_use]
 extern crate diesel;
 #[macro_use]
@@ -33,15 +35,6 @@ use conduit_test::MockRequest;
 use diesel::prelude::*;
 use reqwest::{blocking::Client, Proxy};
 
-macro_rules! t {
-    ($e:expr) => {
-        match $e {
-            Ok(e) => e,
-            Err(m) => panic!("{} failed with: {}", stringify!($e), m),
-        }
-    };
-}
-
 mod account_lock;
 mod authentication;
 mod badge;
@@ -164,7 +157,7 @@ fn build_app(
     };
 
     let app = App::new(config, client);
-    t!(t!(app.primary_database.get()).begin_test_transaction());
+    assert_ok!(assert_ok!(app.primary_database.get()).begin_test_transaction());
     let app = Arc::new(app);
     let handler = cargo_registry::build_handler(Arc::clone(&app));
     (app, handler)

src/tests/builders/publish.rs

@@ -14,7 +14,7 @@ lazy_static! {
         {
             let mut ar =
                 tar::Builder::new(GzEncoder::new(&mut empty_tarball, Compression::default()));
-            t!(ar.finish());
+            assert_ok!(ar.finish());
         }
         empty_tarball
     };
@@ -88,12 +88,12 @@ impl PublishBuilder {
             let mut ar = tar::Builder::new(GzEncoder::new(&mut tarball, Compression::default()));
             for &mut (name, ref mut data, size) in files {
                 let mut header = tar::Header::new_gnu();
-                t!(header.set_path(name));
+                assert_ok!(header.set_path(name));
                 header.set_size(size);
                 header.set_cksum();
-                t!(ar.append(&header, data));
+                assert_ok!(ar.append(&header, data));
             }
-            t!(ar.finish());
+            assert_ok!(ar.finish());
         }
 
         self.tarball = tarball;

src/tests/category.rs

@@ -44,8 +44,10 @@ fn show() {
 
     // Create a category and a subcategory
     app.db(|conn| {
-        t!(new_category("Foo Bar", "foo-bar", "Foo Bar crates").create_or_update(conn));
-        t!(new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates").create_or_update(conn));
+        assert_ok!(new_category("Foo Bar", "foo-bar", "Foo Bar crates").create_or_update(conn));
+        assert_ok!(
+            new_category("Foo Bar::Baz", "foo-bar::baz", "Baz crates").create_or_update(conn)
+        );
     });
 
     // The category and its subcategories should be in the json
@@ -69,8 +71,10 @@ fn update_crate() {
     let user = user.as_model();
 
     app.db(|conn| {
-        t!(new_category("cat1", "cat1", "Category 1 crates").create_or_update(conn));
-        t!(new_category("Category 2", "category-2", "Category 2 crates").create_or_update(conn));
+        assert_ok!(new_category("cat1", "cat1", "Category 1 crates").create_or_update(conn));
+        assert_ok!(
+            new_category("Category 2", "category-2", "Category 2 crates").create_or_update(conn)
+        );
         let krate = CrateBuilder::new("foo_crate", user.id).expect_build(&conn);
 
         // Updating with no categories has no effect
@@ -122,7 +126,7 @@ fn update_crate() {
         assert_eq!(count(&anon, "category-2"), 0);
 
         // Add a category and its subcategory
-        t!(new_category("cat1::bar", "cat1::bar", "bar crates").create_or_update(conn));
+        assert_ok!(new_category("cat1::bar", "cat1::bar", "bar crates").create_or_update(conn));
         Category::update_crate(&conn, &krate, &["cat1", "cat1::bar"]).unwrap();
 
         assert_eq!(count(&anon, "cat1"), 1);

src/tests/krate.rs

@@ -626,7 +626,7 @@ fn show() {
     assert_eq!(json.versions[0].id, versions[0]);
     assert_eq!(json.versions[0].krate, json.krate.id);
     assert_eq!(json.versions[0].num, "1.0.0");
-    assert!(json.versions[0].published_by.is_none());
+    assert_none!(&json.versions[0].published_by);
     let suffix = "/api/v1/crates/foo_show/1.0.0/download";
     assert!(
         json.versions[0].dl_path.ends_with(suffix),
@@ -688,7 +688,7 @@ fn versions() {
     assert_eq!(json.versions[0].num, "1.0.0");
     assert_eq!(json.versions[1].num, "0.5.1");
     assert_eq!(json.versions[2].num, "0.5.0");
-    assert!(json.versions[0].published_by.is_none());
+    assert_none!(&json.versions[0].published_by);
     assert_eq!(
         json.versions[1].published_by.as_ref().unwrap().login,
         user.gh_login
@@ -1182,7 +1182,7 @@ fn new_krate_git_upload() {
     app.run_pending_background_jobs();
 
     let crates = app.crates_from_index_head("3/f/fgt");
-    assert!(crates.len() == 1);
+    assert_eq!(crates.len(), 1);
     assert_eq!(crates[0].name, "fgt");
     assert_eq!(crates[0].vers, "1.0.0");
     assert!(crates[0].deps.is_empty());
@@ -1587,8 +1587,8 @@ fn yank_works_as_intended() {
     app.run_pending_background_jobs();
 
     let crates = app.crates_from_index_head("3/f/fyk");
-    assert!(crates.len() == 1);
-    assert!(!crates[0].yanked.unwrap());
+    assert_eq!(crates.len(), 1);
+    assert_some_eq!(crates[0].yanked, false);
 
     // make sure it's not yanked
     let json = anon.show_version("fyk", "1.0.0");
@@ -1598,8 +1598,8 @@ fn yank_works_as_intended() {
     token.yank("fyk", "1.0.0").good();
 
     let crates = app.crates_from_index_head("3/f/fyk");
-    assert!(crates.len() == 1);
-    assert!(crates[0].yanked.unwrap());
+    assert_eq!(crates.len(), 1);
+    assert_some_eq!(crates[0].yanked, true);
 
     let json = anon.show_version("fyk", "1.0.0");
     assert!(json.version.yanked);
@@ -1608,8 +1608,8 @@ fn yank_works_as_intended() {
     token.unyank("fyk", "1.0.0").good();
 
     let crates = app.crates_from_index_head("3/f/fyk");
-    assert!(crates.len() == 1);
-    assert!(!crates[0].yanked.unwrap());
+    assert_eq!(crates.len(), 1);
+    assert_some_eq!(crates[0].yanked, false);
 
     let json = anon.show_version("fyk", "1.0.0");
     assert!(!json.version.yanked);
@@ -1618,8 +1618,8 @@ fn yank_works_as_intended() {
     cookie.yank("fyk", "1.0.0").good();
 
     let crates = app.crates_from_index_head("3/f/fyk");
-    assert!(crates.len() == 1);
-    assert!(crates[0].yanked.unwrap());
+    assert_eq!(crates.len(), 1);
+    assert_some_eq!(crates[0].yanked, true);
 
     let json = anon.show_version("fyk", "1.0.0");
     assert!(json.version.yanked);
@@ -1628,8 +1628,8 @@ fn yank_works_as_intended() {
     cookie.unyank("fyk", "1.0.0").good();
 
     let crates = app.crates_from_index_head("3/f/fyk");
-    assert!(crates.len() == 1);
-    assert!(!crates[0].yanked.unwrap());
+    assert_eq!(crates.len(), 1);
+    assert_some_eq!(crates[0].yanked, false);
 
     let json = anon.show_version("fyk", "1.0.0");
     assert!(!json.version.yanked);
@@ -2118,7 +2118,7 @@ fn reverse_dependencies_includes_published_by_user_when_present() {
     assert_eq!(deps.versions.len(), 2);
 
     let c2_version = deps.versions.iter().find(|v| v.krate == "c2").unwrap();
-    assert!(c2_version.published_by.is_none());
+    assert_none!(&c2_version.published_by);
 
     let c3_version = deps.versions.iter().find(|v| v.krate == "c3").unwrap();
     assert_eq!(
@@ -2406,13 +2406,13 @@ fn new_krate_tarball_with_hard_links() {
     {
         let mut ar = tar::Builder::new(GzEncoder::new(&mut tarball, Compression::default()));
         let mut header = tar::Header::new_gnu();
-        t!(header.set_path("foo-1.1.0/bar"));
+        assert_ok!(header.set_path("foo-1.1.0/bar"));
         header.set_size(0);
         header.set_cksum();
         header.set_entry_type(tar::EntryType::hard_link());
-        t!(header.set_link_name("foo-1.1.0/another"));
-        t!(ar.append(&header, &[][..]));
-        t!(ar.finish());
+        assert_ok!(header.set_link_name("foo-1.1.0/another"));
+        assert_ok!(ar.append(&header, &[][..]));
+        assert_ok!(ar.finish());
     }
 
     let crate_to_publish = PublishBuilder::new("foo").version("1.1.0").tarball(tarball);

src/tests/record.rs

@@ -65,7 +65,7 @@ impl Drop for Bomb {
             Ok(_) if thread::panicking() => {}
             Ok(None) => {}
             Ok(Some((data, file))) => {
-                t!(t!(File::create(&file)).write_all(&data));
+                assert_ok!(assert_ok!(File::create(&file)).write_all(&data));
             }
         }
     }
@@ -97,7 +97,7 @@ pub fn proxy() -> (String, Bomb) {
         Record::Replay(serde_json::from_slice(b"[]").unwrap())
     } else {
         let mut body = Vec::new();
-        t!(t!(File::open(&data)).read_to_end(&mut body));
+        assert_ok!(assert_ok!(File::open(&data)).read_to_end(&mut body));
         Record::Replay(serde_json::from_slice(&body).unwrap())
     };
 
@@ -107,7 +107,7 @@ pub fn proxy() -> (String, Bomb) {
     let (quittx, quitrx) = oneshot::channel();
 
     let thread = thread::spawn(move || {
-        let mut rt = t!(runtime::Builder::new()
+        let mut rt = assert_ok!(runtime::Builder::new()
             .basic_scheduler()
             .enable_io()
             .build());
@@ -118,9 +118,9 @@ pub fn proxy() -> (String, Bomb) {
             None
         };
 
-        let mut listener = t!(rt.block_on(TcpListener::bind("127.0.0.1:0")));
+        let mut listener = assert_ok!(rt.block_on(TcpListener::bind("127.0.0.1:0")));
         url_tx
-            .send(format!("http://{}", t!(listener.local_addr())))
+            .send(format!("http://{}", assert_ok!(listener.local_addr())))
             .unwrap();
 
         let record = Arc::new(Mutex::new(record));
@@ -139,7 +139,7 @@ pub fn proxy() -> (String, Bomb) {
         let record = record.lock().unwrap();
         match *record {
             Record::Capture(ref data, ref path) => {
-                let data = t!(serde_json::to_string_pretty(data));
+                let data = assert_ok!(serde_json::to_string_pretty(data));
                 Some((data.into_bytes(), path.clone()))
             }
             Record::Replay(..) => None,
@@ -294,7 +294,7 @@ fn replay_http(
 
     assert_eq!(req.uri().to_string(), exchange.request.uri);
     assert_eq!(req.method().to_string(), exchange.request.method);
-    t!(writeln!(
+    assert_ok!(writeln!(
         stdout,
         "expecting: {:?}",
         exchange.request.headers
@@ -304,7 +304,7 @@ fn replay_http(
             name.as_str().to_string(),
             value.to_str().unwrap().to_string(),
         );
-        t!(writeln!(stdout, "received: {:?}", pair));
+        assert_ok!(writeln!(stdout, "received: {:?}", pair));
         if name == "user-agent" {
             assert_eq!(value, "crates.io (https://crates.io)");
             continue;
@@ -386,15 +386,15 @@ impl GhUser {
             })
             .basic_auth(self.login, Some(password));
 
-        let response = t!(req
+        let response = assert_ok!(req
             .send()
             .and_then(reqwest::blocking::Response::error_for_status));
 
         #[derive(Deserialize)]
         struct Response {
             token: String,
         }
-        let resp: Response = t!(response.json());
+        let resp: Response = assert_ok!(response.json());
         File::create(&self.filename())
             .unwrap()
             .write_all(resp.token.as_bytes())