tests: fix CheckErrors::NoSuchContract error in tests

Author: csgui

clarity/src/vm/contexts.rs

@@ -31,11 +31,13 @@ use super::analysis::{self, ContractAnalysis};
 #[cfg(feature = "clarity-wasm")]
 use super::clarity_wasm::call_function;
 use super::EvalHook;
+use crate::vm::analysis::AnalysisDatabase;
 use crate::vm::ast::{ASTRules, ContractAST};
 use crate::vm::callables::{DefinedFunction, FunctionIdentifier};
 use crate::vm::contracts::Contract;
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{runtime_cost, CostErrors, CostTracker, ExecutionCost, LimitedCostTracker};
+use crate::vm::database::MemoryBackingStore;
 use crate::vm::database::{
     ClarityDatabase, DataMapMetadata, DataVariableMetadata, FungibleTokenMetadata,
     NonFungibleTokenMetadata,
@@ -658,13 +660,51 @@ impl<'a> OwnedEnvironment<'a> {
         contract_content: &str,
         sponsor: Option<PrincipalData>,
         ast_rules: ASTRules,
+    ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
+        let mut store = MemoryBackingStore::new();
+        self.initialize_contract_with_db(
+            contract_identifier,
+            contract_content,
+            sponsor,
+            ast_rules,
+            &mut store.as_analysis_db(),
+        )
+    }
+
+    /// Initializes a Clarity smart contract with a custom analysis database within a transaction context.
+    ///
+    /// This function creates a complete transaction environment to initialize a Clarity smart contract
+    /// using a provided memory-backed database for analysis data. It executes the contract initialization
+    /// within a proper execution context.
+    ///
+    /// # Arguments
+    ///
+    /// * `contract_identifier` - Unique identifier for the contract (principal + contract name)
+    /// * `contract_content` - The raw Clarity source code as a string
+    /// * `sponsor` - Optional sponsor principal for transaction fees (if `None`, sender pays)
+    /// * `ast_rules` - Parsing rules to apply during AST construction (e.g., `ASTRules::PrecheckSize`)
+    /// * `analysis_db` - Mutable reference to a database for analysis data
+    ///
+    #[cfg(any(test, feature = "testing"))]
+    pub fn initialize_contract_with_db(
+        &mut self,
+        contract_identifier: QualifiedContractIdentifier,
+        contract_content: &str,
+        sponsor: Option<PrincipalData>,
+        ast_rules: ASTRules,
+        analysis_db: &mut AnalysisDatabase,
     ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
             sponsor,
             None,
             |exec_env| {
-                exec_env.initialize_contract(contract_identifier, contract_content, ast_rules)
+                exec_env.initialize_contract_with_db(
+                    contract_identifier,
+                    contract_content,
+                    ast_rules,
+                    analysis_db,
+                )
             },
         )
     }
@@ -1341,8 +1381,46 @@ impl<'a, 'b> Environment<'a, 'b> {
         contract_content: &str,
         ast_rules: ASTRules,
     ) -> Result<()> {
-        use super::database::MemoryBackingStore;
+        let mut store = MemoryBackingStore::new();
+        let mut analysis_db = store.as_analysis_db();
+        analysis_db.begin();
+
+        self.initialize_contract_with_db(
+            contract_identifier,
+            contract_content,
+            ast_rules,
+            &mut analysis_db,
+        )
+    }
 
+    /// Initializes a Clarity smart contract with a custom analysis database.
+    ///
+    /// This function should only be used for testing.
+    ///
+    /// This function parses and analyzes a Clarity smart contract using
+    /// a provided database for analysis data. It's primarily used for testing
+    /// scenarios where you need control over the backing storage.
+    ///
+    /// # Arguments
+    ///
+    /// * `contract_identifier` - Unique identifier for the contract (principal + name)
+    /// * `contract_content` - The raw Clarity source code as a string
+    /// * `ast_rules` - Parsing rules to apply during AST construction
+    /// * `analysis_db` - Mutable reference to a database for analysis data
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - Contract successfully initialized
+    /// * `Err(Error)` - Initialization failed due to parsing or analysis
+    ///
+    #[cfg(feature = "rusqlite")]
+    pub fn initialize_contract_with_db(
+        &mut self,
+        contract_identifier: QualifiedContractIdentifier,
+        contract_content: &str,
+        ast_rules: ASTRules,
+        analysis_db: &mut AnalysisDatabase,
+    ) -> Result<()> {
         let clarity_version = self.contract_context.clarity_version;
 
         let mut contract_ast = ast::build_ast_with_rules(
@@ -1354,12 +1432,11 @@ impl<'a, 'b> Environment<'a, 'b> {
             ast_rules,
         )?;
 
-        let mut store = MemoryBackingStore::new();
         let contract_analysis = analysis::run_analysis(
             &contract_identifier,
             &contract_ast.expressions,
-            &mut store.as_analysis_db(),
-            false,
+            analysis_db,
+            true,
             LimitedCostTracker::Free,
             self.global_context.epoch_id,
             clarity_version,

clarity/src/vm/tests/assets.rs

@@ -16,8 +16,10 @@
 
 use stacks_common::types::StacksEpochId;
 
+use crate::vm::analysis::analysis_db;
 use crate::vm::ast::ASTRules;
 use crate::vm::contexts::{AssetMap, AssetMapEntry, OwnedEnvironment};
+use crate::vm::database::MemoryBackingStore;
 use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType};
 use crate::vm::events::StacksTransactionEvent;
 use crate::vm::representations::SymbolicExpression;
@@ -176,20 +178,26 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
     let second_contract_id =
         QualifiedContractIdentifier::new(p1_std_principal_data, "second".into());
 
+    let mut store = MemoryBackingStore::new();
+    let mut analysis_db = store.as_analysis_db();
+    analysis_db.begin();
+
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             token_contract_id.clone(),
             contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             second_contract_id.clone(),
             contract_second,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
 
@@ -941,28 +949,35 @@ fn test_overlapping_nfts(
     let names_2_contract_id =
         QualifiedContractIdentifier::new(p1_std_principal_data, "names-2".into());
 
+    let mut store = MemoryBackingStore::new();
+    let mut analysis_db = store.as_analysis_db();
+    analysis_db.begin();
+
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             tokens_contract_id,
             tokens_contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             names_contract_id,
             names_contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             names_2_contract_id,
             names_contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
 }
@@ -1015,22 +1030,28 @@ fn test_simple_naming_system(
     let name_hash_expensive_1 = execute("(hash160 2)");
     let name_hash_cheap_0 = execute("(hash160 100001)");
 
+    let mut store = MemoryBackingStore::new();
+    let mut analysis_db = store.as_analysis_db();
+    analysis_db.begin();
+
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             tokens_contract_id,
             tokens_contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();
 
     let names_contract_id = QualifiedContractIdentifier::new(p1_std_principal_data, "names".into());
     owned_env
-        .initialize_contract(
+        .initialize_contract_with_db(
             names_contract_id.clone(),
             names_contract,
             None,
             ASTRules::PrecheckSize,
+            &mut analysis_db,
         )
         .unwrap();