github.com/lino-network/lino@v0.6.11/x/global/manager/manager_test.go

package manager

import (
	"io/ioutil"
	"os"
	"path/filepath"
	"testing"
	"time"

	wire "github.com/cosmos/cosmos-sdk/codec"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/suite"

	mparam "github.com/lino-network/lino/param/mocks"
	"github.com/lino-network/lino/testsuites"
	"github.com/lino-network/lino/testutils"
	linotypes "github.com/lino-network/lino/types"
	mapp "github.com/lino-network/lino/x/global/manager/mocks"
	"github.com/lino-network/lino/x/global/model"
)

type testEvent struct {
	Id int64 `json:"id"`
}

type testBadEvent struct {
	Id int64 `json:"id"`
}

type testIgnoredEvent struct {
	Id int64 `json:"id"`
}

func regTestCodec(c *wire.Codec) {
	c.RegisterInterface((*linotypes.Event)(nil), nil)
	c.RegisterConcrete(testEvent{}, "lino/testevent", nil)
	c.RegisterConcrete(testBadEvent{}, "lino/testbadevent", nil)
	c.RegisterConcrete(testIgnoredEvent{}, "lino/testignoredevent", nil)
}

func testCodec() *wire.Codec {
	c := wire.New()
	regTestCodec(c)
	return c
}

var (
	storeKeyStr = "testGlobalStore"
	kvStoreKey  = sdk.NewKVStoreKey(storeKeyStr)
)

type storeDumper struct{}

func (dumper storeDumper) NewDumper() *testutils.Dumper {
	return model.NewDumper(model.NewGlobalStorage(kvStoreKey, testCodec()), regTestCodec)
}

type globalManagerTestSuite struct {
	testsuites.GoldenTestSuite
	global       GlobalManager
	mParamKeeper *mparam.ParamKeeper
	mApp         *mapp.FakeApp
}

func NewGlobalManagerTestSuite() *globalManagerTestSuite {
	return &globalManagerTestSuite{
		GoldenTestSuite: testsuites.NewGoldenTestSuite(storeDumper{}, kvStoreKey),
	}
}

func (suite *globalManagerTestSuite) SetupTest() {
	suite.mParamKeeper = new(mparam.ParamKeeper)
	suite.mApp = new(mapp.FakeApp)
	suite.SetupCtx(0, time.Unix(0, 0), kvStoreKey)
	suite.global = NewGlobalManager(kvStoreKey, suite.mParamKeeper, testCodec(),
		suite.mApp.Hourly,
		suite.mApp.Daily,
		suite.mApp.Monthly,
		suite.mApp.Yearly)
}

func TestGlobalManagerSuite(t *testing.T) {
	suite.Run(t, NewGlobalManagerTestSuite())
}

func (suite *globalManagerTestSuite) TestInitGenesis() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)
	suite.Equal(init, suite.global.GetLastBlockTime(suite.Ctx))
	suite.Golden()
}

func (suite *globalManagerTestSuite) TestGetPastDay() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)

	suite.Equal(int64(0), suite.global.GetPastDay(suite.Ctx, init+3600*24-1))
	suite.Equal(int64(1), suite.global.GetPastDay(suite.Ctx, init+3600*24))
	suite.Equal(int64(1), suite.global.GetPastDay(suite.Ctx, init+3600*24*2-1))
	suite.Equal(int64(2), suite.global.GetPastDay(suite.Ctx, init+3600*24*2))
}

func (suite *globalManagerTestSuite) TestOnBeginBlockExecuted() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)

	suite.mApp.On("Hourly", mock.Anything).Return(nil).Times(linotypes.HoursPerYear)
	suite.mApp.On("Daily", mock.Anything).Return(nil).Times(linotypes.HoursPerYear / 24)
	suite.mApp.On("Monthly", mock.Anything).Return(nil).Times(12)
	suite.mApp.On("Yearly", mock.Anything).Return(nil).Times(1)
	for i := init + 3600; i <= init+linotypes.MinutesPerYear*60; i += 3600 {
		suite.NextBlock(time.Unix(i, 0))
		suite.global.OnBeginBlock(suite.Ctx)
		suite.global.OnEndBlock(suite.Ctx)
	}
	suite.mApp.AssertExpectations(suite.T())
}

func (suite *globalManagerTestSuite) TestOnBeginBlockErrLogged() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)

	suite.mApp.On("Hourly", mock.Anything).Return(nil).Times(linotypes.HoursPerYear)
	suite.mApp.On("Daily", mock.Anything).Return(nil).Times(linotypes.HoursPerYear / 24)
	suite.mApp.On("Yearly", mock.Anything).Return(nil).Times(1)

	last := int64(0)
	for i := init + 3600; i <= init+linotypes.MinutesPerYear*60; i += 3600 {
		suite.NextBlock(time.Unix(i, 0))
		if (i-init)/60/linotypes.MinutesPerMonth > last {
			last = (i - init) / 60 / linotypes.MinutesPerMonth
			suite.mApp.On("Monthly", mock.Anything).Return([]linotypes.BCEventErr{
				linotypes.NewBCEventErr(suite.Ctx, linotypes.ErrTestDummyError(), "test"),
			}).Once()
		}
		suite.global.OnBeginBlock(suite.Ctx)
		suite.global.OnEndBlock(suite.Ctx)
	}
	suite.mApp.AssertExpectations(suite.T())
	suite.Equal(12, len(suite.global.GetBCEventErrors(suite.Ctx)))
	suite.Golden()
}

func (suite *globalManagerTestSuite) TestRegisterEventsAndExec() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)
	suite.mApp.On("Hourly", mock.Anything).Return(nil)
	suite.mApp.On("Daily", mock.Anything).Return(nil)
	suite.mApp.On("Monthly", mock.Anything).Return(nil)
	suite.mApp.On("Yearly", mock.Anything).Return(nil)

	// a simple counter event
	nExecuted := int64(0)
	exec := func(ctx sdk.Context, event linotypes.Event) sdk.Error {
		e := event.(testEvent)
		nExecuted++
		if e.Id%7 == 0 {
			return linotypes.ErrTestDummyError()
		}
		return nil
	}

	// register event of past time.
	suite.NotNil(suite.global.RegisterEventAtTime(suite.Ctx, init-1, testEvent{}))

	// events will be executed starting from an hour later
	nScheduled := int64(0)
	for i := init + 3; i <= init+7*3600; i += 600 {
		err := suite.global.RegisterEventAtTime(suite.Ctx, i, testEvent{Id: nScheduled})
		suite.Nil(err)
		nScheduled++
	}
	// events can be scheduled at same time
	for i := init + 3 + 600*4; i <= init+7*3600; i += 600 {
		err := suite.global.RegisterEventAtTime(suite.Ctx, i, testEvent{Id: nScheduled})
		suite.Nil(err)
		nScheduled++
	}

	// while execution, new events are scheduled, but not executed
	for i := init + 1; i <= init+10*3600; i += 577 {
		suite.NextBlock(time.Unix(i, 0))
		suite.global.OnBeginBlock(suite.Ctx)
		suite.global.ExecuteEvents(suite.Ctx, exec)
		err := suite.global.RegisterEventAtTime(suite.Ctx, i+10000000000, testEvent{Id: -1})
		suite.Nil(err)
		suite.global.OnEndBlock(suite.Ctx)
	}

	suite.Equal(nScheduled, nExecuted)
	suite.Golden()
}

func (suite *globalManagerTestSuite) TestEventOKWrite() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)
	suite.mApp.On("Hourly", mock.Anything).Return(nil)
	suite.mApp.On("Daily", mock.Anything).Return(nil)
	suite.mApp.On("Monthly", mock.Anything).Return(nil)
	suite.mApp.On("Yearly", mock.Anything).Return(nil)

	bad := func(ctx sdk.Context, event linotypes.Event) sdk.Error {
		// this bad exec will reset global time to zero while return an error.
		suite.global.storage.SetGlobalTime(ctx, &model.GlobalTime{
			ChainStartTime: 999,
		})
		return nil
	}

	err := suite.global.RegisterEventAtTime(suite.Ctx, init+30, testEvent{})
	suite.Nil(err)

	suite.NextBlock(time.Unix(init+30+10, 0))
	suite.global.ExecuteEvents(suite.Ctx, bad)
	suite.Equal(int64(999),
		suite.global.GetGlobalTime(suite.Ctx).ChainStartTime) // state not changed
	// suite.Golden()
}

func (suite *globalManagerTestSuite) TestEventErrIsolation() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)
	suite.mApp.On("Hourly", mock.Anything).Return(nil)
	suite.mApp.On("Daily", mock.Anything).Return(nil)
	suite.mApp.On("Monthly", mock.Anything).Return(nil)
	suite.mApp.On("Yearly", mock.Anything).Return(nil)

	bad := func(ctx sdk.Context, event linotypes.Event) sdk.Error {
		// this bad exec will reset global time to zero while return an error.
		suite.global.storage.SetGlobalTime(ctx, &model.GlobalTime{})
		return linotypes.ErrTestDummyError()
	}

	err := suite.global.RegisterEventAtTime(suite.Ctx, init+30, testEvent{})
	suite.Nil(err)

	suite.NextBlock(time.Unix(init+30+10, 0))
	suite.global.ExecuteEvents(suite.Ctx, bad)
	suite.Equal(1, len(suite.global.GetEventErrors(suite.Ctx)))             // err logged
	suite.Equal(init, suite.global.GetGlobalTime(suite.Ctx).ChainStartTime) // state not changed
	suite.Golden()
}

func (suite *globalManagerTestSuite) TestExecFutureEvents() {
	suite.NextBlock(time.Unix(0, 0))
	suite.global.InitGenesis(suite.Ctx)

	init := int64(123456)
	t0 := init - 1
	t1 := init + 1
	t2 := init + 30

	id := int64(0)
	for _, t := range []int64{t0, t1, t2} {
		err := suite.global.RegisterEventAtTime(suite.Ctx, t, testEvent{Id: id})
		suite.Nil(err)
		err = suite.global.RegisterEventAtTime(suite.Ctx, t, testEvent{Id: id})
		suite.Nil(err)
		err = suite.global.RegisterEventAtTime(suite.Ctx, t, testBadEvent{Id: id})
		suite.Nil(err)
		err = suite.global.RegisterEventAtTime(suite.Ctx, t, testIgnoredEvent{Id: id})
		suite.Nil(err)

	}

	suite.NextBlock(time.Unix(init, 0))

	count := 0
	filter := func(ts int64, event linotypes.Event) bool {
		if ts < init {
			return false
		}
		switch event.(type) {
		case testEvent, testBadEvent:
			return true
		default:
			return false
		}
	}
	suite.global.execFutureEvents(suite.Ctx,
		func(ctx sdk.Context, event linotypes.Event) sdk.Error {
			switch event.(type) {
			case testEvent:
				count++
				return nil
			case testBadEvent:
				return linotypes.ErrTestDummyError()
			default:
				suite.FailNow("executing events that should be ignored")
				return nil
			}
		},
		filter,
	)
	suite.Equal(4, count)

	// bad is no longer bad.
	suite.global.execFutureEvents(suite.Ctx,
		func(ctx sdk.Context, event linotypes.Event) sdk.Error {
			switch event.(type) {
			case testEvent, testBadEvent:
				count++
				return nil
			default:
				suite.FailNow("executing events that should be ignored")
				return nil
			}
		},
		filter,
	)
	suite.Equal(6, count)

	// ignored is not ignored.
	suite.global.execFutureEvents(suite.Ctx,
		func(ctx sdk.Context, event linotypes.Event) sdk.Error {
			count++
			return nil
		},
		func(ts int64, event linotypes.Event) bool { return ts > init },
	)
	suite.Equal(8, count)
}

func (suite *globalManagerTestSuite) TestImportExport() {
	init := int64(123456)
	suite.NextBlock(time.Unix(init, 0))
	suite.global.InitGenesis(suite.Ctx)

	err := suite.global.RegisterEventAtTime(suite.Ctx, init+30, testEvent{Id: 1})
	suite.Nil(err)
	err = suite.global.RegisterEventAtTime(suite.Ctx, init+30, testEvent{Id: 2})
	suite.Nil(err)
	err = suite.global.RegisterEventAtTime(suite.Ctx, init+45, testEvent{Id: 3})
	suite.Nil(err)

	cdc := testCodec()

	dir, err2 := ioutil.TempDir("", "test")
	suite.Require().Nil(err2)
	defer os.RemoveAll(dir) // clean up

	tmpfn := filepath.Join(dir, "tmpfile")
	err2 = suite.global.ExportToFile(suite.Ctx, cdc, tmpfn)
	suite.Nil(err2)

	// reset state
	suite.SetupTest()
	err2 = suite.global.ImportFromFile(suite.Ctx, cdc, tmpfn)
	suite.Nil(err2)

	suite.Golden()
}