func TestByteValidation(t *testing.T) {
cases := []VersionCaseB{
VersionCaseB{"foo.bar", Legacy, Strict, true},
VersionCaseB{"foo.bar", Legacy, Medium, true},
VersionCaseB{"foo.bar", Legacy, None, true},
VersionCaseB{"foo..bar", Legacy, Strict, false},
VersionCaseB{"foo..bar", Legacy, Medium, true},
VersionCaseB{"foo..bar", Legacy, None, true},
VersionCaseB{"foo..bar.ba::z", Legacy, Strict, false},
VersionCaseB{"foo..bar.ba::z", Legacy, Medium, true},
VersionCaseB{"foo..bar.ba::z", Legacy, None, true},
VersionCaseB{"foo..bar.b\xbdz", Legacy, Strict, false},
VersionCaseB{"foo..bar.b\xbdz", Legacy, Medium, false},
VersionCaseB{"foo..bar.b\xbdz", Legacy, None, true},
VersionCaseB{"foo..bar.b\x00z", Legacy, Strict, false},
VersionCaseB{"foo..bar.b\x00z", Legacy, Medium, false},
VersionCaseB{"foo..bar.b\x00z", Legacy, None, true},
VersionCaseB{"foo.bar.aunit=no.baz", M20, Strict, false},
VersionCaseB{"foo.bar.UNIT=no.baz", M20, Strict, false},
VersionCaseB{"foo.bar.unita=no.bar", M20, None, false},
VersionCaseB{"foo.bar.target_type_is_count.baz", M20NoEquals, Medium, false},
VersionCaseB{"foo.bar.target_type_is_count", M20NoEquals, None, false},
VersionCaseB{"target_type_is_count.foo.bar", M20NoEquals, Strict, false},
}
for _, c := range cases {
version := GetVersion(c.in)
assert.Equal(t, c.version, version)
assert.Equal(t, InitialValidationB([]byte(c.in), version, c.legacyValidation) == nil, c.valid)
}
}
func TestRateCountPckt(t *testing.T) {
cases := []Case{
Case{"foo.bar.unit=yes.baz", "foo.bar.unit=Pckt.baz.orig_unit=yes.pckt_type=sent.direction=in"},
Case{"foo.bar.unit=yes", "foo.bar.unit=Pckt.orig_unit=yes.pckt_type=sent.direction=in"},
Case{"unit=yes.foo.bar", "unit=Pckt.foo.bar.orig_unit=yes.pckt_type=sent.direction=in"},
Case{"target_type=count.foo.unit=ok.bar", "target_type=count.foo.unit=Pckt.bar.orig_unit=ok.pckt_type=sent.direction=in"},
}
for _, c := range cases {
assert.Equal(t, CountPckt(c.in, "prefix."), c.out)
c = Case{
c.in,
strings.Replace(strings.Replace(c.out, "unit=Pckt", "unit=Pcktps", -1), "target_type=count", "target_type=rate", -1),
}
assert.Equal(t, RatePckt(c.in, "prefix."), c.out)
}
for _, c := range cases {
c = Case{
strings.Replace(c.in, "=", "_is_", -1),
strings.Replace(c.out, "=", "_is_", -1),
}
assert.Equal(t, CountPckt(c.in, "prefix."), c.out)
c = Case{
c.in,
strings.Replace(strings.Replace(c.out, "unit_is_Pckt", "unit_is_Pcktps", -1), "target_type_is_count", "target_type_is_rate", -1),
}
assert.Equal(t, RatePckt(c.in, "prefix."), c.out)
}
}
func TestConsistentHashingDestinations(t *testing.T) {
initialDestinations := []*Destination{
&Destination{Addr: "10.0.0.1"},
&Destination{Addr: "127.0.0.1:2003", Instance: "a"},
&Destination{Addr: "127.0.0.1:2004", Instance: "b"}}
hasher := NewConsistentHasherReplicaCount(initialDestinations, 2)
expectedHashRing := hashRing{
hashRingEntry{Position: uint16(7885), Hostname: "127.0.0.1", Instance: "a", DestinationIndex: 1},
hashRingEntry{Position: uint16(10461), Hostname: "127.0.0.1", Instance: "b", DestinationIndex: 2},
hashRingEntry{Position: uint16(24043), Hostname: "127.0.0.1", Instance: "a", DestinationIndex: 1},
hashRingEntry{Position: uint16(35540), Hostname: "10.0.0.1", DestinationIndex: 0},
hashRingEntry{Position: uint16(46982), Hostname: "10.0.0.1", DestinationIndex: 0},
hashRingEntry{Position: uint16(54295), Hostname: "127.0.0.1", Instance: "b", DestinationIndex: 2}}
assert.Equal(t, expectedHashRing, hasher.Ring)
hasher.AddDestination(&Destination{Addr: "127.0.0.1", Instance: "c"})
hasher.AddDestination(&Destination{Addr: "10.0.0.2"})
expectedHashRing = hashRing{
hashRingEntry{Position: uint16(6639), Hostname: "10.0.0.2", DestinationIndex: 4},
hashRingEntry{Position: uint16(7885), Hostname: "127.0.0.1", Instance: "a", DestinationIndex: 1},
hashRingEntry{Position: uint16(10461), Hostname: "127.0.0.1", Instance: "b", DestinationIndex: 2},
hashRingEntry{Position: uint16(24043), Hostname: "127.0.0.1", Instance: "a", DestinationIndex: 1},
hashRingEntry{Position: uint16(24467), Hostname: "127.0.0.1", Instance: "c", DestinationIndex: 3},
hashRingEntry{Position: uint16(35540), Hostname: "10.0.0.1", DestinationIndex: 0},
hashRingEntry{Position: uint16(46982), Hostname: "10.0.0.1", DestinationIndex: 0},
hashRingEntry{Position: uint16(52177), Hostname: "10.0.0.2", DestinationIndex: 4},
hashRingEntry{Position: uint16(53472), Hostname: "127.0.0.1", Instance: "c", DestinationIndex: 3},
hashRingEntry{Position: uint16(54295), Hostname: "127.0.0.1", Instance: "b", DestinationIndex: 2}}
assert.Equal(t, expectedHashRing, hasher.Ring)
assert.Equal(t, 4, hasher.GetDestinationIndex([]byte("a.b.c.d")))
assert.Equal(t, 1, hasher.GetDestinationIndex([]byte("a.b.c..d")))
assert.Equal(t, 3, hasher.GetDestinationIndex([]byte("collectd.bar.memory.free")))
}
func TestValidate(t *testing.T) {
cases := []VersionCase{
VersionCase{"foo.bar.aunit=no.baz", M20, false},
VersionCase{"foo.bar.UNIT=no.baz", M20, false},
VersionCase{"foo.bar.unita=no.bar", M20, false},
VersionCase{"foo.bar.target_type_is_count.baz", M20NoEquals, false},
VersionCase{"foo.bar.target_type_is_count", M20NoEquals, false},
VersionCase{"target_type_is_count.foo.bar", M20NoEquals, false},
}
for _, c := range cases {
version := GetVersion(c.in)
assert.Equal(t, c.version, version)
assert.Equal(t, InitialValidation(c.in, version) == nil, c.valid)
}
}
// only 1 kind of stat is enough, cause they all behave the same
func TestStat(t *testing.T) {
cases := []Case{
Case{"foo.bar.unit=yes.baz", "foo.bar.unit=yes.baz.stat=max_90"},
Case{"foo.bar.unit=yes", "foo.bar.unit=yes.stat=max_90"},
Case{"unit=yes.foo.bar", "unit=yes.foo.bar.stat=max_90"},
Case{"target_type=count.foo.unit=ok.bar", "target_type=count.foo.unit=ok.bar.stat=max_90"},
}
for _, c := range cases {
assert.Equal(t, Max(c.in, "prefix.", "90", ""), c.out)
}
// same but with equals and no percentile
for i, c := range cases {
cases[i] = Case{
strings.Replace(c.in, "=", "_is_", -1),
strings.Replace(strings.Replace(c.out, "=", "_is_", -1), "max_90", "max", 1),
}
}
for _, c := range cases {
assert.Equal(t, Max(c.in, "prefix.", "", ""), c.out)
}
}
func TestDeriveCount(t *testing.T) {
// metrics 2.0 cases with equals
cases := []Case{
Case{"foo.bar.unit=yes.baz", "foo.bar.unit=yesps.baz"},
Case{"foo.bar.unit=yes", "foo.bar.unit=yesps"},
Case{"unit=yes.foo.bar", "unit=yesps.foo.bar"},
Case{"target_type=count.foo.unit=ok.bar", "target_type=rate.foo.unit=okps.bar"},
}
for _, c := range cases {
assert.Equal(t, DeriveCount(c.in, "prefix."), c.out)
}
// same but with equals
for i, c := range cases {
cases[i] = Case{
strings.Replace(c.in, "=", "_is_", -1),
strings.Replace(c.out, "=", "_is_", -1),
}
}
for _, c := range cases {
assert.Equal(t, DeriveCount(c.in, "prefix."), c.out)
}
}
func TestConsistentHashingComputeRingPosition(t *testing.T) {
assert.Equal(t, uint16(54437), computeRingPosition([]byte("a.b.c.d")))
assert.Equal(t, uint16(54301), computeRingPosition([]byte("")))
}