package netmap
import (
"bytes"
"encoding/json"
"math/rand"
"sync"
"testing"
"time"
"github.com/nspcc-dev/neofs-api-go/bootstrap"
"github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/netmap"
"github.com/stretchr/testify/require"
)
func TestNetMap_DataRace(t *testing.T) {
var (
nm = NewNetmap()
wg = new(sync.WaitGroup)
nodes = []bootstrap.NodeInfo{
{Address: "SPB1", Options: []string{"/Location:Europe/Country:USA"}},
{Address: "SPB2", Options: []string{"/Location:Europe/Country:Italy"}},
{Address: "MSK1", Options: []string{"/Location:Europe/Country:Germany"}},
{Address: "MSK2", Options: []string{"/Location:Europe/Country:Russia"}},
}
)
wg.Add(10)
for i := 0; i < 10; i++ {
go func(n int) {
for _, node := range nodes {
require.NoError(t, nm.Add(node.Address, node.PubKey, 0, node.Options...))
// t.Logf("%02d: add node %q", n, node.Address)
}
wg.Done()
}(i)
}
wg.Add(3 * 10)
for i := 0; i < 10; i++ {
go func(n int) {
nm.Copy()
// t.Logf("%02d: Copy", n)
wg.Done()
}(i)
go func(n int) {
nm.Items()
// t.Logf("%02d: Items", n)
wg.Done()
}(i)
go func(n int) {
nm.Root()
// t.Logf("%02d: Root", n)
wg.Done()
}(i)
}
wg.Wait()
}
func TestNetMapSuite(t *testing.T) {
var (
err error
nm1 = NewNetmap()
nodes = []bootstrap.NodeInfo{
{Address: "SPB1", Options: []string{"/Location:Europe/Country:USA"}, Status: 1},
{Address: "SPB2", Options: []string{"/Location:Europe/Country:Italy"}, Status: 2},
{Address: "MSK1", Options: []string{"/Location:Europe/Country:Germany"}, Status: 3},
{Address: "MSK2", Options: []string{"/Location:Europe/Country:Russia"}, Status: 4},
}
)
for _, node := range nodes {
err = nm1.Add(node.Address, nil, node.Status, node.Options...)
require.NoError(t, err)
}
t.Run("copy should work like expected", func(t *testing.T) {
nm2 := nm1.Copy()
require.Equal(t, nm1.root, nm2.root)
require.Equal(t, nm1.items, nm2.items)
})
t.Run("add node should not ignore options", func(t *testing.T) {
items := nm1.ItemsCopy()
nm2 := NewNetmap()
err = nm2.AddNode(&items[0], "/New/Option")
require.NoError(t, err)
require.Len(t, nm2.items, 1)
require.Equal(t, append(items[0].Options, "/New/Option"), nm2.items[0].Options)
})
t.Run("copyItems should work like expected", func(t *testing.T) {
require.Equal(t, nm1.items, nm1.ItemsCopy())
})
t.Run("marshal / unmarshal should be identical on same data", func(t *testing.T) {
var nm2 *NetMap
want, err := json.Marshal(nodes)
require.NoError(t, err)
actual, err := json.Marshal(nm1)
require.NoError(t, err)
require.Equal(t, want, actual)
err = json.Unmarshal(actual, &nm2)
require.NoError(t, err)
require.Equal(t, nm1.root, nm2.root)
require.Equal(t, nm1.items, nm2.items)
})
t.Run("unmarshal should override existing data", func(t *testing.T) {
var nm2 *NetMap
want, err := json.Marshal(nodes)
require.NoError(t, err)
actual, err := json.Marshal(nm1)
require.NoError(t, err)
require.Equal(t, want, actual)
nm2 = nm1.Copy()
err = nm2.Add("SOMEADDR", nil, 0, "/Location:Europe/Country:USA")
require.NoError(t, err)
err = json.Unmarshal(actual, &nm2)
require.NoError(t, err)
require.Equal(t, nm1.root, nm2.root)
require.Equal(t, nm1.items, nm2.items)
})
t.Run("unmarshal should fail on bad data", func(t *testing.T) {
var nm2 *NetMap
require.Error(t, json.Unmarshal([]byte(`"some bad data"`), &nm2))
})
t.Run("unmarshal should fail on add nodes", func(t *testing.T) {
var nm2 *NetMap
require.Error(t, json.Unmarshal([]byte(`[{"address": "SPB1","options":["1-2-3-4"]}]`), &nm2))
})
t.Run("merge two netmaps", func(t *testing.T) {
newNodes := []bootstrap.NodeInfo{
{Address: "SPB3", Options: []string{"/Location:Europe/Country:France"}},
}
nm2 := NewNetmap()
for _, node := range newNodes {
err = nm2.Add(node.Address, nil, 0, node.Options...)
require.NoError(t, err)
}
err = nm2.Merge(nm1)
require.NoError(t, err)
require.Len(t, nm2.items, len(nodes)+len(newNodes))
ns := nm2.FindNodes([]byte("pivot"), netmap.SFGroup{
Filters: []Filter{{Key: "Country", F: FilterEQ("Germany")}},
Selectors: []Select{{Count: 1, Key: NodesBucket}},
})
require.Len(t, ns, 1)
})
t.Run("weighted netmaps", func(t *testing.T) {
strawNodes := []bootstrap.NodeInfo{
{Address: "SPB2", Options: []string{"/Location:Europe/Country:Italy", "/Capacity:10", "/Price:100"}},
{Address: "MSK1", Options: []string{"/Location:Europe/Country:Germany", "/Capacity:10", "/Price:1"}},
{Address: "MSK2", Options: []string{"/Location:Europe/Country:Russia", "/Capacity:5", "/Price:10"}},
{Address: "SPB1", Options: []string{"/Location:Europe/Country:France", "/Capacity:20", "/Price:2"}},
}
nm2 := NewNetmap()
for _, node := range strawNodes {
err = nm2.Add(node.Address, nil, 0, node.Options...)
require.NoError(t, err)
}
ns1 := nm1.FindNodes([]byte("pivot"), netmap.SFGroup{
Selectors: []Select{{Count: 2, Key: NodesBucket}},
})
require.Len(t, ns1, 2)
ns2 := nm2.FindNodes([]byte("pivot"), netmap.SFGroup{
Selectors: []Select{{Count: 2, Key: NodesBucket}},
})
require.Len(t, ns2, 2)
require.NotEqual(t, ns1, ns2)
require.Equal(t, []uint32{1, 3}, ns2)
})
}
func TestNetMap_Normalise(t *testing.T) {
const testCount = 5
nodes := []bootstrap.NodeInfo{
{Address: "SPB2", PubKey: []byte{4}, Options: []string{"/Location:Europe/Country:Italy", "/Capacity:10", "/Price:100"}},
{Address: "MSK1", PubKey: []byte{2}, Options: []string{"/Location:Europe/Country:Germany", "/Capacity:10", "/Price:1"}},
{Address: "MSK2", PubKey: []byte{3}, Options: []string{"/Location:Europe/Country:Russia", "/Capacity:5", "/Price:10"}},
{Address: "SPB1", PubKey: []byte{1}, Options: []string{"/Location:Europe/Country:France", "/Capacity:20", "/Price:2"}},
}
add := func(nm *NetMap, indices ...int) {
for _, i := range indices {
err := nm.Add(nodes[i].Address, nodes[i].PubKey, 0, nodes[i].Options...)
require.NoError(t, err)
}
}
indices := []int{0, 1, 2, 3}
nm1 := NewNetmap()
add(nm1, indices...)
norm := nm1.Normalise()
for i := 0; i < testCount; i++ {
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(indices), func(i, j int) { indices[i], indices[j] = indices[j], indices[i] })
nm := NewNetmap()
add(nm, indices...)
require.Equal(t, norm, nm.Normalise())
}
t.Run("normalise removes duplicates", func(t *testing.T) {
before := NewNetmap()
add(before, indices...)
before.items = append(before.items, before.items...)
nm := before.Normalise()
require.Len(t, nm.items, len(indices))
loop:
for i := range nodes {
for j := range nm.items {
if bytes.Equal(nm.items[j].PubKey, nodes[i].PubKey) {
continue loop
}
}
require.Fail(t, "normalized netmap does not contain '%s' node", nodes[i].Address)
}
})
}
func TestNodeInfo_Price(t *testing.T) {
var info bootstrap.NodeInfo
// too small value
info = bootstrap.NodeInfo{Options: []string{"/Price:0.01048575"}}
require.Equal(t, uint64(0), info.Price())
// min value
info = bootstrap.NodeInfo{Options: []string{"/Price:0.01048576"}}
require.Equal(t, uint64(1), info.Price())
// big value
info = bootstrap.NodeInfo{Options: []string{"/Price:1000000000.666"}}
require.Equal(t, uint64(1000000000.666*1e8/object.UnitsMB), info.Price())
}