forked from TrueCloudLab/frostfs-sdk-go
[#42] netmap: move package from neofs-api-go
Signed-off-by: Evgenii Stratonikov <evgeniy@nspcc.ru>
This commit is contained in:
Evgenii Stratonikov
Alex Vanin
parent
1bd89bf797
commit
369bd382b3
24 changed files with 3881 additions and 0 deletions
530
netmap/selector_test.go
Normal file
530
netmap/selector_test.go
Normal file
|
|
@ -0,0 +1,530 @@
|
|||
package netmap
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"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 TestPlacementPolicy_UnspecifiedClause(t *testing.T) {
|
||||
p := newPlacementPolicy(1,
|
||||
[]*Replica{newReplica(1, "X")},
|
||||
[]*Selector{
|
||||
newSelector("X", "", ClauseDistinct, 4, "*"),
|
||||
},
|
||||
nil,
|
||||
)
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("ID", "1", "Country", "RU", "City", "St.Petersburg", "SSD", "0"),
|
||||
nodeInfoFromAttributes("ID", "2", "Country", "RU", "City", "St.Petersburg", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "3", "Country", "RU", "City", "Moscow", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "4", "Country", "RU", "City", "Moscow", "SSD", "1"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 4, len(v.Flatten()))
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_Minimal(t *testing.T) {
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("City", "Saint-Petersburg"),
|
||||
nodeInfoFromAttributes("City", "Moscow"),
|
||||
nodeInfoFromAttributes("City", "Berlin"),
|
||||
nodeInfoFromAttributes("City", "Paris"),
|
||||
}
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
|
||||
runTest := func(t *testing.T, rep uint32, expectError bool) {
|
||||
p := newPlacementPolicy(0,
|
||||
[]*Replica{newReplica(rep, "")},
|
||||
nil, nil)
|
||||
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
|
||||
if expectError {
|
||||
require.Error(t, err)
|
||||
return
|
||||
}
|
||||
|
||||
require.NoError(t, err)
|
||||
count := int(rep * defaultCBF)
|
||||
if count > len(nm.Nodes) {
|
||||
count = len(nm.Nodes)
|
||||
}
|
||||
require.EqualValues(t, count, len(v.Flatten()))
|
||||
}
|
||||
|
||||
t.Run("REP 1", func(t *testing.T) {
|
||||
runTest(t, 1, false)
|
||||
})
|
||||
t.Run("REP 3", func(t *testing.T) {
|
||||
runTest(t, 3, false)
|
||||
})
|
||||
t.Run("REP 5", func(t *testing.T) {
|
||||
runTest(t, 5, true)
|
||||
})
|
||||
}
|
||||
|
||||
// Issue #215.
|
||||
func TestPlacementPolicy_MultipleREP(t *testing.T) {
|
||||
p := newPlacementPolicy(1,
|
||||
[]*Replica{
|
||||
newReplica(1, "LOC_SPB_PLACE"),
|
||||
newReplica(1, "LOC_MSK_PLACE"),
|
||||
},
|
||||
[]*Selector{
|
||||
newSelector("LOC_SPB_PLACE", "", ClauseUnspecified, 1, "LOC_SPB"),
|
||||
newSelector("LOC_MSK_PLACE", "", ClauseUnspecified, 1, "LOC_MSK"),
|
||||
},
|
||||
[]*Filter{
|
||||
newFilter("LOC_SPB", "City", "Saint-Petersburg", OpEQ),
|
||||
newFilter("LOC_MSK", "City", "Moscow", OpEQ),
|
||||
},
|
||||
)
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("City", "Saint-Petersburg"),
|
||||
nodeInfoFromAttributes("City", "Moscow"),
|
||||
nodeInfoFromAttributes("City", "Berlin"),
|
||||
nodeInfoFromAttributes("City", "Paris"),
|
||||
}
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
|
||||
rs := v.Replicas()
|
||||
require.Equal(t, 2, len(rs))
|
||||
require.Equal(t, 1, len(rs[0]))
|
||||
require.Equal(t, "Saint-Petersburg", rs[0][0].Attribute("City"))
|
||||
require.Equal(t, 1, len(rs[1]))
|
||||
require.Equal(t, "Moscow", rs[1][0].Attribute("City"))
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_DefaultCBF(t *testing.T) {
|
||||
p := newPlacementPolicy(0,
|
||||
[]*Replica{
|
||||
newReplica(1, "EU"),
|
||||
},
|
||||
[]*Selector{
|
||||
newSelector("EU", "Location", ClauseSame, 1, "*"),
|
||||
},
|
||||
nil)
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "RU", "City", "St.Petersburg"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "RU", "City", "Moscow"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "DE", "City", "Berlin"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "FR", "City", "Paris"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, defaultCBF, len(v.Flatten()))
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_GetPlacementVectors(t *testing.T) {
|
||||
p := newPlacementPolicy(2,
|
||||
[]*Replica{
|
||||
newReplica(1, "SPB"),
|
||||
newReplica(2, "Americas"),
|
||||
},
|
||||
[]*Selector{
|
||||
newSelector("SPB", "City", ClauseSame, 1, "SPBSSD"),
|
||||
newSelector("Americas", "City", ClauseDistinct, 2, "Americas"),
|
||||
},
|
||||
[]*Filter{
|
||||
newFilter("SPBSSD", "", "", OpAND,
|
||||
newFilter("", "Country", "RU", OpEQ),
|
||||
newFilter("", "City", "St.Petersburg", OpEQ),
|
||||
newFilter("", "SSD", "1", OpEQ)),
|
||||
newFilter("Americas", "", "", OpOR,
|
||||
newFilter("", "Continent", "NA", OpEQ),
|
||||
newFilter("", "Continent", "SA", OpEQ)),
|
||||
})
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("ID", "1", "Country", "RU", "City", "St.Petersburg", "SSD", "0"),
|
||||
nodeInfoFromAttributes("ID", "2", "Country", "RU", "City", "St.Petersburg", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "3", "Country", "RU", "City", "Moscow", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "4", "Country", "RU", "City", "Moscow", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "5", "Country", "RU", "City", "St.Petersburg", "SSD", "1"),
|
||||
nodeInfoFromAttributes("ID", "6", "Continent", "NA", "City", "NewYork"),
|
||||
nodeInfoFromAttributes("ID", "7", "Continent", "AF", "City", "Cairo"),
|
||||
nodeInfoFromAttributes("ID", "8", "Continent", "AF", "City", "Cairo"),
|
||||
nodeInfoFromAttributes("ID", "9", "Continent", "SA", "City", "Lima"),
|
||||
nodeInfoFromAttributes("ID", "10", "Continent", "AF", "City", "Cairo"),
|
||||
nodeInfoFromAttributes("ID", "11", "Continent", "NA", "City", "NewYork"),
|
||||
nodeInfoFromAttributes("ID", "12", "Continent", "NA", "City", "LosAngeles"),
|
||||
nodeInfoFromAttributes("ID", "13", "Continent", "SA", "City", "Lima"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 2, len(v.Replicas()))
|
||||
require.Equal(t, 6, len(v.Flatten()))
|
||||
|
||||
require.Equal(t, 2, len(v.Replicas()[0]))
|
||||
ids := map[string]struct{}{}
|
||||
for _, ni := range v.Replicas()[0] {
|
||||
require.Equal(t, "RU", ni.Attribute("Country"))
|
||||
require.Equal(t, "St.Petersburg", ni.Attribute("City"))
|
||||
require.Equal(t, "1", ni.Attribute("SSD"))
|
||||
ids[ni.Attribute("ID")] = struct{}{}
|
||||
}
|
||||
require.Equal(t, len(v.Replicas()[0]), len(ids), "not all nodes we distinct")
|
||||
|
||||
require.Equal(t, 4, len(v.Replicas()[1])) // 2 cities * 2 HRWB
|
||||
ids = map[string]struct{}{}
|
||||
for _, ni := range v.Replicas()[1] {
|
||||
require.Contains(t, []string{"NA", "SA"}, ni.Attribute("Continent"))
|
||||
ids[ni.Attribute("ID")] = struct{}{}
|
||||
}
|
||||
require.Equal(t, len(v.Replicas()[1]), len(ids), "not all nodes we distinct")
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_LowerBound(t *testing.T) {
|
||||
p := newPlacementPolicy(
|
||||
2, // backup factor
|
||||
[]*Replica{
|
||||
newReplica(1, "X"),
|
||||
},
|
||||
[]*Selector{
|
||||
newSelector("X", "Country", ClauseSame, 2, "*"),
|
||||
},
|
||||
nil, // filters
|
||||
)
|
||||
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("ID", "1", "Country", "DE"),
|
||||
nodeInfoFromAttributes("ID", "2", "Country", "DE"),
|
||||
nodeInfoFromAttributes("ID", "3", "Country", "DE"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, 3, len(v.Flatten()))
|
||||
}
|
||||
|
||||
func TestIssue213(t *testing.T) {
|
||||
p := newPlacementPolicy(1,
|
||||
[]*Replica{
|
||||
newReplica(4, ""),
|
||||
},
|
||||
[]*Selector{
|
||||
newSelector("", "", ClauseDistinct, 4, "LOC_EU"),
|
||||
},
|
||||
[]*Filter{
|
||||
newFilter("LOC_EU", "Location", "Europe", OpEQ),
|
||||
})
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "Russia", "City", "Moscow"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "Russia", "City", "Saint-Petersburg"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "Sweden", "City", "Stockholm"),
|
||||
nodeInfoFromAttributes("Location", "Europe", "Country", "Finalnd", "City", "Helsinki"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
|
||||
v, err := nm.GetContainerNodes(p, nil)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 4, len(v.Flatten()))
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_ProcessSelectors(t *testing.T) {
|
||||
p := newPlacementPolicy(2, nil,
|
||||
[]*Selector{
|
||||
newSelector("SameRU", "City", ClauseSame, 2, "FromRU"),
|
||||
newSelector("DistinctRU", "City", ClauseDistinct, 2, "FromRU"),
|
||||
newSelector("Good", "Country", ClauseDistinct, 2, "Good"),
|
||||
newSelector("Main", "Country", ClauseDistinct, 3, "*"),
|
||||
},
|
||||
[]*Filter{
|
||||
newFilter("FromRU", "Country", "Russia", OpEQ),
|
||||
newFilter("Good", "Rating", "4", OpGE),
|
||||
})
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "1", "City", "SPB"),
|
||||
nodeInfoFromAttributes("Country", "Germany", "Rating", "5", "City", "Berlin"),
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "6", "City", "Moscow"),
|
||||
nodeInfoFromAttributes("Country", "France", "Rating", "4", "City", "Paris"),
|
||||
nodeInfoFromAttributes("Country", "France", "Rating", "1", "City", "Lyon"),
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "5", "City", "SPB"),
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "7", "City", "Moscow"),
|
||||
nodeInfoFromAttributes("Country", "Germany", "Rating", "3", "City", "Darmstadt"),
|
||||
nodeInfoFromAttributes("Country", "Germany", "Rating", "7", "City", "Frankfurt"),
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "9", "City", "SPB"),
|
||||
nodeInfoFromAttributes("Country", "Russia", "Rating", "9", "City", "SPB"),
|
||||
}
|
||||
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
c := NewContext(nm)
|
||||
c.setCBF(p.ContainerBackupFactor())
|
||||
require.NoError(t, c.processFilters(p))
|
||||
require.NoError(t, c.processSelectors(p))
|
||||
|
||||
for _, s := range p.Selectors() {
|
||||
sel := c.Selections[s.Name()]
|
||||
s := c.Selectors[s.Name()]
|
||||
bucketCount, nodesInBucket := GetNodesCount(p, s)
|
||||
nodesInBucket *= int(c.cbf)
|
||||
targ := fmt.Sprintf("selector '%s'", s.Name())
|
||||
require.Equal(t, bucketCount, len(sel), targ)
|
||||
for _, res := range sel {
|
||||
require.Equal(t, nodesInBucket, len(res), targ)
|
||||
for j := range res {
|
||||
require.True(t, c.applyFilter(s.Filter(), res[j]), targ)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_ProcessSelectorsHRW(t *testing.T) {
|
||||
p := newPlacementPolicy(1, nil,
|
||||
[]*Selector{
|
||||
newSelector("Main", "Country", ClauseDistinct, 3, "*"),
|
||||
}, nil)
|
||||
|
||||
// bucket weight order: RU > DE > FR
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("Country", "Germany", AttrPrice, "2", AttrCapacity, "10000"),
|
||||
nodeInfoFromAttributes("Country", "Germany", AttrPrice, "4", AttrCapacity, "1"),
|
||||
nodeInfoFromAttributes("Country", "France", AttrPrice, "3", AttrCapacity, "10"),
|
||||
nodeInfoFromAttributes("Country", "Russia", AttrPrice, "2", AttrCapacity, "10000"),
|
||||
nodeInfoFromAttributes("Country", "Russia", AttrPrice, "1", AttrCapacity, "10000"),
|
||||
nodeInfoFromAttributes("Country", "Russia", AttrCapacity, "10000"),
|
||||
nodeInfoFromAttributes("Country", "France", AttrPrice, "100", AttrCapacity, "1"),
|
||||
nodeInfoFromAttributes("Country", "France", AttrPrice, "7", AttrCapacity, "10000"),
|
||||
nodeInfoFromAttributes("Country", "Russia", AttrPrice, "2", AttrCapacity, "1"),
|
||||
}
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
c := NewContext(nm)
|
||||
c.setPivot([]byte("containerID"))
|
||||
c.setCBF(p.ContainerBackupFactor())
|
||||
c.weightFunc = newWeightFunc(newMaxNorm(10000), newReverseMinNorm(1))
|
||||
c.aggregator = func() aggregator {
|
||||
return new(maxAgg)
|
||||
}
|
||||
|
||||
require.NoError(t, c.processFilters(p))
|
||||
require.NoError(t, c.processSelectors(p))
|
||||
|
||||
cnt := c.Selections["Main"]
|
||||
expected := []Nodes{
|
||||
{{Index: 4, Capacity: 10000, Price: 1}}, // best RU
|
||||
{{Index: 0, Capacity: 10000, Price: 2}}, // best DE
|
||||
{{Index: 7, Capacity: 10000, Price: 7}}, // best FR
|
||||
}
|
||||
require.Equal(t, len(expected), len(cnt))
|
||||
for i := range expected {
|
||||
require.Equal(t, len(expected[i]), len(cnt[i]))
|
||||
require.Equal(t, expected[i][0].Index, cnt[i][0].Index)
|
||||
require.Equal(t, expected[i][0].Capacity, cnt[i][0].Capacity)
|
||||
require.Equal(t, expected[i][0].Price, cnt[i][0].Price)
|
||||
}
|
||||
|
||||
res, err := nm.GetPlacementVectors(containerNodes(cnt), []byte("objectID"))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, res, cnt)
|
||||
}
|
||||
|
||||
func newMaxNorm(max float64) normalizer {
|
||||
return &maxNorm{max: max}
|
||||
}
|
||||
|
||||
func TestPlacementPolicy_ProcessSelectorsInvalid(t *testing.T) {
|
||||
testCases := []struct {
|
||||
name string
|
||||
p *PlacementPolicy
|
||||
err error
|
||||
}{
|
||||
{
|
||||
"MissingSelector",
|
||||
newPlacementPolicy(2, nil,
|
||||
[]*Selector{nil},
|
||||
[]*Filter{}),
|
||||
ErrMissingField,
|
||||
},
|
||||
{
|
||||
"InvalidFilterReference",
|
||||
newPlacementPolicy(1, nil,
|
||||
[]*Selector{newSelector("MyStore", "Country", ClauseDistinct, 1, "FromNL")},
|
||||
[]*Filter{newFilter("FromRU", "Country", "Russia", OpEQ)}),
|
||||
ErrFilterNotFound,
|
||||
},
|
||||
{
|
||||
"NotEnoughNodes (backup factor)",
|
||||
newPlacementPolicy(2, nil,
|
||||
[]*Selector{newSelector("MyStore", "Country", ClauseDistinct, 2, "FromRU")},
|
||||
[]*Filter{newFilter("FromRU", "Country", "Russia", OpEQ)}),
|
||||
ErrNotEnoughNodes,
|
||||
},
|
||||
{
|
||||
"NotEnoughNodes (buckets)",
|
||||
newPlacementPolicy(1, nil,
|
||||
[]*Selector{newSelector("MyStore", "Country", ClauseDistinct, 2, "FromRU")},
|
||||
[]*Filter{newFilter("FromRU", "Country", "Russia", OpEQ)}),
|
||||
ErrNotEnoughNodes,
|
||||
},
|
||||
}
|
||||
nodes := []NodeInfo{
|
||||
nodeInfoFromAttributes("Country", "Russia"),
|
||||
nodeInfoFromAttributes("Country", "Germany"),
|
||||
nodeInfoFromAttributes(),
|
||||
}
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
nm, err := NewNetmap(NodesFromInfo(nodes))
|
||||
require.NoError(t, err)
|
||||
c := NewContext(nm)
|
||||
c.setCBF(tc.p.ContainerBackupFactor())
|
||||
require.NoError(t, c.processFilters(tc.p))
|
||||
|
||||
err = c.processSelectors(tc.p)
|
||||
require.True(t, errors.Is(err, tc.err), "got: %v", err)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func testSelector() *Selector {
|
||||
s := new(Selector)
|
||||
s.SetName("name")
|
||||
s.SetCount(3)
|
||||
s.SetFilter("filter")
|
||||
s.SetAttribute("attribute")
|
||||
s.SetClause(ClauseDistinct)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
func TestSelector_Name(t *testing.T) {
|
||||
s := NewSelector()
|
||||
name := "some name"
|
||||
|
||||
s.SetName(name)
|
||||
|
||||
require.Equal(t, name, s.Name())
|
||||
}
|
||||
|
||||
func TestSelector_Count(t *testing.T) {
|
||||
s := NewSelector()
|
||||
c := uint32(3)
|
||||
|
||||
s.SetCount(c)
|
||||
|
||||
require.Equal(t, c, s.Count())
|
||||
}
|
||||
|
||||
func TestSelector_Clause(t *testing.T) {
|
||||
s := NewSelector()
|
||||
c := ClauseSame
|
||||
|
||||
s.SetClause(c)
|
||||
|
||||
require.Equal(t, c, s.Clause())
|
||||
}
|
||||
|
||||
func TestSelector_Attribute(t *testing.T) {
|
||||
s := NewSelector()
|
||||
a := "some attribute"
|
||||
|
||||
s.SetAttribute(a)
|
||||
|
||||
require.Equal(t, a, s.Attribute())
|
||||
}
|
||||
|
||||
func TestSelector_Filter(t *testing.T) {
|
||||
s := NewSelector()
|
||||
f := "some filter"
|
||||
|
||||
s.SetFilter(f)
|
||||
|
||||
require.Equal(t, f, s.Filter())
|
||||
}
|
||||
|
||||
func TestSelectorEncoding(t *testing.T) {
|
||||
s := newSelector("name", "atte", ClauseSame, 1, "filter")
|
||||
|
||||
t.Run("binary", func(t *testing.T) {
|
||||
data, err := s.Marshal()
|
||||
require.NoError(t, err)
|
||||
|
||||
s2 := NewSelector()
|
||||
require.NoError(t, s2.Unmarshal(data))
|
||||
|
||||
require.Equal(t, s, s2)
|
||||
})
|
||||
|
||||
t.Run("json", func(t *testing.T) {
|
||||
data, err := s.MarshalJSON()
|
||||
require.NoError(t, err)
|
||||
|
||||
s2 := NewSelector()
|
||||
require.NoError(t, s2.UnmarshalJSON(data))
|
||||
|
||||
require.Equal(t, s, s2)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSelector_ToV2(t *testing.T) {
|
||||
t.Run("nil", func(t *testing.T) {
|
||||
var x *Selector
|
||||
|
||||
require.Nil(t, x.ToV2())
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewSelectorFromV2(t *testing.T) {
|
||||
t.Run("from nil", func(t *testing.T) {
|
||||
var x *netmap.Selector
|
||||
|
||||
require.Nil(t, NewSelectorFromV2(x))
|
||||
})
|
||||
|
||||
t.Run("from non-nil", func(t *testing.T) {
|
||||
sV2 := testv2.GenerateSelector(false)
|
||||
|
||||
s := NewSelectorFromV2(sV2)
|
||||
|
||||
require.Equal(t, sV2, s.ToV2())
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewSelector(t *testing.T) {
|
||||
t.Run("default values", func(t *testing.T) {
|
||||
s := NewSelector()
|
||||
|
||||
// check initial values
|
||||
require.Zero(t, s.Count())
|
||||
require.Equal(t, ClauseUnspecified, s.Clause())
|
||||
require.Empty(t, s.Attribute())
|
||||
require.Empty(t, s.Name())
|
||||
require.Empty(t, s.Filter())
|
||||
|
||||
// convert to v2 message
|
||||
sV2 := s.ToV2()
|
||||
|
||||
require.Zero(t, sV2.GetCount())
|
||||
require.Equal(t, netmap.UnspecifiedClause, sV2.GetClause())
|
||||
require.Empty(t, sV2.GetAttribute())
|
||||
require.Empty(t, sV2.GetName())
|
||||
require.Empty(t, sV2.GetFilter())
|
||||
})
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue