Prepare initial states for testing

.Lib9c.Benchmarks/Program.cs

@@ -81,7 +81,11 @@ static void Main(string[] args)
             IKeyValueStore stateKeyValueStore = new RocksDBKeyValueStore(Path.Combine(storePath, "states"));
             var stateStore = new TrieStateStore(stateKeyValueStore);
             var actionEvaluator = new ActionEvaluator(
-                _ => policy.BlockAction,
+                new PolicyActionsRegistry(
+                    _ => policy.BeginBlockActions,
+                    _ => policy.EndBlockActions,
+                    _ => policy.BeginTxActions,
+                    _ => policy.EndTxActions),
                 stateStore,
                 new NCActionLoader());
             var chain = new BlockChain(

.Lib9c.Plugin/PluginActionEvaluator.cs

@@ -1,10 +1,12 @@
+using System.Collections.Immutable;
 using System.Security.Cryptography;
 using Lib9c.Plugin.Shared;
 using Libplanet.Action;
 using Libplanet.Common;
 using Libplanet.Extensions.ActionEvaluatorCommonComponents;
 using Libplanet.Store;
 using Nekoyume.Action;
+using Nekoyume.Action.DPoS.Sys;
 using Nekoyume.Action.Loader;
 
 
@@ -18,7 +20,11 @@ public PluginActionEvaluator(IPluginKeyValueStore keyValueStore)
         {
             var stateStore = new TrieStateStore(new WrappedKeyValueStore(keyValueStore));
             _actionEvaluator = new ActionEvaluator(
-                _ => new RewardGold(),
+                new PolicyActionsRegistry(
+                    _ => new IAction[] { }.ToImmutableArray(),
+                    _ => new IAction[] { new RewardGold() }.ToImmutableArray(),
+                    _ => new IAction[] { }.ToImmutableArray(),
+                    _ => new IAction[] { }.ToImmutableArray()),
                 stateStore,
                 new NCActionLoader());
         }

.Lib9c.Tests/Action/ActionContext.cs

@@ -5,6 +5,7 @@ namespace Lib9c.Tests.Action
     using Libplanet.Action.State;
     using Libplanet.Common;
     using Libplanet.Crypto;
+    using Libplanet.Types.Assets;
     using Libplanet.Types.Blocks;
     using Libplanet.Types.Tx;
 
@@ -28,13 +29,17 @@ public class ActionContext : IActionContext
 
         public int BlockProtocolVersion { get; set; }
 
+        public BlockCommit LastCommit { get; set; }
+
         public IWorld PreviousState { get; set; }
 
         public int RandomSeed { get; set; }
 
         public HashDigest<SHA256>? PreviousStateRootHash { get; set; }
 
-        public bool BlockAction { get; }
+        public bool IsBlockAction { get; }
+
+        public FungibleAssetValue? MaxGasPrice { get; set; }
 
         public void UseGas(long gas)
         {

.Lib9c.Tests/Action/DPoS/BlockTest.cs

@@ -0,0 +1,67 @@
+namespace Lib9c.Tests.Action.DPoS
+{
+    using System;
+    using System.Collections.Immutable;
+    using Libplanet.Action;
+    using Libplanet.Action.Loader;
+    using Libplanet.Blockchain;
+    using Libplanet.Blockchain.Policies;
+    using Libplanet.Crypto;
+    using Libplanet.Store;
+    using Libplanet.Store.Trie;
+    using Libplanet.Types.Tx;
+    using Nekoyume.Action;
+    using Nekoyume.Action.DPoS.Sys;
+    using Serilog;
+    using Xunit.Abstractions;
+
+    public class BlockTest
+    {
+        private IBlockPolicy _policy;
+        private BlockChain _blockChain;
+
+        public BlockTest(ITestOutputHelper outputHelper)
+        {
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Verbose()
+                .WriteTo.TestOutput(outputHelper)
+                .CreateLogger();
+
+            var genesisProposer = new PrivateKey();
+            _policy = new BlockPolicy(
+                beginBlockActions: new IAction[] { new AllocateReward() }.ToImmutableArray(),
+                endBlockActions: new IAction[]
+                    {
+                        new UpdateValidators(),
+                        new RecordProposer(),
+                    }.ToImmutableArray(),
+                beginTxActions: new IAction[] { new Mortgage() }.ToImmutableArray(),
+                endTxActions: new IAction[] { new Refund(), new Reward() }.ToImmutableArray());
+
+            var store = new MemoryStore();
+            var stateStore = new TrieStateStore(new MemoryKeyValueStore());
+            var actionEvaluator = new ActionEvaluator(
+                new PolicyActionsRegistry(
+                    _ => _policy.BeginBlockActions,
+                    _ => _policy.EndBlockActions,
+                    _ => _policy.BeginTxActions,
+                    _ => _policy.EndTxActions),
+                stateStore: stateStore,
+                actionTypeLoader: new SingleActionLoader(typeof(ActionBase)));
+            var genesisBlock = BlockChain.ProposeGenesisBlock(
+                    actionEvaluator,
+                    transactions: ImmutableList<Transaction>.Empty,
+                    privateKey: genesisProposer,
+                    timestamp: DateTimeOffset.UtcNow);
+            var blockChainStates = new BlockChainStates(store, stateStore);
+            _blockChain = new BlockChain(
+                policy: _policy,
+                stagePolicy: new VolatileStagePolicy(),
+                store: new MemoryStore(),
+                stateStore: stateStore,
+                genesisBlock: genesisBlock,
+                blockChainStates: blockChainStates,
+                actionEvaluator: actionEvaluator);
+        }
+    }
+}

.Lib9c.Tests/Action/DPoS/Control/DelegateCtrlTest.cs

@@ -0,0 +1,196 @@
+namespace Lib9c.Tests.Action.DPoS.Control
+{
+    using System.Collections.Immutable;
+    using Libplanet.Action.State;
+    using Libplanet.Crypto;
+    using Libplanet.Types.Assets;
+    using Nekoyume.Action.DPoS.Control;
+    using Nekoyume.Action.DPoS.Exception;
+    using Nekoyume.Action.DPoS.Misc;
+    using Nekoyume.Action.DPoS.Model;
+    using Nekoyume.Module;
+    using Xunit;
+
+    public class DelegateCtrlTest : PoSTest
+    {
+        private readonly PublicKey _operatorPublicKey;
+        private readonly Address _operatorAddress;
+        private readonly Address _delegatorAddress;
+        private readonly Address _validatorAddress;
+        private ImmutableHashSet<Currency> _nativeTokens;
+        private IWorld _states;
+
+        public DelegateCtrlTest()
+        {
+            _operatorPublicKey = new PrivateKey().PublicKey;
+            _operatorAddress = _operatorPublicKey.Address;
+            _delegatorAddress = CreateAddress();
+            _validatorAddress = Validator.DeriveAddress(_operatorAddress);
+            _nativeTokens = ImmutableHashSet.Create(
+                Asset.GovernanceToken, Asset.ConsensusToken, Asset.Share);
+            _states = InitializeStates();
+        }
+
+        [Fact]
+        public void InvalidCurrencyTest()
+        {
+            Initialize(500, 500, 100);
+            _states = _states.MintAsset(
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _delegatorAddress,
+                Asset.ConsensusFromGovernance(50));
+            Assert.Throws<InvalidCurrencyException>(
+                    () => _states = DelegateCtrl.Execute(
+                        _states,
+                        new ActionContext
+                        {
+                            PreviousState = _states,
+                            BlockIndex = 1,
+                        },
+                        _delegatorAddress,
+                        _validatorAddress,
+                        Asset.ConsensusFromGovernance(30),
+                        _nativeTokens));
+        }
+
+        [Fact]
+        public void InvalidValidatorTest()
+        {
+            Initialize(500, 500, 100);
+            Assert.Throws<NullValidatorException>(
+                    () => _states = DelegateCtrl.Execute(
+                        _states,
+                        new ActionContext
+                        {
+                            PreviousState = _states,
+                            BlockIndex = 1,
+                        },
+                        _delegatorAddress,
+                        CreateAddress(),
+                        Asset.GovernanceToken * 10,
+                        _nativeTokens));
+        }
+
+        [Fact]
+        public void InvalidShareTest()
+        {
+            Initialize(500, 500, 100);
+            _states = _states.BurnAsset(
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _validatorAddress,
+                Asset.ConsensusFromGovernance(100));
+            Assert.Throws<InvalidExchangeRateException>(
+                () => _states = DelegateCtrl.Execute(
+                    _states,
+                    new ActionContext
+                    {
+                        PreviousState = _states,
+                        BlockIndex = 1,
+                    },
+                    _delegatorAddress,
+                    _validatorAddress,
+                    Asset.GovernanceToken * 10,
+                    _nativeTokens));
+        }
+
+        [Theory]
+        [InlineData(500, 500, 100, 10)]
+        [InlineData(500, 500, 100, 20)]
+        public void BalanceTest(
+            int operatorMintAmount,
+            int delegatorMintAmount,
+            int selfDelegateAmount,
+            int delegateAmount)
+        {
+            Initialize(operatorMintAmount, delegatorMintAmount, selfDelegateAmount);
+            _states = DelegateCtrl.Execute(
+                _states,
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _delegatorAddress,
+                _validatorAddress,
+                Asset.GovernanceToken * delegateAmount,
+                _nativeTokens);
+            Assert.Equal(
+                Asset.GovernanceToken * 0,
+                _states.GetBalance(_validatorAddress, Asset.GovernanceToken));
+            Assert.Equal(
+                Asset.ConsensusFromGovernance(0),
+                _states.GetBalance(_operatorAddress, Asset.ConsensusToken));
+            Assert.Equal(
+                Asset.ConsensusFromGovernance(0),
+                _states.GetBalance(_delegatorAddress, Asset.ConsensusToken));
+            Assert.Equal(
+                ShareFromGovernance(0),
+                _states.GetBalance(_operatorAddress, Asset.Share));
+            Assert.Equal(
+                ShareFromGovernance(0),
+                _states.GetBalance(_delegatorAddress, Asset.Share));
+            Assert.Equal(
+                Asset.ConsensusFromGovernance(selfDelegateAmount + delegateAmount),
+                _states.GetBalance(_validatorAddress, Asset.ConsensusToken));
+            Assert.Equal(
+                Asset.GovernanceToken * (operatorMintAmount - selfDelegateAmount),
+                _states.GetBalance(_operatorAddress, Asset.GovernanceToken));
+            Assert.Equal(
+                Asset.GovernanceToken * (delegatorMintAmount - delegateAmount),
+                _states.GetBalance(_delegatorAddress, Asset.GovernanceToken));
+            Assert.Equal(
+                Asset.GovernanceToken * (selfDelegateAmount + delegateAmount),
+                _states.GetBalance(ReservedAddress.UnbondedPool, Asset.GovernanceToken));
+            var balanceA = _states.GetBalance(
+                Delegation.DeriveAddress(_operatorAddress, _validatorAddress),
+                Asset.Share);
+            var balanceB = _states.GetBalance(
+                Delegation.DeriveAddress(_delegatorAddress, _validatorAddress),
+                Asset.Share);
+            Assert.Equal(
+                ValidatorCtrl.GetValidator(_states, _validatorAddress)!.DelegatorShares,
+                balanceA + balanceB);
+        }
+
+        private void Initialize(
+            int operatorMintAmount, int delegatorMintAmount, int selfDelegateAmount)
+        {
+            _states = InitializeStates();
+            _states = _states.MintAsset(
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _operatorAddress,
+                Asset.GovernanceToken * operatorMintAmount);
+            _states = _states.MintAsset(
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _delegatorAddress,
+                Asset.GovernanceToken * delegatorMintAmount);
+            _states = ValidatorCtrl.Create(
+                _states,
+                new ActionContext
+                {
+                    PreviousState = _states,
+                    BlockIndex = 1,
+                },
+                _operatorAddress,
+                _operatorPublicKey,
+                Asset.GovernanceToken * selfDelegateAmount,
+                _nativeTokens);
+        }
+    }
+}