1package core
  2
  3import (
  4	"testing"
  5	"time"
  6
  7	"github.com/stretchr/testify/assert"
  8)
  9
 10func TestBlockchainDataStructure(t *testing.T) {
 11	// dir, err := ioutil.TempDir("", "db")
 12	// assert.Nil(t, err)
 13	// db, err := db.New(dir)
 14	// assert.Nil(t, err)
 15	//
 16	// bc := NewBlockchain(db, uint64(1))
 17	block := &Block{
 18		PrevHash:  Hash{},
 19		Txs:       []Tx{},
 20		Miner:     Address{},
 21		Timestamp: time.Now(),
 22		Nonce:     0,
 23		Hash:      HashBytes([]byte("blockhash")),
 24	}
 25
 26	block2, err := BlockFromBytes(block.Bytes())
 27	assert.Nil(t, err)
 28	assert.Equal(t, block2.Bytes(), block.Bytes())
 29}
 30
 31/*
 32func TestGetBlock(t *testing.T) {
 33	// dir, err := ioutil.TempDir("", "db")
 34	// assert.Nil(t, err)
 35	// db, err := db.New(dir)
 36	// assert.Nil(t, err)
 37	//
 38	// bc := NewBlockchain(db, uint64(1))
 39
 40	block := &Block{
 41		Height:    uint64(1),
 42		PrevHash:  Hash{},
 43		Txs:       []Tx{},
 44		Miner:     Address{},
 45		Timestamp: time.Now(),
 46		Nonce:     0,
 47		Hash:      HashBytes([]byte("blockhash")),
 48	}
 49	assert.Equal(t, block.Height, uint64(1))
 50
 51	// block.CalculateHash()
 52
 53	// err = bc.AddBlock(block)
 54	// assert.Nil(t, err)
 55	//
 56	// block2, err := bc.GetBlock(block.Hash)
 57	// assert.Nil(t, err)
 58	// assert.Equal(t, block.Bytes(), block2.Bytes())
 59}
 60
 61func TestGetPrevBlock(t *testing.T) {
 62	dir, err := ioutil.TempDir("", "db")
 63	assert.Nil(t, err)
 64	db, err := db.New(dir)
 65	assert.Nil(t, err)
 66
 67	bc := NewBlockchain(db, uint64(1))
 68
 69	var prevHash Hash
 70	for i := 0; i < 10; i++ {
 71		block := &Block{
 72			Height:    uint64(i + 1),
 73			PrevHash:  prevHash,
 74			Txs:       []Tx{},
 75			Miner:     Address{},
 76			Timestamp: time.Now(),
 77			Nonce:     0,
 78			Hash:      Hash{},
 79		}
 80		block.CalculatePoW(bc.Difficulty)
 81		assert.Equal(t, block.Height, uint64(i+1))
 82		prevHash = block.Hash
 83
 84		err = bc.AddBlock(block)
 85		assert.Nil(t, err)
 86		assert.Equal(t, bc.LastBlock.Height, block.Height)
 87	}
 88	block9, err := bc.GetPrevBlock(bc.LastBlock.Hash)
 89	assert.Nil(t, err)
 90	assert.Equal(t, block9.Height, uint64(9))
 91
 92	block8, err := bc.GetPrevBlock(block9.Hash)
 93	assert.Nil(t, err)
 94	assert.Equal(t, block8.Height, uint64(8))
 95
 96	currentBlock := bc.LastBlock
 97	for err == nil {
 98		currentBlock, err = bc.GetPrevBlock(currentBlock.Hash)
 99	}
100	assert.Equal(t, err.Error(), "This was the oldest block")
101}
102
103func TestAddBlockWithTx(t *testing.T) {
104	addr0 := Address(HashBytes([]byte("addr0")))
105	addr1 := Address(HashBytes([]byte("addr1")))
106
107	dir, err := ioutil.TempDir("", "db")
108	assert.Nil(t, err)
109	db, err := db.New(dir)
110	assert.Nil(t, err)
111
112	bc := NewBlockchain(db, uint64(1))
113
114	var txs []Tx
115	tx := NewTx(addr0, addr1, []Input{}, []Output{})
116	txs = append(txs, *tx)
117	block := &Block{
118		PrevHash:  Hash{},
119		NextHash:  Hash{},
120		Txs:       txs,
121		Miner:     Address{},
122		Timestamp: time.Now(),
123		Nonce:     0,
124		Hash:      HashBytes([]byte("blockhash")),
125	}
126
127	block2, err := BlockFromBytes(block.Bytes())
128	assert.Nil(t, err)
129	assert.Equal(t, block2.Bytes(), block.Bytes())
130}
131
132func TestPoABlockchainDataStructure(t *testing.T) {
133	dir, err := ioutil.TempDir("", "db")
134	assert.Nil(t, err)
135	db, err := db.New(dir)
136	assert.Nil(t, err)
137
138	var authNodesPubK []*ecdsa.PublicKey
139	for i := 0; i < 3; i++ {
140		privK, err := NewKey()
141		assert.Nil(t, err)
142		authNodesPubK = append(authNodesPubK, &privK.PublicKey)
143	}
144
145	bc := NewPoABlockchain(db, authNodesPubK)
146	block := &Block{
147		PrevHash:  Hash{},
148		NextHash:  Hash{},
149		Txs:       []Tx{},
150		Miner:     Address{},
151		Timestamp: time.Now(),
152		Nonce:     0,
153		Hash:      HashBytes([]byte("blockhash")),
154	}
155
156	block2, err := BlockFromBytes(block.Bytes())
157	assert.Nil(t, err)
158	assert.Equal(t, block2.Bytes(), block.Bytes())
159}
160*/