Merge pull request #2940 from blockstack/feat/test-mainnet

testing: Unit tests for cost contracts on mainnet

Author: Aaron Blankstein

Cargo.lock

@@ -385,17 +385,18 @@ impl ClarityInstance {
             header_db,
             burn_state_db,
             cost_track,
-            mainnet: false,
+            mainnet: self.mainnet,
             epoch,
         };
 
+        let use_mainnet = self.mainnet;
         conn.as_transaction(|clarity_db| {
             let (ast, _) = clarity_db
-                .analyze_smart_contract(&boot_code_id("costs", false), BOOT_CODE_COSTS)
+                .analyze_smart_contract(&boot_code_id("costs", use_mainnet), BOOT_CODE_COSTS)
                 .unwrap();
             clarity_db
                 .initialize_smart_contract(
-                    &boot_code_id("costs", false),
+                    &boot_code_id("costs", use_mainnet),
                     &ast,
                     BOOT_CODE_COSTS,
                     |_, _| false,
@@ -406,31 +407,31 @@ impl ClarityInstance {
         conn.as_transaction(|clarity_db| {
             let (ast, analysis) = clarity_db
                 .analyze_smart_contract(
-                    &boot_code_id("cost-voting", false),
+                    &boot_code_id("cost-voting", use_mainnet),
                     &*BOOT_CODE_COST_VOTING,
                 )
                 .unwrap();
             clarity_db
                 .initialize_smart_contract(
-                    &boot_code_id("cost-voting", false),
+                    &boot_code_id("cost-voting", use_mainnet),
                     &ast,
                     &*BOOT_CODE_COST_VOTING,
                     |_, _| false,
                 )
                 .unwrap();
 
             clarity_db
-                .save_analysis(&boot_code_id("cost-voting", false), &analysis)
+                .save_analysis(&boot_code_id("cost-voting", use_mainnet), &analysis)
                 .unwrap();
         });
 
         conn.as_transaction(|clarity_db| {
             let (ast, _) = clarity_db
-                .analyze_smart_contract(&boot_code_id("pox", false), &*BOOT_CODE_POX_TESTNET)
+                .analyze_smart_contract(&boot_code_id("pox", use_mainnet), &*BOOT_CODE_POX_TESTNET)
                 .unwrap();
             clarity_db
                 .initialize_smart_contract(
-                    &boot_code_id("pox", false),
+                    &boot_code_id("pox", use_mainnet),
                     &ast,
                     &*BOOT_CODE_POX_TESTNET,
                     |_, _| false,

src/clarity_vm/clarity.rs

@@ -39,9 +39,9 @@ use crate::core::StacksEpochId;
 use crate::types::chainstate::{BlockHeaderHash, StacksBlockId};
 use crate::types::proof::ClarityMarfTrieId;
 
-pub fn test_tracked_costs(prog: &str, epoch: StacksEpochId) -> ExecutionCost {
+pub fn test_tracked_costs(prog: &str, use_mainnet: bool, epoch: StacksEpochId) -> ExecutionCost {
     let marf = MarfedKV::temporary();
-    let mut clarity_instance = ClarityInstance::new(false, marf);
+    let mut clarity_instance = ClarityInstance::new(use_mainnet, marf);
 
     let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR");
 
@@ -173,24 +173,42 @@ pub fn test_tracked_costs(prog: &str, epoch: StacksEpochId) -> ExecutionCost {
     }
 }
 
-#[test]
-fn test_all() {
-    let baseline = test_tracked_costs("1", StacksEpochId::Epoch20);
+fn test_all(use_mainnet: bool) {
+    let baseline = test_tracked_costs("1", use_mainnet, StacksEpochId::Epoch20);
 
     for f in NativeFunctions::ALL.iter() {
         let test = get_simple_test(f);
-        let cost = test_tracked_costs(test, StacksEpochId::Epoch20);
+        let cost = test_tracked_costs(test, use_mainnet, StacksEpochId::Epoch20);
         assert!(cost.exceeds(&baseline));
     }
 }
 
 #[test]
-fn epoch_205_test_all() {
-    let baseline = test_tracked_costs("1", StacksEpochId::Epoch2_05);
+fn test_all_mainnet() {
+    test_all(true)
+}
+
+#[test]
+fn test_all_testnet() {
+    test_all(false)
+}
+
+fn epoch_205_test_all(use_mainnet: bool) {
+    let baseline = test_tracked_costs("1", use_mainnet, StacksEpochId::Epoch2_05);
 
     for f in NativeFunctions::ALL.iter() {
         let test = get_simple_test(f);
-        let cost = test_tracked_costs(test, StacksEpochId::Epoch2_05);
+        let cost = test_tracked_costs(test, use_mainnet, StacksEpochId::Epoch2_05);
         assert!(cost.exceeds(&baseline));
     }
 }
+
+#[test]
+fn epoch_205_test_all_mainnet() {
+    epoch_205_test_all(true)
+}
+
+#[test]
+fn epoch_205_test_all_testnet() {
+    epoch_205_test_all(false)
+}

src/vm/analysis/tests/costs.rs

@@ -544,11 +544,12 @@ impl<'a> OwnedEnvironment<'a> {
     pub fn new_max_limit(
         mut database: ClarityDatabase<'a>,
         epoch: StacksEpochId,
+        use_mainnet: bool,
     ) -> OwnedEnvironment<'a> {
-        let cost_track = LimitedCostTracker::new_max_limit(&mut database, epoch)
+        let cost_track = LimitedCostTracker::new_max_limit(&mut database, epoch, use_mainnet)
             .expect("FAIL: problem instantiating cost tracking");
         OwnedEnvironment {
-            context: GlobalContext::new(false, database, cost_track, epoch),
+            context: GlobalContext::new(use_mainnet, database, cost_track, epoch),
             default_contract: ContractContext::new(QualifiedContractIdentifier::transient()),
             call_stack: CallStack::new(),
         }