Freshgomod (#106)
* initial go modules, fresh start to find breaking change * change dep to go mod vendor * main go modules done, tests passed locally * upgrade go in dockerfileserver
This commit is contained in:
Amrit K Kandola
committed by
GitHub Enterprise
GitHub Enterprise
parent
a2940a4ba8
commit
678a62f152
118
vendor/github.com/prometheus/common/model/alert_test.go
generated
vendored
118
vendor/github.com/prometheus/common/model/alert_test.go
generated
vendored
@@ -1,118 +0,0 @@
|
||||
// Copyright 2013 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestAlertValidate(t *testing.T) {
|
||||
ts := time.Now()
|
||||
|
||||
var cases = []struct {
|
||||
alert *Alert
|
||||
err string
|
||||
}{
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
StartsAt: ts,
|
||||
},
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
},
|
||||
err: "start time missing",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
},
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts.Add(1 * time.Minute),
|
||||
},
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts.Add(-1 * time.Minute),
|
||||
},
|
||||
err: "start time must be before end time",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
StartsAt: ts,
|
||||
},
|
||||
err: "at least one label pair required",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b", "!bad": "label"},
|
||||
StartsAt: ts,
|
||||
},
|
||||
err: "invalid label set: invalid name",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b", "bad": "\xfflabel"},
|
||||
StartsAt: ts,
|
||||
},
|
||||
err: "invalid label set: invalid value",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
Annotations: LabelSet{"!bad": "label"},
|
||||
StartsAt: ts,
|
||||
},
|
||||
err: "invalid annotations: invalid name",
|
||||
},
|
||||
{
|
||||
alert: &Alert{
|
||||
Labels: LabelSet{"a": "b"},
|
||||
Annotations: LabelSet{"bad": "\xfflabel"},
|
||||
StartsAt: ts,
|
||||
},
|
||||
err: "invalid annotations: invalid value",
|
||||
},
|
||||
}
|
||||
|
||||
for i, c := range cases {
|
||||
err := c.alert.Validate()
|
||||
if err == nil {
|
||||
if c.err == "" {
|
||||
continue
|
||||
}
|
||||
t.Errorf("%d. Expected error %q but got none", i, c.err)
|
||||
continue
|
||||
}
|
||||
if c.err == "" && err != nil {
|
||||
t.Errorf("%d. Expected no error but got %q", i, err)
|
||||
continue
|
||||
}
|
||||
if !strings.Contains(err.Error(), c.err) {
|
||||
t.Errorf("%d. Expected error to contain %q but got %q", i, c.err, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
2
vendor/github.com/prometheus/common/model/fnv.go
generated
vendored
2
vendor/github.com/prometheus/common/model/fnv.go
generated
vendored
@@ -20,7 +20,7 @@ const (
|
||||
prime64 = 1099511628211
|
||||
)
|
||||
|
||||
// hashNew initializies a new fnv64a hash value.
|
||||
// hashNew initializes a new fnv64a hash value.
|
||||
func hashNew() uint64 {
|
||||
return offset64
|
||||
}
|
||||
|
||||
140
vendor/github.com/prometheus/common/model/labels_test.go
generated
vendored
140
vendor/github.com/prometheus/common/model/labels_test.go
generated
vendored
@@ -1,140 +0,0 @@
|
||||
// Copyright 2013 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"sort"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func testLabelNames(t testing.TB) {
|
||||
var scenarios = []struct {
|
||||
in LabelNames
|
||||
out LabelNames
|
||||
}{
|
||||
{
|
||||
in: LabelNames{"ZZZ", "zzz"},
|
||||
out: LabelNames{"ZZZ", "zzz"},
|
||||
},
|
||||
{
|
||||
in: LabelNames{"aaa", "AAA"},
|
||||
out: LabelNames{"AAA", "aaa"},
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
sort.Sort(scenario.in)
|
||||
|
||||
for j, expected := range scenario.out {
|
||||
if expected != scenario.in[j] {
|
||||
t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLabelNames(t *testing.T) {
|
||||
testLabelNames(t)
|
||||
}
|
||||
|
||||
func BenchmarkLabelNames(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
testLabelNames(b)
|
||||
}
|
||||
}
|
||||
|
||||
func testLabelValues(t testing.TB) {
|
||||
var scenarios = []struct {
|
||||
in LabelValues
|
||||
out LabelValues
|
||||
}{
|
||||
{
|
||||
in: LabelValues{"ZZZ", "zzz"},
|
||||
out: LabelValues{"ZZZ", "zzz"},
|
||||
},
|
||||
{
|
||||
in: LabelValues{"aaa", "AAA"},
|
||||
out: LabelValues{"AAA", "aaa"},
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
sort.Sort(scenario.in)
|
||||
|
||||
for j, expected := range scenario.out {
|
||||
if expected != scenario.in[j] {
|
||||
t.Errorf("%d.%d expected %s, got %s", i, j, expected, scenario.in[j])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLabelValues(t *testing.T) {
|
||||
testLabelValues(t)
|
||||
}
|
||||
|
||||
func BenchmarkLabelValues(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
testLabelValues(b)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLabelNameIsValid(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
ln LabelName
|
||||
valid bool
|
||||
}{
|
||||
{
|
||||
ln: "Avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
ln: "_Avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
ln: "1valid_23name",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
ln: "avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
ln: "Ava:lid_23name",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
ln: "a lid_23name",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
ln: ":leading_colon",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
ln: "colon:in:the:middle",
|
||||
valid: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, s := range scenarios {
|
||||
if s.ln.IsValid() != s.valid {
|
||||
t.Errorf("Expected %v for %q using IsValid method", s.valid, s.ln)
|
||||
}
|
||||
if LabelNameRE.MatchString(string(s.ln)) != s.valid {
|
||||
t.Errorf("Expected %v for %q using regexp match", s.valid, s.ln)
|
||||
}
|
||||
}
|
||||
}
|
||||
1
vendor/github.com/prometheus/common/model/metric.go
generated
vendored
1
vendor/github.com/prometheus/common/model/metric.go
generated
vendored
@@ -21,7 +21,6 @@ import (
|
||||
)
|
||||
|
||||
var (
|
||||
separator = []byte{0}
|
||||
// MetricNameRE is a regular expression matching valid metric
|
||||
// names. Note that the IsValidMetricName function performs the same
|
||||
// check but faster than a match with this regular expression.
|
||||
|
||||
132
vendor/github.com/prometheus/common/model/metric_test.go
generated
vendored
132
vendor/github.com/prometheus/common/model/metric_test.go
generated
vendored
@@ -1,132 +0,0 @@
|
||||
// Copyright 2013 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import "testing"
|
||||
|
||||
func testMetric(t testing.TB) {
|
||||
var scenarios = []struct {
|
||||
input LabelSet
|
||||
fingerprint Fingerprint
|
||||
fastFingerprint Fingerprint
|
||||
}{
|
||||
{
|
||||
input: LabelSet{},
|
||||
fingerprint: 14695981039346656037,
|
||||
fastFingerprint: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
input: LabelSet{
|
||||
"first_name": "electro",
|
||||
"occupation": "robot",
|
||||
"manufacturer": "westinghouse",
|
||||
},
|
||||
fingerprint: 5911716720268894962,
|
||||
fastFingerprint: 11310079640881077873,
|
||||
},
|
||||
{
|
||||
input: LabelSet{
|
||||
"x": "y",
|
||||
},
|
||||
fingerprint: 8241431561484471700,
|
||||
fastFingerprint: 13948396922932177635,
|
||||
},
|
||||
{
|
||||
input: LabelSet{
|
||||
"a": "bb",
|
||||
"b": "c",
|
||||
},
|
||||
fingerprint: 3016285359649981711,
|
||||
fastFingerprint: 3198632812309449502,
|
||||
},
|
||||
{
|
||||
input: LabelSet{
|
||||
"a": "b",
|
||||
"bb": "c",
|
||||
},
|
||||
fingerprint: 7122421792099404749,
|
||||
fastFingerprint: 5774953389407657638,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
input := Metric(scenario.input)
|
||||
|
||||
if scenario.fingerprint != input.Fingerprint() {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.fingerprint, input.Fingerprint())
|
||||
}
|
||||
if scenario.fastFingerprint != input.FastFingerprint() {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.fastFingerprint, input.FastFingerprint())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetric(t *testing.T) {
|
||||
testMetric(t)
|
||||
}
|
||||
|
||||
func BenchmarkMetric(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
testMetric(b)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetricNameIsValid(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
mn LabelValue
|
||||
valid bool
|
||||
}{
|
||||
{
|
||||
mn: "Avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
mn: "_Avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
mn: "1valid_23name",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
mn: "avalid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
mn: "Ava:lid_23name",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
mn: "a lid_23name",
|
||||
valid: false,
|
||||
},
|
||||
{
|
||||
mn: ":leading_colon",
|
||||
valid: true,
|
||||
},
|
||||
{
|
||||
mn: "colon:in:the:middle",
|
||||
valid: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, s := range scenarios {
|
||||
if IsValidMetricName(s.mn) != s.valid {
|
||||
t.Errorf("Expected %v for %q using IsValidMetricName function", s.valid, s.mn)
|
||||
}
|
||||
if MetricNameRE.MatchString(string(s.mn)) != s.valid {
|
||||
t.Errorf("Expected %v for %q using regexp matching", s.valid, s.mn)
|
||||
}
|
||||
}
|
||||
}
|
||||
314
vendor/github.com/prometheus/common/model/signature_test.go
generated
vendored
314
vendor/github.com/prometheus/common/model/signature_test.go
generated
vendored
@@ -1,314 +0,0 @@
|
||||
// Copyright 2014 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"runtime"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLabelsToSignature(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
in map[string]string
|
||||
out uint64
|
||||
}{
|
||||
{
|
||||
in: map[string]string{},
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: map[string]string{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
actual := LabelsToSignature(scenario.in)
|
||||
|
||||
if actual != scenario.out {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetricToFingerprint(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
in LabelSet
|
||||
out Fingerprint
|
||||
}{
|
||||
{
|
||||
in: LabelSet{},
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: LabelSet{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
actual := labelSetToFingerprint(scenario.in)
|
||||
|
||||
if actual != scenario.out {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetricToFastFingerprint(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
in LabelSet
|
||||
out Fingerprint
|
||||
}{
|
||||
{
|
||||
in: LabelSet{},
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: LabelSet{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
out: 12952432476264840823,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
actual := labelSetToFastFingerprint(scenario.in)
|
||||
|
||||
if actual != scenario.out {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureForLabels(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
in Metric
|
||||
labels LabelNames
|
||||
out uint64
|
||||
}{
|
||||
{
|
||||
in: Metric{},
|
||||
labels: nil,
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: Metric{},
|
||||
labels: LabelNames{"empty"},
|
||||
out: 7187873163539638612,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: LabelNames{"empty"},
|
||||
out: 7187873163539638612,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: LabelNames{"fear", "name"},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"},
|
||||
labels: LabelNames{"fear", "name"},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: LabelNames{},
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: nil,
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
actual := SignatureForLabels(scenario.in, scenario.labels...)
|
||||
|
||||
if actual != scenario.out {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureWithoutLabels(t *testing.T) {
|
||||
var scenarios = []struct {
|
||||
in Metric
|
||||
labels map[LabelName]struct{}
|
||||
out uint64
|
||||
}{
|
||||
{
|
||||
in: Metric{},
|
||||
labels: nil,
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: map[LabelName]struct{}{"fear": struct{}{}, "name": struct{}{}},
|
||||
out: 14695981039346656037,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough", "foo": "bar"},
|
||||
labels: map[LabelName]struct{}{"foo": struct{}{}},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: map[LabelName]struct{}{},
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
{
|
||||
in: Metric{"name": "garland, briggs", "fear": "love is not enough"},
|
||||
labels: nil,
|
||||
out: 5799056148416392346,
|
||||
},
|
||||
}
|
||||
|
||||
for i, scenario := range scenarios {
|
||||
actual := SignatureWithoutLabels(scenario.in, scenario.labels)
|
||||
|
||||
if actual != scenario.out {
|
||||
t.Errorf("%d. expected %d, got %d", i, scenario.out, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkLabelToSignature(b *testing.B, l map[string]string, e uint64) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
if a := LabelsToSignature(l); a != e {
|
||||
b.Fatalf("expected signature of %d for %s, got %d", e, l, a)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkLabelToSignatureScalar(b *testing.B) {
|
||||
benchmarkLabelToSignature(b, nil, 14695981039346656037)
|
||||
}
|
||||
|
||||
func BenchmarkLabelToSignatureSingle(b *testing.B) {
|
||||
benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value"}, 5146282821936882169)
|
||||
}
|
||||
|
||||
func BenchmarkLabelToSignatureDouble(b *testing.B) {
|
||||
benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717)
|
||||
}
|
||||
|
||||
func BenchmarkLabelToSignatureTriple(b *testing.B) {
|
||||
benchmarkLabelToSignature(b, map[string]string{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121)
|
||||
}
|
||||
|
||||
func benchmarkMetricToFingerprint(b *testing.B, ls LabelSet, e Fingerprint) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
if a := labelSetToFingerprint(ls); a != e {
|
||||
b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFingerprintScalar(b *testing.B) {
|
||||
benchmarkMetricToFingerprint(b, nil, 14695981039346656037)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFingerprintSingle(b *testing.B) {
|
||||
benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5146282821936882169)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFingerprintDouble(b *testing.B) {
|
||||
benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 3195800080984914717)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFingerprintTriple(b *testing.B) {
|
||||
benchmarkMetricToFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 13843036195897128121)
|
||||
}
|
||||
|
||||
func benchmarkMetricToFastFingerprint(b *testing.B, ls LabelSet, e Fingerprint) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
if a := labelSetToFastFingerprint(ls); a != e {
|
||||
b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintScalar(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprint(b, nil, 14695981039346656037)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintSingle(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value"}, 5147259542624943964)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintDouble(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value"}, 18269973311206963528)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintTriple(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprint(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676)
|
||||
}
|
||||
|
||||
func BenchmarkEmptyLabelSignature(b *testing.B) {
|
||||
input := []map[string]string{nil, {}}
|
||||
|
||||
var ms runtime.MemStats
|
||||
runtime.ReadMemStats(&ms)
|
||||
|
||||
alloc := ms.Alloc
|
||||
|
||||
for _, labels := range input {
|
||||
LabelsToSignature(labels)
|
||||
}
|
||||
|
||||
runtime.ReadMemStats(&ms)
|
||||
|
||||
if got := ms.Alloc; alloc != got {
|
||||
b.Fatal("expected LabelsToSignature with empty labels not to perform allocations")
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkMetricToFastFingerprintConc(b *testing.B, ls LabelSet, e Fingerprint, concLevel int) {
|
||||
var start, end sync.WaitGroup
|
||||
start.Add(1)
|
||||
end.Add(concLevel)
|
||||
|
||||
for i := 0; i < concLevel; i++ {
|
||||
go func() {
|
||||
start.Wait()
|
||||
for j := b.N / concLevel; j >= 0; j-- {
|
||||
if a := labelSetToFastFingerprint(ls); a != e {
|
||||
b.Fatalf("expected signature of %d for %s, got %d", e, ls, a)
|
||||
}
|
||||
}
|
||||
end.Done()
|
||||
}()
|
||||
}
|
||||
b.ResetTimer()
|
||||
start.Done()
|
||||
end.Wait()
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintTripleConc1(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 1)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintTripleConc2(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 2)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintTripleConc4(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 4)
|
||||
}
|
||||
|
||||
func BenchmarkMetricToFastFingerprintTripleConc8(b *testing.B) {
|
||||
benchmarkMetricToFastFingerprintConc(b, LabelSet{"first-label": "first-label-value", "second-label": "second-label-value", "third-label": "third-label-value"}, 15738406913934009676, 8)
|
||||
}
|
||||
228
vendor/github.com/prometheus/common/model/silence_test.go
generated
vendored
228
vendor/github.com/prometheus/common/model/silence_test.go
generated
vendored
@@ -1,228 +0,0 @@
|
||||
// Copyright 2015 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestMatcherValidate(t *testing.T) {
|
||||
var cases = []struct {
|
||||
matcher *Matcher
|
||||
err string
|
||||
}{
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "name",
|
||||
Value: "value",
|
||||
},
|
||||
},
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "name",
|
||||
Value: "value",
|
||||
IsRegex: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "name!",
|
||||
Value: "value",
|
||||
},
|
||||
err: "invalid name",
|
||||
},
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "",
|
||||
Value: "value",
|
||||
},
|
||||
err: "invalid name",
|
||||
},
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "name",
|
||||
Value: "value\xff",
|
||||
},
|
||||
err: "invalid value",
|
||||
},
|
||||
{
|
||||
matcher: &Matcher{
|
||||
Name: "name",
|
||||
Value: "",
|
||||
},
|
||||
err: "invalid value",
|
||||
},
|
||||
}
|
||||
|
||||
for i, c := range cases {
|
||||
err := c.matcher.Validate()
|
||||
if err == nil {
|
||||
if c.err == "" {
|
||||
continue
|
||||
}
|
||||
t.Errorf("%d. Expected error %q but got none", i, c.err)
|
||||
continue
|
||||
}
|
||||
if c.err == "" && err != nil {
|
||||
t.Errorf("%d. Expected no error but got %q", i, err)
|
||||
continue
|
||||
}
|
||||
if !strings.Contains(err.Error(), c.err) {
|
||||
t.Errorf("%d. Expected error to contain %q but got %q", i, c.err, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSilenceValidate(t *testing.T) {
|
||||
ts := time.Now()
|
||||
|
||||
var cases = []struct {
|
||||
sil *Silence
|
||||
err string
|
||||
}{
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
{Name: "name", Value: "value"},
|
||||
{Name: "name", Value: "value"},
|
||||
{Name: "name", Value: "value", IsRegex: true},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts.Add(-1 * time.Minute),
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "start time must be before end time",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "end time missing",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "start time missing",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "!name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "invalid matcher",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
CreatedBy: "name",
|
||||
},
|
||||
err: "comment missing",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedBy: "name",
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "creation timestamp missing",
|
||||
},
|
||||
{
|
||||
sil: &Silence{
|
||||
Matchers: []*Matcher{
|
||||
{Name: "name", Value: "value"},
|
||||
},
|
||||
StartsAt: ts,
|
||||
EndsAt: ts,
|
||||
CreatedAt: ts,
|
||||
Comment: "comment",
|
||||
},
|
||||
err: "creator information missing",
|
||||
},
|
||||
}
|
||||
|
||||
for i, c := range cases {
|
||||
err := c.sil.Validate()
|
||||
if err == nil {
|
||||
if c.err == "" {
|
||||
continue
|
||||
}
|
||||
t.Errorf("%d. Expected error %q but got none", i, c.err)
|
||||
continue
|
||||
}
|
||||
if c.err == "" && err != nil {
|
||||
t.Errorf("%d. Expected no error but got %q", i, err)
|
||||
continue
|
||||
}
|
||||
if !strings.Contains(err.Error(), c.err) {
|
||||
t.Errorf("%d. Expected error to contain %q but got %q", i, c.err, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
110
vendor/github.com/prometheus/common/model/time.go
generated
vendored
110
vendor/github.com/prometheus/common/model/time.go
generated
vendored
@@ -43,7 +43,7 @@ const (
|
||||
// (1970-01-01 00:00 UTC) excluding leap seconds.
|
||||
type Time int64
|
||||
|
||||
// Interval describes and interval between two timestamps.
|
||||
// Interval describes an interval between two timestamps.
|
||||
type Interval struct {
|
||||
Start, End Time
|
||||
}
|
||||
@@ -150,7 +150,13 @@ func (t *Time) UnmarshalJSON(b []byte) error {
|
||||
return err
|
||||
}
|
||||
|
||||
*t = Time(v + va)
|
||||
// If the value was something like -0.1 the negative is lost in the
|
||||
// parsing because of the leading zero, this ensures that we capture it.
|
||||
if len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 {
|
||||
*t = Time(v+va) * -1
|
||||
} else {
|
||||
*t = Time(v + va)
|
||||
}
|
||||
|
||||
default:
|
||||
return fmt.Errorf("invalid time %q", string(b))
|
||||
@@ -175,73 +181,77 @@ func (d *Duration) Type() string {
|
||||
return "duration"
|
||||
}
|
||||
|
||||
var durationRE = regexp.MustCompile("^([0-9]+)(y|w|d|h|m|s|ms)$")
|
||||
var durationRE = regexp.MustCompile("^(([0-9]+)y)?(([0-9]+)w)?(([0-9]+)d)?(([0-9]+)h)?(([0-9]+)m)?(([0-9]+)s)?(([0-9]+)ms)?$")
|
||||
|
||||
// ParseDuration parses a string into a time.Duration, assuming that a year
|
||||
// always has 365d, a week always has 7d, and a day always has 24h.
|
||||
func ParseDuration(durationStr string) (Duration, error) {
|
||||
switch durationStr {
|
||||
case "0":
|
||||
// Allow 0 without a unit.
|
||||
return 0, nil
|
||||
case "":
|
||||
return 0, fmt.Errorf("empty duration string")
|
||||
}
|
||||
matches := durationRE.FindStringSubmatch(durationStr)
|
||||
if len(matches) != 3 {
|
||||
if matches == nil {
|
||||
return 0, fmt.Errorf("not a valid duration string: %q", durationStr)
|
||||
}
|
||||
var (
|
||||
n, _ = strconv.Atoi(matches[1])
|
||||
dur = time.Duration(n) * time.Millisecond
|
||||
)
|
||||
switch unit := matches[2]; unit {
|
||||
case "y":
|
||||
dur *= 1000 * 60 * 60 * 24 * 365
|
||||
case "w":
|
||||
dur *= 1000 * 60 * 60 * 24 * 7
|
||||
case "d":
|
||||
dur *= 1000 * 60 * 60 * 24
|
||||
case "h":
|
||||
dur *= 1000 * 60 * 60
|
||||
case "m":
|
||||
dur *= 1000 * 60
|
||||
case "s":
|
||||
dur *= 1000
|
||||
case "ms":
|
||||
// Value already correct
|
||||
default:
|
||||
return 0, fmt.Errorf("invalid time unit in duration string: %q", unit)
|
||||
var dur time.Duration
|
||||
|
||||
// Parse the match at pos `pos` in the regex and use `mult` to turn that
|
||||
// into ms, then add that value to the total parsed duration.
|
||||
m := func(pos int, mult time.Duration) {
|
||||
if matches[pos] == "" {
|
||||
return
|
||||
}
|
||||
n, _ := strconv.Atoi(matches[pos])
|
||||
d := time.Duration(n) * time.Millisecond
|
||||
dur += d * mult
|
||||
}
|
||||
|
||||
m(2, 1000*60*60*24*365) // y
|
||||
m(4, 1000*60*60*24*7) // w
|
||||
m(6, 1000*60*60*24) // d
|
||||
m(8, 1000*60*60) // h
|
||||
m(10, 1000*60) // m
|
||||
m(12, 1000) // s
|
||||
m(14, 1) // ms
|
||||
|
||||
return Duration(dur), nil
|
||||
}
|
||||
|
||||
func (d Duration) String() string {
|
||||
var (
|
||||
ms = int64(time.Duration(d) / time.Millisecond)
|
||||
unit = "ms"
|
||||
ms = int64(time.Duration(d) / time.Millisecond)
|
||||
r = ""
|
||||
)
|
||||
if ms == 0 {
|
||||
return "0s"
|
||||
}
|
||||
factors := map[string]int64{
|
||||
"y": 1000 * 60 * 60 * 24 * 365,
|
||||
"w": 1000 * 60 * 60 * 24 * 7,
|
||||
"d": 1000 * 60 * 60 * 24,
|
||||
"h": 1000 * 60 * 60,
|
||||
"m": 1000 * 60,
|
||||
"s": 1000,
|
||||
"ms": 1,
|
||||
|
||||
f := func(unit string, mult int64, exact bool) {
|
||||
if exact && ms%mult != 0 {
|
||||
return
|
||||
}
|
||||
if v := ms / mult; v > 0 {
|
||||
r += fmt.Sprintf("%d%s", v, unit)
|
||||
ms -= v * mult
|
||||
}
|
||||
}
|
||||
|
||||
switch int64(0) {
|
||||
case ms % factors["y"]:
|
||||
unit = "y"
|
||||
case ms % factors["w"]:
|
||||
unit = "w"
|
||||
case ms % factors["d"]:
|
||||
unit = "d"
|
||||
case ms % factors["h"]:
|
||||
unit = "h"
|
||||
case ms % factors["m"]:
|
||||
unit = "m"
|
||||
case ms % factors["s"]:
|
||||
unit = "s"
|
||||
}
|
||||
return fmt.Sprintf("%v%v", ms/factors[unit], unit)
|
||||
// Only format years and weeks if the remainder is zero, as it is often
|
||||
// easier to read 90d than 12w6d.
|
||||
f("y", 1000*60*60*24*365, true)
|
||||
f("w", 1000*60*60*24*7, true)
|
||||
|
||||
f("d", 1000*60*60*24, false)
|
||||
f("h", 1000*60*60, false)
|
||||
f("m", 1000*60, false)
|
||||
f("s", 1000, false)
|
||||
f("ms", 1, false)
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
// MarshalYAML implements the yaml.Marshaler interface.
|
||||
|
||||
132
vendor/github.com/prometheus/common/model/time_test.go
generated
vendored
132
vendor/github.com/prometheus/common/model/time_test.go
generated
vendored
@@ -1,132 +0,0 @@
|
||||
// Copyright 2013 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestComparators(t *testing.T) {
|
||||
t1a := TimeFromUnix(0)
|
||||
t1b := TimeFromUnix(0)
|
||||
t2 := TimeFromUnix(2*second - 1)
|
||||
|
||||
if !t1a.Equal(t1b) {
|
||||
t.Fatalf("Expected %s to be equal to %s", t1a, t1b)
|
||||
}
|
||||
if t1a.Equal(t2) {
|
||||
t.Fatalf("Expected %s to not be equal to %s", t1a, t2)
|
||||
}
|
||||
|
||||
if !t1a.Before(t2) {
|
||||
t.Fatalf("Expected %s to be before %s", t1a, t2)
|
||||
}
|
||||
if t1a.Before(t1b) {
|
||||
t.Fatalf("Expected %s to not be before %s", t1a, t1b)
|
||||
}
|
||||
|
||||
if !t2.After(t1a) {
|
||||
t.Fatalf("Expected %s to be after %s", t2, t1a)
|
||||
}
|
||||
if t1b.After(t1a) {
|
||||
t.Fatalf("Expected %s to not be after %s", t1b, t1a)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTimeConversions(t *testing.T) {
|
||||
unixSecs := int64(1136239445)
|
||||
unixNsecs := int64(123456789)
|
||||
unixNano := unixSecs*1e9 + unixNsecs
|
||||
|
||||
t1 := time.Unix(unixSecs, unixNsecs-unixNsecs%nanosPerTick)
|
||||
t2 := time.Unix(unixSecs, unixNsecs)
|
||||
|
||||
ts := TimeFromUnixNano(unixNano)
|
||||
if !ts.Time().Equal(t1) {
|
||||
t.Fatalf("Expected %s, got %s", t1, ts.Time())
|
||||
}
|
||||
|
||||
// Test available precision.
|
||||
ts = TimeFromUnixNano(t2.UnixNano())
|
||||
if !ts.Time().Equal(t1) {
|
||||
t.Fatalf("Expected %s, got %s", t1, ts.Time())
|
||||
}
|
||||
|
||||
if ts.UnixNano() != unixNano-unixNano%nanosPerTick {
|
||||
t.Fatalf("Expected %d, got %d", unixNano, ts.UnixNano())
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuration(t *testing.T) {
|
||||
duration := time.Second + time.Minute + time.Hour
|
||||
goTime := time.Unix(1136239445, 0)
|
||||
|
||||
ts := TimeFromUnix(goTime.Unix())
|
||||
if !goTime.Add(duration).Equal(ts.Add(duration).Time()) {
|
||||
t.Fatalf("Expected %s to be equal to %s", goTime.Add(duration), ts.Add(duration))
|
||||
}
|
||||
|
||||
earlier := ts.Add(-duration)
|
||||
delta := ts.Sub(earlier)
|
||||
if delta != duration {
|
||||
t.Fatalf("Expected %s to be equal to %s", delta, duration)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseDuration(t *testing.T) {
|
||||
var cases = []struct {
|
||||
in string
|
||||
out time.Duration
|
||||
}{
|
||||
{
|
||||
in: "0s",
|
||||
out: 0,
|
||||
}, {
|
||||
in: "324ms",
|
||||
out: 324 * time.Millisecond,
|
||||
}, {
|
||||
in: "3s",
|
||||
out: 3 * time.Second,
|
||||
}, {
|
||||
in: "5m",
|
||||
out: 5 * time.Minute,
|
||||
}, {
|
||||
in: "1h",
|
||||
out: time.Hour,
|
||||
}, {
|
||||
in: "4d",
|
||||
out: 4 * 24 * time.Hour,
|
||||
}, {
|
||||
in: "3w",
|
||||
out: 3 * 7 * 24 * time.Hour,
|
||||
}, {
|
||||
in: "10y",
|
||||
out: 10 * 365 * 24 * time.Hour,
|
||||
},
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
d, err := ParseDuration(c.in)
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error on input %q", c.in)
|
||||
}
|
||||
if time.Duration(d) != c.out {
|
||||
t.Errorf("Expected %v but got %v", c.out, d)
|
||||
}
|
||||
if d.String() != c.in {
|
||||
t.Errorf("Expected duration string %q but got %q", c.in, d.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
468
vendor/github.com/prometheus/common/model/value_test.go
generated
vendored
468
vendor/github.com/prometheus/common/model/value_test.go
generated
vendored
@@ -1,468 +0,0 @@
|
||||
// Copyright 2013 The Prometheus Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package model
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"math"
|
||||
"reflect"
|
||||
"sort"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestEqualValues(t *testing.T) {
|
||||
tests := map[string]struct {
|
||||
in1, in2 SampleValue
|
||||
want bool
|
||||
}{
|
||||
"equal floats": {
|
||||
in1: 3.14,
|
||||
in2: 3.14,
|
||||
want: true,
|
||||
},
|
||||
"unequal floats": {
|
||||
in1: 3.14,
|
||||
in2: 3.1415,
|
||||
want: false,
|
||||
},
|
||||
"positive inifinities": {
|
||||
in1: SampleValue(math.Inf(+1)),
|
||||
in2: SampleValue(math.Inf(+1)),
|
||||
want: true,
|
||||
},
|
||||
"negative inifinities": {
|
||||
in1: SampleValue(math.Inf(-1)),
|
||||
in2: SampleValue(math.Inf(-1)),
|
||||
want: true,
|
||||
},
|
||||
"different inifinities": {
|
||||
in1: SampleValue(math.Inf(+1)),
|
||||
in2: SampleValue(math.Inf(-1)),
|
||||
want: false,
|
||||
},
|
||||
"number and infinity": {
|
||||
in1: 42,
|
||||
in2: SampleValue(math.Inf(+1)),
|
||||
want: false,
|
||||
},
|
||||
"number and NaN": {
|
||||
in1: 42,
|
||||
in2: SampleValue(math.NaN()),
|
||||
want: false,
|
||||
},
|
||||
"NaNs": {
|
||||
in1: SampleValue(math.NaN()),
|
||||
in2: SampleValue(math.NaN()),
|
||||
want: true, // !!!
|
||||
},
|
||||
}
|
||||
|
||||
for name, test := range tests {
|
||||
got := test.in1.Equal(test.in2)
|
||||
if got != test.want {
|
||||
t.Errorf("Comparing %s, %f and %f: got %t, want %t", name, test.in1, test.in2, got, test.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEqualSamples(t *testing.T) {
|
||||
testSample := &Sample{}
|
||||
|
||||
tests := map[string]struct {
|
||||
in1, in2 *Sample
|
||||
want bool
|
||||
}{
|
||||
"equal pointers": {
|
||||
in1: testSample,
|
||||
in2: testSample,
|
||||
want: true,
|
||||
},
|
||||
"different metrics": {
|
||||
in1: &Sample{Metric: Metric{"foo": "bar"}},
|
||||
in2: &Sample{Metric: Metric{"foo": "biz"}},
|
||||
want: false,
|
||||
},
|
||||
"different timestamp": {
|
||||
in1: &Sample{Timestamp: 0},
|
||||
in2: &Sample{Timestamp: 1},
|
||||
want: false,
|
||||
},
|
||||
"different value": {
|
||||
in1: &Sample{Value: 0},
|
||||
in2: &Sample{Value: 1},
|
||||
want: false,
|
||||
},
|
||||
"equal samples": {
|
||||
in1: &Sample{
|
||||
Metric: Metric{"foo": "bar"},
|
||||
Timestamp: 0,
|
||||
Value: 1,
|
||||
},
|
||||
in2: &Sample{
|
||||
Metric: Metric{"foo": "bar"},
|
||||
Timestamp: 0,
|
||||
Value: 1,
|
||||
},
|
||||
want: true,
|
||||
},
|
||||
}
|
||||
|
||||
for name, test := range tests {
|
||||
got := test.in1.Equal(test.in2)
|
||||
if got != test.want {
|
||||
t.Errorf("Comparing %s, %v and %v: got %t, want %t", name, test.in1, test.in2, got, test.want)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestSamplePairJSON(t *testing.T) {
|
||||
input := []struct {
|
||||
plain string
|
||||
value SamplePair
|
||||
}{
|
||||
{
|
||||
plain: `[1234.567,"123.1"]`,
|
||||
value: SamplePair{
|
||||
Value: 123.1,
|
||||
Timestamp: 1234567,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range input {
|
||||
b, err := json.Marshal(test.value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if string(b) != test.plain {
|
||||
t.Errorf("encoding error: expected %q, got %q", test.plain, b)
|
||||
continue
|
||||
}
|
||||
|
||||
var sp SamplePair
|
||||
err = json.Unmarshal(b, &sp)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if sp != test.value {
|
||||
t.Errorf("decoding error: expected %v, got %v", test.value, sp)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSampleJSON(t *testing.T) {
|
||||
input := []struct {
|
||||
plain string
|
||||
value Sample
|
||||
}{
|
||||
{
|
||||
plain: `{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]}`,
|
||||
value: Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "test_metric",
|
||||
},
|
||||
Value: 123.1,
|
||||
Timestamp: 1234567,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range input {
|
||||
b, err := json.Marshal(test.value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if string(b) != test.plain {
|
||||
t.Errorf("encoding error: expected %q, got %q", test.plain, b)
|
||||
continue
|
||||
}
|
||||
|
||||
var sv Sample
|
||||
err = json.Unmarshal(b, &sv)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(sv, test.value) {
|
||||
t.Errorf("decoding error: expected %v, got %v", test.value, sv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestVectorJSON(t *testing.T) {
|
||||
input := []struct {
|
||||
plain string
|
||||
value Vector
|
||||
}{
|
||||
{
|
||||
plain: `[]`,
|
||||
value: Vector{},
|
||||
},
|
||||
{
|
||||
plain: `[{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]}]`,
|
||||
value: Vector{&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "test_metric",
|
||||
},
|
||||
Value: 123.1,
|
||||
Timestamp: 1234567,
|
||||
}},
|
||||
},
|
||||
{
|
||||
plain: `[{"metric":{"__name__":"test_metric"},"value":[1234.567,"123.1"]},{"metric":{"foo":"bar"},"value":[1.234,"+Inf"]}]`,
|
||||
value: Vector{
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "test_metric",
|
||||
},
|
||||
Value: 123.1,
|
||||
Timestamp: 1234567,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
"foo": "bar",
|
||||
},
|
||||
Value: SampleValue(math.Inf(1)),
|
||||
Timestamp: 1234,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range input {
|
||||
b, err := json.Marshal(test.value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if string(b) != test.plain {
|
||||
t.Errorf("encoding error: expected %q, got %q", test.plain, b)
|
||||
continue
|
||||
}
|
||||
|
||||
var vec Vector
|
||||
err = json.Unmarshal(b, &vec)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(vec, test.value) {
|
||||
t.Errorf("decoding error: expected %v, got %v", test.value, vec)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestScalarJSON(t *testing.T) {
|
||||
input := []struct {
|
||||
plain string
|
||||
value Scalar
|
||||
}{
|
||||
{
|
||||
plain: `[123.456,"456"]`,
|
||||
value: Scalar{
|
||||
Timestamp: 123456,
|
||||
Value: 456,
|
||||
},
|
||||
},
|
||||
{
|
||||
plain: `[123123.456,"+Inf"]`,
|
||||
value: Scalar{
|
||||
Timestamp: 123123456,
|
||||
Value: SampleValue(math.Inf(1)),
|
||||
},
|
||||
},
|
||||
{
|
||||
plain: `[123123.456,"-Inf"]`,
|
||||
value: Scalar{
|
||||
Timestamp: 123123456,
|
||||
Value: SampleValue(math.Inf(-1)),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range input {
|
||||
b, err := json.Marshal(test.value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if string(b) != test.plain {
|
||||
t.Errorf("encoding error: expected %q, got %q", test.plain, b)
|
||||
continue
|
||||
}
|
||||
|
||||
var sv Scalar
|
||||
err = json.Unmarshal(b, &sv)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if sv != test.value {
|
||||
t.Errorf("decoding error: expected %v, got %v", test.value, sv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStringJSON(t *testing.T) {
|
||||
input := []struct {
|
||||
plain string
|
||||
value String
|
||||
}{
|
||||
{
|
||||
plain: `[123.456,"test"]`,
|
||||
value: String{
|
||||
Timestamp: 123456,
|
||||
Value: "test",
|
||||
},
|
||||
},
|
||||
{
|
||||
plain: `[123123.456,"台北"]`,
|
||||
value: String{
|
||||
Timestamp: 123123456,
|
||||
Value: "台北",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range input {
|
||||
b, err := json.Marshal(test.value)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if string(b) != test.plain {
|
||||
t.Errorf("encoding error: expected %q, got %q", test.plain, b)
|
||||
continue
|
||||
}
|
||||
|
||||
var sv String
|
||||
err = json.Unmarshal(b, &sv)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
if sv != test.value {
|
||||
t.Errorf("decoding error: expected %v, got %v", test.value, sv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestVectorSort(t *testing.T) {
|
||||
input := Vector{
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "A",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "A",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "C",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "C",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "B",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "B",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
}
|
||||
|
||||
expected := Vector{
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "A",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "A",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "B",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "B",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "C",
|
||||
},
|
||||
Timestamp: 1,
|
||||
},
|
||||
&Sample{
|
||||
Metric: Metric{
|
||||
MetricNameLabel: "C",
|
||||
},
|
||||
Timestamp: 2,
|
||||
},
|
||||
}
|
||||
|
||||
sort.Sort(input)
|
||||
|
||||
for i, actual := range input {
|
||||
actualFp := actual.Metric.Fingerprint()
|
||||
expectedFp := expected[i].Metric.Fingerprint()
|
||||
|
||||
if actualFp != expectedFp {
|
||||
t.Fatalf("%d. Incorrect fingerprint. Got %s; want %s", i, actualFp.String(), expectedFp.String())
|
||||
}
|
||||
|
||||
if actual.Timestamp != expected[i].Timestamp {
|
||||
t.Fatalf("%d. Incorrect timestamp. Got %s; want %s", i, actual.Timestamp, expected[i].Timestamp)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user