283 lines
7 KiB
Go
283 lines
7 KiB
Go
package netmap
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestNodeInfo_NetworkEndpoints(t *testing.T) {
|
|
t.Run("empty", func(t *testing.T) {
|
|
var n NodeInfo
|
|
for range n.NetworkEndpoints() {
|
|
t.Fatalf("handler is called, but it shouldn't")
|
|
}
|
|
})
|
|
|
|
var n NodeInfo
|
|
n.SetNetworkEndpoints("1", "2", "3")
|
|
|
|
t.Run("break", func(t *testing.T) {
|
|
var res []string
|
|
for s := range n.NetworkEndpoints() {
|
|
if s == "2" {
|
|
break
|
|
}
|
|
res = append(res, s)
|
|
}
|
|
require.Equal(t, []string{"1"}, res)
|
|
})
|
|
t.Run("continue", func(t *testing.T) {
|
|
var res []string
|
|
for s := range n.NetworkEndpoints() {
|
|
if s == "2" {
|
|
continue
|
|
}
|
|
res = append(res, s)
|
|
}
|
|
require.Equal(t, []string{"1", "3"}, res)
|
|
})
|
|
|
|
var res []string
|
|
for s := range n.NetworkEndpoints() {
|
|
res = append(res, s)
|
|
}
|
|
require.Equal(t, []string{"1", "2", "3"}, res)
|
|
}
|
|
|
|
func TestNodeInfo_Attributes(t *testing.T) {
|
|
t.Run("empty", func(t *testing.T) {
|
|
var n NodeInfo
|
|
for range n.Attributes() {
|
|
t.Fatalf("handler is called, but it shouldn't")
|
|
}
|
|
})
|
|
|
|
var n NodeInfo
|
|
n.SetAttribute("key1", "value1")
|
|
n.SetAttribute("key2", "value2")
|
|
n.SetAttribute("key3", "value3")
|
|
|
|
t.Run("break", func(t *testing.T) {
|
|
var res [][2]string
|
|
for k, v := range n.Attributes() {
|
|
if k == "key2" {
|
|
break
|
|
}
|
|
res = append(res, [2]string{k, v})
|
|
}
|
|
require.Equal(t, [][2]string{{"key1", "value1"}}, res)
|
|
})
|
|
t.Run("continue", func(t *testing.T) {
|
|
var res [][2]string
|
|
for k, v := range n.Attributes() {
|
|
if k == "key2" {
|
|
continue
|
|
}
|
|
res = append(res, [2]string{k, v})
|
|
}
|
|
require.Equal(t, [][2]string{{"key1", "value1"}, {"key3", "value3"}}, res)
|
|
})
|
|
|
|
var res [][2]string
|
|
for k, v := range n.Attributes() {
|
|
res = append(res, [2]string{k, v})
|
|
}
|
|
require.Equal(t, [][2]string{{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}}, res)
|
|
}
|
|
|
|
func TestNodeInfo_SetAttribute(t *testing.T) {
|
|
var n NodeInfo
|
|
|
|
const key = "some key"
|
|
val := "some value"
|
|
|
|
require.Zero(t, n.Attribute(val))
|
|
|
|
n.SetAttribute(key, val)
|
|
require.Equal(t, val, n.Attribute(key))
|
|
|
|
val = "some other value"
|
|
|
|
n.SetAttribute(key, val)
|
|
require.Equal(t, val, n.Attribute(key))
|
|
}
|
|
|
|
func TestNodeState(t *testing.T) {
|
|
m := map[NodeState]netmap.NodeState{
|
|
UnspecifiedState: netmap.UnspecifiedState,
|
|
Online: netmap.Online,
|
|
Offline: netmap.Offline,
|
|
Maintenance: netmap.Maintenance,
|
|
}
|
|
|
|
t.Run("from sdk to v2", func(t *testing.T) {
|
|
for stateSDK, stateV2 := range m {
|
|
require.Equal(t, stateV2, stateSDK.ToV2())
|
|
}
|
|
})
|
|
|
|
t.Run("from v2 to sdk", func(t *testing.T) {
|
|
for stateSDK, stateV2 := range m {
|
|
var state NodeState
|
|
state.FromV2(stateV2)
|
|
require.Equal(t, stateSDK, state)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestNodeInfo_Status(t *testing.T) {
|
|
t.Run("deprecated getters/setters", func(t *testing.T) {
|
|
var n NodeInfo
|
|
|
|
require.False(t, n.IsOnline())
|
|
require.False(t, n.IsOffline())
|
|
require.False(t, n.IsMaintenance())
|
|
|
|
n.SetOnline()
|
|
require.True(t, n.IsOnline())
|
|
require.False(t, n.IsOffline())
|
|
require.False(t, n.IsMaintenance())
|
|
|
|
n.SetOffline()
|
|
require.True(t, n.IsOffline())
|
|
require.False(t, n.IsOnline())
|
|
require.False(t, n.IsMaintenance())
|
|
|
|
n.SetMaintenance()
|
|
require.True(t, n.IsMaintenance())
|
|
require.False(t, n.IsOnline())
|
|
require.False(t, n.IsOffline())
|
|
})
|
|
|
|
t.Run("brand new getters/setters", func(t *testing.T) {
|
|
var n NodeInfo
|
|
|
|
require.False(t, n.Status().IsOnline())
|
|
require.False(t, n.Status().IsOffline())
|
|
require.False(t, n.Status().IsMaintenance())
|
|
|
|
n.SetStatus(Online)
|
|
require.True(t, n.Status().IsOnline())
|
|
require.False(t, n.Status().IsOffline())
|
|
require.False(t, n.Status().IsMaintenance())
|
|
|
|
n.SetStatus(Offline)
|
|
require.False(t, n.Status().IsOnline())
|
|
require.True(t, n.Status().IsOffline())
|
|
require.False(t, n.Status().IsMaintenance())
|
|
|
|
n.SetStatus(Maintenance)
|
|
require.False(t, n.Status().IsOnline())
|
|
require.False(t, n.Status().IsOffline())
|
|
require.True(t, n.Status().IsMaintenance())
|
|
})
|
|
}
|
|
|
|
func TestNodeInfo_ExternalAddr(t *testing.T) {
|
|
var n NodeInfo
|
|
|
|
require.Empty(t, n.ExternalAddresses())
|
|
require.Panics(t, func() { n.SetExternalAddresses() })
|
|
|
|
addr := []string{"1", "2", "3"}
|
|
n.SetExternalAddresses(addr[0])
|
|
require.Equal(t, addr[:1], n.ExternalAddresses())
|
|
|
|
n.SetExternalAddresses(addr[1:]...)
|
|
require.Equal(t, addr[1:], n.ExternalAddresses())
|
|
}
|
|
|
|
func TestNodeInfo_Clone(t *testing.T) {
|
|
var ni NodeInfo
|
|
ni.SetPublicKey([]byte{2, 3})
|
|
|
|
c := ni.Clone()
|
|
require.True(t, c != &ni)
|
|
require.True(t, &(c.PublicKey()[0]) != &(ni.PublicKey()[0]))
|
|
}
|
|
|
|
func TestNodeInfo_Unmarshal(t *testing.T) {
|
|
pk, err := keys.NewPrivateKey()
|
|
require.NoError(t, err)
|
|
|
|
attrs := make([]netmap.Attribute, 2)
|
|
for i := range attrs {
|
|
attrs[i].SetKey(fmt.Sprintf("key%d", i))
|
|
attrs[i].SetValue(fmt.Sprintf("value%d", i))
|
|
}
|
|
goodNodeInfo := func() netmap.NodeInfo {
|
|
var nodev2 netmap.NodeInfo
|
|
nodev2.SetPublicKey(pk.PublicKey().Bytes())
|
|
nodev2.SetAddresses("127.0.0.1:2025")
|
|
nodev2.SetState(netmap.Online)
|
|
nodev2.SetAttributes(attrs)
|
|
return nodev2
|
|
}
|
|
|
|
// Check that goodNodeInfo indeed returns good node.
|
|
// Otherwise, the whole test is garbage.
|
|
require.NoError(t, new(NodeInfo).ReadFromV2(goodNodeInfo()))
|
|
|
|
t.Run("empty public key", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
n.SetPublicKey(nil)
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n), "missing public key")
|
|
})
|
|
t.Run("missing addresses", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
n.SetAddresses()
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n), "missing network endpoints")
|
|
})
|
|
t.Run("empty attribute key", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
|
|
var a netmap.Attribute
|
|
a.SetValue("non-empty")
|
|
n.SetAttributes(append(attrs, a))
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n),
|
|
fmt.Sprintf("empty key of the attribute #%d", len(attrs)))
|
|
})
|
|
t.Run("empty attribute value", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
|
|
var a netmap.Attribute
|
|
a.SetKey("non-empty-key")
|
|
n.SetAttributes(append(attrs, a))
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n),
|
|
"empty value of the attribute non-empty-key")
|
|
})
|
|
t.Run("invalid price attribute", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
|
|
var a netmap.Attribute
|
|
a.SetKey(attrPrice)
|
|
a.SetValue("not a number")
|
|
n.SetAttributes(append(attrs, a))
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n),
|
|
fmt.Sprintf("invalid %s attribute", attrPrice))
|
|
})
|
|
t.Run("invalid capacity attribute", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
|
|
var a netmap.Attribute
|
|
a.SetKey(attrCapacity)
|
|
a.SetValue("not a number")
|
|
n.SetAttributes(append(attrs, a))
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n),
|
|
fmt.Sprintf("invalid %s attribute", attrCapacity))
|
|
})
|
|
t.Run("duplicate attributes", func(t *testing.T) {
|
|
n := goodNodeInfo()
|
|
|
|
var a netmap.Attribute
|
|
a.SetKey("key1")
|
|
a.SetValue("value3")
|
|
n.SetAttributes(append(attrs, a))
|
|
require.ErrorContains(t, new(NodeInfo).ReadFromV2(n),
|
|
"duplicate attributes key1")
|
|
})
|
|
}
|