Add test for rev-dep API endpoint.

This includes making some changes to the test harness, e.g. allowing
dependencies to be added from multiple versions of the dependent crate.

Author: huonw

src/tests/all.rs

@@ -24,6 +24,7 @@ use conduit_test::MockRequest;
 use cargo_registry::app::App;
 use cargo_registry::db::{mod, RequestTransaction};
 use cargo_registry::{User, Crate, Version, Keyword};
+use cargo_registry::util::CargoResult;
 
 macro_rules! t( ($e:expr) => (
     match $e {
@@ -213,8 +214,14 @@ fn mock_user(req: &mut Request, u: User) -> User {
 }
 
 fn mock_crate(req: &mut Request, krate: Crate) -> Crate {
+    let (c, v) = mock_crate_vers(req, krate, &semver::Version::parse("1.0.0").unwrap());
+    v.unwrap();
+    c
+}
+fn mock_crate_vers(req: &mut Request, krate: Crate, v: &semver::Version)
+                   -> (Crate, CargoResult<Version>) {
     let user = req.extensions().find::<User>().unwrap();
-    let krate = Crate::find_or_insert(req.tx().unwrap(), krate.name.as_slice(),
+    let mut krate = Crate::find_or_insert(req.tx().unwrap(), krate.name.as_slice(),
                                       user.id, &krate.description,
                                       &krate.homepage,
                                       &krate.documentation,
@@ -224,10 +231,8 @@ fn mock_crate(req: &mut Request, krate: Crate) -> Crate {
                                       &krate.license).unwrap();
     Keyword::update_crate(req.tx().unwrap(), &krate,
                           krate.keywords.as_slice()).unwrap();
-    Version::insert(req.tx().unwrap(), krate.id,
-                    &semver::Version::parse("1.0.0").unwrap(),
-                    &HashMap::new(), &[]).unwrap();
-    return krate;
+    let v = krate.add_version(req.tx().unwrap(), v, &HashMap::new(), &[]);
+    (krate, v)
 }
 
 fn mock_keyword(req: &mut Request, name: &str) -> Keyword {

src/tests/krate.rs

@@ -506,7 +506,7 @@ fn dependencies() {
     let c1 = ::krate("foo");
     let c2 = ::krate("bar");
     middle.add(::middleware::MockUser(user.clone()));
-    middle.add(::middleware::MockDependency(c1.clone(), c2.clone()));
+    middle.add(::middleware::MockDependency(c1.clone(), "1.0.0", c2.clone()));
     let rel = format!("/api/v1/crates/{}/1.0.0/dependencies", c1.name);
     let mut req = MockRequest::new(conduit::Get, rel.as_slice());
     let mut response = ok_resp!(middle.call(&mut req));
@@ -710,16 +710,24 @@ fn reverse_dependencies() {
     let c1 = ::krate("foo");
     let c2 = ::krate("bar");
     middle.add(::middleware::MockUser(user.clone()));
-    middle.add(::middleware::MockDependency(c1.clone(), c2.clone()));
-    let rel = format!("/api/v1/crates/{}/1.0.0/reverse_dependencies", c2.name);
+    // multiple dependencies of c1 on c2, to detect we handle this
+    // correctly.
+    middle.add(::middleware::MockDependency(c1.clone(), "1.0.0", c2.clone()));
+    middle.add(::middleware::MockDependency(c1.clone(), "1.1.0", c2.clone()));
+
+    let rel = format!("/api/v1/crates/{}/reverse_dependencies", c2.name);
     let mut req = MockRequest::new(conduit::Get, rel.as_slice());
     let mut response = ok_resp!(middle.call(&mut req));
     let deps = ::json::<RevDeps>(&mut response);
+    assert_eq!(deps.reverse_dependencies.len(), 1);
     assert_eq!(deps.reverse_dependencies[0].crate_id.as_slice(), &*c1.name);
     drop(req);
 
-    let rel = format!("/api/v1/crates/{}/1.0.2/reverse_dependencies", c1.name);
+    // c1 has no dependent crates.
+    let rel = format!("/api/v1/crates/{}/reverse_dependencies", c1.name);
     let mut req = MockRequest::new(conduit::Get, rel.as_slice());
     let mut response = ok_resp!(middle.call(&mut req));
-    ::json::<::Bad>(&mut response);
+    let deps = ::json::<RevDeps>(&mut response);
+    assert_eq!(deps.reverse_dependencies.len(), 0);
+    drop(req);
 }

src/tests/middleware.rs

@@ -28,15 +28,19 @@ impl Middleware for MockCrate {
     }
 }
 
-pub struct MockDependency(pub Crate, pub Crate);
+pub struct MockDependency(pub Crate, pub &'static str, pub Crate);
 
 impl Middleware for MockDependency {
     fn before(&self, req: &mut Request) -> Result<(), Box<Show + 'static>> {
-        let MockDependency(ref a, ref b) = *self;
-        let crate_a = ::mock_crate(req, a.clone());
-        let crate_b = ::mock_crate(req, b.clone());
-        let va = crate_a.versions(req.tx().unwrap()).unwrap()[0].id;
-        Dependency::insert(req.tx().unwrap(), va, crate_b.id,
+        let MockDependency(ref a, version, ref b) = *self;
+        let vers = semver::Version::parse(version).unwrap();
+        let (_crate_a, va) = ::mock_crate_vers(req, a.clone(), &vers);
+
+        // don't panic on duplicate uploads
+        let (crate_b, _) = ::mock_crate_vers(req, b.clone(),
+                                             &semver::Version::parse("1.0.0").unwrap());
+
+        Dependency::insert(req.tx().unwrap(), va.unwrap().id, crate_b.id,
                            &semver::VersionReq::parse(">= 0").unwrap(),
                            Kind::Normal,
                            false, true, &[], &None).unwrap();