Test solver behavior when using options

It is expected that the solver will make an effort to resolve packages
that fit the options, even though it is not required to. Create a test
where multiple builds exist with different values for a var and add an option
to the solver for a specific value. A build exists with that value so
the solver should pick it.

Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spk-solve/crates/macros/src/lib.rs

@@ -13,14 +13,14 @@ pub use {serde_json, spfs};
 /// make_repo!({"pkg": "mypkg/1.0.0"}, options = {"debug" => "off"});
 #[macro_export]
 macro_rules! make_repo {
-    ( [ $( $spec:tt ),+ $(,)? ] ) => {{
+    ( [ $( $spec:tt ),* $(,)? ] ) => {{
         make_repo!([ $( $spec ),* ], options={})
     }};
-    ( [ $( $spec:tt ),+ $(,)? ], options={ $($k:expr => $v:expr),* } ) => {{
+    ( [ $( $spec:tt ),* $(,)? ], options={ $($k:expr => $v:expr),* } ) => {{
         let options = spk_schema::foundation::option_map!{$($k => $v),*};
         make_repo!([ $( $spec ),* ], options=options)
     }};
-    ( [ $( $spec:tt ),+ $(,)? ], options=$options:expr ) => {{
+    ( [ $( $spec:tt ),* $(,)? ], options=$options:expr ) => {{
         tracing::debug!("creating in-memory repository");
         let repo = spk_storage::RepositoryHandle::new_mem();
         let _opts = $options;

crates/spk-solve/src/solvers/solver_test.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/spkenv/spk
 
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use rstest::{fixture, rstest};
@@ -3083,3 +3084,63 @@ async fn request_for_all_component_picks_correct_version(
     let solution = run_and_print_resolve_for_tests(&mut solver).await.unwrap();
     assert_resolved!(solution, "mypkg", version = version);
 }
+
+/// Test that adding options to the solver make the solver pick the build that
+/// satisfies those options, when possible.
+#[rstest]
+#[case::step(step_solver())]
+#[case::resolvo(resolvo_solver())]
+#[tokio::test]
+async fn options_influence_build_choice(
+    #[case] mut solver: SolverImpl,
+    #[values(true, false)] scope_var: bool,
+) {
+    // Create 10 builds of a package, varying the value of an option called
+    // "num".
+    let builds = (0..10)
+        .map(|num| {
+            (
+                num.to_string(),
+                make_build!({
+                    "pkg": "mypkg/1.0.0",
+                    "build": {"options": [{"var": format!("num/{num}")}]},
+                }),
+            )
+        })
+        .inspect(|(num, spec)| {
+            eprintln!("Created build with num {num}: {}", spec.ident().build());
+        })
+        .collect::<HashMap<_, _>>();
+
+    let repo = make_repo!([]);
+    let _options = option_map! {};
+    for spec in builds.values() {
+        let (s, cmpts) = make_package!(repo, spec, _options);
+        repo.publish_package(&s, &cmpts).await.unwrap();
+    }
+
+    let repo = Arc::new(repo);
+
+    // For each option value from above, ask the solver to resolve mypkg using
+    // an option with that value for "num". It is expected that it will pick the
+    // build that was created with that value for "num".
+    //
+    // Since there are 10 builds, the odds of this succeeding by chance are 1 in
+    // 10 billion.
+    for (num, spec) in &builds {
+        solver.reset();
+
+        solver.add_repository(Arc::clone(&repo));
+        solver.add_request(request!("mypkg"));
+
+        let options = if scope_var {
+            option_map! { "mypkg.num" => num.to_string() }
+        } else {
+            option_map! { "num" => num.to_string() }
+        };
+        solver.update_options(options);
+
+        let solution = run_and_print_resolve_for_tests(&mut solver).await.unwrap();
+        assert_resolved!(solution, "mypkg", build = *spec.ident().build());
+    }
+}