use proptest to fuzz the resolver

Cargo.toml

@@ -93,6 +93,8 @@ features = [
 
 [dev-dependencies]
 bufstream = "0.1"
+proptest = "0.8.4"
+wait-timeout = "0.1.4" # required only for minimal-versions. brought in by proptest.
 
 [[bin]]
 name = "cargo"

tests/testsuite/main.rs

@@ -9,8 +9,12 @@ extern crate flate2;
 extern crate git2;
 extern crate glob;
 extern crate hex;
+#[macro_use]
+extern crate lazy_static;
 extern crate libc;
 #[macro_use]
+extern crate proptest;
+#[macro_use]
 extern crate serde_derive;
 #[macro_use]
 extern crate serde_json;

tests/testsuite/resolve.rs

@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 
 use support::hamcrest::{assert_that, contains, is_not};
 
@@ -12,6 +12,10 @@ use support::ChannelChanger;
 use support::{execs, project};
 use support::registry::Package;
 
+use proptest::collection::{btree_map, btree_set, vec};
+use proptest::prelude::*;
+use proptest::sample::subsequence;
+
 fn resolve(
     pkg: &PackageId,
     deps: Vec<Dependency>,
@@ -56,10 +60,13 @@ trait ToDep {
     fn to_dep(self) -> Dependency;
 }
 
+lazy_static! {
+    static ref EXAMPLE_DOT_COM: ::url::Url = "http://example.com".to_url().unwrap();
+}
+
 impl ToDep for &'static str {
     fn to_dep(self) -> Dependency {
-        let url = "http://example.com".to_url().unwrap();
-        let source_id = SourceId::for_registry(&url).unwrap();
+        let source_id = SourceId::for_registry(&EXAMPLE_DOT_COM).unwrap();
         Dependency::parse_no_deprecated(self, Some("1.0.0"), &source_id).unwrap()
     }
 }
@@ -111,8 +118,7 @@ macro_rules! pkg {
 }
 
 fn registry_loc() -> SourceId {
-    let remote = "http://example.com".to_url().unwrap();
-    SourceId::for_registry(&remote).unwrap()
+    SourceId::for_registry(&EXAMPLE_DOT_COM).unwrap()
 }
 
 fn pkg(name: &str) -> Summary {
@@ -155,8 +161,7 @@ fn dep(name: &str) -> Dependency {
     dep_req(name, "1.0.0")
 }
 fn dep_req(name: &str, req: &str) -> Dependency {
-    let url = "http://example.com".to_url().unwrap();
-    let source_id = SourceId::for_registry(&url).unwrap();
+    let source_id = SourceId::for_registry(&EXAMPLE_DOT_COM).unwrap();
     Dependency::parse_no_deprecated(name, Some(req), &source_id).unwrap()
 }
 
@@ -185,6 +190,97 @@ fn loc_names(names: &[(&'static str, &'static str)]) -> Vec<PackageId> {
         .collect()
 }
 
+/// This generates a random registry index.
+/// Unlike vec((Name, Ver, vec((Name, VerRq), ..), ..)
+/// This strategy has a high probability of having valid dependencies
+fn registry_strategy() -> impl Strategy<Value=Vec<Summary>> {
+    const VALID_NAME_STRATEGY: &str = "[A-Za-z_-][A-Za-z0-9_-]*";
+    const MAX_CRATES: usize = 10;
+    const MAX_VERSIONS: usize = 10;
+
+    fn range(max: usize) -> impl Strategy<Value = (usize, usize)> {
+        (0..max).prop_flat_map(move |low| (Just(low), low..=max))
+    }
+
+    fn ver(max: usize) -> impl Strategy<Value=(usize, usize, usize)> {
+        (0..=max, 0..=max, 0..=max)
+    }
+
+    btree_map(
+        VALID_NAME_STRATEGY,
+        btree_set(
+            ver(MAX_VERSIONS).prop_map(|(a, b, c)| format!("{}.{}.{}", a, b, c)),
+            1..=MAX_VERSIONS,
+        ),
+        1..=MAX_CRATES,
+    ).prop_map(|mut b| {
+        // root is the name of the thing being compiled
+        // so it would be confusing to have it in the index
+        b.remove("root");
+        // if randomly pointing to a dependency that does not exist then call it `bad`
+        b.insert("bad".to_owned(), BTreeSet::new());
+        (
+            b.iter()
+                .map(|(name, _)| name.clone())
+                .collect::<Vec<String>>(),
+            b.iter()
+                .flat_map(|(name, vers)| vers.into_iter().map(move |v| (name.clone(), v.clone())))
+                .collect::<Vec<_>>(),
+        )
+    }).prop_flat_map(|(names, data)| {
+        let names_len = names.len();
+        let data_len = data.len();
+        (
+            Just(data),
+            vec(subsequence(names, 0..names_len), data_len..=data_len),
+        )
+    }).prop_flat_map(|(data, deps)| {
+        let len = deps.iter().map(|x| x.len()).sum();
+        (
+            Just(data),
+            Just(deps),
+            vec(
+                range(MAX_VERSIONS).prop_map(|(b, e)| format!(">={}.0.0, <={}.0.0", b, e)),
+                len..=len,
+            ),
+        )
+    }).prop_map(|(data, deps, vers)| {
+        let mut i = 0;
+        data.into_iter()
+            .zip(deps.into_iter())
+            .map(|((name, ver), deps)| {
+                let d: Vec<Dependency> = deps.into_iter()
+                    .filter(|n| &name < n)
+                    .map(|n| {
+                        i += 1;
+                        dep_req(&n, &vers[i - 1])
+                    })
+                    .collect();
+                let pkgid = (name.as_str(), &*ver).to_pkgid();
+                let link = if pkgid.name().ends_with("-sys") { Some(pkgid.name().as_str()) } else { None };
+
+                Summary::new(pkgid, d, &BTreeMap::<String, Vec<String>>::new(), link, false).unwrap()
+            })
+            .collect()
+    })
+}
+
+proptest! {
+    #[test]
+    fn doesnt_crash(input in registry_strategy()) {
+        let reg = registry(input.clone());
+        // there is only a small chance that eny one
+        // crate will be interesting. So we try them all.
+        for this in input {
+            let _res = resolve(
+                &pkg_id("root"),
+                vec![dep_req(&this.name(), &format!("={}", this.version()))],
+                &reg,
+            );
+        }
+    }
+}
+
 #[test]
 #[should_panic(expected = "assertion failed: !name.is_empty()")]
 fn test_dependency_with_empty_name() {