1package core
  2
  3import (
  4	"io/ioutil"
  5	"testing"
  6	"time"
  7
  8	"github.com/arnaucube/slowlorisdb/db"
  9	"github.com/stretchr/testify/assert"
 10)
 11
 12func TestBlockchainDataStructure(t *testing.T) {
 13	// dir, err := ioutil.TempDir("", "db")
 14	// assert.Nil(t, err)
 15	// db, err := db.New(dir)
 16	// assert.Nil(t, err)
 17	//
 18	// bc := NewBlockchain(db, uint64(1))
 19	block := &Block{
 20		PrevHash:  Hash{},
 21		Txs:       []Tx{},
 22		Miner:     Address{},
 23		Timestamp: time.Now(),
 24		Nonce:     0,
 25		Hash:      HashBytes([]byte("blockhash")),
 26	}
 27
 28	block2, err := BlockFromBytes(block.Bytes())
 29	assert.Nil(t, err)
 30	assert.Equal(t, block2.Bytes(), block.Bytes())
 31}
 32
 33func TestGetBlock(t *testing.T) {
 34	dir, err := ioutil.TempDir("", "db")
 35	assert.Nil(t, err)
 36	db, err := db.New(dir)
 37	assert.Nil(t, err)
 38
 39	bc := NewBlockchain(db, uint64(1))
 40
 41	block := &Block{
 42		Height:    uint64(1),
 43		PrevHash:  Hash{},
 44		Txs:       []Tx{},
 45		Miner:     Address{},
 46		Timestamp: time.Now(),
 47		Nonce:     0,
 48		Hash:      HashBytes([]byte("blockhash")),
 49	}
 50	assert.Equal(t, block.Height, uint64(1))
 51
 52	err = bc.AddBlock(block)
 53	assert.Nil(t, err)
 54
 55	block2, err := bc.GetBlock(block.Hash)
 56	assert.Nil(t, err)
 57	assert.Equal(t, block.Bytes(), block2.Bytes())
 58}
 59
 60func TestGetPrevBlock(t *testing.T) {
 61	dir, err := ioutil.TempDir("", "db")
 62	assert.Nil(t, err)
 63	db, err := db.New(dir)
 64	assert.Nil(t, err)
 65
 66	bc := NewBlockchain(db, uint64(1))
 67
 68	var prevHash Hash
 69	for i := 0; i < 10; i++ {
 70		block := &Block{
 71			Height:    uint64(i + 1),
 72			PrevHash:  prevHash,
 73			Txs:       []Tx{},
 74			Miner:     Address{},
 75			Timestamp: time.Now(),
 76			Nonce:     0,
 77			Hash:      Hash{},
 78		}
 79		block.CalculatePoW(bc.Difficulty)
 80		assert.Equal(t, block.Height, uint64(i+1))
 81		prevHash = block.Hash
 82
 83		err = bc.AddBlock(block)
 84		assert.Nil(t, err)
 85		assert.Equal(t, bc.LastBlock.Height, block.Height)
 86	}
 87	block9, err := bc.GetPrevBlock(bc.LastBlock.Hash)
 88	assert.Nil(t, err)
 89	assert.Equal(t, block9.Height, uint64(9))
 90
 91	block8, err := bc.GetPrevBlock(block9.Hash)
 92	assert.Nil(t, err)
 93	assert.Equal(t, block8.Height, uint64(8))
 94
 95	currentBlock := bc.LastBlock
 96	for err == nil {
 97		currentBlock, err = bc.GetPrevBlock(currentBlock.Hash)
 98	}
 99	assert.Equal(t, err.Error(), "This was the oldest block")
100}
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*/