blob: c357813a5309ec9b519938a76336d97e52aefd07 [file]
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
package attribute_test
import (
"math"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/stretchr/testify/assert"
"go.opentelemetry.io/otel/attribute"
)
func TestKeyValueConstructors(t *testing.T) {
tt := []struct {
name string
actual attribute.KeyValue
expected attribute.KeyValue
}{
{
name: "Bool",
actual: attribute.Bool("k1", true),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.BoolValue(true),
},
},
{
name: "Int64",
actual: attribute.Int64("k1", 123),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.Int64Value(123),
},
},
{
name: "Float64",
actual: attribute.Float64("k1", 123.5),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.Float64Value(123.5),
},
},
{
name: "String",
actual: attribute.String("k1", "123.5"),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.StringValue("123.5"),
},
},
{
name: "Int",
actual: attribute.Int("k1", 123),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.IntValue(123),
},
},
{
name: "ByteSlice",
actual: attribute.ByteSlice("k1", []byte{123}),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.ByteSliceValue([]byte{123}),
},
},
{
name: "Slice",
actual: attribute.Slice("k1", attribute.BoolValue(true), attribute.IntValue(42)),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.SliceValue(attribute.BoolValue(true), attribute.IntValue(42)),
},
},
{
name: "Map",
actual: attribute.Map("k1", attribute.String("b", "two"), attribute.Int("a", 1)),
expected: attribute.KeyValue{
Key: "k1",
Value: attribute.MapValue(
attribute.Int("a", 1),
attribute.String("b", "two"),
),
},
},
}
for _, test := range tt {
t.Run(test.name, func(t *testing.T) {
if diff := cmp.Diff(test.actual, test.expected, cmp.AllowUnexported(attribute.Value{})); diff != "" {
t.Fatal(diff)
}
})
}
}
func TestKeyValueValid(t *testing.T) {
tests := []struct {
desc string
valid bool
kv attribute.KeyValue
}{
{
desc: "uninitialized KeyValue should be invalid",
valid: false,
kv: attribute.KeyValue{},
},
{
desc: "empty key value should be invalid",
valid: false,
kv: attribute.Key("").Bool(true),
},
{
desc: "EMPTY value type should be valid",
valid: true,
kv: attribute.KeyValue{
Key: attribute.Key("valid key"),
// Default type is EMPTY.
Value: attribute.Value{},
},
},
{
desc: "non-empty key with BOOL type Value should be valid",
valid: true,
kv: attribute.Bool("bool", true),
},
{
desc: "non-empty key with INT64 type Value should be valid",
valid: true,
kv: attribute.Int64("int64", 0),
},
{
desc: "non-empty key with FLOAT64 type Value should be valid",
valid: true,
kv: attribute.Float64("float64", 0),
},
{
desc: "non-empty key with STRING type Value should be valid",
valid: true,
kv: attribute.String("string", ""),
},
{
desc: "non-empty key with BYTESLICE type Value should be valid",
valid: true,
kv: attribute.ByteSlice("bytes", []byte{}),
},
{
desc: "non-empty key with SLICE type Value should be valid",
valid: true,
kv: attribute.Slice("slice", attribute.StringValue("value")),
},
{
desc: "non-empty key with MAP type Value should be valid",
valid: true,
kv: attribute.Map("map", attribute.String("key", "value")),
},
}
for _, test := range tests {
if got, want := test.kv.Valid(), test.valid; got != want {
t.Error(test.desc)
}
}
}
func TestKeyValueString(t *testing.T) {
for _, tc := range []struct {
name string
kv attribute.KeyValue
want string
}{
{
name: "zero value",
kv: attribute.KeyValue{},
want: `{"":null}`,
},
{
name: "bool true",
kv: attribute.Bool("bool", true),
want: `{"bool":true}`,
},
{
name: "bool false",
kv: attribute.Bool("bool", false),
want: `{"bool":false}`,
},
{
name: "bool slice",
kv: attribute.BoolSlice("bools", []bool{true, false}),
want: `{"bools":[true,false]}`,
},
{
name: "empty bool slice",
kv: attribute.BoolSlice("bools", []bool{}),
want: `{"bools":[]}`,
},
{
name: "int64",
kv: attribute.Int64("count", -42),
want: `{"count":-42}`,
},
{
name: "int64 slice",
kv: attribute.Int64Slice("counts", []int64{42, -3}),
want: `{"counts":[42,-3]}`,
},
{
name: "empty int64 slice",
kv: attribute.Int64Slice("counts", []int64{}),
want: `{"counts":[]}`,
},
{
name: "float64",
kv: attribute.Float64("float", 3.14),
want: `{"float":3.14}`,
},
{
name: "string",
kv: attribute.String("greeting", `hello "world"`),
want: `{"greeting":"hello \"world\""}`,
},
{
name: "string slice",
kv: attribute.StringSlice("strings", []string{"one", "two"}),
want: `{"strings":["one","two"]}`,
},
{
name: "empty string slice",
kv: attribute.StringSlice("strings", []string{}),
want: `{"strings":[]}`,
},
{
name: "byte slice",
kv: attribute.ByteSlice("bytes", []byte("one")),
want: `{"bytes":"b25l"}`,
},
{
name: "float64 slice",
kv: attribute.Float64Slice(
"floats",
[]float64{1.5, math.NaN(), math.Inf(1), math.Inf(-1)},
),
want: `{"floats":[1.5,"NaN","Infinity","-Infinity"]}`,
},
{
name: "empty float64 slice",
kv: attribute.Float64Slice("floats", []float64{}),
want: `{"floats":[]}`,
},
{
name: "float64 NaN",
kv: attribute.Float64("float", math.NaN()),
want: `{"float":"NaN"}`,
},
{
name: "float64 Infinity",
kv: attribute.Float64("float", math.Inf(1)),
want: `{"float":"Infinity"}`,
},
{
name: "float64 negative Infinity",
kv: attribute.Float64("float", math.Inf(-1)),
want: `{"float":"-Infinity"}`,
},
{
name: "value slice",
kv: attribute.Slice(
"slice",
attribute.StringValue("one"),
attribute.IntValue(2),
attribute.BoolValue(false),
attribute.Value{},
),
want: `{"slice":["one",2,false,null]}`,
},
{
name: "empty value slice",
kv: attribute.Slice("slice"),
want: `{"slice":[]}`,
},
{
name: "map",
kv: attribute.Map(
"context",
attribute.String("name", "x"),
attribute.Map("nested", attribute.Bool("value", true)),
),
want: `{"context":{"name":"x","nested":{"value":true}}}`,
},
{
name: "key needs escaping",
kv: attribute.String("line\n\"quoted\"\\key", "value"),
want: `{"line\n\"quoted\"\\key":"value"}`,
},
{
name: "key has invalid UTF-8",
kv: attribute.String(string([]byte{'a', 0xff, 'b'}), "value"),
want: `{"a\ufffdb":"value"}`,
},
{
name: "empty value",
kv: attribute.KeyValue{Key: "empty"},
want: `{"empty":null}`,
},
} {
t.Run(tc.name, func(t *testing.T) {
assert.Equal(t, tc.want, tc.kv.String())
})
}
}
func TestIncorrectCast(t *testing.T) {
testCases := []struct {
name string
val attribute.Value
}{
{
name: "Float64",
val: attribute.Float64Value(1.0),
},
{
name: "Int64",
val: attribute.Int64Value(2),
},
{
name: "String",
val: attribute.BoolValue(true),
},
{
name: "Float64Slice",
val: attribute.Float64SliceValue([]float64{1.0}),
},
{
name: "Int64Slice",
val: attribute.Int64SliceValue([]int64{2}),
},
{
name: "StringSlice",
val: attribute.BoolSliceValue([]bool{true}),
},
{
name: "ByteSlice",
val: attribute.ByteSliceValue([]byte{123}),
},
{
name: "Empty",
val: attribute.Value{},
},
{
name: "Slice",
val: attribute.SliceValue(attribute.StringValue("value")),
},
{
name: "Map",
val: attribute.MapValue(attribute.String("key", "value")),
},
}
for _, tt := range testCases {
t.Run(tt.name, func(t *testing.T) {
assert.NotPanics(t, func() {
tt.val.AsBool()
tt.val.AsBoolSlice()
tt.val.AsFloat64()
tt.val.AsFloat64Slice()
tt.val.AsInt64()
tt.val.AsInt64Slice()
tt.val.AsInterface()
tt.val.AsMap()
tt.val.AsSlice()
tt.val.AsString()
tt.val.AsStringSlice()
tt.val.AsByteSlice()
})
})
}
}