Split krate test module into multiple files

src/tests/krate/dependencies.rs

@@ -0,0 +1,31 @@
+use crate::builders::{CrateBuilder, VersionBuilder};
+use crate::new_dependency;
+use crate::util::{RequestHelper, TestApp};
+use cargo_registry::views::EncodableDependency;
+use http::StatusCode;
+
+#[derive(Deserialize)]
+struct Deps {
+    dependencies: Vec<EncodableDependency>,
+}
+
+#[test]
+fn dependencies() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        let c1 = CrateBuilder::new("foo_deps", user.id).expect_build(conn);
+        let v = VersionBuilder::new("1.0.0").expect_build(c1.id, user.id, conn);
+        let c2 = CrateBuilder::new("bar_deps", user.id).expect_build(conn);
+        new_dependency(conn, &v, &c2);
+    });
+
+    let deps: Deps = anon
+        .get("/api/v1/crates/foo_deps/1.0.0/dependencies")
+        .good();
+    assert_eq!(deps.dependencies[0].crate_id, "bar_deps");
+
+    anon.get::<()>("/api/v1/crates/foo_deps/1.0.2/dependencies")
+        .bad_with_status(StatusCode::OK);
+}

src/tests/krate/downloads.rs

@@ -0,0 +1,92 @@
+use crate::builders::{CrateBuilder, VersionBuilder};
+use crate::util::{RequestHelper, TestApp};
+use cargo_registry::views::EncodableVersionDownload;
+use chrono::{Duration, Utc};
+use http::StatusCode;
+
+#[derive(Deserialize)]
+struct Downloads {
+    version_downloads: Vec<EncodableVersionDownload>,
+}
+
+#[test]
+fn download() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        CrateBuilder::new("foo_download", user.id)
+            .version(VersionBuilder::new("1.0.0"))
+            .expect_build(conn);
+    });
+
+    let assert_dl_count = |name_and_version: &str, query: Option<&str>, count: i32| {
+        let url = format!("/api/v1/crates/{}/downloads", name_and_version);
+        let downloads: Downloads = if let Some(query) = query {
+            anon.get_with_query(&url, query).good()
+        } else {
+            anon.get(&url).good()
+        };
+        let total_downloads = downloads
+            .version_downloads
+            .iter()
+            .map(|vd| vd.downloads)
+            .sum::<i32>();
+        assert_eq!(total_downloads, count);
+    };
+
+    let download = |name_and_version: &str| {
+        let url = format!("/api/v1/crates/{}/download", name_and_version);
+        anon.get::<()>(&url).assert_status(StatusCode::FOUND);
+        // TODO: test the with_json code path
+    };
+
+    download("foo_download/1.0.0");
+    assert_dl_count("foo_download/1.0.0", None, 1);
+    assert_dl_count("foo_download", None, 1);
+
+    download("FOO_DOWNLOAD/1.0.0");
+    assert_dl_count("FOO_DOWNLOAD/1.0.0", None, 2);
+    assert_dl_count("FOO_DOWNLOAD", None, 2);
+
+    let yesterday = (Utc::today() + Duration::days(-1)).format("%F");
+    let query = format!("before_date={}", yesterday);
+    assert_dl_count("FOO_DOWNLOAD/1.0.0", Some(&query), 0);
+    // crate/downloads always returns the last 90 days and ignores date params
+    assert_dl_count("FOO_DOWNLOAD", Some(&query), 2);
+
+    let tomorrow = (Utc::today() + Duration::days(1)).format("%F");
+    let query = format!("before_date={}", tomorrow);
+    assert_dl_count("FOO_DOWNLOAD/1.0.0", Some(&query), 2);
+    assert_dl_count("FOO_DOWNLOAD", Some(&query), 2);
+}
+
+#[test]
+fn download_nonexistent_version_of_existing_crate_404s() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        CrateBuilder::new("foo_bad", user.id).expect_build(conn);
+    });
+
+    anon.get("/api/v1/crates/foo_bad/0.1.0/download")
+        .assert_not_found();
+}
+
+#[test]
+fn download_noncanonical_crate_name() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        CrateBuilder::new("foo_download", user.id)
+            .version(VersionBuilder::new("1.0.0"))
+            .expect_build(conn);
+    });
+
+    // Request download for "foo-download" with a dash instead of an underscore,
+    // and assert that the correct download link is returned.
+    anon.get::<()>("/api/v1/crates/foo-download/1.0.0/download")
+        .assert_redirect_ends_with("/crates/foo_download/foo_download-1.0.0.crate");
+}

src/tests/krate/following.rs

@@ -0,0 +1,59 @@
+use crate::builders::CrateBuilder;
+use crate::util::{RequestHelper, TestApp};
+use crate::OkBool;
+
+#[test]
+fn diesel_not_found_results_in_404() {
+    let (_, _, user) = TestApp::init().with_user();
+
+    user.get("/api/v1/crates/foo_following/following")
+        .assert_not_found();
+}
+
+#[test]
+fn following() {
+    // TODO: Test anon requests as well?
+    let (app, _, user) = TestApp::init().with_user();
+
+    app.db(|conn| {
+        CrateBuilder::new("foo_following", user.as_model().id).expect_build(conn);
+    });
+
+    let is_following = || -> bool {
+        #[derive(Deserialize)]
+        struct F {
+            following: bool,
+        }
+
+        user.get::<F>("/api/v1/crates/foo_following/following")
+            .good()
+            .following
+    };
+
+    let follow = || {
+        assert!(
+            user.put::<OkBool>("/api/v1/crates/foo_following/follow", b"")
+                .good()
+                .ok
+        );
+    };
+
+    let unfollow = || {
+        assert!(
+            user.delete::<OkBool>("api/v1/crates/foo_following/follow")
+                .good()
+                .ok
+        );
+    };
+
+    assert!(!is_following());
+    follow();
+    follow();
+    assert!(is_following());
+    assert_eq!(user.search("following=1").crates.len(), 1);
+
+    unfollow();
+    unfollow();
+    assert!(!is_following());
+    assert_eq!(user.search("following=1").crates.len(), 0);
+}

src/tests/krate/mod.rs

@@ -0,0 +1,11 @@
+mod dependencies;
+mod downloads;
+mod following;
+mod owners;
+mod publish;
+mod reverse_dependencies;
+mod search;
+mod show;
+mod summary;
+mod versions;
+mod yanking;

src/tests/krate/owners.rs

@@ -0,0 +1,44 @@
+use crate::builders::CrateBuilder;
+use crate::util::{RequestHelper, TestApp};
+
+// This is testing Cargo functionality! ! !
+// specifically functions modify_owners and add_owners
+// which call the `PUT /crates/:crate_id/owners` route
+#[test]
+fn test_cargo_invite_owners() {
+    let (app, _, owner) = TestApp::init().with_user();
+
+    let new_user = app.db_new_user("cilantro");
+    app.db(|conn| {
+        CrateBuilder::new("guacamole", owner.as_model().id).expect_build(conn);
+    });
+
+    #[derive(Serialize)]
+    struct OwnerReq {
+        owners: Option<Vec<String>>,
+    }
+    #[derive(Deserialize, Debug)]
+    struct OwnerResp {
+        // server must include `ok: true` to support old cargo clients
+        ok: bool,
+        msg: String,
+    }
+
+    let body = serde_json::to_string(&OwnerReq {
+        owners: Some(vec![new_user.as_model().gh_login.clone()]),
+    });
+    let json: OwnerResp = owner
+        .put("/api/v1/crates/guacamole/owners", body.unwrap().as_bytes())
+        .good();
+
+    // this ok:true field is what old versions of Cargo
+    // need - do not remove unless you're cool with
+    // dropping support for old versions
+    assert!(json.ok);
+    // msg field is what is sent and used in updated
+    // version of cargo
+    assert_eq!(
+        json.msg,
+        "user cilantro has been invited to be an owner of crate guacamole"
+    )
+}