test: improve observer module coverage

changelog.md

@@ -48,6 +48,7 @@
 * [1879](https://github.com/zeta-chain/node/pull/1879) - full coverage for messages in types packages
 * [1899](https://github.com/zeta-chain/node/pull/1899) - add empty test files so packages are included in coverage
 * [1903](https://github.com/zeta-chain/node/pull/1903) - common package tests
+* [1961](https://github.com/zeta-chain/node/pull/1961) - improve observer module coverage
 
 ### Fixes
 

codecov.yml

@@ -49,6 +49,8 @@ ignore:
   - "x/**/types/types.go"
   - "x/**/types/expected_keepers.go"
   - "x/**/module.go"
+  - "x/**/events.go"
+  - "x/**/migrator.go"
   - "x/**/module_simulation.go"
   - "x/**/simulation/"
   - "**/*.proto"

x/observer/abci.go

@@ -21,10 +21,6 @@ func BeginBlocker(ctx sdk.Context, k keeper.Keeper) {
 		return
 	}
 	totalObserverCountCurrentBlock := allObservers.LenUint()
-	if totalObserverCountCurrentBlock < 0 {
-		ctx.Logger().Error("TotalObserverCount is negative at height", ctx.BlockHeight())
-		return
-	}
 	// #nosec G701 always in range
 	if totalObserverCountCurrentBlock == lastBlockObserverCount.Count {
 		return

x/observer/abci_test.go

@@ -0,0 +1,98 @@
+package observer_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	keepertest "github.com/zeta-chain/zetacore/testutil/keeper"
+	"github.com/zeta-chain/zetacore/testutil/sample"
+	"github.com/zeta-chain/zetacore/x/observer"
+	"github.com/zeta-chain/zetacore/x/observer/types"
+)
+
+func TestBeginBlocker(t *testing.T) {
+	t.Run("should not update LastObserverCount if not found", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+
+		observer.BeginBlocker(ctx, *k)
+
+		_, found := k.GetLastObserverCount(ctx)
+		require.False(t, found)
+
+		_, found = k.GetKeygen(ctx)
+		require.False(t, found)
+	})
+
+	t.Run("should not update LastObserverCount if observer set not found", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+
+		count := 1
+		k.SetLastObserverCount(ctx, &types.LastObserverCount{
+			Count: uint64(count),
+		})
+
+		observer.BeginBlocker(ctx, *k)
+
+		lastObserverCount, found := k.GetLastObserverCount(ctx)
+		require.True(t, found)
+		require.Equal(t, uint64(count), lastObserverCount.Count)
+		require.Equal(t, int64(0), lastObserverCount.LastChangeHeight)
+
+		_, found = k.GetKeygen(ctx)
+		require.False(t, found)
+	})
+
+	t.Run("should not update LastObserverCount if observer set count equal last observed count", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+
+		count := 1
+		os := sample.ObserverSet(count)
+		k.SetObserverSet(ctx, os)
+		k.SetLastObserverCount(ctx, &types.LastObserverCount{
+			Count: uint64(count),
+		})
+
+		observer.BeginBlocker(ctx, *k)
+
+		lastObserverCount, found := k.GetLastObserverCount(ctx)
+		require.True(t, found)
+		require.Equal(t, uint64(count), lastObserverCount.Count)
+		require.Equal(t, int64(0), lastObserverCount.LastChangeHeight)
+
+		_, found = k.GetKeygen(ctx)
+		require.False(t, found)
+	})
+
+	t.Run("should update LastObserverCount", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+
+		observeSetLen := 10
+		count := 1
+		os := sample.ObserverSet(observeSetLen)
+		k.SetObserverSet(ctx, os)
+		k.SetLastObserverCount(ctx, &types.LastObserverCount{
+			Count: uint64(count),
+		})
+
+		keygen, found := k.GetKeygen(ctx)
+		require.False(t, found)
+		require.Equal(t, types.Keygen{}, keygen)
+
+		observer.BeginBlocker(ctx, *k)
+
+		keygen, found = k.GetKeygen(ctx)
+		require.True(t, found)
+		require.Empty(t, keygen.GranteePubkeys)
+		require.Equal(t, types.KeygenStatus_PendingKeygen, keygen.Status)
+		require.Equal(t, int64(math.MaxInt64), keygen.BlockNumber)
+
+		inboundEnabled := k.IsInboundEnabled(ctx)
+		require.False(t, inboundEnabled)
+
+		lastObserverCount, found := k.GetLastObserverCount(ctx)
+		require.True(t, found)
+		require.Equal(t, uint64(observeSetLen), lastObserverCount.Count)
+		require.Equal(t, ctx.BlockHeight(), lastObserverCount.LastChangeHeight)
+	})
+}

x/observer/genesis.go

@@ -16,7 +16,7 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState)
 		observerCount = uint64(len(genState.Observers.ObserverList))
 	}
 
-	// if chian params are defined set them
+	// if chain params are defined set them
 	if len(genState.ChainParamsList.ChainParams) > 0 {
 		k.SetChainParamsList(ctx, genState.ChainParamsList)
 	} else {

x/observer/genesis_test.go

@@ -12,45 +12,151 @@ import (
 )
 
 func TestGenesis(t *testing.T) {
-	params := types.DefaultParams()
-	tss := sample.Tss()
-	genesisState := types.GenesisState{
-		Params:    &params,
-		Tss:       &tss,
-		BlameList: sample.BlameRecordsList(t, 10),
-		Ballots: []*types.Ballot{
-			sample.Ballot(t, "0"),
-			sample.Ballot(t, "1"),
-			sample.Ballot(t, "2"),
-		},
-		Observers: sample.ObserverSet(3),
-		NodeAccountList: []*types.NodeAccount{
-			sample.NodeAccount(),
-			sample.NodeAccount(),
-			sample.NodeAccount(),
-		},
-		CrosschainFlags:   types.DefaultCrosschainFlags(),
-		Keygen:            sample.Keygen(t),
-		ChainParamsList:   sample.ChainParamsList(),
-		LastObserverCount: sample.LastObserverCount(10),
-		TssFundMigrators:  []types.TssFundMigratorInfo{sample.TssFundsMigrator(1), sample.TssFundsMigrator(2)},
-		ChainNonces: []types.ChainNonces{
-			sample.ChainNonces(t, "0"),
-			sample.ChainNonces(t, "1"),
-			sample.ChainNonces(t, "2"),
-		},
-		PendingNonces: sample.PendingNoncesList(t, "sample", 20),
-		NonceToCctx:   sample.NonceToCctxList(t, "sample", 20),
-	}
-
-	// Init and export
-	k, ctx, _, _ := keepertest.ObserverKeeper(t)
-	observer.InitGenesis(ctx, *k, genesisState)
-	got := observer.ExportGenesis(ctx, *k)
-	require.NotNil(t, got)
-
-	// Compare genesis after init and export
-	nullify.Fill(&genesisState)
-	nullify.Fill(got)
-	require.Equal(t, genesisState, *got)
+	t.Run("genState fields defined", func(t *testing.T) {
+		params := types.DefaultParams()
+		tss := sample.Tss()
+		genesisState := types.GenesisState{
+			Params:    &params,
+			Tss:       &tss,
+			BlameList: sample.BlameRecordsList(t, 10),
+			Ballots: []*types.Ballot{
+				sample.Ballot(t, "0"),
+				sample.Ballot(t, "1"),
+				sample.Ballot(t, "2"),
+			},
+			Observers: sample.ObserverSet(3),
+			NodeAccountList: []*types.NodeAccount{
+				sample.NodeAccount(),
+				sample.NodeAccount(),
+				sample.NodeAccount(),
+			},
+			CrosschainFlags:   types.DefaultCrosschainFlags(),
+			Keygen:            sample.Keygen(t),
+			ChainParamsList:   sample.ChainParamsList(),
+			LastObserverCount: sample.LastObserverCount(10),
+			TssFundMigrators:  []types.TssFundMigratorInfo{sample.TssFundsMigrator(1), sample.TssFundsMigrator(2)},
+			ChainNonces: []types.ChainNonces{
+				sample.ChainNonces(t, "0"),
+				sample.ChainNonces(t, "1"),
+				sample.ChainNonces(t, "2"),
+			},
+			PendingNonces: sample.PendingNoncesList(t, "sample", 20),
+			NonceToCctx:   sample.NonceToCctxList(t, "sample", 20),
+			TssHistory:    []types.TSS{sample.Tss()},
+		}
+
+		// Init and export
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+		observer.InitGenesis(ctx, *k, genesisState)
+		got := observer.ExportGenesis(ctx, *k)
+		require.NotNil(t, got)
+
+		// Compare genesis after init and export
+		nullify.Fill(&genesisState)
+		nullify.Fill(got)
+		require.Equal(t, genesisState, *got)
+	})
+
+	t.Run("genState fields not defined", func(t *testing.T) {
+		genesisState := types.GenesisState{}
+
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+		observer.InitGenesis(ctx, *k, genesisState)
+		got := observer.ExportGenesis(ctx, *k)
+		require.NotNil(t, got)
+
+		defaultParams := types.DefaultParams()
+		btcChainParams := types.GetDefaultBtcRegtestChainParams()
+		btcChainParams.IsSupported = true
+		goerliChainParams := types.GetDefaultGoerliLocalnetChainParams()
+		goerliChainParams.IsSupported = true
+		zetaPrivnetChainParams := types.GetDefaultZetaPrivnetChainParams()
+		zetaPrivnetChainParams.IsSupported = true
+		localnetChainParams := types.ChainParamsList{
+			ChainParams: []*types.ChainParams{
+				btcChainParams,
+				goerliChainParams,
+				zetaPrivnetChainParams,
+			},
+		}
+		expectedGenesisState := types.GenesisState{
+			Params:            &defaultParams,
+			CrosschainFlags:   types.DefaultCrosschainFlags(),
+			ChainParamsList:   localnetChainParams,
+			Tss:               &types.TSS{},
+			Keygen:            &types.Keygen{},
+			LastObserverCount: &types.LastObserverCount{},
+			NodeAccountList:   []*types.NodeAccount{},
+		}
+
+		require.Equal(t, expectedGenesisState, *got)
+	})
+
+	t.Run("genState fields not defined except tss", func(t *testing.T) {
+		tss := sample.Tss()
+		genesisState := types.GenesisState{
+			Tss: &tss,
+		}
+
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+		observer.InitGenesis(ctx, *k, genesisState)
+		got := observer.ExportGenesis(ctx, *k)
+		require.NotNil(t, got)
+
+		defaultParams := types.DefaultParams()
+		btcChainParams := types.GetDefaultBtcRegtestChainParams()
+		btcChainParams.IsSupported = true
+		goerliChainParams := types.GetDefaultGoerliLocalnetChainParams()
+		goerliChainParams.IsSupported = true
+		zetaPrivnetChainParams := types.GetDefaultZetaPrivnetChainParams()
+		zetaPrivnetChainParams.IsSupported = true
+		localnetChainParams := types.ChainParamsList{
+			ChainParams: []*types.ChainParams{
+				btcChainParams,
+				goerliChainParams,
+				zetaPrivnetChainParams,
+			},
+		}
+		pendingNonces, err := k.GetAllPendingNonces(ctx)
+		require.NoError(t, err)
+		require.NotEmpty(t, pendingNonces)
+		expectedGenesisState := types.GenesisState{
+			Params:            &defaultParams,
+			CrosschainFlags:   types.DefaultCrosschainFlags(),
+			ChainParamsList:   localnetChainParams,
+			Tss:               &tss,
+			Keygen:            &types.Keygen{},
+			LastObserverCount: &types.LastObserverCount{},
+			NodeAccountList:   []*types.NodeAccount{},
+			PendingNonces:     pendingNonces,
+		}
+
+		require.Equal(t, expectedGenesisState, *got)
+	})
+
+	t.Run("export without init", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.ObserverKeeper(t)
+
+		got := observer.ExportGenesis(ctx, *k)
+		require.NotNil(t, got)
+
+		params := k.GetParamsIfExists(ctx)
+		expectedGenesisState := types.GenesisState{
+			Params:            &params,
+			CrosschainFlags:   types.DefaultCrosschainFlags(),
+			ChainParamsList:   types.ChainParamsList{},
+			Tss:               &types.TSS{},
+			Keygen:            &types.Keygen{},
+			LastObserverCount: &types.LastObserverCount{},
+			NodeAccountList:   []*types.NodeAccount{},
+			Ballots:           k.GetAllBallots(ctx),
+			TssHistory:        k.GetAllTSS(ctx),
+			TssFundMigrators:  k.GetAllTssFundMigrators(ctx),
+			BlameList:         k.GetAllBlame(ctx),
+			ChainNonces:       k.GetAllChainNonces(ctx),
+			NonceToCctx:       k.GetAllNonceToCctx(ctx),
+		}
+
+		require.Equal(t, expectedGenesisState, *got)
+	})
 }