Merge rust-lang#1085

1085: Decline owner invites r=carols10cents

This implements deployable chunk 3: declining invitations of issue rust-lang#924. The api route for declining an invite is the same as for accepting an invite. To know that an invite is being declined instead of accepted, the `accepted` field passed to the backend is set to `false`. If declined, the invite should be replaced with a message to the user confirming that they declined the invitation for the crate.

Author: bors-voyager[bot]

app/components/pending-owner-invite-row.js

@@ -1,7 +1,8 @@
 import Ember from 'ember';
 
 export default Ember.Component.extend({
-    isSuccess: false,
+    isAccepted: false,
+    isDeclined: false,
     isError: false,
     inviteError: 'default error message',
 
@@ -10,7 +11,7 @@ export default Ember.Component.extend({
             invite.set('accepted', true);
             invite.save()
                 .then(() => {
-                    this.set('isSuccess', true);
+                    this.set('isAccepted', true);
                 })
                 .catch((error) => {
                     this.set('isError', true);
@@ -22,6 +23,23 @@ export default Ember.Component.extend({
                         this.set('inviteError', 'Error in accepting invite');
                     }
                 });
+        },
+        declineInvitation(invite) {
+            invite.set('accepted', false);
+            invite.save()
+                .then(() => {
+                    this.set('isDeclined', true);
+                })
+                .catch((error) => {
+                    this.set('isError', true);
+                    if (error.payload) {
+                        this.set('inviteError',
+                            `Error in declining invite: ${error.payload.errors[0].detail}`
+                        );
+                    } else {
+                        this.set('inviteError', 'Error in declining invite');
+                    }
+                });
         }
     }
 });

app/templates/components/pending-owner-invite-row.hbs

@@ -1,8 +1,12 @@
 <div class='row'>
-    {{#if isSuccess }}
+    {{#if isAccepted }}
         <p>Success! You've been added as an owner of crate
             {{#link-to 'crate' invite.crate_name}}{{invite.crate_name}}{{/link-to}}.
-            </p>
+        </p>
+    {{else if isDeclined}}
+        <p>Declined. You have not been added as an owner of crate
+            {{#link-to 'crate' invite.crate_name}}{{invite.crate_name}}{{/link-to}}.
+        </p>
     {{else}}
     <div class='info'>
         <div class='name'>
@@ -24,7 +28,7 @@
         </div>
         <div class='actions'>
             <button class='small yellow-button' {{action 'acceptInvitation' invite}}>Accept</button>
-            <button class='small yellow-button'>Deny</button>
+            <button class='small yellow-button' {{action 'declineInvitation' invite}}>Decline</button>
         </div>
         {{#if isError}}
             <div class='label'>

src/crate_owner_invitation.rs

@@ -112,11 +112,7 @@ pub fn handle_invite(req: &mut Request) -> CargoResult<Response> {
     if crate_invite.accepted {
         accept_invite(req, conn, crate_invite)
     } else {
-        #[derive(Serialize)]
-        struct R {
-            crate_owner_invitation: InvitationResponse,
-        }
-        Ok(req.json(&R { crate_owner_invitation: crate_invite }))
+        decline_invite(req, conn, crate_invite)
     }
 }
 
@@ -154,3 +150,25 @@ fn accept_invite(
         Ok(req.json(&R { crate_owner_invitation: crate_invite }))
     })
 }
+
+fn decline_invite(
+    req: &mut Request,
+    conn: &PgConnection,
+    crate_invite: InvitationResponse,
+) -> CargoResult<Response> {
+    use diesel::delete;
+    let user_id = req.user()?.id;
+
+    delete(
+        crate_owner_invitations::table
+            .filter(crate_owner_invitations::crate_id.eq(crate_invite.crate_id))
+            .filter(crate_owner_invitations::invited_user_id.eq(user_id)),
+    ).execute(conn)?;
+
+    #[derive(Serialize)]
+    struct R {
+        crate_owner_invitation: InvitationResponse,
+    }
+
+    Ok(req.json(&R { crate_owner_invitation: crate_invite }))
+}

src/tests/owners.rs

@@ -467,3 +467,101 @@ fn test_accept_invitation() {
     let json: Q = ::json(&mut response);
     assert_eq!(json.users.len(), 2);
 }
+
+
+/*  Given a user inviting a different user to be a crate
+    owner, check that the user invited can decline their
+    invitation and the invitation will be deleted from
+    the invitations table.
+*/
+#[test]
+fn test_decline_invitation() {
+    #[derive(Deserialize)]
+    struct R {
+        crate_owner_invitations: Vec<EncodableCrateOwnerInvitation>,
+    }
+
+    #[derive(Deserialize)]
+    struct Q {
+        users: Vec<EncodablePublicUser>,
+    }
+
+    #[derive(Deserialize)]
+    struct T {
+        crate_owner_invitation: InvitationResponse,
+    }
+
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(
+        app.clone(),
+        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.
+        let invitation = NewCrateOwnerInvitation {
+            invited_by_user_id: owner.id,
+            invited_user_id: user.id,
+            crate_id: krate.id,
+        };
+        diesel::insert(&invitation)
+            .into(crate_owner_invitations::table)
+            .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
+        }
+    });
+
+    // 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 = ::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: R = ::json(&mut response);
+    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 = ::json(&mut response);
+    assert_eq!(json.users.len(), 1);
+}