mirror of
https://github.com/yggdrasil-network/yggdrasil-go.git
synced 2025-04-28 14:15:06 +03:00
396 lines
9.7 KiB
Go
396 lines
9.7 KiB
Go
package db_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/ed25519"
|
|
"crypto/rand"
|
|
"crypto/x509"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/DATA-DOG/go-sqlmock"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/yggdrasil-network/yggdrasil-go/src/core"
|
|
peerinfodb "github.com/yggdrasil-network/yggdrasil-go/src/db/PeerInfoDB"
|
|
)
|
|
|
|
func TestPeerGetCoords(t *testing.T) {
|
|
peer := core.PeerInfo{
|
|
Coords: []uint64{1, 2, 3, 4},
|
|
}
|
|
target := []byte{1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0}
|
|
var coordinates = peer.GetCoordinates()
|
|
if reflect.DeepEqual(target, coordinates) {
|
|
t.Error(fmt.Errorf("Not equal"))
|
|
}
|
|
}
|
|
|
|
func TestPeerSetCoords(t *testing.T) {
|
|
peer := core.PeerInfo{
|
|
Coords: []uint64{1, 2, 3, 4},
|
|
}
|
|
target := []byte{4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}
|
|
var coordinates = peer.SetCoordinates(&target)
|
|
if reflect.DeepEqual(target, coordinates) {
|
|
t.Error(fmt.Errorf("Not equal"))
|
|
}
|
|
fmt.Print(peer.Coords)
|
|
}
|
|
|
|
func TestAddPeer(t *testing.T) {
|
|
mockDB, mock, err := sqlmock.New()
|
|
require.NoError(t, err)
|
|
defer mockDB.Close()
|
|
|
|
cfg, err := peerinfodb.New()
|
|
require.NoError(t, err)
|
|
cfg.DbConfig.DB = mockDB
|
|
|
|
pubkey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
rootPubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
|
|
peer := core.PeerInfo{
|
|
URI: "test.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: rootPubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
pKey, err := x509.MarshalPKIXPublicKey(peer.Key)
|
|
require.NoError(t, err)
|
|
pKeyRoot, err := x509.MarshalPKIXPublicKey(peer.Root)
|
|
require.NoError(t, err)
|
|
var coordsBlob []byte
|
|
if peer.Coords != nil {
|
|
coordsBlob = make([]byte, len(peer.Coords)*8)
|
|
for i, coord := range peer.Coords {
|
|
binary.LittleEndian.PutUint64(coordsBlob[i*8:], coord)
|
|
}
|
|
}
|
|
mock.ExpectExec("INSERT OR REPLACE INTO peer_infos").
|
|
WithArgs(
|
|
peer.URI,
|
|
peer.Up,
|
|
peer.Inbound,
|
|
nil,
|
|
peer.LastErrorTime,
|
|
pKey,
|
|
pKeyRoot,
|
|
coordsBlob,
|
|
peer.Port,
|
|
peer.Priority,
|
|
peer.RXBytes,
|
|
peer.TXBytes,
|
|
peer.Uptime,
|
|
peer.Latency,
|
|
).
|
|
WillReturnResult(sqlmock.NewResult(1, 1))
|
|
|
|
err = cfg.AddPeer(peer)
|
|
require.NoError(t, err)
|
|
|
|
err = mock.ExpectationsWereMet()
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestRemovePeer(t *testing.T) {
|
|
mockDB, mock, err := sqlmock.New()
|
|
require.NoError(t, err)
|
|
defer mockDB.Close()
|
|
|
|
cfg, err := peerinfodb.New()
|
|
require.NoError(t, err)
|
|
cfg.DbConfig.DB = mockDB
|
|
|
|
pubkey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
rootPubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
|
|
peer := core.PeerInfo{
|
|
URI: "test.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: rootPubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
pKey, err := x509.MarshalPKIXPublicKey(peer.Key)
|
|
require.NoError(t, err)
|
|
pKeyRoot, err := x509.MarshalPKIXPublicKey(peer.Root)
|
|
require.NoError(t, err)
|
|
mock.ExpectExec("DELETE FROM peer_infos WHERE uri = \\? AND key = \\? AND root = \\?").
|
|
WithArgs(peer.URI, pKey, pKeyRoot).
|
|
WillReturnResult(sqlmock.NewResult(1, 1))
|
|
|
|
err = cfg.RemovePeer(peer)
|
|
require.NoError(t, err)
|
|
|
|
err = mock.ExpectationsWereMet()
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestGetPeer(t *testing.T) {
|
|
mockDB, mock, err := sqlmock.New()
|
|
require.NoError(t, err)
|
|
defer mockDB.Close()
|
|
|
|
cfg, err := peerinfodb.New()
|
|
require.NoError(t, err)
|
|
cfg.DbConfig.DB = mockDB
|
|
|
|
pubkey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
rootPubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
|
|
peer := core.PeerInfo{
|
|
URI: "test.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: rootPubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
pKey, err := x509.MarshalPKIXPublicKey(peer.Key)
|
|
require.NoError(t, err)
|
|
pKeyRoot, err := x509.MarshalPKIXPublicKey(peer.Root)
|
|
require.NoError(t, err)
|
|
var coords []byte
|
|
rows := sqlmock.NewRows([]string{"uri", "up", "Inbound", "LastError", "LastErrorTime", "Key", "Root", "Coords", "Port", "Priority", "Rxbytes", "Txbytes", "Uptime", "Latency"}).
|
|
AddRow(peer.URI, peer.Up, peer.Inbound, peer.LastError, peer.LastErrorTime, peer.Key, peer.Root, coords, peer.Port, peer.Priority, peer.RXBytes, peer.TXBytes, peer.Uptime, peer.Latency)
|
|
|
|
mock.ExpectQuery("SELECT * FROM peer_infos WHERE uri = ? AND key = ? AND root = ?").
|
|
WithArgs(peer.URI, pKey, pKeyRoot).
|
|
WillReturnRows(rows)
|
|
|
|
err = cfg.GetPeer(&peer)
|
|
require.NoError(t, err)
|
|
|
|
err = mock.ExpectationsWereMet()
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestUpdatePeer(t *testing.T) {
|
|
mockDB, mock, err := sqlmock.New()
|
|
require.NoError(t, err)
|
|
defer mockDB.Close()
|
|
|
|
cfg, err := peerinfodb.New()
|
|
require.NoError(t, err)
|
|
cfg.DbConfig.DB = mockDB
|
|
|
|
pubkey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
rootPubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
|
|
peer := core.PeerInfo{
|
|
URI: "test.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: rootPubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
pKey, err := x509.MarshalPKIXPublicKey(peer.Key)
|
|
require.NoError(t, err)
|
|
pKeyRoot, err := x509.MarshalPKIXPublicKey(peer.Root)
|
|
var coordsBlob []byte
|
|
if peer.Coords != nil {
|
|
coordsBlob = make([]byte, len(peer.Coords)*8)
|
|
for i, coord := range peer.Coords {
|
|
binary.LittleEndian.PutUint64(coordsBlob[i*8:], coord)
|
|
}
|
|
}
|
|
require.NoError(t, err)
|
|
mock.ExpectExec(`UPDATE peer_infos
|
|
SET
|
|
up = \?,
|
|
inbound = \?,
|
|
last_error = \?,
|
|
last_error_time = \?,
|
|
coords = \?,
|
|
port = \?,
|
|
priority = \?,
|
|
RXBytes = RXBytes \+ \?,
|
|
TXBytes = TXBytes \+ \?,
|
|
uptime = \?,
|
|
latency = \?
|
|
WHERE
|
|
uri = \? AND key = \? AND root = \?`).
|
|
WithArgs(
|
|
peer.Up, peer.Inbound, peer.LastError, peer.LastErrorTime, coordsBlob, peer.Port, peer.Priority,
|
|
peer.RXBytes, peer.TXBytes, peer.Uptime, peer.Latency, peer.URI, pKey, pKeyRoot).
|
|
WillReturnResult(sqlmock.NewResult(1, 1))
|
|
|
|
err = cfg.UpdatePeer(peer)
|
|
require.NoError(t, err)
|
|
|
|
err = mock.ExpectationsWereMet()
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// One more test here
|
|
func TestMain(t *testing.T) {
|
|
peerinfodb.Name = fmt.Sprintf(
|
|
"%s.%s",
|
|
peerinfodb.Name,
|
|
strconv.Itoa(int(time.Now().Unix())),
|
|
)
|
|
|
|
peerdb, err := peerinfodb.New()
|
|
require.NoError(t, err)
|
|
|
|
peerdb.DbConfig.OpenDb()
|
|
isOpened := peerdb.DbConfig.DBIsOpened()
|
|
condition := func() bool {
|
|
return isOpened
|
|
}
|
|
require.Condition(t, condition, "Expected db is opened", isOpened)
|
|
|
|
pubkey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
rootPubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
peer := core.PeerInfo{
|
|
URI: "test.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: rootPubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
root2PubKey, _, err := ed25519.GenerateKey(rand.Reader)
|
|
require.NoError(t, err)
|
|
peer2 := core.PeerInfo{
|
|
URI: "new.test",
|
|
Up: true,
|
|
Inbound: true,
|
|
LastError: nil,
|
|
LastErrorTime: time.Now(),
|
|
Key: pubkey,
|
|
Root: root2PubKey,
|
|
Coords: []uint64{0, 0, 0, 0},
|
|
Port: 8080,
|
|
Priority: 1,
|
|
RXBytes: 1024,
|
|
TXBytes: 2048,
|
|
Uptime: 3600,
|
|
Latency: 50.0,
|
|
}
|
|
|
|
peerdb.AddPeer(peer)
|
|
peerdb.AddPeer(peer2)
|
|
count, err := peerdb.Count()
|
|
require.NoError(t, err)
|
|
condition = func() bool {
|
|
return count == 2
|
|
}
|
|
require.Condition(t, condition, "Expected count to be 2", count)
|
|
|
|
peerdb.RemovePeer(peer)
|
|
count, err = peerdb.Count()
|
|
require.NoError(t, err)
|
|
condition = func() bool {
|
|
return count == 1
|
|
}
|
|
require.Condition(t, condition, "Expected count to be 1", count)
|
|
|
|
peer2.Latency = 10
|
|
peer2.RXBytes = 1024
|
|
peer2.TXBytes = 1024
|
|
peer2.Port = 80
|
|
peerdb.UpdatePeer(peer2)
|
|
peerdb.GetPeer(&peer2)
|
|
condition = func() bool {
|
|
return peer2.Latency == 10 &&
|
|
peer2.RXBytes == 2048 &&
|
|
peer2.TXBytes == 3072 &&
|
|
peer2.Port == 80 && peer2.URI == "new.test" && bytes.Equal(peer.Key, pubkey)
|
|
}
|
|
require.Condition(t, condition, "Inner exception")
|
|
|
|
peerdb.RemovePeer(peer2)
|
|
count, err = peerdb.Count()
|
|
require.NoError(t, err)
|
|
|
|
condition = func() bool {
|
|
return count == 0
|
|
}
|
|
|
|
require.Condition(t, condition, "Expected count to be 0", count)
|
|
|
|
err = peerdb.DbConfig.CloseDb()
|
|
isOpened = peerdb.DbConfig.DBIsOpened()
|
|
|
|
condition = func() bool {
|
|
return !isOpened
|
|
}
|
|
|
|
require.Condition(t, condition, "Expected db is not opened", isOpened)
|
|
|
|
require.NoError(t, err)
|
|
err = peerdb.DbConfig.DeleteDb()
|
|
require.NoError(t, err)
|
|
isExist := peerdb.DbConfig.DBIsExist()
|
|
|
|
condition = func() bool {
|
|
return !isExist
|
|
}
|
|
|
|
require.Condition(t, condition, "Expected db is not exist", isExist)
|
|
}
|