Share structs between controller and tests

Changed from .contains() to .first().unwrap() == in tests because
contains is weird rust-lang/rust#42671

Author: carols10cents

src/controllers/krate/publish.rs

@@ -14,7 +14,7 @@ use util::{read_fill, read_le_u32};
 use controllers::prelude::*;
 use models::dependency;
 use models::{Badge, Category, Keyword, NewCrate, NewVersion, Rights, User};
-use views::{EncodableCrate, EncodableCrateUpload};
+use views::{EncodableCrateUpload, GoodCrate, PublishWarnings};
 
 /// Handles the `PUT /crates/new` route.
 /// Used by `cargo publish` to publish a new crate or to publish a new version of an
@@ -196,23 +196,12 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
         crate_bomb.path = None;
         readme_bomb.path = None;
 
-        #[derive(Serialize)]
-        struct Warnings<'a> {
-            invalid_categories: Vec<&'a str>,
-            invalid_badges: Vec<&'a str>,
-        }
-        let warnings = Warnings {
+        let warnings = PublishWarnings {
             invalid_categories: ignored_invalid_categories,
             invalid_badges: ignored_invalid_badges,
         };
 
-        #[derive(Serialize)]
-        struct R<'a> {
-            #[serde(rename = "crate")]
-            krate: EncodableCrate,
-            warnings: Warnings<'a>,
-        }
-        Ok(req.json(&R {
+        Ok(req.json(&GoodCrate {
             krate: krate.minimal_encodable(&max_version, None, false, None),
             warnings,
         }))

src/models/badge.rs

@@ -104,11 +104,11 @@ impl Badge {
         serde_json::from_value(serde_json::to_value(self).unwrap()).unwrap()
     }
 
-    pub fn update_crate<'a>(
+    pub fn update_crate(
         conn: &PgConnection,
         krate: &Crate,
-        badges: Option<&'a HashMap<String, HashMap<String, String>>>,
-    ) -> QueryResult<Vec<&'a str>> {
+        badges: Option<&HashMap<String, HashMap<String, String>>>,
+    ) -> QueryResult<Vec<String>> {
         use diesel::{delete, insert_into};
 
         let mut invalid_badges = vec![];
@@ -126,7 +126,7 @@ impl Badge {
                         badges::attributes.eq(attributes_json),
                     ));
                 } else {
-                    invalid_badges.push(&**k);
+                    invalid_badges.push(k.to_string());
                 }
             }
         }

src/models/category.rs

@@ -101,17 +101,18 @@ impl Category {
         }
     }
 
-    pub fn update_crate<'a>(
+    pub fn update_crate(
         conn: &PgConnection,
         krate: &Crate,
-        slugs: &[&'a str],
-    ) -> QueryResult<Vec<&'a str>> {
+        slugs: &[&str],
+    ) -> QueryResult<Vec<String>> {
         conn.transaction(|| {
             let categories = Category::by_slugs_case_sensitive(slugs).load::<Category>(conn)?;
             let invalid_categories = slugs
                 .iter()
                 .cloned()
                 .filter(|s| !categories.iter().any(|c| c.slug == *s))
+                .map(|s| s.to_string())
                 .collect();
             let crate_categories = categories
                 .iter()

src/tests/all.rs

@@ -45,7 +45,7 @@ use models::{Crate, CrateOwner, Dependency, Team, User, Version};
 use models::{NewCategory, NewTeam, NewUser};
 use schema::*;
 use views::krate_publish as u;
-use views::{EncodableCrate, EncodableKeyword, EncodableOwner, EncodableVersion};
+use views::{EncodableCrate, EncodableKeyword, EncodableOwner, EncodableVersion, GoodCrate};
 
 macro_rules! t {
     ($e:expr) => {
@@ -93,22 +93,11 @@ mod user;
 mod util;
 mod version;
 
-#[derive(Deserialize, Debug)]
-pub struct GoodCrate {
-    #[serde(rename = "crate")]
-    krate: EncodableCrate,
-    warnings: Warnings,
-}
 #[derive(Deserialize)]
 pub struct CrateList {
     crates: Vec<EncodableCrate>,
     meta: CrateMeta,
 }
-#[derive(Deserialize, Debug)]
-struct Warnings {
-    invalid_categories: Vec<String>,
-    invalid_badges: Vec<String>,
-}
 #[derive(Deserialize)]
 struct CrateMeta {
     total: i32,

src/tests/badge.rs

@@ -367,7 +367,7 @@ fn travis_ci_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"travis-ci"));
+    assert_eq!(invalid_badges.first().unwrap(), "travis-ci");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -384,7 +384,7 @@ fn gitlab_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"gitlab"));
+    assert_eq!(invalid_badges.first().unwrap(), "gitlab");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -406,7 +406,10 @@ fn isitmaintained_issue_resolution_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"isitmaintained_issue_resolution"));
+    assert_eq!(
+        invalid_badges.first().unwrap(),
+        "isitmaintained_issue_resolution"
+    );
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -428,7 +431,10 @@ fn isitmaintained_open_issues_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"isitmaintained_open_issues"));
+    assert_eq!(
+        invalid_badges.first().unwrap(),
+        "isitmaintained_open_issues"
+    );
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -445,7 +451,7 @@ fn codecov_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"codecov"));
+    assert_eq!(invalid_badges.first().unwrap(), "codecov");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -462,7 +468,7 @@ fn coveralls_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"coveralls"));
+    assert_eq!(invalid_badges.first().unwrap(), "coveralls");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -479,7 +485,7 @@ fn circle_ci_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"circle-ci"));
+    assert_eq!(invalid_badges.first().unwrap(), "circle-ci");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -499,7 +505,7 @@ fn maintenance_required_keys() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"maintenance"));
+    assert_eq!(invalid_badges.first().unwrap(), "maintenance");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -521,7 +527,7 @@ fn maintenance_invalid_values() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"maintenance"));
+    assert_eq!(invalid_badges.first().unwrap(), "maintenance");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }
 
@@ -542,6 +548,6 @@ fn unknown_badge() {
 
     let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap();
     assert_eq!(invalid_badges.len(), 1);
-    assert!(invalid_badges.contains(&"not-a-badge"));
+    assert_eq!(invalid_badges.first().unwrap(), "not-a-badge");
     assert_eq!(krate.badges(&conn).unwrap(), vec![]);
 }

src/views/mod.rs

@@ -210,6 +210,19 @@ pub struct EncodableVersionLinks {
     pub authors: String,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GoodCrate {
+    #[serde(rename = "crate")]
+    pub krate: EncodableCrate,
+    pub warnings: PublishWarnings,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct PublishWarnings {
+    pub invalid_categories: Vec<String>,
+    pub invalid_badges: Vec<String>,
+}
+
 // TODO: Prefix many of these with `Encodable` then clean up the reexports
 pub mod krate_publish;
 pub use self::krate_publish::CrateDependency as EncodableCrateDependency;