tests/user: Move tests into routes submodules (#5541)

Author: Turbo87

src/tests/routes/crates/list.rs

@@ -819,3 +819,31 @@ fn pagination_parameters_only_accept_integers() {
         json!({ "errors": [{ "detail": "invalid digit found in string" }] })
     );
 }
+
+#[test]
+fn crates_by_user_id() {
+    let (app, _, user) = TestApp::init().with_user();
+    let id = user.as_model().id;
+    app.db(|conn| {
+        CrateBuilder::new("foo_my_packages", id).expect_build(conn);
+    });
+
+    let response = user.search_by_user_id(id);
+    assert_eq!(response.crates.len(), 1);
+}
+
+#[test]
+fn crates_by_user_id_not_including_deleted_owners() {
+    let (app, anon, user) = TestApp::init().with_user();
+    let user = user.as_model();
+
+    app.db(|conn| {
+        let krate = CrateBuilder::new("foo_my_packages", user.id).expect_build(conn);
+        krate
+            .owner_remove(app.as_inner(), conn, user, "foo")
+            .unwrap();
+    });
+
+    let response = anon.search_by_user_id(user.id);
+    assert_eq!(response.crates.len(), 0);
+}

src/tests/routes/me/email_notifications.rs

@@ -0,0 +1,136 @@
+use crate::builders::CrateBuilder;
+use crate::util::{RequestHelper, TestApp};
+use crate::{new_user, OkBool};
+use cargo_registry::schema::crate_owners;
+use diesel::prelude::*;
+
+#[derive(Serialize)]
+struct EmailNotificationsUpdate {
+    id: i32,
+    email_notifications: bool,
+}
+
+impl crate::util::MockCookieUser {
+    fn update_email_notifications(&self, updates: Vec<EmailNotificationsUpdate>) -> OkBool {
+        self.put(
+            "/api/v1/me/email_notifications",
+            json!(updates).to_string().as_bytes(),
+        )
+        .good()
+    }
+}
+
+/// A user should be able to update the email notifications for crates they own. Only the crates that
+/// were sent in the request should be updated to the corresponding `email_notifications` value.
+#[test]
+fn test_update_email_notifications() {
+    let (app, _, user) = TestApp::init().with_user();
+
+    let my_crates = app.db(|conn| {
+        vec![
+            CrateBuilder::new("test_package", user.as_model().id).expect_build(conn),
+            CrateBuilder::new("another_package", user.as_model().id).expect_build(conn),
+        ]
+    });
+
+    let a_id = my_crates.get(0).unwrap().id;
+    let b_id = my_crates.get(1).unwrap().id;
+
+    // Update crate_a: email_notifications = false
+    // crate_a should be false, crate_b should be true
+    user.update_email_notifications(vec![EmailNotificationsUpdate {
+        id: a_id,
+        email_notifications: false,
+    }]);
+    let json = user.show_me();
+
+    assert!(
+        !json
+            .owned_crates
+            .iter()
+            .find(|c| c.id == a_id)
+            .unwrap()
+            .email_notifications
+    );
+    assert!(
+        json.owned_crates
+            .iter()
+            .find(|c| c.id == b_id)
+            .unwrap()
+            .email_notifications
+    );
+
+    // Update crate_b: email_notifications = false
+    // Both should be false now
+    user.update_email_notifications(vec![EmailNotificationsUpdate {
+        id: b_id,
+        email_notifications: false,
+    }]);
+    let json = user.show_me();
+
+    assert!(
+        !json
+            .owned_crates
+            .iter()
+            .find(|c| c.id == a_id)
+            .unwrap()
+            .email_notifications
+    );
+    assert!(
+        !json
+            .owned_crates
+            .iter()
+            .find(|c| c.id == b_id)
+            .unwrap()
+            .email_notifications
+    );
+
+    // Update crate_a and crate_b: email_notifications = true
+    // Both should be true
+    user.update_email_notifications(vec![
+        EmailNotificationsUpdate {
+            id: a_id,
+            email_notifications: true,
+        },
+        EmailNotificationsUpdate {
+            id: b_id,
+            email_notifications: true,
+        },
+    ]);
+    let json = user.show_me();
+
+    json.owned_crates.iter().for_each(|c| {
+        assert!(c.email_notifications);
+    })
+}
+
+/// A user should not be able to update the `email_notifications` value for a crate that is not
+/// owned by them.
+#[test]
+fn test_update_email_notifications_not_owned() {
+    let (app, _, user) = TestApp::init().with_user();
+
+    let not_my_crate = app.db(|conn| {
+        let u = new_user("arbitrary_username")
+            .create_or_update(None, &app.as_inner().emails, conn)
+            .unwrap();
+        CrateBuilder::new("test_package", u.id).expect_build(conn)
+    });
+
+    user.update_email_notifications(vec![EmailNotificationsUpdate {
+        id: not_my_crate.id,
+        email_notifications: false,
+    }]);
+
+    let email_notifications: bool = app
+        .db(|conn| {
+            crate_owners::table
+                .select(crate_owners::email_notifications)
+                .filter(crate_owners::crate_id.eq(not_my_crate.id))
+                .first(conn)
+        })
+        .unwrap();
+
+    // There should be no change to the `email_notifications` value for a crate not belonging to me
+    assert!(email_notifications);
+}

src/tests/routes/me/get.rs

@@ -0,0 +1,52 @@
+use crate::builders::CrateBuilder;
+use crate::util::{RequestHelper, TestApp};
+use cargo_registry::views::{EncodablePrivateUser, OwnedCrate};
+
+impl crate::util::MockCookieUser {
+    pub fn show_me(&self) -> UserShowPrivateResponse {
+        let url = "/api/v1/me";
+        self.get(url).good()
+    }
+}
+
+#[derive(Deserialize)]
+pub struct UserShowPrivateResponse {
+    pub user: EncodablePrivateUser,
+    pub owned_crates: Vec<OwnedCrate>,
+}
+
+#[test]
+fn me() {
+    let url = "/api/v1/me";
+    let (app, anon) = TestApp::init().empty();
+    anon.get(url).assert_forbidden();
+
+    let user = app.db_new_user("foo");
+    let json = user.show_me();
+
+    assert_eq!(json.owned_crates.len(), 0);
+
+    app.db(|conn| {
+        CrateBuilder::new("foo_my_packages", user.as_model().id).expect_build(conn);
+        assert_eq!(json.user.email, user.as_model().email(conn).unwrap());
+    });
+    let updated_json = user.show_me();
+
+    assert_eq!(updated_json.owned_crates.len(), 1);
+}
+
+#[test]
+fn test_user_owned_crates_doesnt_include_deleted_ownership() {
+    let (app, _, user) = TestApp::init().with_user();
+    let user_model = user.as_model();
+
+    app.db(|conn| {
+        let krate = CrateBuilder::new("foo_my_packages", user_model.id).expect_build(conn);
+        krate
+            .owner_remove(app.as_inner(), conn, user_model, &user_model.gh_login)
+            .unwrap();
+    });
+
+    let json = user.show_me();
+    assert_eq!(json.owned_crates.len(), 0);
+}

src/tests/routes/me/mod.rs

@@ -1 +1,4 @@
+mod email_notifications;
+pub mod get;
 pub mod tokens;
+mod updates;

src/tests/routes/me/updates.rs

@@ -0,0 +1,97 @@
+use crate::builders::{CrateBuilder, VersionBuilder};
+use crate::util::{RequestHelper, TestApp};
+use crate::OkBool;
+use cargo_registry::schema::versions;
+use cargo_registry::views::EncodableVersion;
+use diesel::prelude::*;
+use diesel::update;
+use http::StatusCode;
+
+#[test]
+fn api_token_cannot_get_user_updates() {
+    let (_, _, _, token) = TestApp::init().with_token();
+    token.get("/api/v1/me/updates").assert_forbidden();
+}
+
+#[test]
+fn following() {
+    #[derive(Deserialize)]
+    struct R {
+        versions: Vec<EncodableVersion>,
+        meta: Meta,
+    }
+    #[derive(Deserialize)]
+    struct Meta {
+        more: bool,
+    }
+
+    let (app, _, user) = TestApp::init().with_user();
+    let user_model = user.as_model();
+    let user_id = user_model.id;
+    app.db(|conn| {
+        CrateBuilder::new("foo_fighters", user_id)
+            .version(VersionBuilder::new("1.0.0"))
+            .expect_build(conn);
+
+        // Make foo_fighters's version mimic a version published before we started recording who
+        // published versions
+        let none: Option<i32> = None;
+        update(versions::table)
+            .set(versions::published_by.eq(none))
+            .execute(conn)
+            .unwrap();
+
+        CrateBuilder::new("bar_fighters", user_id)
+            .version(VersionBuilder::new("1.0.0"))
+            .expect_build(conn);
+    });
+
+    let r: R = user.get("/api/v1/me/updates").good();
+    assert_eq!(r.versions.len(), 0);
+    assert!(!r.meta.more);
+
+    user.put::<OkBool>("/api/v1/crates/foo_fighters/follow", b"")
+        .good();
+    user.put::<OkBool>("/api/v1/crates/bar_fighters/follow", b"")
+        .good();
+
+    let r: R = user.get("/api/v1/me/updates").good();
+    assert_eq!(r.versions.len(), 2);
+    assert!(!r.meta.more);
+    let foo_version = r
+        .versions
+        .iter()
+        .find(|v| v.krate == "foo_fighters")
+        .unwrap();
+    assert_none!(&foo_version.published_by);
+    let bar_version = r
+        .versions
+        .iter()
+        .find(|v| v.krate == "bar_fighters")
+        .unwrap();
+    assert_eq!(
+        bar_version.published_by.as_ref().unwrap().login,
+        user_model.gh_login
+    );
+
+    let r: R = user
+        .get_with_query("/api/v1/me/updates", "per_page=1")
+        .good();
+    assert_eq!(r.versions.len(), 1);
+    assert!(r.meta.more);
+
+    user.delete::<OkBool>("/api/v1/crates/bar_fighters/follow")
+        .good();
+    let r: R = user
+        .get_with_query("/api/v1/me/updates", "page=2&per_page=1")
+        .good();
+    assert_eq!(r.versions.len(), 0);
+    assert!(!r.meta.more);
+
+    let response = user.get_with_query::<()>("/api/v1/me/updates", "page=0");
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(
+        response.into_json(),
+        json!({ "errors": [{ "detail": "page indexing starts from 1, page 0 is invalid" }] })
+    );
+}

src/tests/routes/mod.rs

@@ -17,5 +17,7 @@ pub mod crates;
 pub mod keywords;
 pub mod me;
 pub mod metrics;
+pub mod session;
 pub mod summary;
+pub mod users;
 pub mod versions;

src/tests/routes/session/authorize.rs

@@ -0,0 +1,13 @@
+use crate::util::{RequestHelper, TestApp};
+use http::StatusCode;
+
+#[test]
+fn access_token_needs_data() {
+    let (_, anon) = TestApp::init().empty();
+    let response = anon.get::<()>("/api/private/session/authorize");
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(
+        response.into_json(),
+        json!({ "errors": [{ "detail": "invalid state parameter" }] })
+    );
+}

src/tests/routes/session/begin.rs

@@ -0,0 +1,14 @@
+use crate::util::{RequestHelper, TestApp};
+
+#[derive(Deserialize)]
+struct AuthResponse {
+    url: String,
+    state: String,
+}
+
+#[test]
+fn auth_gives_a_token() {
+    let (_, anon) = TestApp::init().empty();
+    let json: AuthResponse = anon.get("/api/private/session/begin").good();
+    assert!(json.url.contains(&json.state));
+}

src/tests/routes/session/mod.rs

@@ -0,0 +1,2 @@
+mod authorize;
+mod begin;

src/tests/routes/users/mod.rs

@@ -0,0 +1,3 @@
+mod read;
+mod stats;
+pub mod update;