From abaa467558db09f0d40e86c0f60aa89abacf10b7 Mon Sep 17 00:00:00 2001 From: stackman27 Date: Fri, 2 Sep 2022 22:16:14 -0700 Subject: [PATCH] adding tests --- app/apptesting/events.go | 10 +- x/lockup/keeper/msg_server_test.go | 158 ++++++++++++++++++++++++++--- 2 files changed, 154 insertions(+), 14 deletions(-) diff --git a/app/apptesting/events.go b/app/apptesting/events.go index 2fa0b7635d4..e7758600c69 100644 --- a/app/apptesting/events.go +++ b/app/apptesting/events.go @@ -6,7 +6,7 @@ import ( // AssertEventEmitted asserts that ctx's event manager has emitted the given number of events // of the given type. -func (s *KeeperTestHelper) AssertEventEmitted(ctx sdk.Context, eventTypeExpected string, numEventsExpected int) { +func (s *KeeperTestHelper) AssertEventEmitted(ctx sdk.Context, eventTypeExpected string, numEventsExpected int, expectedEvents sdk.Events, expectPass bool) { allEvents := ctx.EventManager().Events() // filter out other events actualEvents := make([]sdk.Event, 0) @@ -16,5 +16,11 @@ func (s *KeeperTestHelper) AssertEventEmitted(ctx sdk.Context, eventTypeExpected } } - s.Require().Equal(numEventsExpected, len(actualEvents)) + if expectPass { + s.Require().Equal(expectedEvents[0], actualEvents[0]) + s.Require().Equal(numEventsExpected, len(actualEvents)) + } else { + s.Require().NotEqual(expectedEvents[0], actualEvents[0]) + s.Require().NotEqual(numEventsExpected, len(actualEvents)) + } } diff --git a/x/lockup/keeper/msg_server_test.go b/x/lockup/keeper/msg_server_test.go index e58fc100fff..6e95dde1d32 100644 --- a/x/lockup/keeper/msg_server_test.go +++ b/x/lockup/keeper/msg_server_test.go @@ -92,8 +92,6 @@ func (suite *KeeperTestSuite) TestMsgLockTokens() { Duration: test.param.duration, }) suite.Require().Equal(accum.String(), "20") - // check to see if events are emitted properly - suite.AssertEventEmitted(suite.Ctx, types.TypeEvtLockTokens, 1) } else { // Fail simple lock token suite.Require().Error(err) @@ -411,21 +409,157 @@ func (suite *KeeperTestSuite) TestMsgLockToken_EmitEvent() { ), } - allEvents := suite.Ctx.EventManager().Events() - // filter out other events - actualEvents := make([]sdk.Event, 0) - for _, event := range allEvents { - if event.Type == types.TypeEvtLockTokens { - actualEvents = append(actualEvents, event) - } + suite.AssertEventEmitted(suite.Ctx, types.TypeEvtLockTokens, 1, expectedEvents, tc.expectPass) + }) + } +} + +func (suite *KeeperTestSuite) TestMsgBeginUnlocking_EmitEvent() { + type param struct { + coinsToLock sdk.Coins + lockOwner sdk.AccAddress + duration time.Duration + coinsInOwnerAddress sdk.Coins + } + + type events struct { + Id string + Owner string + Coins string + Duration string + EndTime string + } + + testCases := map[string]struct { + events events + expectPass bool + }{ + "events emitted correctly": { + events: events{ + Id: "1", + Owner: "osmo1v9jxgu3395kj6tfd95kj6tfd95kj6tfd0hptum", + Duration: "1s", + EndTime: "0001-01-01 00:00:00 +0000 UTC", + }, + expectPass: true, + }, + "events emitted with incorrect values": { + events: events{ + Id: "1", + Owner: "osmo1v9jxgu3395kj6tfd95kj6tfd95kj6tfd0hptum", + Duration: "1s", + EndTime: "0001-01-01 00:00:00 +0000 UTC", + }, + expectPass: false, + }, + "events emitted with missing values": { + events: events{ + Id: "1", + Coins: "10stake", + Duration: "1s", + }, + expectPass: false, + }, + } + + for name, tc := range testCases { + suite.Run(name, func() { + suite.SetupTest() + + suite.FundAcc(test.param.lockOwner, test.param.coinsInOwnerAddress) + + msgServer := keeper.NewMsgServerImpl(suite.App.LockupKeeper) + c := sdk.WrapSDKContext(suite.Ctx) + resp, err := msgServer.LockTokens(c, types.NewMsgLockTokens(test.param.lockOwner, test.param.duration, test.param.coinsToLock)) + suite.Require().NoError(err) + + if test.param.isSyntheticLockup { + err = suite.App.LockupKeeper.CreateSyntheticLockup(suite.Ctx, resp.ID, "synthetic", time.Second, false) + suite.Require().NoError(err) + } + + _, err = msgServer.BeginUnlocking(c, types.NewMsgBeginUnlocking(test.param.lockOwner, resp.ID, test.param.coinsToUnlock)) + + expectedEvents := sdk.Events{ + sdk.NewEvent( + types.TypeEvtBeginUnlock, + sdk.NewAttribute(types.AttributePeriodLockID, tc.events.Id), + sdk.NewAttribute(types.AttributePeriodLockOwner, tc.events.Owner), + sdk.NewAttribute(types.AttributePeriodLockDuration, tc.events.Duration), + sdk.NewAttribute(types.AttributePeriodLockUnlockTime, tc.events.EndTime), + ), + } + + suite.AssertEventEmitted(suite.Ctx, types.TypeEvtLockTokens, 1, expectedEvents, tc.expectPass) + }) + } +} + +func (suite *KeeperTestSuite) TestMsgBeginUnlockingAll_EmitEvent() { + type events struct { + Owner string + Coins string + } + + testCases := map[string]struct { + events events + expectPass bool + }{ + "events emitted correctly": { + events: events{ + Owner: "osmo1v9jxgu3395kj6tfd95kj6tfd95kj6tfd0hptum", + Coins: "11stake", + }, + expectPass: true, + }, + "events emitted with incorrect values": { + events: events{ + Owner: "osmo1v9jxgu3395kj6tfd95kj6tfd95kj6tfd0hptum", + Coins: "11stake", + }, + expectPass: false, + }, + "events emitted with missing values": { + events: events{ + Coins: "10stake", + }, + expectPass: false, + }, + } + + for name, tc := range testCases { + suite.Run(name, func() { + suite.SetupTest() + + suite.FundAcc(test.param.lockOwner, test.param.coinsInOwnerAddress) + + msgServer := keeper.NewMsgServerImpl(suite.App.LockupKeeper) + c := sdk.WrapSDKContext(suite.Ctx) + resp, err := msgServer.LockTokens(c, types.NewMsgLockTokens(test.param.lockOwner, test.param.duration, test.param.coinsToLock)) + suite.Require().NoError(err) + + if test.param.isSyntheticLockup { + err = suite.App.LockupKeeper.CreateSyntheticLockup(suite.Ctx, resp.ID, "synthetic", time.Second, false) + suite.Require().NoError(err) + } + + _, err = msgServer.BeginUnlockingAll(c, types.NewMsgBeginUnlockingAll(test.param.lockOwner)) + + expectedEvents := sdk.Events{ + sdk.NewEvent( + types.TypeEvtBeginUnlockAll, + sdk.NewAttribute(types.AttributePeriodLockOwner, tc.events.Owner), + sdk.NewAttribute(types.AttributeUnlockedCoins, tc.events.Coins), + ), } - if tc.expectPass { - suite.Require().Equal(expectedEvents[0], actualEvents[0]) + if test.expectPass { + suite.Require().NoError(err) } else { - suite.Require().NotEqual(expectedEvents[0], actualEvents[0]) + suite.Require().Error(err) } + suite.AssertEventEmitted(suite.Ctx, types.TypeEvtBeginUnlockAll, 1, expectedEvents, test.ExpectPass) }) } }