test: follow-up for #7812: use less fixture to test quorum dkgstatus

 - Rotation test. The existing check after the DKG finishes now asserts 0 for each masternode. It no longer sums the stale debug sessions. The PR's two added scenarios are removed.
 - rpc_quorum.py. It now mines to the next DKG start block while the DKG spork is still off. Then it asserts the masternode's active_dkgs is above 0, before turning the spork on. The PR's separate scenario is removed.
  - test_framework.py. The helper that only the removed scenarios used is gone.

Author: knst

test/functional/feature_llmq_rotation.py

@@ -81,7 +81,6 @@ def run_test(self):
         llmq_type_name="llmq_test_dip0024"
 
         self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn())
-        self.test_unknown_active_membership()
 
         # Connect all nodes to node1 so that we always have the whole network connected
         # Otherwise only masternode connections will be established between nodes, which won't propagate TXs/blocks
@@ -119,13 +118,10 @@ def run_test(self):
         tip = self.nodes[0].getblockcount()
         next_dkg = 24 - (tip % 24)
         assert next_dkg < 24
-        stale_sessions = 0
         for mn in self.mninfo:
             dkg_info = mn.get_node(self).quorum("dkginfo")
             assert_equal(dkg_info['active_dkgs'], 0)
-            stale_sessions += len(mn.get_node(self).quorum("dkgstatus")["session"])
             assert_equal(dkg_info['next_dkg'], next_dkg)
-        assert stale_sessions > 0  # Expired debug sessions do not contribute to the count.
 
         expectedDeleted = []
         expectedNew = [h_100_0, h_100_1]
@@ -281,52 +277,6 @@ def run_test(self):
         assert_equal(rpc_qr_info["mnListDiffAtHMinus3C"]["baseBlockHash"], genesis_blockhash)
 
         self.test_getqrinfo_base_block_hashes_limit(int(best_block_hash, 16), int(hmc_base_blockhash, 16))
-        self.test_active_rotated_membership()
-
-    def test_unknown_active_membership(self):
-        self.log.info("Unknown active membership is counted conservatively before v20")
-        self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 4070908800)
-        self.wait_for_sporks_same()
-        tip = self.nodes[0].getblockcount()
-        start_height = tip + 24 - tip % 24
-        assert start_height < self.v20_height
-        self.generate(self.nodes[0], start_height - tip - 1)
-        node = self.mninfo[0].get_node(self)
-        upcoming = node.quorum("dkginfo")["upcoming_dkgs"]
-        assert upcoming
-        assert all(d["reason"] == "pre-v20 quorum selection needs future quorum base block hash" for d in upcoming)
-        self.generate(self.nodes[0], 1)
-        info = node.quorum("dkginfo")
-        assert info["active_dkgs"] > 0
-        assert_equal(info["active_dkgs"], self.expected_active_dkgs(upcoming, start_height))
-        assert_equal(node.quorum("dkgstatus")["session"], [])
-        self.generate(self.nodes[0], 13)
-        assert_equal(node.quorum("dkginfo")["active_dkgs"], 0)
-
-    def test_active_rotated_membership(self):
-        self.log.info("Active rotated membership is counted without DKG initialization")
-        self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 4070908800)
-        self.wait_for_sporks_same()
-        node = self.mninfo[0].get_node(self)
-        tip = self.nodes[0].getblockcount()
-        start_height = tip + 24 - tip % 24
-        self.generate(self.nodes[0], start_height - tip - 1)
-        upcoming = {mn.proTxHash: node.quorum("dkginfo", mn.proTxHash)["upcoming_dkgs"] for mn in self.mninfo}
-
-        # Each index's Commit phase ends after 10 blocks, independently of the
-        # shared mining window starting 12 blocks after the cycle base.
-        for offset in (0, 1, 9, 10, 11, 12, 13):
-            height = start_height + offset
-            self.generate(self.nodes[0], height - self.nodes[0].getblockcount())
-            counts = [node.quorum("dkginfo", mn.proTxHash)["active_dkgs"] for mn in self.mninfo]
-            assert_equal(counts, [self.expected_active_dkgs(upcoming[mn.proTxHash], height) for mn in self.mninfo])
-            # All other enabled regtest types share the cycle base, so only index 1 remains at offset 10.
-            if offset == 10:
-                assert sum(counts) > 0
-            elif offset > 10:
-                assert_equal(sum(counts), 0)
-            sessions = node.quorum("dkgstatus")["session"]
-            assert all(d["status"]["quorumHeight"] < start_height for d in sessions)
 
     def test_duplicate_rotated_commitment(self, quorum_info, llmq_type):
         self.log.info("A block mining one rotated commitment twice instead of its sibling is rejected")

test/functional/rpc_quorum.py

@@ -25,8 +25,9 @@ def set_test_params(self):
         self.set_dash_llmq_test_params(1, 1)
 
     def run_test(self):
-        self.test_active_dkg_membership()
-
+        self.mine_until_mns_confirmed_for_next_dkg()
+        self.generate(self.nodes[0], 24 - self.nodes[0].getblockcount() % 24)
+        assert self.mninfo[0].get_node(self).quorum("dkginfo")["active_dkgs"] > 0  # DKG is still disabled by spork
         self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 0)
         self.wait_for_sporks_same()
         self.mine_until_mns_confirmed_for_next_dkg()
@@ -39,41 +40,5 @@ def run_test(self):
                 if member["proTxHash"] == mn.proTxHash:
                     assert_equal(member['addresses']['core_p2p'][0], f'127.0.0.1:{mn.nodePort}')
 
-    def test_active_dkg_membership(self):
-        # Keep DKG disabled so no local session record can hide a reporting gap.
-        # Membership must remain counted for the whole current window anyway.
-        self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 4070908800)
-        self.wait_for_sporks_same()
-        self.mine_until_mns_confirmed_for_next_dkg()
-        mn = self.mninfo[0]
-        node = mn.get_node(self)
-        other = "01" * 32
-        tip = self.nodes[0].getblockcount()
-        start_height = tip + 24 - tip % 24
-        self.generate(self.nodes[0], start_height - tip - 1)
-        info = node.quorum("dkginfo")
-        assert_equal(info["active_dkgs"], 0)
-        upcoming = info["upcoming_dkgs"]
-        other_upcoming = node.quorum("dkginfo", other)["upcoming_dkgs"]
-        [llmq_test] = [d for d in upcoming if d["llmqType"] == 100]
-        assert_equal(llmq_test["blocksUntilStart"], 1)
-        assert_equal(llmq_test["known"], True)
-        assert_equal(llmq_test["isMember"], True)
-        [other_llmq_test] = [d for d in other_upcoming if d["llmqType"] == 100]
-        assert_equal(other_llmq_test["known"], True)
-        assert_equal(other_llmq_test["isMember"], False)
-
-        for offset in (0, 1, 9, 10):
-            height = start_height + offset
-            self.generate(self.nodes[0], height - self.nodes[0].getblockcount())
-            info = node.quorum("dkginfo")
-            if offset < 10:
-                assert info["active_dkgs"] > 0
-            assert_equal(info["active_dkgs"], self.expected_active_dkgs(upcoming, height))
-            assert_equal(node.quorum("dkginfo", other)["active_dkgs"], self.expected_active_dkgs(other_upcoming, height))
-            assert_equal(node.quorum("dkgstatus")["session"], [])
-            assert all(d["blocksUntilStart"] > 0 for d in info["upcoming_dkgs"])
-
-
 if __name__ == '__main__':
     RPCMasternodeTest().main()

test/functional/test_framework/test_framework.py

@@ -2218,11 +2218,6 @@ def get_upcoming_dkg_predictions(self, node, llmq_type):
                                if d["llmqType"] == llmq_type]
                 for mn in self.mninfo}
 
-    def expected_active_dkgs(self, upcoming, height):
-        # 'quorum dkginfo' active_dkgs at height from earlier upcoming_dkgs entries. Every regtest
-        # LLMQ type has dkgPhaseBlocks = 2, so a session is active through Commit for 10 blocks.
-        return sum(0 <= height - d["quorumHeight"] < 10 and (not d["known"] or d["isMember"]) for d in upcoming)
-
     def verify_upcoming_dkg_predictions(self, predictions, quorum_info):
         # 'quorum info' lists members in member-index order
         members = [m["proTxHash"] for m in quorum_info["members"]]