hermez-node/api/state_test.go
api/state_test.goRaw
1package api
2
3import (
4 "math/big"
5 "testing"
6
7 "github.com/hermeznetwork/hermez-node/apitypes"
8 "github.com/hermeznetwork/hermez-node/common"
9 "github.com/hermeznetwork/hermez-node/db/historydb"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12)
13
14type testStatus struct {
15 Network testNetwork `json:"network"`
16 Metrics historydb.Metrics `json:"metrics"`
17 Rollup historydb.RollupVariablesAPI `json:"rollup"`
18 Auction historydb.AuctionVariablesAPI `json:"auction"`
19 WithdrawalDelayer common.WDelayerVariables `json:"withdrawalDelayer"`
20 RecommendedFee common.RecommendedFee `json:"recommendedFee"`
21}
22
23type testNetwork struct {
24 LastEthBlock int64 `json:"lastEthereumBlock"`
25 LastSyncBlock int64 `json:"lastSynchedBlock"`
26 LastBatch testBatch `json:"lastBatch"`
27 CurrentSlot int64 `json:"currentSlot"`
28 NextForgers []NextForger `json:"nextForgers"`
29}
30
31func TestSetRollupVariables(t *testing.T) {
32 rollupVars := &common.RollupVariables{}
33 assertEqualRollupVariables(t, *rollupVars, api.status.Rollup, true)
34 api.SetRollupVariables(tc.rollupVars)
35 assertEqualRollupVariables(t, tc.rollupVars, api.status.Rollup, true)
36}
37
38func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVariables, apiVariables historydb.RollupVariablesAPI, checkBuckets bool) {
39 assert.Equal(t, apitypes.NewBigIntStr(rollupVariables.FeeAddToken), apiVariables.FeeAddToken)
40 assert.Equal(t, rollupVariables.ForgeL1L2BatchTimeout, apiVariables.ForgeL1L2BatchTimeout)
41 assert.Equal(t, rollupVariables.WithdrawalDelay, apiVariables.WithdrawalDelay)
42 assert.Equal(t, rollupVariables.SafeMode, apiVariables.SafeMode)
43 if checkBuckets {
44 for i, bucket := range rollupVariables.Buckets {
45 assert.Equal(t, apitypes.NewBigIntStr(bucket.BlockWithdrawalRate), apiVariables.Buckets[i].BlockWithdrawalRate)
46 assert.Equal(t, apitypes.NewBigIntStr(bucket.CeilUSD), apiVariables.Buckets[i].CeilUSD)
47 assert.Equal(t, apitypes.NewBigIntStr(bucket.MaxWithdrawals), apiVariables.Buckets[i].MaxWithdrawals)
48 assert.Equal(t, apitypes.NewBigIntStr(bucket.Withdrawals), apiVariables.Buckets[i].Withdrawals)
49 }
50 }
51}
52
53func TestSetWDelayerVariables(t *testing.T) {
54 wdelayerVars := &common.WDelayerVariables{}
55 assert.Equal(t, *wdelayerVars, api.status.WithdrawalDelayer)
56 api.SetWDelayerVariables(tc.wdelayerVars)
57 assert.Equal(t, tc.wdelayerVars, api.status.WithdrawalDelayer)
58}
59
60func TestSetAuctionVariables(t *testing.T) {
61 auctionVars := &common.AuctionVariables{}
62 assertEqualAuctionVariables(t, *auctionVars, api.status.Auction)
63 api.SetAuctionVariables(tc.auctionVars)
64 assertEqualAuctionVariables(t, tc.auctionVars, api.status.Auction)
65}
66
67func assertEqualAuctionVariables(t *testing.T, auctionVariables common.AuctionVariables, apiVariables historydb.AuctionVariablesAPI) {
68 assert.Equal(t, auctionVariables.EthBlockNum, apiVariables.EthBlockNum)
69 assert.Equal(t, auctionVariables.DonationAddress, apiVariables.DonationAddress)
70 assert.Equal(t, auctionVariables.BootCoordinator, apiVariables.BootCoordinator)
71 assert.Equal(t, auctionVariables.BootCoordinatorURL, apiVariables.BootCoordinatorURL)
72 assert.Equal(t, auctionVariables.DefaultSlotSetBidSlotNum, apiVariables.DefaultSlotSetBidSlotNum)
73 assert.Equal(t, auctionVariables.ClosedAuctionSlots, apiVariables.ClosedAuctionSlots)
74 assert.Equal(t, auctionVariables.OpenAuctionSlots, apiVariables.OpenAuctionSlots)
75 assert.Equal(t, auctionVariables.Outbidding, apiVariables.Outbidding)
76 assert.Equal(t, auctionVariables.SlotDeadline, apiVariables.SlotDeadline)
77
78 for i, slot := range auctionVariables.DefaultSlotSetBid {
79 assert.Equal(t, apitypes.NewBigIntStr(slot), apiVariables.DefaultSlotSetBid[i])
80 }
81
82 for i, ratio := range auctionVariables.AllocationRatio {
83 assert.Equal(t, ratio, apiVariables.AllocationRatio[i])
84 }
85}
86
87func TestUpdateNetworkInfo(t *testing.T) {
88 status := &Network{}
89 assert.Equal(t, status.LastSyncBlock, api.status.Network.LastSyncBlock)
90 assert.Equal(t, status.LastBatch, api.status.Network.LastBatch)
91 assert.Equal(t, status.CurrentSlot, api.status.Network.CurrentSlot)
92 assert.Equal(t, status.NextForgers, api.status.Network.NextForgers)
93 lastBlock := tc.blocks[3]
94 lastBatchNum := common.BatchNum(3)
95 currentSlotNum := int64(1)
96
97 // Generate some bucket_update data
98 bucketUpdates := []common.BucketUpdate{
99 {
100 EthBlockNum: 4,
101 NumBucket: 0,
102 BlockStamp: 4,
103 Withdrawals: big.NewInt(123),
104 },
105 {
106 EthBlockNum: 5,
107 NumBucket: 2,
108 BlockStamp: 5,
109 Withdrawals: big.NewInt(42),
110 },
111 {
112 EthBlockNum: 5,
113 NumBucket: 2, // Repeated bucket
114 BlockStamp: 5,
115 Withdrawals: big.NewInt(43),
116 },
117 }
118 err := api.h.AddBucketUpdatesTest(api.h.DB(), bucketUpdates)
119 require.NoError(t, err)
120
121 err = api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
122 assert.NoError(t, err)
123 assert.Equal(t, lastBlock.Num, api.status.Network.LastSyncBlock)
124 assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
125 assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
126 assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
127 assert.Equal(t, api.status.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
128 assert.Equal(t, api.status.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
129}
130
131func TestUpdateMetrics(t *testing.T) {
132 // Update Metrics needs api.status.Network.LastBatch.BatchNum to be updated
133 lastBlock := tc.blocks[3]
134 lastBatchNum := common.BatchNum(3)
135 currentSlotNum := int64(1)
136 err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
137 assert.NoError(t, err)
138
139 err = api.UpdateMetrics()
140 assert.NoError(t, err)
141 assert.Greater(t, api.status.Metrics.TransactionsPerBatch, float64(0))
142 assert.Greater(t, api.status.Metrics.BatchFrequency, float64(0))
143 assert.Greater(t, api.status.Metrics.TransactionsPerSecond, float64(0))
144 assert.Greater(t, api.status.Metrics.TotalAccounts, int64(0))
145 assert.Greater(t, api.status.Metrics.TotalBJJs, int64(0))
146 assert.Greater(t, api.status.Metrics.AvgTransactionFee, float64(0))
147}
148
149func TestUpdateRecommendedFee(t *testing.T) {
150 err := api.UpdateRecommendedFee()
151 assert.NoError(t, err)
152 assert.Greater(t, api.status.RecommendedFee.ExistingAccount, float64(0))
153 assert.Equal(t, api.status.RecommendedFee.CreatesAccount,
154 api.status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
155 assert.Equal(t, api.status.RecommendedFee.CreatesAccountAndRegister,
156 api.status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
157}
158
159func TestGetState(t *testing.T) {
160 lastBlock := tc.blocks[3]
161 lastBatchNum := common.BatchNum(3)
162 currentSlotNum := int64(1)
163 api.SetRollupVariables(tc.rollupVars)
164 api.SetWDelayerVariables(tc.wdelayerVars)
165 api.SetAuctionVariables(tc.auctionVars)
166 err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
167 assert.NoError(t, err)
168 err = api.UpdateMetrics()
169 assert.NoError(t, err)
170 err = api.UpdateRecommendedFee()
171 assert.NoError(t, err)
172
173 endpoint := apiURL + "state"
174 var status testStatus
175
176 assert.NoError(t, doGoodReq("GET", endpoint, nil, &status))
177
178 // SC vars
179 // UpdateNetworkInfo will overwrite buckets withdrawal values
180 // So they won't be checked here, they are checked at
181 // TestUpdateNetworkInfo
182 assertEqualRollupVariables(t, tc.rollupVars, status.Rollup, false)
183 assertEqualAuctionVariables(t, tc.auctionVars, status.Auction)
184 assert.Equal(t, tc.wdelayerVars, status.WithdrawalDelayer)
185 // Network
186 assert.Equal(t, lastBlock.Num, status.Network.LastEthBlock)
187 assert.Equal(t, lastBlock.Num, status.Network.LastSyncBlock)
188 // TODO: assert all the batch, not just the batch num
189 assert.Equal(t, lastBatchNum, status.Network.LastBatch.BatchNum)
190 assert.Equal(t, currentSlotNum, status.Network.CurrentSlot)
191 assertNextForgers(t, tc.nextForgers, status.Network.NextForgers)
192 // Metrics
193 // TODO: perform real asserts (not just greater than 0)
194 assert.Greater(t, status.Metrics.TransactionsPerBatch, float64(0))
195 assert.Greater(t, status.Metrics.BatchFrequency, float64(0))
196 assert.Greater(t, status.Metrics.TransactionsPerSecond, float64(0))
197 assert.Greater(t, status.Metrics.TotalAccounts, int64(0))
198 assert.Greater(t, status.Metrics.TotalBJJs, int64(0))
199 assert.Greater(t, status.Metrics.AvgTransactionFee, float64(0))
200 // Recommended fee
201 // TODO: perform real asserts (not just greater than 0)
202 assert.Greater(t, status.RecommendedFee.ExistingAccount, float64(0))
203 assert.Equal(t, status.RecommendedFee.CreatesAccount,
204 status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
205 assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
206 status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
207}
208
209func assertNextForgers(t *testing.T, expected, actual []NextForger) {
210 assert.Equal(t, len(expected), len(actual))
211 for i := range expected {
212 // ignore timestamps and other metadata
213 actual[i].Period.FromTimestamp = expected[i].Period.FromTimestamp
214 actual[i].Period.ToTimestamp = expected[i].Period.ToTimestamp
215 actual[i].Coordinator.ItemID = expected[i].Coordinator.ItemID
216 actual[i].Coordinator.EthBlockNum = expected[i].Coordinator.EthBlockNum
217 assert.Equal(t, expected[i], actual[i])
218 }
219}