Don't run transaction middleware in tests

But always insert a new transaction and be sure to finish the transaction as
part of the request so we can pick up errors and include it in our timing.

Author: alexcrichton

src/db.rs

@@ -37,7 +37,7 @@ pub struct Transaction {
     // provide this stable address.
     tx: LazyCell<pg::Transaction<'static>>,
     slot: LazyCell<Box<PooledConnnection>>,
-    commit: Cell<bool>,
+    commit: Cell<Option<bool>>,
 
     // Keep a handle to the app which keeps a handle to the database to ensure
     // that this `'static` is indeed at least a little more accurate (in that
@@ -51,7 +51,7 @@ impl Transaction {
             app: app,
             slot: LazyCell::new(),
             tx: LazyCell::new(),
-            commit: Cell::new(false),
+            commit: Cell::new(None),
         }
     }
 
@@ -83,32 +83,37 @@ impl Transaction {
         Ok(tx)
     }
 
-    pub fn rollback(&self) { self.commit.set(false); }
-    pub fn commit(&self) { self.commit.set(true); }
+    pub fn rollback(&self) {
+        self.commit.set(Some(false));
+    }
+
+    pub fn commit(&self) {
+        if self.commit.get().is_none() {
+            self.commit.set(Some(true));
+        }
+    }
 }
 
 impl Middleware for TransactionMiddleware {
     fn before(&self, req: &mut Request) -> Result<(), Box<Error+Send>> {
-        if !req.extensions().contains::<Transaction>() {
-            let app = req.app().clone();
-            req.mut_extensions().insert(Transaction::new(app));
-        }
+        let app = req.app().clone();
+        req.mut_extensions().insert(Transaction::new(app));
         Ok(())
     }
 
     fn after(&self, req: &mut Request, res: Result<Response, Box<Error+Send>>)
              -> Result<Response, Box<Error+Send>> {
-        if res.is_ok() {
-            let tx = req.extensions().find::<Transaction>()
-                        .expect("Transaction not present in request");
-            match tx.tx.borrow() {
-                Some(transaction) if tx.commit.get() => {
-                    transaction.set_commit();
-                }
-                _ => {}
+        let tx = req.mut_extensions().pop::<Transaction>()
+                    .expect("Transaction not present in request");
+        if let Some(transaction) = tx.tx.into_inner() {
+            if res.is_ok() && tx.commit.get() == Some(true) {
+                transaction.set_commit();
             }
+            try!(transaction.finish().map_err(|e| {
+                Box::new(e) as Box<Error+Send>
+            }));
         }
-        return res;
+        return res
     }
 }
 

src/lib.rs

@@ -140,7 +140,9 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     m.add(conduit_cookie::SessionMiddleware::new("cargo_session",
                                                  env == Env::Production));
     m.add(app::AppMiddleware::new(app));
-    m.add(db::TransactionMiddleware);
+    if env != Env::Test {
+        m.add(db::TransactionMiddleware);
+    }
     m.add(user::Middleware);
     if env != Env::Test {
         m.around(dist::Middleware::new());

src/tests/all.rs

@@ -73,7 +73,6 @@ mod version;
 mod team;
 
 fn app() -> (record::Bomb, Arc<App>, conduit_middleware::MiddlewareBuilder) {
-    struct NoCommit;
     static INIT: Once = ONCE_INIT;
     git::init();
 
@@ -95,26 +94,14 @@ fn app() -> (record::Bomb, Arc<App>, conduit_middleware::MiddlewareBuilder) {
     INIT.call_once(|| db_setup(&config.db_url));
     let app = App::new(&config);
     let app = Arc::new(app);
-    let mut middleware = cargo_registry::middleware(app.clone());
-    middleware.add(NoCommit);
+    let middleware = cargo_registry::middleware(app.clone());
     return (bomb, app, middleware);
 
     fn db_setup(db: &str) {
         let migrate = t!(env::current_exe()).parent().unwrap().join("migrate");
         assert!(t!(Command::new(&migrate).env("DATABASE_URL", db)
                            .status()).success());
     }
-
-    impl conduit_middleware::Middleware for NoCommit {
-        fn after(&self, req: &mut Request,
-                 res: Result<conduit::Response, Box<StdError+Send>>)
-                 -> Result<conduit::Response, Box<StdError+Send>> {
-            req.extensions().find::<db::Transaction>()
-               .expect("Transaction not present in request")
-               .rollback();
-            return res;
-        }
-    }
 }
 
 fn env(s: &str) -> String {

src/util/lazy_cell.rs

@@ -46,4 +46,9 @@ impl<T> LazyCell<T> {
             None => None
         }
     }
+
+    /// Consumes this `LazyCell`, returning the underlying value.
+    pub fn into_inner(self) -> Option<T> {
+        self.inner.into_inner()
+    }
 }