more test cleanup

* follower_bootup_across_multiple_cycles at least fails faster now: the failure scenario for this test involved not making it to nakamoto blocks,
  this puts a tighter timeout on that aspect of the test.
* block_proposal_max_age_rejections: make the message assertions specifically about the proposed test blocks, not any proposals
  that the miner might otherwise be trying to submit.

Author: kantai

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -4101,8 +4101,31 @@ fn follower_bootup_across_multiple_cycles() {
 
     debug!("Booted follower-thread");
 
-    // Wait a long time for the follower to catch up because CI is slow.
-    wait_for(600, || {
+    // Wait some time for the follower to at least get some nakamoto blocks
+    wait_for(120, || {
+        thread::sleep(Duration::from_secs(5));
+        let Ok(follower_node_info) = get_chain_info_result(&follower_conf) else {
+            return Ok(false);
+        };
+
+        let block_id = StacksBlockId::new(
+            &follower_node_info.stacks_tip_consensus_hash,
+            &follower_node_info.stacks_tip,
+        );
+        let tip = NakamotoChainState::get_block_header(chainstate.db(), &block_id)
+            .unwrap()
+            .unwrap();
+        info!(
+            "Latest follower tip";
+            "height" => tip.stacks_block_height,
+            "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
+        );
+
+        Ok(tip.anchored_header.as_stacks_nakamoto().is_some())
+    })
+    .unwrap();
+
+    wait_for(480, || {
         sleep_ms(1000);
         let Ok(follower_node_info) = get_chain_info_result(&follower_conf) else {
             return Ok(false);

testnet/stacks-node/src/tests/signer/v0.rs

@@ -8163,47 +8163,51 @@ fn block_proposal_max_age_rejections() {
 
     info!("------------------------- Test Block Proposal Rejected -------------------------");
     // Verify the signers rejected only the SECOND block proposal. The first was not even processed.
-    wait_for(30, || {
-        let rejections = test_observer::get_stackerdb_chunks()
+    wait_for(120, || {
+        let mut status_map = HashMap::new();
+        for chunk in test_observer::get_stackerdb_chunks()
             .into_iter()
             .flat_map(|chunk| chunk.modified_slots)
-            .map(|chunk| {
-                let Ok(message) = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
-                else {
-                    return None;
-                };
-                match message {
-                    SignerMessage::BlockResponse(BlockResponse::Rejected(BlockRejection {
-                        signer_signature_hash,
-                        signature,
-                        ..
-                    })) => {
-                        assert_eq!(
-                            signer_signature_hash, block_signer_signature_hash_2,
-                            "We should only reject the second block"
-                        );
-                        Some(signature)
-                    }
-                    SignerMessage::BlockResponse(BlockResponse::Accepted(BlockAccepted {
-                        signer_signature_hash,
-                        ..
-                    })) => {
-                        assert_ne!(
-                            signer_signature_hash, block_signer_signature_hash_1,
-                            "We should never have accepted block"
-                        );
-                        None
-                    }
-                    _ => None,
+        {
+            let Ok(message) = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
+            else {
+                continue;
+            };
+            match message {
+                SignerMessage::BlockResponse(BlockResponse::Rejected(BlockRejection {
+                    signer_signature_hash,
+                    ..
+                })) => {
+                    let entry = status_map.entry(signer_signature_hash).or_insert((0, 0));
+                    entry.0 += 1;
                 }
-            });
-        Ok(rejections.count() > num_signers * 7 / 10)
+                SignerMessage::BlockResponse(BlockResponse::Accepted(BlockAccepted {
+                    signer_signature_hash,
+                    ..
+                })) => {
+                    let entry = status_map.entry(signer_signature_hash).or_insert((0, 0));
+                    entry.1 += 1;
+                }
+                _ => continue,
+            }
+        }
+        let block_1_status = status_map
+            .get(&block_signer_signature_hash_1)
+            .cloned()
+            .unwrap_or((0, 0));
+        assert_eq!(block_1_status, (0, 0));
+
+        let block_2_status = status_map
+            .get(&block_signer_signature_hash_2)
+            .cloned()
+            .unwrap_or((0, 0));
+        assert_eq!(block_2_status.1, 0, "Block 2 should always be rejected");
+
+        info!("Block 2 status"; "accepted" => block_2_status.1, "rejected" => block_2_status.0);
+        Ok(block_2_status.0 > num_signers * 7 / 10)
     })
     .expect("Timed out waiting for block rejections");
 
-    info!("------------------------- Test Peer Info-------------------------");
-    assert_eq!(info_before, get_chain_info(&signer_test.running_nodes.conf));
-
     info!("------------------------- Test Shutdown-------------------------");
     signer_test.shutdown();
 }