OSDN Git Service

get BlockNode from database (#188)
[bytom/vapor.git] / database / store_test.go
1 package database
2
3 import (
4         "os"
5         "testing"
6
7         dbm "github.com/vapor/database/leveldb"
8         "github.com/vapor/database/storage"
9         "github.com/vapor/protocol"
10         "github.com/vapor/protocol/bc"
11         "github.com/vapor/protocol/bc/types"
12         "github.com/vapor/protocol/state"
13         "github.com/vapor/testutil"
14 )
15
16 func TestSaveChainStatus(t *testing.T) {
17         testDB := dbm.NewDB("testdb", "leveldb", "temp")
18         defer func() {
19                 testDB.Close()
20                 os.RemoveAll("temp")
21         }()
22
23         store := NewStore(testDB)
24
25         blockHeader := &types.BlockHeader{Height: 100}
26         blockHash := blockHeader.Hash() //Hash: bc.Hash{V0: 0, V1: 1, V2: 2, V3: 3}
27         view := &state.UtxoViewpoint{
28                 Entries: map[bc.Hash]*storage.UtxoEntry{
29                         bc.Hash{V0: 1, V1: 2, V2: 3, V3: 4}: &storage.UtxoEntry{Type: storage.NormalUTXOType, BlockHeight: 100, Spent: false},
30                         bc.Hash{V0: 1, V1: 2, V2: 3, V3: 4}: &storage.UtxoEntry{Type: storage.CoinbaseUTXOType, BlockHeight: 100, Spent: true},
31                         bc.Hash{V0: 1, V1: 1, V2: 3, V3: 4}: &storage.UtxoEntry{Type: storage.NormalUTXOType, BlockHeight: 100, Spent: true},
32                         bc.Hash{V0: 1, V1: 1, V2: 3, V3: 5}: &storage.UtxoEntry{Type: storage.CrosschainUTXOType, BlockHeight: 100, Spent: false},
33                         bc.Hash{V0: 1, V1: 1, V2: 3, V3: 6}: &storage.UtxoEntry{Type: storage.CrosschainUTXOType, BlockHeight: 100, Spent: true},
34                         bc.Hash{V0: 1, V1: 3, V2: 3, V3: 7}: &storage.UtxoEntry{Type: storage.VoteUTXOType, BlockHeight: 100, Spent: false},
35                         bc.Hash{V0: 1, V1: 3, V2: 3, V3: 7}: &storage.UtxoEntry{Type: storage.VoteUTXOType, BlockHeight: 100, Spent: true},
36                 },
37         }
38
39         if err := store.SaveChainStatus(blockHeader, blockHeader, []*types.BlockHeader{blockHeader}, view, []*state.VoteResult{}); err != nil {
40                 t.Fatal(err)
41         }
42
43         expectStatus := &protocol.BlockStoreState{Height: blockHeader.Height, Hash: &blockHash, IrreversibleHeight: blockHeader.Height, IrreversibleHash: &blockHash}
44         if !testutil.DeepEqual(store.GetStoreStatus(), expectStatus) {
45                 t.Errorf("got block status:%v, expect block status:%v", store.GetStoreStatus(), expectStatus)
46         }
47
48         for hash, utxo := range view.Entries {
49                 if (utxo.Type == storage.NormalUTXOType) && utxo.Spent {
50                         continue
51                 }
52                 if (utxo.Type == storage.CrosschainUTXOType) && (!utxo.Spent) {
53                         continue
54                 }
55                 if (utxo.Type == storage.VoteUTXOType) && (utxo.Spent) {
56                         continue
57                 }
58
59                 gotUtxo, err := store.GetUtxo(&hash)
60                 if err != nil {
61                         t.Fatal(err)
62                 }
63
64                 if !testutil.DeepEqual(utxo, gotUtxo) {
65                         t.Errorf("got utxo entry:%v, expect utxo entry:%v", gotUtxo, utxo)
66                 }
67         }
68 }
69
70 func TestSaveBlock(t *testing.T) {
71         testDB := dbm.NewDB("testdb", "leveldb", "temp")
72         defer func() {
73                 testDB.Close()
74                 os.RemoveAll("temp")
75         }()
76
77         store := NewStore(testDB)
78         block := mockGenesisBlock()
79         status := &bc.TransactionStatus{VerifyStatus: []*bc.TxVerifyResult{{StatusFail: true}}}
80         if err := store.SaveBlock(block, status); err != nil {
81                 t.Fatal(err)
82         }
83
84         blockHash := block.Hash()
85         gotBlock, err := store.GetBlock(&blockHash)
86         if err != nil {
87                 t.Fatal(err)
88         }
89
90         gotBlock.Transactions[0].Tx.SerializedSize = 0
91         gotBlock.Transactions[0].SerializedSize = 0
92         if !testutil.DeepEqual(block, gotBlock) {
93                 t.Errorf("got block:%v, expect block:%v", gotBlock, block)
94         }
95
96         gotStatus, err := store.GetTransactionStatus(&blockHash)
97         if err != nil {
98                 t.Fatal(err)
99         }
100
101         if !testutil.DeepEqual(status, gotStatus) {
102                 t.Errorf("got status:%v, expect status:%v", gotStatus, status)
103         }
104
105         data := store.db.Get(calcBlockHeaderKey(&blockHash))
106         gotBlockHeader := types.BlockHeader{}
107         if err := gotBlockHeader.UnmarshalText(data); err != nil {
108                 t.Fatal(err)
109         }
110
111         if !testutil.DeepEqual(block.BlockHeader, gotBlockHeader) {
112                 t.Errorf("got block header:%v, expect block header:%v", gotBlockHeader, block.BlockHeader)
113         }
114 }
115
116 func mockGenesisBlock() *types.Block {
117         txData := types.TxData{
118                 Version: 1,
119                 Inputs: []*types.TxInput{
120                         types.NewCoinbaseInput([]byte("Information is power. -- Jan/11/2013. Computing is power. -- Apr/24/2018.")),
121                 },
122                 Outputs: []*types.TxOutput{
123                         types.NewVoteOutput(bc.AssetID{V0: 1}, uint64(10000), []byte{0x51}, []byte{0x51}),
124                 },
125         }
126         tx := types.NewTx(txData)
127         txStatus := bc.NewTransactionStatus()
128         txStatus.SetStatus(0, false)
129         txStatusHash, _ := types.TxStatusMerkleRoot(txStatus.VerifyStatus)
130         merkleRoot, _ := types.TxMerkleRoot([]*bc.Tx{tx.Tx})
131         block := &types.Block{
132                 BlockHeader: types.BlockHeader{
133                         Version:   1,
134                         Height:    0,
135                         Timestamp: 1528945000,
136                         BlockCommitment: types.BlockCommitment{
137                                 TransactionsMerkleRoot: merkleRoot,
138                                 TransactionStatusHash:  txStatusHash,
139                         },
140                 },
141                 Transactions: []*types.Tx{tx},
142         }
143         return block
144 }