Add configure_for_build_environment to AbstractSolver

Fix commented out code in cmd_test for build stage tests and add a new
test that checks the basic behavior of a build stage test that the test
environment includes the build dependencies of the package being tested.

Lift the old solver's configure_for_build_environment method to
AbstractSolver. Although the other test stages have code that only lives
in the cmd_test crate to configure the solver properly, the build stage
uses this method that was defined in the solver itself. While the logic
of configure_for_build_environment could be duplicated in cmd_test, it
is also reused by other code in the solver so it made sense to preserve
the logic as a reusable solver method.

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

Author: jrray

crates/spk-cli/cmd-test/src/cmd_test_test.rs

@@ -541,3 +541,58 @@ tests:
         .await
         .expect_err("the test run should fail, otherwise the selectors aren't working properly");
 }
+
+#[rstest]
+#[case::cli("cli")]
+#[case::checks("checks")]
+#[case::resolvo("resolvo")]
+#[tokio::test]
+async fn build_stage_test_env_includes_build_deps(
+    tmpdir: tempfile::TempDir,
+    #[case] solver_to_run: &str,
+) {
+    let _rt = spfs_runtime().await;
+
+    let _ = build_package!(
+        tmpdir,
+        "base.spk.yaml",
+        br#"
+pkg: base/1.0.0
+build:
+  script:
+    - touch "$PREFIX"/base
+"#,
+        solver_to_run
+    );
+
+    let filename_str = build_package!(
+        tmpdir,
+        "simple1.spk.yaml",
+        br#"
+pkg: simple1/1.0.0
+build:
+  options:
+    - pkg: base
+  script:
+    - "true"
+
+tests:
+  - stage: build
+    script:
+      # simple's build options should exist in a build stage test environment.
+      - test -f "$PREFIX"/base
+"#,
+        solver_to_run
+    );
+
+    let mut opt = TestOpt::try_parse_from([
+        "test",
+        // Don't exec a new process to move into a new runtime, this confuses
+        // coverage testing.
+        "--no-runtime",
+        "--disable-repo=origin",
+        filename_str,
+    ])
+    .unwrap();
+    opt.test.run().await.unwrap();
+}

crates/spk-cli/cmd-test/src/test/build.rs

@@ -117,8 +117,8 @@ where
         for repo in self.repos.iter().cloned() {
             solver.add_repository(repo);
         }
-        // TODO
-        // solver.configure_for_build_environment(&self.recipe)?;
+        // Configure solver for build environment.
+        solver.configure_for_build_environment(&self.recipe)?;
         for request in self.additional_requirements.drain(..) {
             solver.add_request(request)
         }

crates/spk-solve/src/abstract_solver.rs

@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/spkenv/spk
 
+use std::borrow::Cow;
 use std::sync::Arc;
 
 use enum_dispatch::enum_dispatch;
 use spk_schema::ident::{PkgRequest, VarRequest};
-use spk_schema::{OptionMap, Request};
+use spk_schema::{OptionMap, Recipe, Request};
 use spk_solve_solution::Solution;
 use spk_storage::RepositoryHandle;
 use variantly::Variantly;
@@ -28,6 +29,12 @@ pub enum SolverImpl {
 pub trait AbstractSolver {
     fn as_any(&self) -> &dyn std::any::Any;
 
+    /// Return the options that the solver is currently configured with.
+    ///
+    /// These are the options that have been set via
+    /// [`AbstractSolverMut::update_options`].
+    fn get_options(&self) -> Cow<'_, OptionMap>;
+
     /// Return the PkgRequests added to the solver.
     fn get_pkg_requests(&self) -> Vec<PkgRequest>;
 
@@ -40,10 +47,26 @@ pub trait AbstractSolver {
 
 #[async_trait::async_trait]
 #[enum_dispatch]
-pub trait AbstractSolverMut {
+pub trait AbstractSolverMut: AbstractSolver {
     /// Add a request to this solver.
     fn add_request(&mut self, request: Request);
 
+    /// Adds requests for all build requirements of the given recipe.
+    fn configure_for_build_environment<T: Recipe>(&mut self, recipe: &T) -> Result<()> {
+        let options = self.get_options();
+
+        let build_options = recipe.resolve_options(&*options)?;
+        for req in recipe
+            .get_build_requirements(&build_options)?
+            .iter()
+            .cloned()
+        {
+            self.add_request(req)
+        }
+
+        Ok(())
+    }
+
     /// Put this solver back into its default state
     fn reset(&mut self);
 
@@ -92,6 +115,10 @@ where
         T::as_any(self)
     }
 
+    fn get_options(&self) -> Cow<'_, OptionMap> {
+        T::get_options(self)
+    }
+
     fn get_pkg_requests(&self) -> Vec<PkgRequest> {
         T::get_pkg_requests(self)
     }
@@ -113,6 +140,10 @@ where
         T::as_any(self)
     }
 
+    fn get_options(&self) -> Cow<'_, OptionMap> {
+        T::get_options(self)
+    }
+
     fn get_pkg_requests(&self) -> Vec<PkgRequest> {
         T::get_pkg_requests(self)
     }

crates/spk-solve/src/cdcl_solver/mod.rs

@@ -299,6 +299,10 @@ impl AbstractSolver for Solver {
         self
     }
 
+    fn get_options(&self) -> Cow<'_, OptionMap> {
+        Cow::Borrowed(&self.options)
+    }
+
     fn get_pkg_requests(&self) -> Vec<PkgRequest> {
         self.requests
             .iter()

crates/spk-solve/src/solver.rs

@@ -1050,22 +1050,6 @@ impl Solver {
             || self.impossible_checks.use_in_build_keys
     }
 
-    /// Adds requests for all build requirements
-    pub fn configure_for_build_environment<T: Recipe>(&mut self, recipe: &T) -> Result<()> {
-        let state = self.get_initial_state();
-
-        let build_options = recipe.resolve_options(state.get_option_map())?;
-        for req in recipe
-            .get_build_requirements(&build_options)?
-            .iter()
-            .cloned()
-        {
-            self.add_request(req)
-        }
-
-        Ok(())
-    }
-
     /// Adds requests for all build requirements and solves
     pub async fn solve_build_environment(&mut self, recipe: &SpecRecipe) -> Result<Solution> {
         self.configure_for_build_environment(recipe)?;
@@ -1108,6 +1092,10 @@ impl AbstractSolver for Solver {
         self
     }
 
+    fn get_options(&self) -> Cow<'_, OptionMap> {
+        Cow::Owned(self.get_initial_state().get_option_map().clone())
+    }
+
     fn get_pkg_requests(&self) -> Vec<PkgRequest> {
         self.get_initial_state()
             .get_pkg_requests()