From bb00e27e3a2cb65227c75a9fa49860c5fa3661b7 Mon Sep 17 00:00:00 2001 From: kirdatatjana Date: Tue, 27 Aug 2024 16:04:13 +0200 Subject: [PATCH] Improved slashing.go test descriptions --- tests/integration/provider_gov_hooks.go | 2 +- tests/integration/query_providerinfo_test.go | 2 +- tests/integration/slashing.go | 65 +++++++++++++++++--- 3 files changed, 59 insertions(+), 10 deletions(-) diff --git a/tests/integration/provider_gov_hooks.go b/tests/integration/provider_gov_hooks.go index bebdb35d67..322f772be4 100644 --- a/tests/integration/provider_gov_hooks.go +++ b/tests/integration/provider_gov_hooks.go @@ -14,7 +14,7 @@ import ( ) // TestAfterPropSubmissionAndVotingPeriodEnded tests the results of GetProviderInfo method. -// @Long Description +// @Long Description@ // The test sets up the account that will submit the proposal, and then the proposal is created. // After the proposal is submitted the AfterProposalSubmission hook is triggered // and it should handle the submission of the proposal in the provider module. diff --git a/tests/integration/query_providerinfo_test.go b/tests/integration/query_providerinfo_test.go index 57bbfd8d1a..5e29bdbc5a 100644 --- a/tests/integration/query_providerinfo_test.go +++ b/tests/integration/query_providerinfo_test.go @@ -1,7 +1,7 @@ package integration // TestQueryProviderInfo tests the results of GetProviderInfo method. -// @Long Description +// @Long Description@ // The test sets up a CVV channel and sends an empty VSC packet. // Then verifies that the result of GetProviderInfo method is correct and it // provides expected information about the blockchain provider and consumer. diff --git a/tests/integration/slashing.go b/tests/integration/slashing.go index 254a8467a4..f58a7ef725 100644 --- a/tests/integration/slashing.go +++ b/tests/integration/slashing.go @@ -29,9 +29,18 @@ import ( ccv "github.com/cosmos/interchain-security/v5/x/ccv/types" ) -// TestRelayAndApplyDowntimePacket tests that downtime slash packets can be properly relayed -// from consumer to provider, handled by provider, with a VSC and jailing -// eventually effective on consumer and provider. +// TestRelayAndApplyDowntimePacket tests that downtime slash packets can be properly relayed from consumer to provider, +// handled by provider, with a VSC and jailing eventually effective on consumer and provider. +// @Long Description@ +// It sets up CCV channels and retrieves consumer validators. A validator is selected and its consensus address is created. +// The test then retrieves the provider consensus address that corresponds to the consumer consensus address of the validator. +// Also the validator's current state is retrieved, including its token balance, and the validator's signing information is set to ensure +// it will be jailed for downtime. The slashing packet is then created and sent from the consumer chain to the provider chain with a specified +// timeout. The packet is then received and the test also verifies that the validator was removed from the provider validator set. +// After, the test relays VSC packets from the provider chain to each consumer chain and verifies that the consumer chains correctly +// process these packets. The validator's balance and status on the provider chain are checked to ensure it was jailed correctly but not slashed, +// and its unjailing time is updated. The outstanding downtime flag is reset on the consumer chain, and lastly, the test ensures that the consumer +// chain acknowledges receipt of the packet from the provider chain. // // Note: This method does not test the actual slash packet sending logic for downtime // and double-signing, see TestValidatorDowntime and TestValidatorDoubleSigning for @@ -172,7 +181,17 @@ func (s *CCVTestSuite) TestRelayAndApplyDowntimePacket() { s.Require().NoError(err) } -// Similar setup to TestRelayAndApplyDowntimePacket, but with a double sign slash packet. +// TestRelayAndApplyDoubleSignPacket tests correct processing of double sign slashing packets. +// handled by provider, with a VSC and jailing eventually effective on consumer and provider. +// @Long Description@ +// It sets up CCV channels and retrieves consumer validators. A validator is selected and its consensus address is created. +// The test then retrieves the provider consensus address that corresponds to the consumer consensus address of the validator. +// Also the validator's current state is retrieved, including its token balance, and the validator's signing information is set to ensure +// The double sign slashing packet is then created and sent from the consumer chain to the provider chain. +// timeout and sets infraction type to be double signed. The test then verifies that the validator wasn't slashed, that its status is still bonded, +// and that the unjailing time and tombstone status are correctly managed. Provider chain then sends an acknowledgment for the slashing +// packet to confirm that it has been processed. +// // Note that double-sign slash packets should not affect the provider validator set. func (s *CCVTestSuite) TestRelayAndApplyDoubleSignPacket() { // Setup CCV channel for all instantiated consumers @@ -303,6 +322,12 @@ func (s *CCVTestSuite) TestSlashPacketAcknowledgement() { } // TestHandleSlashPacketDowntime tests the handling of a downtime related slash packet, with integration tests. +// @Long Description@ +// It retrives a validator from provider chain's validators and cheks if it's bonded. +// The signing information for the validator is then set. The provider processes the downtime slashing packet from the consumer. +// The test then checks that the validator has been jailed as a result of the downtime slashing packet being processed. +// It also verifies that the validator’s signing information is updated and that the jailing duration is set correctly. +// // Note that only downtime slash packets are processed by HandleSlashPacket. func (suite *CCVTestSuite) TestHandleSlashPacketDowntime() { providerKeeper := suite.providerApp.GetProviderKeeper() @@ -345,6 +370,11 @@ func (suite *CCVTestSuite) TestHandleSlashPacketDowntime() { } // TestOnRecvSlashPacketErrors tests errors for the OnRecvSlashPacket method in an integration testing setting +// @Long Description@ +// It sets up all CCV channels and expects panic if ccv channel is not established via dest channel of packet. +// After the correct channelID is added to the packet, a panic shouldn't occur anymore. +// The test creates an instance of SlashPacketData and then verifies correct processing and error handling +// for slashing packets received by the provider chain. func (suite *CCVTestSuite) TestOnRecvSlashPacketErrors() { providerKeeper := suite.providerApp.GetProviderKeeper() firstBundle := suite.getFirstBundle() @@ -441,9 +471,15 @@ func (suite *CCVTestSuite) TestOnRecvSlashPacketErrors() { suite.Require().Equal(ccv.SlashPacketHandledResult, ackResult, "expected successful ack") } -// TestValidatorDowntime tests if a slash packet is sent -// and if the outstanding slashing flag is switched +// TestValidatorDowntime tests if a slash packet is sent and if the outstanding slashing flag is switched // when a validator has downtime on the slashing module +// @Long Description@ +// It sets up all CCV channel and send an empty VSC packet, then retrives the address of a validator. +// Validator signins blocks for the duration of the signedBlocksWindow and a slash packet is constructed to be sent and commited. +// The test simulates the validator missing blocks and then verifies that the validator is jailed and the jailed time is correctly updated. +// Also it ensures that the missed block counters are reset. After it checks that there is a pending slash packet in the queue, the test sends the pending packets. +// Then checks if slash record is created and verifies that the consumer queue still contains the packet since no acknowledgment has been received from the provider. +// It verifies that the slash packet was sent and check that the outstanding slashing flag prevents the jailed validator to keep missing block. func (suite *CCVTestSuite) TestValidatorDowntime() { // initial setup suite.SetupCCVChannel(suite.path) @@ -555,8 +591,12 @@ func (suite *CCVTestSuite) TestValidatorDowntime() { }) } -// TestValidatorDoubleSigning tests if a slash packet is sent -// when a double-signing evidence is handled by the evidence module +// TestValidatorDoubleSigning tests if a slash packet is sent when a double-signing evidence is handled by the evidence module +// @Long Description@ +// It sets up all CCV channel and sends an empty VSC packet, then creates a validator public key and address. Then the infraction parameters are set and +// evidence of double signing is created. Validator signing-info are also added to the store and the slash packet is constructed. +// The test then simulates double signing and sends the slash packet. It then verifies the handling of slash packet, and after +// it cheks if slash record was created and if it's waiting for reply. Lastly the test confirms that the queue is not cleared and the slash packet is sent func (suite *CCVTestSuite) TestValidatorDoubleSigning() { // initial setup suite.SetupCCVChannel(suite.path) @@ -644,6 +684,11 @@ func (suite *CCVTestSuite) TestValidatorDoubleSigning() { // TestQueueAndSendSlashPacket tests the integration of QueueSlashPacket with SendPackets. // In normal operation slash packets are queued in BeginBlock and sent in EndBlock. +// @Long Description@ +// It sets up all CCV channels and then queues slash packets for both downtime and double-signing infractions. +// Then, it checks that the correct number of slash requests are stored in the queue, including duplicates for downtime infractions. +// After the CCV channel for sending actual slash packets is prepared, the slash packets are sent, and the test checks that the outstanding downtime flags +// are correctly set for validators that were slashed for downtime infractions. Lastly, the test ensures that the pending data packets queue is empty. func (suite *CCVTestSuite) TestQueueAndSendSlashPacket() { suite.SetupCCVChannel(suite.path) @@ -724,6 +769,10 @@ func (suite *CCVTestSuite) TestQueueAndSendSlashPacket() { // TestCISBeforeCCVEstablished tests that the consumer chain doesn't panic or // have any undesired behavior when a slash packet is queued before the CCV channel is established. // Then once the CCV channel is established, the slash packet should be sent soon after. +// @Long Description@ +// It checks that no pending packets exist and that there's no slash record found. Then it triggers a slashing event which queues a slash packet. +// The slash packet should be queued but not sent, and it should stay like that until the CCV channel is established and the packet is sent. +// The test then verifies that a slashing record now exists, indicating that the slashing packet has been successfully sent. func (suite *CCVTestSuite) TestCISBeforeCCVEstablished() { consumerKeeper := suite.consumerApp.GetConsumerKeeper()