Port versions/index to use Diesel

Author: sgrif

src/tests/version.rs

@@ -1,39 +1,37 @@
-use std::collections::HashMap;
+extern crate diesel;
+
 use rustc_serialize::json::Json;
 
 use conduit::{Handler, Method};
-use semver;
+use self::diesel::prelude::*;
 
-use cargo_registry::db::RequestTransaction;
-use cargo_registry::version::{EncodableVersion, Version};
+use cargo_registry::version::EncodableVersion;
+use cargo_registry::schema::versions;
 
 #[derive(RustcDecodable)]
 struct VersionList { versions: Vec<EncodableVersion> }
 #[derive(RustcDecodable)]
 struct VersionResponse { version: EncodableVersion }
 
-fn sv(s: &str) -> semver::Version {
-    semver::Version::parse(s).unwrap()
-}
-
 #[test]
 fn index() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, Method::Get, "/api/v1/versions");
+    let mut req = ::req(app.clone(), Method::Get, "/api/v1/versions");
     let mut response = ok_resp!(middle.call(&mut req));
     let json: VersionList = ::json(&mut response);
     assert_eq!(json.versions.len(), 0);
 
     let (v1, v2) = {
-        ::mock_user(&mut req, ::user("foo"));
-        let (c, _) = ::mock_crate(&mut req, ::krate("foo_vers_index"));
-        let tx = req.tx().unwrap();
-        let m = HashMap::new();
-        let v1 = Version::insert(tx, c.id, &sv("2.0.0"), &m, &[]).unwrap();
-        let v2 = Version::insert(tx, c.id, &sv("2.0.1"), &m, &[]).unwrap();
-        (v1, v2)
+        let conn = app.diesel_database.get().unwrap();
+        let u = ::new_user("foo").create_or_update(&conn).unwrap();
+        ::CrateBuilder::new("foo_vers_index", u.id)
+            .version("2.0.0")
+            .version("2.0.1")
+            .expect_build(&conn);
+        let ids = versions::table.select(versions::id).load::<i32>(&*conn).unwrap();
+        (ids[0], ids[1])
     };
-    req.with_query(&format!("ids[]={}&ids[]={}", v1.id, v2.id));
+    req.with_query(&format!("ids[]={}&ids[]={}", v1, v2));
     let mut response = ok_resp!(middle.call(&mut req));
     let json: VersionList = ::json(&mut response);
     assert_eq!(json.versions.len(), 2);

src/version.rs

@@ -280,7 +280,8 @@ impl Model for Version {
 /// Handles the `GET /versions` route.
 // FIXME: where/how is this used?
 pub fn index(req: &mut Request) -> CargoResult<Response> {
-    let conn = req.tx()?;
+    use diesel::expression::dsl::any;
+    let conn = req.db_conn()?;
 
     // Extract all ids requested.
     let query = url::form_urlencoded::parse(req.query_string().unwrap_or("")
@@ -293,23 +294,13 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
         }
     }).collect::<Vec<i32>>();
 
-    // Load all versions
-    //
-    // TODO: can rust-postgres do this for us?
-    let mut versions = Vec::new();
-    if !ids.is_empty() {
-        let stmt = conn.prepare("\
-            SELECT versions.*, crates.name AS crate_name
-              FROM versions
-            LEFT JOIN crates ON crates.id = versions.crate_id
-            WHERE versions.id = ANY($1)
-        ")?;
-        for row in stmt.query(&[&ids])?.iter() {
-            let v: Version = Model::from_row(&row);
-            let crate_name: String = row.get("crate_name");
-            versions.push(v.encodable(&crate_name));
-        }
-    }
+    let versions = versions::table.inner_join(crates::table)
+        .select((versions::all_columns, crates::name))
+        .filter(versions::id.eq(any(ids)))
+        .load::<(Version, String)>(&*conn)?
+        .into_iter()
+        .map(|(version, crate_name)| version.encodable(&crate_name))
+        .collect();
 
     #[derive(RustcEncodable)]
     struct R { versions: Vec<EncodableVersion> }