|
- // Copyright 2018, OpenCensus 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 tracestate
-
- import (
- "fmt"
- "testing"
- )
-
- func checkFront(t *testing.T, tracestate *Tracestate, wantKey, testname string) {
- gotKey := tracestate.entries[0].Key
- if gotKey != wantKey {
- t.Errorf("test:%s: first entry in the list: got %q want %q", testname, gotKey, wantKey)
- }
- }
-
- func checkBack(t *testing.T, tracestate *Tracestate, wantKey, testname string) {
- gotKey := tracestate.entries[len(tracestate.entries)-1].Key
- if gotKey != wantKey {
- t.Errorf("test:%s: last entry in the list: got %q want %q", testname, gotKey, wantKey)
- }
- }
-
- func checkSize(t *testing.T, tracestate *Tracestate, wantSize int, testname string) {
- if gotSize := len(tracestate.entries); gotSize != wantSize {
- t.Errorf("test:%s: size of the list: got %q want %q", testname, gotSize, wantSize)
- }
- }
-
- func (ts *Tracestate) get(key string) (string, bool) {
- if ts == nil {
- return "", false
- }
- for _, entry := range ts.entries {
- if entry.Key == key {
- return entry.Value, true
- }
- }
- return "", false
- }
-
- func checkKeyValue(t *testing.T, tracestate *Tracestate, key, wantValue, testname string) {
- wantOk := true
- if wantValue == "" {
- wantOk = false
- }
- gotValue, gotOk := tracestate.get(key)
- if wantOk != gotOk || gotValue != wantValue {
- t.Errorf("test:%s: get value for key=%s failed: got %q want %q", testname, key, gotValue, wantValue)
- }
- }
-
- func checkError(t *testing.T, tracestate *Tracestate, err error, testname, msg string) {
- if err != nil {
- t.Errorf("test:%s: %s: tracestate=%v, error= %v", testname, msg, tracestate, err)
- }
- }
-
- func wantError(t *testing.T, tracestate *Tracestate, err error, testname, msg string) {
- if err == nil {
- t.Errorf("test:%s: %s: tracestate=%v, error=%v", testname, msg, tracestate, err)
- }
- }
-
- func TestCreateWithNullParent(t *testing.T) {
- key1, value1 := "hello", "world"
- testname := "TestCreateWithNullParent"
-
- entry := Entry{key1, value1}
- tracestate, err := New(nil, entry)
- checkError(t, tracestate, err, testname, "create failed from null parent")
- checkKeyValue(t, tracestate, key1, value1, testname)
- }
-
- func TestCreateFromParentWithSingleKey(t *testing.T) {
- key1, value1, key2, value2 := "hello", "world", "foo", "bar"
- testname := "TestCreateFromParentWithSingleKey"
-
- entry1 := Entry{key1, value1}
- entry2 := Entry{key2, value2}
- parent, _ := New(nil, entry1)
- tracestate, err := New(parent, entry2)
-
- checkError(t, tracestate, err, testname, "create failed from parent with single key")
- checkKeyValue(t, tracestate, key2, value2, testname)
- checkFront(t, tracestate, key2, testname)
- checkBack(t, tracestate, key1, testname)
- }
-
- func TestCreateFromParentWithDoubleKeys(t *testing.T) {
- key1, value1, key2, value2, key3, value3 := "hello", "world", "foo", "bar", "bar", "baz"
- testname := "TestCreateFromParentWithDoubleKeys"
-
- entry1 := Entry{key1, value1}
- entry2 := Entry{key2, value2}
- entry3 := Entry{key3, value3}
- parent, _ := New(nil, entry2, entry1)
- tracestate, err := New(parent, entry3)
-
- checkError(t, tracestate, err, testname, "create failed from parent with double keys")
- checkKeyValue(t, tracestate, key3, value3, testname)
- checkFront(t, tracestate, key3, testname)
- checkBack(t, tracestate, key1, testname)
- }
-
- func TestCreateFromParentWithExistingKey(t *testing.T) {
- key1, value1, key2, value2, key3, value3 := "hello", "world", "foo", "bar", "hello", "baz"
- testname := "TestCreateFromParentWithExistingKey"
-
- entry1 := Entry{key1, value1}
- entry2 := Entry{key2, value2}
- entry3 := Entry{key3, value3}
- parent, _ := New(nil, entry2, entry1)
- tracestate, err := New(parent, entry3)
-
- checkError(t, tracestate, err, testname, "create failed with an existing key")
- checkKeyValue(t, tracestate, key3, value3, testname)
- checkFront(t, tracestate, key3, testname)
- checkBack(t, tracestate, key2, testname)
- checkSize(t, tracestate, 2, testname)
- }
-
- func TestImplicitImmutableTracestate(t *testing.T) {
- key1, value1, key2, value2, key3, value3 := "hello", "world", "hello", "bar", "foo", "baz"
- testname := "TestImplicitImmutableTracestate"
-
- entry1 := Entry{key1, value1}
- entry2 := Entry{key2, value2}
- parent, _ := New(nil, entry1)
- tracestate, err := New(parent, entry2)
-
- checkError(t, tracestate, err, testname, "create failed")
- checkKeyValue(t, tracestate, key2, value2, testname)
- checkKeyValue(t, parent, key2, value1, testname)
-
- // Get and update entries.
- entries := tracestate.Entries()
- entry := Entry{key3, value3}
- entries = append(entries, entry)
-
- // Check Tracestate does not have key3.
- checkKeyValue(t, tracestate, key3, "", testname)
- // Check that we added the key3 in the entries
- tracestate, err = New(nil, entries...)
- checkError(t, tracestate, err, testname, "create failed")
- checkKeyValue(t, tracestate, key3, value3, testname)
- }
-
- func TestKeyWithValidChar(t *testing.T) {
- testname := "TestKeyWithValidChar"
-
- arrayRune := []rune("")
- for c := 'a'; c <= 'z'; c++ {
- arrayRune = append(arrayRune, c)
- }
- for c := '0'; c <= '9'; c++ {
- arrayRune = append(arrayRune, c)
- }
- arrayRune = append(arrayRune, '_')
- arrayRune = append(arrayRune, '-')
- arrayRune = append(arrayRune, '*')
- arrayRune = append(arrayRune, '/')
- key := string(arrayRune)
- entry := Entry{key, "world"}
- tracestate, err := New(nil, entry)
-
- checkError(t, tracestate, err, testname, "create failed when the key contains all valid characters")
- }
-
- func TestKeyWithInvalidChar(t *testing.T) {
- testname := "TestKeyWithInvalidChar"
-
- keys := []string{"1ab", "1ab2", "Abc", " abc", "a=b"}
-
- for _, key := range keys {
- entry := Entry{key, "world"}
- tracestate, err := New(nil, entry)
- wantError(t, tracestate, err, testname, fmt.Sprintf(
- "create did not err with invalid key=%q", key))
- }
- }
-
- func TestNilKey(t *testing.T) {
- testname := "TestNilKey"
-
- entry := Entry{"", "world"}
- tracestate, err := New(nil, entry)
- wantError(t, tracestate, err, testname, "create did not err when the key is nil (\"\")")
- }
-
- func TestValueWithInvalidChar(t *testing.T) {
- testname := "TestValueWithInvalidChar"
-
- keys := []string{"A=B", "A,B", "AB "}
-
- for _, value := range keys {
- entry := Entry{"hello", value}
- tracestate, err := New(nil, entry)
- wantError(t, tracestate, err, testname,
- fmt.Sprintf("create did not err when the value is invalid (%q)", value))
- }
- }
-
- func TestNilValue(t *testing.T) {
- testname := "TestNilValue"
-
- tracestate, err := New(nil, Entry{"hello", ""})
- wantError(t, tracestate, err, testname, "create did not err when the value is nil (\"\")")
- }
-
- func TestInvalidKeyLen(t *testing.T) {
- testname := "TestInvalidKeyLen"
-
- arrayRune := []rune("")
- for i := 0; i <= keyMaxSize+1; i++ {
- arrayRune = append(arrayRune, 'a')
- }
- key := string(arrayRune)
- tracestate, err := New(nil, Entry{key, "world"})
-
- wantError(t, tracestate, err, testname,
- fmt.Sprintf("create did not err when the length (%d) of the key is larger than max (%d)",
- len(key), keyMaxSize))
- }
-
- func TestInvalidValueLen(t *testing.T) {
- testname := "TestInvalidValueLen"
-
- arrayRune := []rune("")
- for i := 0; i <= valueMaxSize+1; i++ {
- arrayRune = append(arrayRune, 'a')
- }
- value := string(arrayRune)
- tracestate, err := New(nil, Entry{"hello", value})
-
- wantError(t, tracestate, err, testname,
- fmt.Sprintf("create did not err when the length (%d) of the value is larger than max (%d)",
- len(value), valueMaxSize))
- }
-
- func TestCreateFromArrayWithOverLimitKVPairs(t *testing.T) {
- testname := "TestCreateFromArrayWithOverLimitKVPairs"
-
- entries := []Entry{}
- for i := 0; i <= maxKeyValuePairs; i++ {
- key := fmt.Sprintf("a%db", i)
- entry := Entry{key, "world"}
- entries = append(entries, entry)
- }
- tracestate, err := New(nil, entries...)
- wantError(t, tracestate, err, testname,
- fmt.Sprintf("create did not err when the number (%d) of key-value pairs is larger than max (%d)",
- len(entries), maxKeyValuePairs))
- }
-
- func TestCreateFromEmptyArray(t *testing.T) {
- testname := "TestCreateFromEmptyArray"
-
- tracestate, err := New(nil, nil...)
- checkError(t, tracestate, err, testname,
- "failed to create nil tracestate")
- }
-
- func TestCreateFromParentWithOverLimitKVPairs(t *testing.T) {
- testname := "TestCreateFromParentWithOverLimitKVPairs"
-
- entries := []Entry{}
- for i := 0; i < maxKeyValuePairs; i++ {
- key := fmt.Sprintf("a%db", i)
- entry := Entry{key, "world"}
- entries = append(entries, entry)
- }
- parent, err := New(nil, entries...)
-
- checkError(t, parent, err, testname, fmt.Sprintf("create failed to add %d key-value pair", maxKeyValuePairs))
-
- // Add one more to go over the limit
- key := fmt.Sprintf("a%d", maxKeyValuePairs)
- tracestate, err := New(parent, Entry{key, "world"})
- wantError(t, tracestate, err, testname,
- fmt.Sprintf("create did not err when attempted to exceed the key-value pair limit of %d", maxKeyValuePairs))
- }
-
- func TestCreateFromArrayWithDuplicateKeys(t *testing.T) {
- key1, value1, key2, value2, key3, value3 := "hello", "world", "foo", "bar", "hello", "baz"
- testname := "TestCreateFromArrayWithDuplicateKeys"
-
- entry1 := Entry{key1, value1}
- entry2 := Entry{key2, value2}
- entry3 := Entry{key3, value3}
- tracestate, err := New(nil, entry1, entry2, entry3)
-
- wantError(t, tracestate, err, testname,
- "create did not err when entries contained duplicate keys")
- }
-
- func TestEntriesWithNil(t *testing.T) {
- ts, err := New(nil)
- if err != nil {
- t.Fatal(err)
- }
- if got, want := len(ts.Entries()), 0; got != want {
- t.Errorf("zero value should have no entries, got %v; want %v", got, want)
- }
- }
|