iterator_test.go

Documentation: go.opentelemetry.io/otel/attribute

     1  // Copyright The OpenTelemetry Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package attribute_test
    16  
    17  import (
    18  	"fmt"
    19  	"testing"
    20  
    21  	"github.com/stretchr/testify/require"
    22  
    23  	"go.opentelemetry.io/otel/attribute"
    24  )
    25  
    26  func TestIterator(t *testing.T) {
    27  	one := attribute.String("one", "1")
    28  	two := attribute.Int("two", 2)
    29  	lbl := attribute.NewSet(one, two)
    30  	iter := lbl.Iter()
    31  	require.Equal(t, 2, iter.Len())
    32  
    33  	require.True(t, iter.Next())
    34  	require.Equal(t, one, iter.Attribute())
    35  	idx, attr := iter.IndexedAttribute()
    36  	require.Equal(t, 0, idx)
    37  	require.Equal(t, one, attr)
    38  	require.Equal(t, 2, iter.Len())
    39  
    40  	require.True(t, iter.Next())
    41  	require.Equal(t, two, iter.Attribute())
    42  	idx, attr = iter.IndexedAttribute()
    43  	require.Equal(t, 1, idx)
    44  	require.Equal(t, two, attr)
    45  	require.Equal(t, 2, iter.Len())
    46  
    47  	require.False(t, iter.Next())
    48  	require.Equal(t, 2, iter.Len())
    49  }
    50  
    51  func TestEmptyIterator(t *testing.T) {
    52  	lbl := attribute.NewSet()
    53  	iter := lbl.Iter()
    54  	require.Equal(t, 0, iter.Len())
    55  	require.False(t, iter.Next())
    56  }
    57  
    58  func TestMergedIterator(t *testing.T) {
    59  	type inputs struct {
    60  		name   string
    61  		keys1  []string
    62  		keys2  []string
    63  		expect []string
    64  	}
    65  
    66  	makeAttributes := func(keys []string, num int) (result []attribute.KeyValue) {
    67  		for _, k := range keys {
    68  			result = append(result, attribute.Int(k, num))
    69  		}
    70  		return
    71  	}
    72  
    73  	for _, input := range []inputs{
    74  		{
    75  			name:   "one overlap",
    76  			keys1:  []string{"A", "B"},
    77  			keys2:  []string{"B", "C"},
    78  			expect: []string{"A/1", "B/1", "C/2"},
    79  		},
    80  		{
    81  			name:   "reversed one overlap",
    82  			keys1:  []string{"B", "A"},
    83  			keys2:  []string{"C", "B"},
    84  			expect: []string{"A/1", "B/1", "C/2"},
    85  		},
    86  		{
    87  			name:   "one empty",
    88  			keys1:  nil,
    89  			keys2:  []string{"C", "B"},
    90  			expect: []string{"B/2", "C/2"},
    91  		},
    92  		{
    93  			name:   "two empty",
    94  			keys1:  []string{"C", "B"},
    95  			keys2:  nil,
    96  			expect: []string{"B/1", "C/1"},
    97  		},
    98  		{
    99  			name:   "no overlap both",
   100  			keys1:  []string{"C"},
   101  			keys2:  []string{"B"},
   102  			expect: []string{"B/2", "C/1"},
   103  		},
   104  		{
   105  			name:   "one empty single two",
   106  			keys1:  nil,
   107  			keys2:  []string{"B"},
   108  			expect: []string{"B/2"},
   109  		},
   110  		{
   111  			name:   "two empty single one",
   112  			keys1:  []string{"A"},
   113  			keys2:  nil,
   114  			expect: []string{"A/1"},
   115  		},
   116  		{
   117  			name:   "all empty",
   118  			keys1:  nil,
   119  			keys2:  nil,
   120  			expect: nil,
   121  		},
   122  		{
   123  			name:   "full overlap",
   124  			keys1:  []string{"A", "B", "C", "D"},
   125  			keys2:  []string{"A", "B", "C", "D"},
   126  			expect: []string{"A/1", "B/1", "C/1", "D/1"},
   127  		},
   128  	} {
   129  		t.Run(input.name, func(t *testing.T) {
   130  			attr1 := makeAttributes(input.keys1, 1)
   131  			attr2 := makeAttributes(input.keys2, 2)
   132  
   133  			set1 := attribute.NewSet(attr1...)
   134  			set2 := attribute.NewSet(attr2...)
   135  
   136  			merge := attribute.NewMergeIterator(&set1, &set2)
   137  
   138  			var result []string
   139  
   140  			for merge.Next() {
   141  				attr := merge.Attribute()
   142  				result = append(result, fmt.Sprint(attr.Key, "/", attr.Value.Emit()))
   143  			}
   144  
   145  			require.Equal(t, input.expect, result)
   146  		})
   147  	}
   148  }
   149
View as plain text