Convert owner tests to use the TestHelper API

Author: carols10cents

src/tests/all.rs

@@ -110,6 +110,10 @@ pub struct OwnerTeamsResponse {
     teams: Vec<EncodableOwner>,
 }
 #[derive(Deserialize)]
+pub struct OwnersResponse {
+    users: Vec<EncodableOwner>,
+}
+#[derive(Deserialize)]
 pub struct OkBool {
     ok: bool,
 }

src/tests/owners.rs

@@ -1,19 +1,15 @@
 use crate::{
-    add_team_to_crate, app,
+    add_team_to_crate,
     builders::{CrateBuilder, PublishBuilder},
-    new_team, new_user, req, sign_in_as,
+    new_team,
     util::RequestHelper,
     TestApp,
 };
 use cargo_registry::{
-    models::{Crate, NewCrateOwnerInvitation},
-    schema::crate_owner_invitations,
-    views::{
-        EncodableCrateOwnerInvitation, EncodableOwner, EncodablePublicUser, InvitationResponse,
-    },
+    models::Crate,
+    views::{EncodableCrateOwnerInvitation, EncodableOwner, InvitationResponse},
 };
 
-use conduit::{Handler, Method};
 use diesel::prelude::*;
 
 #[derive(Deserialize)]
@@ -56,6 +52,31 @@ impl crate::util::MockCookieUser {
         assert_eq!(crate_owner_invite.crate_owner_invitation.crate_id, krate_id);
     }
 
+    /// As the currently logged in user, decline an invitation to become an owner of the named
+    /// crate.
+    fn decline_ownership_invitation(&self, krate_name: &str, krate_id: i32) {
+        let body = json!({
+            "crate_owner_invite": {
+                "invited_by_username": "",
+                "crate_name": krate_name,
+                "crate_id": krate_id,
+                "created_at": "",
+                "accepted": false
+            }
+        });
+
+        #[derive(Deserialize)]
+        struct CrateOwnerInvitation {
+            crate_owner_invitation: InvitationResponse,
+        }
+
+        let url = format!("/api/v1/me/crate_owner_invitations/{}", krate_id);
+        let crate_owner_invite: CrateOwnerInvitation =
+            self.put(&url, body.to_string().as_bytes()).good();
+        assert!(!crate_owner_invite.crate_owner_invitation.accepted);
+        assert_eq!(crate_owner_invite.crate_owner_invitation.crate_id, krate_id);
+    }
+
     /// As the currently logged in user, list my pending invitations.
     fn list_invitations(&self) -> InvitationListResponse {
         self.get("/api/v1/me/crate_owner_invitations").good()
@@ -228,76 +249,23 @@ fn invitations_list() {
 */
 #[test]
 fn test_accept_invitation() {
-    #[derive(Deserialize)]
-    struct Q {
-        users: Vec<EncodablePublicUser>,
-    }
+    let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let owner = owner.as_model();
+    let invited_user = app.db_new_user("user_bar");
+    let krate = app.db(|conn| CrateBuilder::new("accept_invitation", owner.id).expect_build(conn));
 
-    #[derive(Deserialize)]
-    struct T {
-        crate_owner_invitation: InvitationResponse,
-    }
+    // Invite a new owner
+    owner_token.add_user_owner("accept_invitation", invited_user.as_model());
 
-    let (app, middle) = app();
-    let mut req = req(Method::Get, "/api/v1/me/crate_owner_invitations");
-    let (krate, user) = {
-        let conn = app.diesel_database.get().unwrap();
-        let owner = new_user("inviting_user").create_or_update(&conn).unwrap();
-        let user = new_user("invited_user").create_or_update(&conn).unwrap();
-        let krate = CrateBuilder::new("invited_crate", owner.id).expect_build(&conn);
-
-        // This should be replaced by an actual call to the route that `owner --add` hits once
-        // that route creates an invitation.
-        diesel::insert_into(crate_owner_invitations::table)
-            .values(&NewCrateOwnerInvitation {
-                invited_by_user_id: owner.id,
-                invited_user_id: user.id,
-                crate_id: krate.id,
-            })
-            .execute(&*conn)
-            .unwrap();
-        (krate, user)
-    };
-    sign_in_as(&mut req, &user);
-
-    let body = json!({
-        "crate_owner_invite": {
-            "invited_by_username": "inviting_user",
-            "crate_name": "invited_crate",
-            "crate_id": krate.id,
-            "created_at": "",
-            "accepted": true
-        }
-    });
+    // New owner accepts the invitation
+    invited_user.accept_ownership_invitation(&krate.name, krate.id);
 
-    // first check that response from inserting new crate owner
-    // and deleting crate_owner_invitation is okay
-    let mut response = ok_resp!(middle.call(
-        req.with_path(&format!("api/v1/me/crate_owner_invitations/{}", krate.id))
-            .with_method(Method::Put)
-            .with_body(body.to_string().as_bytes()),
-    ));
-
-    let json: T = crate::json(&mut response);
-    assert_eq!(json.crate_owner_invitation.accepted, true);
-    assert_eq!(json.crate_owner_invitation.crate_id, krate.id);
-
-    // then check to make sure that accept_invite did what it
-    // was supposed to
-    // crate_owner_invitation was deleted
-    let mut response = ok_resp!(middle.call(
-        req.with_path("api/v1/me/crate_owner_invitations")
-            .with_method(Method::Get)
-    ));
-    let json: InvitationListResponse = crate::json(&mut response);
+    // New owner's invitation list should now be empty
+    let json = invited_user.list_invitations();
     assert_eq!(json.crate_owner_invitations.len(), 0);
 
-    // new crate owner was inserted
-    let mut response = ok_resp!(middle.call(
-        req.with_path("/api/v1/crates/invited_crate/owners")
-            .with_method(Method::Get)
-    ));
-    let json: Q = crate::json(&mut response);
+    // New owner is now listed as an owner, so the crate has two owners
+    let json = anon.show_crate_owners("accept_invitation");
     assert_eq!(json.users.len(), 2);
 }
 
@@ -308,75 +276,22 @@ fn test_accept_invitation() {
 */
 #[test]
 fn test_decline_invitation() {
-    #[derive(Deserialize)]
-    struct Q {
-        users: Vec<EncodablePublicUser>,
-    }
+    let (app, anon, owner, owner_token) = TestApp::init().with_token();
+    let owner = owner.as_model();
+    let invited_user = app.db_new_user("user_bar");
+    let krate = app.db(|conn| CrateBuilder::new("decline_invitation", owner.id).expect_build(conn));
 
-    #[derive(Deserialize)]
-    struct T {
-        crate_owner_invitation: InvitationResponse,
-    }
+    // Invite a new owner
+    owner_token.add_user_owner("decline_invitation", invited_user.as_model());
 
-    let (app, middle) = app();
-    let mut req = req(Method::Get, "/api/v1/me/crate_owner_invitations");
-    let (krate, user) = {
-        let conn = app.diesel_database.get().unwrap();
-        let owner = new_user("inviting_user").create_or_update(&conn).unwrap();
-        let user = new_user("invited_user").create_or_update(&conn).unwrap();
-        let krate = CrateBuilder::new("invited_crate", owner.id).expect_build(&conn);
-
-        // This should be replaced by an actual call to the route that `owner --add` hits once
-        // that route creates an invitation.
-        diesel::insert_into(crate_owner_invitations::table)
-            .values(&NewCrateOwnerInvitation {
-                invited_by_user_id: owner.id,
-                invited_user_id: user.id,
-                crate_id: krate.id,
-            })
-            .execute(&*conn)
-            .unwrap();
-        (krate, user)
-    };
-    sign_in_as(&mut req, &user);
-
-    let body = json!({
-        "crate_owner_invite": {
-            "invited_by_username": "inviting_user",
-            "crate_name": "invited_crate",
-            "crate_id": krate.id,
-            "created_at": "",
-            "accepted": false
-        }
-    });
+    // Invited user declines the invitation
+    invited_user.decline_ownership_invitation(&krate.name, krate.id);
 
-    // first check that response from deleting
-    // crate_owner_invitation is okay
-    let mut response = ok_resp!(middle.call(
-        req.with_path(&format!("api/v1/me/crate_owner_invitations/{}", krate.id))
-            .with_method(Method::Put)
-            .with_body(body.to_string().as_bytes()),
-    ));
-
-    let json: T = crate::json(&mut response);
-    assert_eq!(json.crate_owner_invitation.accepted, false);
-    assert_eq!(json.crate_owner_invitation.crate_id, krate.id);
-
-    // then check to make sure that decline_invite did what it
-    // was supposed to
-    // crate_owner_invitation was deleted
-    let mut response = ok_resp!(middle.call(
-        req.with_path("api/v1/me/crate_owner_invitations")
-            .with_method(Method::Get)
-    ));
-    let json: InvitationListResponse = crate::json(&mut response);
+    // Invited user's invitation list should now be empty
+    let json = invited_user.list_invitations();
     assert_eq!(json.crate_owner_invitations.len(), 0);
 
-    // new crate owner was not inserted
-    let mut response = ok_resp!(middle.call(
-        req.with_path("/api/v1/crates/invited_crate/owners")
-            .with_method(Method::Get)
-    ));
-    let json: Q = crate::json(&mut response);
+    // Invited user is NOT listed as an owner, so the crate still only has one owner
+    let json = anon.show_crate_owners("decline_invitation");
     assert_eq!(json.users.len(), 1);
 }

src/tests/util.rs

@@ -20,7 +20,8 @@
 //! to the underlying database model value (`User` and `ApiToken` respectively).
 
 use crate::{
-    builders::PublishBuilder, record, CrateList, CrateResponse, GoodCrate, OkBool, VersionResponse,
+    builders::PublishBuilder, record, CrateList, CrateResponse, GoodCrate,
+    OkBool, OwnersResponse, VersionResponse,
 };
 use cargo_registry::{
     background_jobs::Environment,
@@ -382,6 +383,12 @@ pub trait RequestHelper {
         self.get(&url).good()
     }
 
+    /// Request the JSON used to list a crate's owners
+    fn show_crate_owners(&self, krate_name: &str) -> OwnersResponse {
+        let url = format!("/api/v1/crates/{}/owners", krate_name);
+        self.get(&url).good()
+    }
+
     /// Request the JSON used for a crate version's page
     fn show_version(&self, krate_name: &str, version: &str) -> VersionResponse {
         let url = format!("/api/v1/crates/{}/{}", krate_name, version);