From 92874815210a48e7234364115174b8b7f037cfb1 Mon Sep 17 00:00:00 2001
From: acruikshank <acruikshank@example.com>
Date: Wed, 9 Sep 2020 15:52:22 -0400
Subject: [PATCH] add test for recovered replaced sector

---
 actors/builtin/miner/miner_test.go | 66 +++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 2 deletions(-)

diff --git a/actors/builtin/miner/miner_test.go b/actors/builtin/miner/miner_test.go
index a48f8fb9f..9560ee43d 100644
--- a/actors/builtin/miner/miner_test.go
+++ b/actors/builtin/miner/miner_test.go
@@ -1105,7 +1105,7 @@ func TestCCUpgrade(t *testing.T) {
 		rt.Verify()
 	})
 
-	t.Run("declared fault for replaced cc upgrade sector doesn't double subtract power", func(t *testing.T) {
+	t.Run("declare fault for replaced cc upgrade sector doesn't double subtract power", func(t *testing.T) {
 		actor := newHarness(t, periodOffset)
 		rt := builderForHarness(actor).
 			WithBalance(bigBalance, big.Zero()).
@@ -1392,6 +1392,66 @@ func TestCCUpgrade(t *testing.T) {
 		})
 	})
 
+	t.Run("fault and recover a replaced sector", func(t *testing.T) {
+		actor := newHarness(t, periodOffset)
+		rt := builderForHarness(actor).
+			WithBalance(bigBalance, big.Zero()).
+			Build(t)
+		actor.constructAndVerify(rt)
+
+		// create sector and upgrade it
+		oldSector, newSector := actor.commitProveAndUpgradeSector(rt, 100, 200, defaultSectorExpiration, []abi.DealID{1})
+
+		// declare replaced sector faulty
+		powerDelta := actor.declareFaults(rt, oldSector)
+
+		// power for old sector should have been removed
+		oldQAPower := miner.QAPowerForSector(actor.sectorSize, oldSector)
+		oldSectorPower := miner.NewPowerPair(big.NewInt(int64(actor.sectorSize)), oldQAPower)
+		assert.Equal(t, oldSectorPower.Neg(), powerDelta)
+
+		st := getState(rt)
+		dlIdx, partIdx, err := st.FindSector(rt.AdtStore(), oldSector.SectorNumber)
+		require.NoError(t, err)
+
+		// recover replaced sector
+		actor.declareRecoveries(rt, dlIdx, partIdx, bf(uint64(oldSector.SectorNumber)), big.Zero())
+
+		// advance to sector proving deadline
+		dlInfo := actor.deadline(rt)
+		for dlIdx != dlInfo.Index {
+			advanceDeadline(rt, actor, &cronConfig{})
+			dlInfo = actor.deadline(rt)
+		}
+
+		// both sectors now need to be proven.
+		// Upon success, new sector will gain power and replaced sector will briefly regain power/
+		rt.SetEpoch(dlInfo.Last())
+		newQAPower := miner.QAPowerForSector(actor.sectorSize, newSector)
+		newSectorPower := miner.NewPowerPair(big.NewInt(int64(actor.sectorSize)), newQAPower)
+		expectedPowerDelta := oldSectorPower.Add(newSectorPower)
+
+		// miner will still need to pay declared fee recovered power's time as a fault.
+		expectedFee := miner.PledgePenaltyForDeclaredFault(actor.epochRewardSmooth, actor.epochQAPowerSmooth, oldQAPower)
+		actor.applyRewards(rt, expectedFee, big.Zero())
+
+		partitions := []miner.PoStPartition{
+			{Index: partIdx, Skipped: bitfield.New()},
+		}
+		actor.submitWindowPoSt(rt, dlInfo, partitions, []*miner.SectorOnChainInfo{oldSector, newSector}, &poStConfig{
+			expectedPowerDelta: expectedPowerDelta,
+			expectedPenalty:    expectedFee,
+		})
+
+		// At cron replaced sector's power is removed because it expires, and its initial pledge is removed
+		expectedPowerDelta = oldSectorPower.Neg()
+		actor.onDeadlineCron(rt, &cronConfig{
+			expiredSectorsPowerDelta:  &expectedPowerDelta,
+			expiredSectorsPledgeDelta: oldSector.InitialPledge.Neg(),
+			expectedEnrollment:        rt.Epoch() + miner.WPoStChallengeWindow,
+		})
+	})
+
 	t.Run("try to upgrade committed capacity sector twice", func(t *testing.T) {
 		actor := newHarness(t, periodOffset)
 		rt := builderForHarness(actor).
@@ -4460,7 +4520,7 @@ func (h *actorHarness) submitWindowPoSt(rt *mock.Runtime, deadline *miner.Deadli
 	rt.Verify()
 }
 
-func (h *actorHarness) declareFaults(rt *mock.Runtime, faultSectorInfos ...*miner.SectorOnChainInfo) {
+func (h *actorHarness) declareFaults(rt *mock.Runtime, faultSectorInfos ...*miner.SectorOnChainInfo) miner.PowerPair {
 	rt.SetCaller(h.worker, builtin.AccountActorCodeID)
 	rt.ExpectValidateCallerAddr(append(h.controlAddrs, h.owner, h.worker)...)
 
@@ -4489,6 +4549,8 @@ func (h *actorHarness) declareFaults(rt *mock.Runtime, faultSectorInfos ...*mine
 	params := makeFaultParamsFromFaultingSectors(h.t, st, rt.AdtStore(), faultSectorInfos)
 	rt.Call(h.a.DeclareFaults, params)
 	rt.Verify()
+
+	return miner.NewPowerPair(claim.RawByteDelta, claim.QualityAdjustedDelta)
 }
 
 func (h *actorHarness) declareRecoveries(rt *mock.Runtime, deadlineIdx uint64, partitionIdx uint64, recoverySectors bitfield.BitField, expectedDebtRepaid abi.TokenAmount) {