WIP: Switch back to diesel for db stuff

Author: Nemo157

src/tests/all.rs

@@ -32,7 +32,6 @@ use cargo_registry::krate::NewCrate;
 use cargo_registry::upload as u;
 use cargo_registry::user::NewUser;
 use cargo_registry::version::NewVersion;
-use cargo_registry::token::ApiToken;
 use cargo_registry::user::AuthenticationSource;
 use cargo_registry::{User, Crate, Version, Dependency, Category, Model, Replica};
 use conduit::{Request, Method};
@@ -299,11 +298,6 @@ fn mock_dep(req: &mut Request, version: &Version, krate: &Crate,
                        &target.map(|s| s.to_string())).unwrap()
 }
 
-fn mock_api_token(req: &mut Request, name: &str) -> ApiToken {
-    let user = req.extensions().find::<User>().unwrap();
-    ApiToken::insert(req.tx().unwrap(), user.id, name).unwrap()
-}
-
 fn new_category<'a>(category: &'a str, slug: &'a str) -> NewCategory<'a> {
     NewCategory { category: category, slug: slug, ..NewCategory::default() }
 }

src/tests/token.rs

@@ -2,7 +2,6 @@ use std::collections::HashSet;
 
 use conduit::{Handler, Method};
 
-use cargo_registry::db::RequestTransaction;
 use cargo_registry::token::{ApiToken, EncodableApiToken};
 
 #[derive(RustcDecodable)]
@@ -23,7 +22,7 @@ macro_rules! assert_contains {
 #[test]
 fn list_logged_out() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Get, "/me/tokens");
 
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 403);
@@ -32,9 +31,13 @@ fn list_logged_out() {
 #[test]
 fn list_empty() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Get, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
 
     let mut response = ok_resp!(middle.call(&mut req));
     let json: ListResponse = ::json(&mut response);
@@ -45,13 +48,18 @@ fn list_empty() {
 #[test]
 fn list_tokens() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Get, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
-    let tokens = vec![
-        ::mock_api_token(&mut req, "bar"),
-        ::mock_api_token(&mut req, "baz"),
-    ];
+    let (user, tokens);
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        tokens = vec![
+            t!(ApiToken::insert(&conn, user.id, "bar")),
+            t!(ApiToken::insert(&conn, user.id, "baz")),
+        ];
+    }
+    ::sign_in_as(&mut req, &user);
 
     let mut response = ok_resp!(middle.call(&mut req));
     let json: ListResponse = ::json(&mut response);
@@ -65,7 +73,7 @@ fn list_tokens() {
 #[test]
 fn create_token_logged_out() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
     req.with_body(br#"{ "api_token": { "name": "bar" } }"#);
 
@@ -76,9 +84,13 @@ fn create_token_logged_out() {
 #[test]
 fn create_token_invalid_request() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
     req.with_body(br#"{ "name": "" }"#);
 
     let mut response = t_resp!(middle.call(&mut req));
@@ -91,9 +103,13 @@ fn create_token_invalid_request() {
 #[test]
 fn create_token_no_name() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
     req.with_body(br#"{ "api_token": { "name": "" } }"#);
 
     let mut response = t_resp!(middle.call(&mut req));
@@ -106,9 +122,13 @@ fn create_token_no_name() {
 #[test]
 fn create_token_long_body() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
     req.with_body(&[5; 5192]); // Send a request with a 5kB body of 5's
 
     let mut response = t_resp!(middle.call(&mut req));
@@ -121,12 +141,17 @@ fn create_token_long_body() {
 #[test]
 fn create_token_exceeded_tokens_per_user() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    ::mock_user(&mut req, ::user("foo"));
-    for i in 0..1000 {
-        ::mock_api_token(&mut req, &format!("token {}", i));
-    }
+    let user;
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        for i in 0..1000 {
+            t!(ApiToken::insert(&conn, user.id, &format!("token {}", i)));
+        }
+    };
+    ::sign_in_as(&mut req, &user);
     req.with_body(br#"{ "api_token": { "name": "bar" } }"#);
 
     let mut response = t_resp!(middle.call(&mut req));
@@ -139,9 +164,13 @@ fn create_token_exceeded_tokens_per_user() {
 #[test]
 fn create_token_success() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    let user = ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
     req.with_body(br#"{ "api_token": { "name": "bar" } }"#);
 
     let mut response = ok_resp!(middle.call(&mut req));
@@ -150,7 +179,8 @@ fn create_token_success() {
     assert_eq!(json.api_token.name, "bar");
     assert!(json.api_token.token.is_some());
 
-    let tokens = ApiToken::find_for_user(req.tx().unwrap(), user.id).unwrap();
+    let conn = t!(app.diesel_database.get());
+    let tokens = t!(ApiToken::find_for_user(&conn, user.id));
     assert_eq!(tokens.len(), 1);
     assert_eq!(tokens[0].name, "bar");
     assert_eq!(tokens[0].token, json.api_token.token.unwrap());
@@ -160,11 +190,14 @@ fn create_token_success() {
 #[test]
 fn create_token_with_token() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Post, "/me/tokens");
+    let mut req = ::req(app.clone(), Method::Post, "/me/tokens");
 
-    let user = ::mock_user(&mut req, ::user("foo"));
-    ::logout(&mut req);
-    let token = t!(ApiToken::insert(req.tx().unwrap(), user.id, "bar"));
+    let (user, token);
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user.id, "bar"));
+    }
     req.header("Authorization", &token.token);
     req.with_body(br#"{ "api_token": { "name": "baz" } }"#);
 
@@ -178,9 +211,13 @@ fn create_token_with_token() {
 #[test]
 fn revoke_token_non_existing() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Delete, "/me/tokens/5");
+    let mut req = ::req(app.clone(), Method::Delete, "/me/tokens/5");
 
-    ::mock_user(&mut req, ::user("foo"));
+    let user = {
+        let conn = t!(app.diesel_database.get());
+        t!(::new_user("foo").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user);
 
     let mut response = ok_resp!(middle.call(&mut req));
     ::json::<RevokedResponse>(&mut response);
@@ -189,18 +226,22 @@ fn revoke_token_non_existing() {
 #[test]
 fn revoke_token_doesnt_revoke_other_users_token() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Delete, "/me/tokens");
-
-    // Create one user with a token
-    let user1 = ::mock_user(&mut req, ::user("foo"));
-    let token = ::mock_api_token(&mut req, "bar");
+    let mut req = ::req(app.clone(), Method::Delete, "/me/tokens");
 
-    // Create and sign in with a different user
-    ::mock_user(&mut req, ::user("baz"));
+    // Create one user with a token and sign in with a different user
+    let (user1, token, user2);
+    {
+        let conn = t!(app.diesel_database.get());
+        user1 = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user1.id, "bar"));
+        user2 = t!(::new_user("baz").create_or_update(&conn))
+    };
+    ::sign_in_as(&mut req, &user2);
 
     // List tokens for first user contains the token
     {
-        let tokens = ApiToken::find_for_user(req.tx().unwrap(), user1.id).unwrap();
+        let conn = t!(app.diesel_database.get());
+        let tokens = t!(ApiToken::find_for_user(&conn, user1.id));
         assert_eq!(tokens.len(), 1);
         assert_eq!(tokens[0].name, token.name);
     }
@@ -215,7 +256,8 @@ fn revoke_token_doesnt_revoke_other_users_token() {
 
     // List tokens for first user still contains the token
     {
-        let tokens = ApiToken::find_for_user(req.tx().unwrap(), user1.id).unwrap();
+        let conn = t!(app.diesel_database.get());
+        let tokens = t!(ApiToken::find_for_user(&conn, user1.id));
         assert_eq!(tokens.len(), 1);
         assert_eq!(tokens[0].name, token.name);
     }
@@ -224,13 +266,20 @@ fn revoke_token_doesnt_revoke_other_users_token() {
 #[test]
 fn revoke_token_success() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Delete, "/me/tokens");
-    let user = ::mock_user(&mut req, ::user("foo"));
-    let token = ::mock_api_token(&mut req, "bar");
+    let mut req = ::req(app.clone(), Method::Delete, "/me/tokens");
+
+    let (user, token);
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user.id, "bar"));
+    }
+    ::sign_in_as(&mut req, &user);
 
     // List tokens contains the token
     {
-        let tokens = ApiToken::find_for_user(req.tx().unwrap(), user.id).unwrap();
+        let conn = t!(app.diesel_database.get());
+        let tokens = ApiToken::find_for_user(&conn, user.id).unwrap();
         assert_eq!(tokens.len(), 1);
         assert_eq!(tokens[0].name, token.name);
     }
@@ -245,22 +294,26 @@ fn revoke_token_success() {
 
     // List tokens no longer contains the token
     {
-        let tokens = ApiToken::find_for_user(req.tx().unwrap(), user.id).unwrap();
+        let conn = t!(app.diesel_database.get());
+        let tokens = ApiToken::find_for_user(&conn, user.id).unwrap();
         assert_eq!(tokens.len(), 0);
     }
 }
 
 #[test]
 fn token_gives_access_to_me() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me");
+    let mut req = ::req(app.clone(), Method::Get, "/me");
+
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 403);
 
-    let user = ::mock_user(&mut req, ::user("foo"));
-    ::logout(&mut req);
-
-    let token = t!(ApiToken::insert(req.tx().unwrap(), user.id, "bar"));
+    let (user, token);
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user.id, "bar"));
+    }
     req.header("Authorization", &token.token);
 
     let mut response = ok_resp!(middle.call(&mut req));
@@ -272,20 +325,25 @@ fn token_gives_access_to_me() {
 #[test]
 fn using_token_updates_last_used_at() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me");
+    let mut req = ::req(app.clone(), Method::Get, "/me");
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 403);
 
-    let user = ::mock_user(&mut req, ::user("foo"));
-    ::logout(&mut req);
-
-    let token = t!(ApiToken::insert(req.tx().unwrap(), user.id, "bar"));
+    let (user, token);
+    {
+        let conn = t!(app.diesel_database.get());
+        user = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user.id, "bar"));
+    }
     req.header("Authorization", &token.token);
     assert!(token.last_used_at.is_none());
 
     ok_resp!(middle.call(&mut req));
 
-    let token = t!(ApiToken::find_for_user(req.tx().unwrap(), user.id)).pop().unwrap();
+    let token = {
+        let conn = t!(app.diesel_database.get());
+        t!(ApiToken::find_for_user(&conn, user.id)).pop().unwrap()
+    };
     assert!(token.last_used_at.is_some());
 
     // Would check that it updates the timestamp here, but the timestamp is
@@ -296,15 +354,18 @@ fn using_token_updates_last_used_at() {
 #[test]
 fn deleted_token_does_not_give_access_to_me() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/me");
+    let mut req = ::req(app.clone(), Method::Get, "/me");
+
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 403);
 
-    let user = ::mock_user(&mut req, ::user("foo"));
-    ::logout(&mut req);
-
-    let token = t!(ApiToken::insert(req.tx().unwrap(), user.id, "bar"));
-    t!(ApiToken::delete(req.tx().unwrap(), user.id, token.id));
+    let token;
+    {
+        let conn = t!(app.diesel_database.get());
+        let user = t!(::new_user("foo").create_or_update(&conn));
+        token = t!(ApiToken::insert(&conn, user.id, "bar"));
+        t!(ApiToken::delete(&conn, user.id, token.id));
+    }
     req.header("Authorization", &token.token);
 
     let response = t_resp!(middle.call(&mut req));