Fix all tests

Author: alexcrichton

src/tests/all.rs

@@ -63,7 +63,6 @@ struct Error { detail: String }
 #[derive(RustcDecodable)]
 struct Bad { errors: Vec<Error> }
 
-mod middleware;
 mod keyword;
 mod krate;
 mod user;

src/tests/krate.rs

@@ -3,7 +3,6 @@ use std::io::prelude::*;
 use std::fs::{self, File};
 
 use conduit::{Handler, Request, Method};
-use conduit_test::MockRequest;
 use git2;
 use rustc_serialize::{json, Decoder};
 use semver;
@@ -54,16 +53,16 @@ fn new_crate(name: &str) -> u::NewCrate {
 
 #[test]
 fn index() {
-    let (_b, _app, mut middle) = ::app();
-    let mut req = MockRequest::new(Method::Get, "/api/v1/crates");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/api/v1/crates");
     let mut response = ok_resp!(middle.call(&mut req));
     let json: CrateList = ::json(&mut response);
     assert_eq!(json.crates.len(), 0);
     assert_eq!(json.meta.total, 0);
 
     let krate = ::krate("foo");
-    middle.add(::middleware::MockUser(::user("foo")));
-    middle.add(::middleware::MockCrate(krate.clone()));
+    ::mock_user(&mut req, ::user("foo"));
+    ::mock_crate(&mut req, krate.clone());
     let mut response = ok_resp!(middle.call(&mut req));
     let json: CrateList = ::json(&mut response);
     assert_eq!(json.crates.len(), 1);
@@ -125,15 +124,15 @@ fn index_queries() {
 
 #[test]
 fn show() {
-    let (_b, _app, mut middle) = ::app();
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/api/v1/crates/foo");
+    ::mock_user(&mut req, ::user("foo"));
     let mut krate = ::krate("foo");
     krate.description = Some(format!("description"));
     krate.documentation = Some(format!("https://example.com"));
     krate.homepage = Some(format!("http://example.com"));
-    middle.add(::middleware::MockUser(::user("foo")));
-    middle.add(::middleware::MockCrate(krate.clone()));
-    let mut req = MockRequest::new(Method::Get,
-                                   &format!("/api/v1/crates/{}", krate.name));
+    ::mock_crate(&mut req, krate.clone());
+
     let mut response = ok_resp!(middle.call(&mut req));
     let json: CrateResponse = ::json(&mut response);
     assert_eq!(json.krate.name, krate.name);
@@ -519,8 +518,8 @@ fn new_krate_dependency_missing() {
 
 #[test]
 fn summary_doesnt_die() {
-    let (_b, _app, middle) = ::app();
-    let mut req = MockRequest::new(Method::Get, "/summary");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/summary");
     ok_resp!(middle.call(&mut req));
 }
 
@@ -550,13 +549,10 @@ fn download() {
 
 #[test]
 fn download_bad() {
-    let (_b, _app, mut middle) = ::app();
-    let user = ::user("foo");
-    let krate = ::krate("foo");
-    middle.add(::middleware::MockUser(user.clone()));
-    middle.add(::middleware::MockCrate(krate.clone()));
-    let rel = format!("/api/v1/crates/{}/0.1.0/download", krate.name);
-    let mut req = MockRequest::new(Method::Get, &rel);
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/api/v1/crates/foo/0.1.0/download");
+    ::mock_user(&mut req, ::user("foo"));
+    ::mock_crate(&mut req, ::krate("foo"));
     let mut response = ok_resp!(middle.call(&mut req));
     ::json::<::Bad>(&mut response);
 }

src/tests/middleware.rs

@@ -1,8 +1,6 @@
 use std::error::Error;
 
-use conduit::{Handler, Request, Response, Method};
-use conduit_middleware::Middleware;
-use conduit_test::MockRequest;
+use conduit::{Handler, Request, Method};
 
 use cargo_registry::Model;
 use cargo_registry::krate::EncodableCrate;
@@ -17,17 +15,17 @@ struct MeResponse { user: EncodableUser, api_token: String }
 
 #[test]
 fn auth_gives_a_token() {
-    let (_b, _app, middle) = ::app();
-    let mut req = MockRequest::new(Method::Get, "/authorize_url");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/authorize_url");
     let mut response = ok_resp!(middle.call(&mut req));
     let json: AuthResponse = ::json(&mut response);
     assert!(json.url.contains(&json.state));
 }
 
 #[test]
 fn access_token_needs_data() {
-    let (_b, _app, middle) = ::app();
-    let mut req = MockRequest::new(Method::Get, "/authorize");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/authorize");
     let mut response = ok_resp!(middle.call(&mut req));
     let json: ::Bad = ::json(&mut response);
     assert!(json.errors[0].detail.contains("invalid state"));
@@ -53,13 +51,13 @@ fn user_insert() {
 
 #[test]
 fn me() {
-    let (_b, _app, mut middle) = ::app();
-    let mut req = MockRequest::new(Method::Get, "/me");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Get, "/me");
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 403);
 
     let user = ::user("foo");
-    middle.add(::middleware::MockUser(user.clone()));
+    ::mock_user(&mut req, user.clone());
     let mut response = ok_resp!(middle.call(&mut req));
     let json: MeResponse = ::json(&mut response);
     assert_eq!(json.user.email, user.email);
@@ -68,30 +66,19 @@ fn me() {
 
 #[test]
 fn reset_token() {
-    struct ResetTokenTest;
-
-    let (_b, _app, mut middle) = ::app();
-    middle.add(ResetTokenTest);
-    let mut req = MockRequest::new(Method::Put, "/me/reset_token");
+    let (_b, app, middle) = ::app();
+    let mut req = ::req(app, Method::Put, "/me/reset_token");
+    let user = {
+        let tx = RequestTransaction::tx(&mut req as &mut Request);
+        User::find_or_insert(tx.unwrap(), "foo", None,
+                             None, None, "bar", "baz").unwrap()
+    };
+    ::mock_user(&mut req, user.clone());
     ok_resp!(middle.call(&mut req));
 
-    impl Middleware for ResetTokenTest {
-        fn before(&self, req: &mut Request) -> Result<(), Box<Error+Send>> {
-            let user = User::find_or_insert(req.tx().unwrap(), "foo", None,
-                                            None, None, "bar", "baz").unwrap();
-            req.mut_extensions().insert(user);
-            Ok(())
-        }
-
-        fn after(&self, req: &mut Request,
-                 response: Result<Response, Box<Error+Send>>)
-                 -> Result<Response, Box<Error+Send>> {
-            let user = req.extensions().find::<User>().unwrap();
-            let u2 = User::find(req.tx().unwrap(), user.id).unwrap();
-            assert!(u2.api_token != user.api_token);
-            response
-        }
-    }
+    let tx = RequestTransaction::tx(&mut req as &mut Request);
+    let u2 = User::find(tx.unwrap(), user.id).unwrap();
+    assert!(u2.api_token != user.api_token);
 }
 
 #[test]

src/tests/user.rs

@@ -1,7 +1,7 @@
 use std::error::Error;
 
 use conduit_middleware;
-use conduit::{Request, Response};
+use conduit::Request;
 use conduit_cookie::RequestSession;
 
 use Model;
@@ -51,12 +51,6 @@ impl conduit_middleware::Middleware for Middleware {
         req.mut_extensions().insert(user);
         Ok(())
     }
-
-    fn after(&self, req: &mut Request, res: Result<Response, Box<Error+Send>>)
-             -> Result<Response, Box<Error+Send>> {
-        req.mut_extensions().remove::<User>();
-        res
-    }
 }
 
 pub trait RequestUser {