itests: Breakup ccupgrade_test.go

.circleci/config.yml

@@ -792,6 +792,11 @@ workflows:
           suite: itest-batch_deal
           target: "./itests/batch_deal_test.go"
       
+      - test:
+          name: test-itest-ccupgrade_post
+          suite: itest-ccupgrade_post
+          target: "./itests/ccupgrade_post_test.go"
+      
       - test:
           name: test-itest-ccupgrade
           suite: itest-ccupgrade
@@ -917,6 +922,11 @@ workflows:
           suite: itest-sector_finalize_early
           target: "./itests/sector_finalize_early_test.go"
       
+      - test:
+          name: test-itest-sector_make_cc_avail
+          suite: itest-sector_make_cc_avail
+          target: "./itests/sector_make_cc_avail_test.go"
+      
       - test:
           name: test-itest-sector_miner_collateral
           suite: itest-sector_miner_collateral
@@ -927,6 +937,16 @@ workflows:
           suite: itest-sector_pledge
           target: "./itests/sector_pledge_test.go"
       
+      - test:
+          name: test-itest-sector_prefer_no_upgrade
+          suite: itest-sector_prefer_no_upgrade
+          target: "./itests/sector_prefer_no_upgrade_test.go"
+      
+      - test:
+          name: test-itest-sector_revert_available
+          suite: itest-sector_revert_available
+          target: "./itests/sector_revert_available_test.go"
+      
       - test:
           name: test-itest-sector_terminate
           suite: itest-sector_terminate

itests/ccupgrade_post_test.go

@@ -0,0 +1,32 @@
+package itests
+
+import (
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/itests/kit"
+)
+
+func TestCCUpgradeAndPoSt(t *testing.T) {
+	kit.QuietMiningLogs()
+	t.Run("upgrade and then post", func(t *testing.T) {
+		ctx := context.Background()
+		n := runTestCCUpgrade(t)
+		ts, err := n.ChainHead(ctx)
+		require.NoError(t, err)
+		start := ts.Height()
+		// wait for a full proving period
+		t.Log("waiting for chain")
+
+		n.WaitTillChain(ctx, func(ts *types.TipSet) bool {
+			if ts.Height() > start+abi.ChainEpoch(2880) {
+				return true
+			}
+			return false
+		})
+	})
+}

itests/ccupgrade_test.go

@@ -4,7 +4,6 @@ package itests
 import (
 	"context"
 	"fmt"
-	"github.com/filecoin-project/lotus/node/config"
 	"testing"
 	"time"
 
@@ -15,9 +14,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/itests/kit"
 )
 
@@ -104,217 +101,3 @@ func waitForSectorActive(ctx context.Context, t *testing.T, sn abi.SectorNumber,
 		time.Sleep(time.Second)
 	}
 }
-
-func TestCCUpgradeAndPoSt(t *testing.T) {
-	kit.QuietMiningLogs()
-	t.Run("upgrade and then post", func(t *testing.T) {
-		ctx := context.Background()
-		n := runTestCCUpgrade(t)
-		ts, err := n.ChainHead(ctx)
-		require.NoError(t, err)
-		start := ts.Height()
-		// wait for a full proving period
-		t.Log("waiting for chain")
-
-		n.WaitTillChain(ctx, func(ts *types.TipSet) bool {
-			if ts.Height() > start+abi.ChainEpoch(2880) {
-				return true
-			}
-			return false
-		})
-	})
-}
-
-func TestAbortUpgradeAvailable(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx := context.Background()
-	blockTime := 1 * time.Millisecond
-
-	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC())
-	ens.InterconnectAll().BeginMiningMustPost(blockTime)
-
-	maddr, err := miner.ActorAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
-	fmt.Printf("CCUpgrade: %d\n", CCUpgrade)
-
-	miner.PledgeSectors(ctx, 1, 0, nil)
-	sl, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 1, "expected 1 sector")
-	require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
-	{
-		si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Less(t, 50000, int(si.Expiration))
-	}
-	waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
-
-	err = miner.SectorMarkForUpgrade(ctx, sl[0], true)
-	require.NoError(t, err)
-
-	sl, err = miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 1, "expected 1 sector")
-
-	ss, err := miner.SectorsStatus(ctx, sl[0], false)
-	require.NoError(t, err)
-
-	for i := 0; i < 100; i++ {
-		ss, err = miner.SectorsStatus(ctx, sl[0], false)
-		require.NoError(t, err)
-		if ss.State == api.SectorState(sealing.Proving) {
-			time.Sleep(50 * time.Millisecond)
-			continue
-		}
-
-		require.Equal(t, api.SectorState(sealing.Available), ss.State)
-		break
-	}
-
-	require.NoError(t, miner.SectorAbortUpgrade(ctx, sl[0]))
-
-	for i := 0; i < 100; i++ {
-		ss, err = miner.SectorsStatus(ctx, sl[0], false)
-		require.NoError(t, err)
-		if ss.State == api.SectorState(sealing.Available) {
-			time.Sleep(50 * time.Millisecond)
-			continue
-		}
-
-		require.Equal(t, api.SectorState(sealing.Proving), ss.State)
-		break
-	}
-}
-
-func TestMakeAvailable(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx := context.Background()
-	blockTime := 1 * time.Millisecond
-
-	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) {
-		sc.MakeCCSectorsAvailable = true
-	}))
-	ens.InterconnectAll().BeginMiningMustPost(blockTime)
-
-	maddr, err := miner.ActorAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
-
-	miner.PledgeSectors(ctx, 1, 0, nil)
-	sl, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 1, "expected 1 sector")
-	require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
-	{
-		si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Less(t, 50000, int(si.Expiration))
-	}
-	waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
-
-	sl, err = miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 1, "expected 1 sector")
-
-	status, err := miner.SectorsStatus(ctx, CCUpgrade, true)
-	require.NoError(t, err)
-	assert.Equal(t, api.SectorState(sealing.Available), status.State)
-
-	dh := kit.NewDealHarness(t, client, miner, miner)
-	deal, res, inPath := dh.MakeOnlineDeal(ctx, kit.MakeFullDealParams{
-		Rseed:                        6,
-		SuspendUntilCryptoeconStable: true,
-	})
-	outPath := dh.PerformRetrieval(context.Background(), deal, res.Root, false)
-	kit.AssertFilesEqual(t, inPath, outPath)
-
-	sl, err = miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 1, "expected 1 sector")
-
-	status, err = miner.SectorsStatus(ctx, CCUpgrade, true)
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(status.Deals))
-	miner.WaitSectorsProving(ctx, map[abi.SectorNumber]struct{}{
-		CCUpgrade: {},
-	})
-}
-
-func TestPreferNoUpgrade(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx := context.Background()
-	blockTime := 1 * time.Millisecond
-
-	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) {
-		sc.PreferNewSectorsForDeals = true
-	}))
-	ens.InterconnectAll().BeginMiningMustPost(blockTime)
-
-	maddr, err := miner.ActorAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
-	Sealed := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 2)
-
-	{
-		miner.PledgeSectors(ctx, 1, 0, nil)
-		sl, err := miner.SectorsList(ctx)
-		require.NoError(t, err)
-		require.Len(t, sl, 1, "expected 1 sector")
-		require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
-		{
-			si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
-			require.NoError(t, err)
-			require.Less(t, 50000, int(si.Expiration))
-		}
-		waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
-
-		err = miner.SectorMarkForUpgrade(ctx, sl[0], true)
-		require.NoError(t, err)
-
-		sl, err = miner.SectorsList(ctx)
-		require.NoError(t, err)
-		require.Len(t, sl, 1, "expected 1 sector")
-	}
-
-	{
-		dh := kit.NewDealHarness(t, client, miner, miner)
-		deal, res, inPath := dh.MakeOnlineDeal(ctx, kit.MakeFullDealParams{
-			Rseed:                        6,
-			SuspendUntilCryptoeconStable: true,
-		})
-		outPath := dh.PerformRetrieval(context.Background(), deal, res.Root, false)
-		kit.AssertFilesEqual(t, inPath, outPath)
-	}
-
-	sl, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-	require.Len(t, sl, 2, "expected 2 sectors")
-
-	{
-		status, err := miner.SectorsStatus(ctx, CCUpgrade, true)
-		require.NoError(t, err)
-		assert.Equal(t, api.SectorState(sealing.Available), status.State)
-	}
-
-	{
-		status, err := miner.SectorsStatus(ctx, Sealed, true)
-		require.NoError(t, err)
-		assert.Equal(t, 1, len(status.Deals))
-		miner.WaitSectorsProving(ctx, map[abi.SectorNumber]struct{}{
-			Sealed: {},
-		})
-	}
-}

itests/sector_make_cc_avail_test.go

@@ -0,0 +1,77 @@
+package itests
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/itests/kit"
+	"github.com/filecoin-project/lotus/node/config"
+)
+
+func TestMakeAvailable(t *testing.T) {
+	kit.QuietMiningLogs()
+
+	ctx := context.Background()
+	blockTime := 1 * time.Millisecond
+
+	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) {
+		sc.MakeCCSectorsAvailable = true
+	}))
+	ens.InterconnectAll().BeginMiningMustPost(blockTime)
+
+	maddr, err := miner.ActorAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
+
+	miner.PledgeSectors(ctx, 1, 0, nil)
+	sl, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 1, "expected 1 sector")
+	require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
+	{
+		si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
+		require.NoError(t, err)
+		require.Less(t, 50000, int(si.Expiration))
+	}
+	waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
+
+	sl, err = miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 1, "expected 1 sector")
+
+	status, err := miner.SectorsStatus(ctx, CCUpgrade, true)
+	require.NoError(t, err)
+	assert.Equal(t, api.SectorState(sealing.Available), status.State)
+
+	dh := kit.NewDealHarness(t, client, miner, miner)
+	deal, res, inPath := dh.MakeOnlineDeal(ctx, kit.MakeFullDealParams{
+		Rseed:                        6,
+		SuspendUntilCryptoeconStable: true,
+	})
+	outPath := dh.PerformRetrieval(context.Background(), deal, res.Root, false)
+	kit.AssertFilesEqual(t, inPath, outPath)
+
+	sl, err = miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 1, "expected 1 sector")
+
+	status, err = miner.SectorsStatus(ctx, CCUpgrade, true)
+	require.NoError(t, err)
+	assert.Equal(t, 1, len(status.Deals))
+	miner.WaitSectorsProving(ctx, map[abi.SectorNumber]struct{}{
+		CCUpgrade: {},
+	})
+}

itests/sector_prefer_no_upgrade_test.go

@@ -0,0 +1,90 @@
+package itests
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/itests/kit"
+	"github.com/filecoin-project/lotus/node/config"
+)
+
+func TestPreferNoUpgrade(t *testing.T) {
+	kit.QuietMiningLogs()
+
+	ctx := context.Background()
+	blockTime := 1 * time.Millisecond
+
+	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) {
+		sc.PreferNewSectorsForDeals = true
+	}))
+	ens.InterconnectAll().BeginMiningMustPost(blockTime)
+
+	maddr, err := miner.ActorAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
+	Sealed := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 2)
+
+	{
+		miner.PledgeSectors(ctx, 1, 0, nil)
+		sl, err := miner.SectorsList(ctx)
+		require.NoError(t, err)
+		require.Len(t, sl, 1, "expected 1 sector")
+		require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
+		{
+			si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
+			require.NoError(t, err)
+			require.Less(t, 50000, int(si.Expiration))
+		}
+		waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
+
+		err = miner.SectorMarkForUpgrade(ctx, sl[0], true)
+		require.NoError(t, err)
+
+		sl, err = miner.SectorsList(ctx)
+		require.NoError(t, err)
+		require.Len(t, sl, 1, "expected 1 sector")
+	}
+
+	{
+		dh := kit.NewDealHarness(t, client, miner, miner)
+		deal, res, inPath := dh.MakeOnlineDeal(ctx, kit.MakeFullDealParams{
+			Rseed:                        6,
+			SuspendUntilCryptoeconStable: true,
+		})
+		outPath := dh.PerformRetrieval(context.Background(), deal, res.Root, false)
+		kit.AssertFilesEqual(t, inPath, outPath)
+	}
+
+	sl, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 2, "expected 2 sectors")
+
+	{
+		status, err := miner.SectorsStatus(ctx, CCUpgrade, true)
+		require.NoError(t, err)
+		assert.Equal(t, api.SectorState(sealing.Available), status.State)
+	}
+
+	{
+		status, err := miner.SectorsStatus(ctx, Sealed, true)
+		require.NoError(t, err)
+		assert.Equal(t, 1, len(status.Deals))
+		miner.WaitSectorsProving(ctx, map[abi.SectorNumber]struct{}{
+			Sealed: {},
+		})
+	}
+}
+

itests/sector_revert_available_test.go

@@ -0,0 +1,84 @@
+package itests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/itests/kit"
+)
+
+func TestAbortUpgradeAvailable(t *testing.T) {
+	kit.QuietMiningLogs()
+
+	ctx := context.Background()
+	blockTime := 1 * time.Millisecond
+
+	client, miner, ens := kit.EnsembleMinimal(t, kit.GenesisNetworkVersion(network.Version15), kit.ThroughRPC())
+	ens.InterconnectAll().BeginMiningMustPost(blockTime)
+
+	maddr, err := miner.ActorAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	CCUpgrade := abi.SectorNumber(kit.DefaultPresealsPerBootstrapMiner + 1)
+	fmt.Printf("CCUpgrade: %d\n", CCUpgrade)
+
+	miner.PledgeSectors(ctx, 1, 0, nil)
+	sl, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 1, "expected 1 sector")
+	require.Equal(t, CCUpgrade, sl[0], "unexpected sector number")
+	{
+		si, err := client.StateSectorGetInfo(ctx, maddr, CCUpgrade, types.EmptyTSK)
+		require.NoError(t, err)
+		require.Less(t, 50000, int(si.Expiration))
+	}
+	waitForSectorActive(ctx, t, CCUpgrade, client, maddr)
+
+	err = miner.SectorMarkForUpgrade(ctx, sl[0], true)
+	require.NoError(t, err)
+
+	sl, err = miner.SectorsList(ctx)
+	require.NoError(t, err)
+	require.Len(t, sl, 1, "expected 1 sector")
+
+	ss, err := miner.SectorsStatus(ctx, sl[0], false)
+	require.NoError(t, err)
+
+	for i := 0; i < 100; i++ {
+		ss, err = miner.SectorsStatus(ctx, sl[0], false)
+		require.NoError(t, err)
+		if ss.State == api.SectorState(sealing.Proving) {
+			time.Sleep(50 * time.Millisecond)
+			continue
+		}
+
+		require.Equal(t, api.SectorState(sealing.Available), ss.State)
+		break
+	}
+
+	require.NoError(t, miner.SectorAbortUpgrade(ctx, sl[0]))
+
+	for i := 0; i < 100; i++ {
+		ss, err = miner.SectorsStatus(ctx, sl[0], false)
+		require.NoError(t, err)
+		if ss.State == api.SectorState(sealing.Available) {
+			time.Sleep(50 * time.Millisecond)
+			continue
+		}
+
+		require.Equal(t, api.SectorState(sealing.Proving), ss.State)
+		break
+	}
+}