frostfs-api-go/pkg/netmap/node_info_test.go

package netmap

import (
	"testing"

	"github.com/nspcc-dev/neofs-api-go/v2/netmap"
	testv2 "github.com/nspcc-dev/neofs-api-go/v2/netmap/test"
	"github.com/stretchr/testify/require"
)

func TestNodeStateFromV2(t *testing.T) {
	for _, item := range []struct {
		s   NodeState
		sV2 netmap.NodeState
	}{
		{
			s:   0,
			sV2: netmap.UnspecifiedState,
		},
		{
			s:   NodeStateOnline,
			sV2: netmap.Online,
		},
		{
			s:   NodeStateOffline,
			sV2: netmap.Offline,
		},
	} {
		require.Equal(t, item.s, NodeStateFromV2(item.sV2))
		require.Equal(t, item.sV2, item.s.ToV2())
	}
}

func TestNodeAttributeFromV2(t *testing.T) {
	t.Run("from nil", func(t *testing.T) {
		var x *netmap.Attribute

		require.Nil(t, NewNodeAttributeFromV2(x))
	})

	t.Run("from non-nil", func(t *testing.T) {
		aV2 := testv2.GenerateAttribute(false)

		a := NewNodeAttributeFromV2(aV2)

		require.Equal(t, aV2, a.ToV2())
	})
}

func TestNodeAttribute_ToV2(t *testing.T) {
	t.Run("nil", func(t *testing.T) {
		var x *NodeAttribute

		require.Nil(t, x.ToV2())
	})
}

func TestNodeAttribute_Key(t *testing.T) {
	a := NewNodeAttribute()
	key := "some key"

	a.SetKey(key)

	require.Equal(t, key, a.Key())
}

func TestNodeAttribute_Value(t *testing.T) {
	a := NewNodeAttribute()
	val := "some value"

	a.SetValue(val)

	require.Equal(t, val, a.Value())
}

func TestNodeAttribute_ParentKeys(t *testing.T) {
	a := NewNodeAttribute()
	keys := []string{"par1", "par2"}

	a.SetParentKeys(keys...)

	require.Equal(t, keys, a.ParentKeys())
}

func testNodeAttribute() *NodeAttribute {
	a := new(NodeAttribute)
	a.SetKey("key")
	a.SetValue("value")
	a.SetParentKeys("par1", "par2")

	return a
}

func TestNodeInfoFromV2(t *testing.T) {
	t.Run("from nil", func(t *testing.T) {
		var x *netmap.NodeInfo

		require.Nil(t, NewNodeInfoFromV2(x))
	})

	t.Run("from non-nil", func(t *testing.T) {
		iV2 := testv2.GenerateNodeInfo(false)

		i := NewNodeInfoFromV2(iV2)

		require.Equal(t, iV2, i.ToV2())
	})
}

func TestNodeInfo_ToV2(t *testing.T) {
	t.Run("nil", func(t *testing.T) {
		var x *NodeInfo

		require.Nil(t, x.ToV2())
	})
}

func TestNodeInfo_PublicKey(t *testing.T) {
	i := new(NodeInfo)
	key := []byte{1, 2, 3}

	i.SetPublicKey(key)

	require.Equal(t, key, i.PublicKey())
}

func TestNodeInfo_Address(t *testing.T) {
	i := new(NodeInfo)
	a := "127.0.0.1:8080"

	i.SetAddress(a)

	require.Equal(t, a, i.Address())
}

func TestNodeInfo_State(t *testing.T) {
	i := new(NodeInfo)
	s := NodeStateOnline

	i.SetState(s)

	require.Equal(t, s, i.State())
}

func TestNodeInfo_Attributes(t *testing.T) {
	i := new(NodeInfo)
	as := []*NodeAttribute{testNodeAttribute(), testNodeAttribute()}

	i.SetAttributes(as...)

	require.Equal(t, as, i.Attributes())
}

func TestNodeAttributeEncoding(t *testing.T) {
	a := testNodeAttribute()

	t.Run("binary", func(t *testing.T) {
		data, err := a.Marshal()
		require.NoError(t, err)

		a2 := NewNodeAttribute()
		require.NoError(t, a2.Unmarshal(data))

		require.Equal(t, a, a2)
	})

	t.Run("json", func(t *testing.T) {
		data, err := a.MarshalJSON()
		require.NoError(t, err)

		a2 := NewNodeAttribute()
		require.NoError(t, a2.UnmarshalJSON(data))

		require.Equal(t, a, a2)
	})
}

func TestNodeInfoEncoding(t *testing.T) {
	i := NewNodeInfo()
	i.SetPublicKey([]byte{1, 2, 3})
	i.SetAddress("192.168.0.1")
	i.SetState(NodeStateOnline)
	i.SetAttributes(testNodeAttribute())

	t.Run("binary", func(t *testing.T) {
		data, err := i.Marshal()
		require.NoError(t, err)

		i2 := NewNodeInfo()
		require.NoError(t, i2.Unmarshal(data))

		require.Equal(t, i, i2)
	})

	t.Run("json", func(t *testing.T) {
		data, err := i.MarshalJSON()
		require.NoError(t, err)

		i2 := NewNodeInfo()
		require.NoError(t, i2.UnmarshalJSON(data))

		require.Equal(t, i, i2)
	})
}

func TestNewNodeAttribute(t *testing.T) {
	t.Run("default values", func(t *testing.T) {
		attr := NewNodeAttribute()

		// check initial values
		require.Empty(t, attr.Key())
		require.Empty(t, attr.Value())
		require.Nil(t, attr.ParentKeys())

		// convert to v2 message
		attrV2 := attr.ToV2()

		require.Empty(t, attrV2.GetKey())
		require.Empty(t, attrV2.GetValue())
		require.Nil(t, attrV2.GetParents())
	})
}

func TestNewNodeInfo(t *testing.T) {
	t.Run("default values", func(t *testing.T) {
		ni := NewNodeInfo()

		// check initial values
		require.Nil(t, ni.PublicKey())
		require.Empty(t, ni.Address())
		require.Nil(t, ni.Attributes())
		require.Zero(t, ni.State())

		// convert to v2 message
		niV2 := ni.ToV2()

		require.Nil(t, niV2.GetPublicKey())
		require.Empty(t, niV2.GetAddress())
		require.Nil(t, niV2.GetAttributes())
		require.EqualValues(t, netmap.UnspecifiedState, niV2.GetState())
	})
}