Debian Codegraph @

baggage/baggage_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package baggage
5
6 import (
7 "fmt"
8 "math/rand/v2"
9 "slices"
10 "strings"
11 "testing"
12 "unicode/utf8"
13
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/require"
16
17 "go.opentelemetry.io/otel/internal/baggage"
18 )
19
20 // Seed with a static value to ensure deterministic results.
21 var rng = rand.New(rand.NewChaCha8([32]byte{}))
22
23 func TestValidateKeyChar(t *testing.T) {
24 // ASCII only
25 invalidKeyRune := []rune{
26 '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
27 '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F',
28 '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
29 '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F', ' ',
30 '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?',
31 '=', '{', '}', '\x7F', 2 >> 20, '\x80',
32 }
33
34 for _, ch := range invalidKeyRune {
35 assert.False(t, validateKeyChar(ch))
36 }
37 }
38
39 func TestValidateValueChar(t *testing.T) {
40 // ASCII only
41 invalidValueRune := []rune{
42 '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
43 '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F',
44 '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
45 '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D', '\x1E', '\x1F', ' ',
46 '"', ',', ';', '\\', '\x7F', '\x80',
47 }
48
49 for _, ch := range invalidValueRune {
50 assert.False(t, validateValueChar(ch))
51 }
52 }
53
54 func TestParseProperty(t *testing.T) {
55 p := Property{key: "key", value: "value", hasValue: true}
56
57 testcases := []struct {
58 in string
59 expected Property
60 }{
61 {
62 in: "",
63 expected: Property{},
64 },
65 {
66 in: "key",
67 expected: Property{
68 key: "key",
69 },
70 },
71 {
72 in: "key=",
73 expected: Property{
74 key: "key",
75 hasValue: true,
76 },
77 },
78 {
79 in: "key=value",
80 expected: p,
81 },
82 {
83 in: " key=value ",
84 expected: p,
85 },
86 {
87 in: "key = value",
88 expected: p,
89 },
90 {
91 in: " key = value ",
92 expected: p,
93 },
94 {
95 in: "\tkey=value",
96 expected: p,
97 },
98 }
99
100 for _, tc := range testcases {
101 actual, err := parseProperty(tc.in)
102
103 if !assert.NoError(t, err) {
104 continue
105 }
106
107 assert.Equal(t, tc.expected.Key(), actual.Key(), tc.in)
108
109 actualV, actualOk := actual.Value()
110 expectedV, expectedOk := tc.expected.Value()
111 assert.Equal(t, expectedOk, actualOk, tc.in)
112 assert.Equal(t, expectedV, actualV, tc.in)
113 }
114 }
115
116 func TestParsePropertyError(t *testing.T) {
117 _, err := parseProperty(",;,")
118 assert.ErrorIs(t, err, errInvalidProperty)
119 }
120
121 func TestNewKeyProperty(t *testing.T) {
122 p, err := NewKeyProperty(" ")
123 assert.NoError(t, err)
124 assert.Equal(t, Property{key: " "}, p)
125
126 p, err = NewKeyProperty("key")
127 assert.NoError(t, err)
128 assert.Equal(t, Property{key: "key"}, p)
129
130 // UTF-8 key
131 p, err = NewKeyProperty("B% 💼")
132 assert.NoError(t, err)
133 assert.Equal(t, Property{key: "B% 💼"}, p)
134
135 // Invalid UTF-8 key
136 p, err = NewKeyProperty(string([]byte{255}))
137 assert.ErrorIs(t, err, errInvalidKey)
138 assert.Equal(t, Property{}, p)
139 }
140
141 func TestNewKeyValueProperty(t *testing.T) {
142 p, err := NewKeyValueProperty(" ", "value")
143 assert.ErrorIs(t, err, errInvalidKey)
144 assert.Equal(t, Property{}, p)
145
146 p, err = NewKeyValueProperty("key", ";")
147 assert.ErrorIs(t, err, errInvalidValue)
148 assert.Equal(t, Property{}, p)
149
150 // it won't use percent decoding for key
151 p, err = NewKeyValueProperty("%zzzzz", "value")
152 assert.NoError(t, err)
153 assert.Equal(t, Property{key: "%zzzzz", value: "value", hasValue: true}, p)
154
155 // wrong value with wrong decoding
156 p, err = NewKeyValueProperty("key", "%zzzzz")
157 assert.ErrorIs(t, err, errInvalidValue)
158 assert.Equal(t, Property{}, p)
159
160 p, err = NewKeyValueProperty("key", "value")
161 assert.NoError(t, err)
162 assert.Equal(t, Property{key: "key", value: "value", hasValue: true}, p)
163
164 // Percent-encoded value
165 p, err = NewKeyValueProperty("key", "%C4%85%C5%9B%C4%87")
166 assert.NoError(t, err)
167 assert.Equal(t, Property{key: "key", value: "ąść", hasValue: true}, p)
168 }
169
170 func TestNewKeyValuePropertyRaw(t *testing.T) {
171 // Empty key
172 p, err := NewKeyValuePropertyRaw("", " ")
173 assert.ErrorIs(t, err, errInvalidKey)
174 assert.Equal(t, Property{}, p)
175
176 // Empty value
177 // Empty string is also a valid UTF-8 string.
178 p, err = NewKeyValuePropertyRaw(" ", "")
179 assert.NoError(t, err)
180 assert.Equal(t, Property{key: " ", hasValue: true}, p)
181
182 // Space value
183 p, err = NewKeyValuePropertyRaw(" ", " ")
184 assert.NoError(t, err)
185 assert.Equal(t, Property{key: " ", value: " ", hasValue: true}, p)
186
187 p, err = NewKeyValuePropertyRaw("B% 💼", "Witaj Świecie!")
188 assert.NoError(t, err)
189 assert.Equal(t, Property{key: "B% 💼", value: "Witaj Świecie!", hasValue: true}, p)
190 }
191
192 func TestPropertyValidate(t *testing.T) {
193 p := Property{}
194 assert.ErrorIs(t, p.validate(), errInvalidKey)
195
196 p.key = "k"
197 assert.NoError(t, p.validate())
198
199 p.value = "v"
200 assert.EqualError(t, p.validate(), "invalid property: inconsistent value")
201
202 p.hasValue = true
203 assert.NoError(t, p.validate())
204
205 // Invalid value
206 p.value = string([]byte{255})
207 assert.ErrorIs(t, p.validate(), errInvalidValue)
208 }
209
210 func TestNewEmptyBaggage(t *testing.T) {
211 b, err := New()
212 assert.NoError(t, err)
213 assert.Equal(t, Baggage{}, b)
214 }
215
216 func TestNewBaggage(t *testing.T) {
217 b, err := New(Member{key: "k", hasData: true})
218 assert.NoError(t, err)
219 assert.Equal(t, Baggage{list: baggage.List{"k": {}}}, b)
220 }
221
222 func TestNewBaggageWithDuplicates(t *testing.T) {
223 // Having this many members would normally cause this to error, but since
224 // these are duplicates of the same key they will be collapsed into a
225 // single entry.
226 m := make([]Member, maxMembers+1)
227 for i := range m {
228 // Duplicates are collapsed.
229 m[i] = Member{
230 key: "a",
231 value: fmt.Sprintf("%d", i),
232 hasData: true,
233 }
234 }
235 b, err := New(m...)
236 assert.NoError(t, err)
237
238 // Ensure that the last-one-wins by verifying the value.
239 v := fmt.Sprintf("%d", maxMembers)
240 want := Baggage{list: baggage.List{"a": {Value: v}}}
241 assert.Equal(t, want, b)
242 }
243
244 func TestNewBaggageErrorEmptyMember(t *testing.T) {
245 _, err := New(Member{})
246 assert.ErrorIs(t, err, errInvalidMember)
247 }
248
249 func key(n int) string {
250 r := []rune("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
251
252 b := make([]rune, n)
253 for i := range b {
254 b[i] = r[rng.IntN(len(r))]
255 }
256 return string(b)
257 }
258
259 func TestNewBaggageErrorTooManyBytes(t *testing.T) {
260 // Create members that together exceed maxBytesPerBaggageString.
261 // Each member needs key + "=" so use keys that sum to > 8192 bytes.
262 keySize := maxBytesPerBaggageString / maxMembers
263 m := make([]Member, maxMembers)
264 for i := range m {
265 m[i] = Member{key: key(keySize), hasData: true}
266 }
267 b, err := New(m...)
268 assert.ErrorIs(t, err, errBaggageBytes)
269 // Partial result should contain members that fit within the byte limit.
270 assert.Positive(t, b.Len(), "should return partial baggage")
271 assert.LessOrEqual(t, len(b.String()), maxBytesPerBaggageString, "partial baggage should be within byte limit")
272 }
273
274 func TestNewBaggageErrorTooManyMembers(t *testing.T) {
275 m := make([]Member, maxMembers+1)
276 for i := range m {
277 m[i] = Member{key: fmt.Sprintf("%d", i), hasData: true}
278 }
279 b, err := New(m...)
280 assert.ErrorIs(t, err, errMemberNumber)
281 // Partial result should contain exactly maxMembers.
282 assert.Equal(t, maxMembers, b.Len(), "should return first %d members", maxMembers)
283 }
284
285 func TestBaggageParse(t *testing.T) {
286 tooLarge := key(maxBytesPerBaggageString + 1)
287
288 m := make([]string, maxMembers+1)
289 for i := range m {
290 m[i] = fmt.Sprintf("a%d=", i)
291 }
292 tooManyMembers := strings.Join(m, listDelimiter)
293
294 testcases := []struct {
295 name string
296 in string
297 want baggage.List
298 err error
299 }{
300 {
301 name: "empty value",
302 in: "",
303 want: baggage.List(nil),
304 },
305 {
306 name: "single member empty value no properties",
307 in: "foo=",
308 want: baggage.List{
309 "foo": {Value: ""},
310 },
311 },
312 {
313 name: "single member no properties",
314 in: "foo=1",
315 want: baggage.List{
316 "foo": {Value: "1"},
317 },
318 },
319 {
320 name: "single member no properties plus",
321 in: "foo=1+1",
322 want: baggage.List{
323 "foo": {Value: "1+1"},
324 },
325 },
326 {
327 name: "single member no properties plus encoded",
328 in: "foo=1%2B1",
329 want: baggage.List{
330 "foo": {Value: "1+1"},
331 },
332 },
333 {
334 name: "single member no properties slash",
335 in: "foo=1/1",
336 want: baggage.List{
337 "foo": {Value: "1/1"},
338 },
339 },
340 {
341 name: "single member no properties slash encoded",
342 in: "foo=1%2F1",
343 want: baggage.List{
344 "foo": {Value: "1/1"},
345 },
346 },
347 {
348 name: "single member no properties equals",
349 in: "foo=1=1",
350 want: baggage.List{
351 "foo": {Value: "1=1"},
352 },
353 },
354 {
355 name: "single member no properties equals encoded",
356 in: "foo=1%3D1",
357 want: baggage.List{
358 "foo": {Value: "1=1"},
359 },
360 },
361 {
362 name: "single member with spaces",
363 in: " foo \t= 1\t\t ",
364 want: baggage.List{
365 "foo": {Value: "1"},
366 },
367 },
368 {
369 name: "single member empty value with properties",
370 in: "foo=;state=on;red",
371 want: baggage.List{
372 "foo": {
373 Value: "",
374 Properties: []baggage.Property{
375 {Key: "state", Value: "on", HasValue: true},
376 {Key: "red"},
377 },
378 },
379 },
380 },
381 {
382 name: "single member with properties",
383 in: "foo=1;state=on;red",
384 want: baggage.List{
385 "foo": {
386 Value: "1",
387 Properties: []baggage.Property{
388 {Key: "state", Value: "on", HasValue: true},
389 {Key: "red"},
390 },
391 },
392 },
393 },
394 {
395 name: "single member with value containing equal signs",
396 in: "foo=0=0=0",
397 want: baggage.List{
398 "foo": {Value: "0=0=0"},
399 },
400 },
401 {
402 name: "two members with properties",
403 in: "foo=1;state=on;red,bar=2;yellow",
404 want: baggage.List{
405 "foo": {
406 Value: "1",
407 Properties: []baggage.Property{
408 {Key: "state", Value: "on", HasValue: true},
409 {Key: "red"},
410 },
411 },
412 "bar": {
413 Value: "2",
414 Properties: []baggage.Property{{Key: "yellow"}},
415 },
416 },
417 },
418 {
419 // According to the OTel spec, last value wins.
420 name: "duplicate key",
421 in: "foo=1;state=on;red,foo=2",
422 want: baggage.List{
423 "foo": {Value: "2"},
424 },
425 },
426 {
427 name: "= value",
428 in: "key==",
429 want: baggage.List{
430 "key": {Value: "="},
431 },
432 },
433 {
434 name: "encoded ASCII string",
435 in: "key1=val%252%2C",
436 want: baggage.List{
437 "key1": {Value: "val%2,"},
438 },
439 },
440 {
441 name: "encoded property",
442 in: "key1=;bar=val%252%2C",
443 want: baggage.List{
444 "key1": {
445 Properties: []baggage.Property{{Key: "bar", HasValue: true, Value: "val%2,"}},
446 },
447 },
448 },
449 {
450 name: "encoded UTF-8 string",
451 in: "foo=%C4%85%C5%9B%C4%87",
452 want: baggage.List{
453 "foo": {Value: "ąść"},
454 },
455 },
456 {
457 name: "encoded UTF-8 string in key",
458 in: "a=b,%C4%85%C5%9B%C4%87=%C4%85%C5%9B%C4%87",
459 want: baggage.List{
460 "a": {Value: "b"},
461 "%C4%85%C5%9B%C4%87": {Value: "ąść"},
462 },
463 },
464 {
465 name: "encoded UTF-8 string in property",
466 in: "a=b,%C4%85%C5%9B%C4%87=%C4%85%C5%9B%C4%87;%C4%85%C5%9B%C4%87=%C4%85%C5%9B%C4%87",
467 want: baggage.List{
468 "a": {Value: "b"},
469 "%C4%85%C5%9B%C4%87": {Value: "ąść", Properties: []baggage.Property{
470 {Key: "%C4%85%C5%9B%C4%87", HasValue: true, Value: "ąść"},
471 }},
472 },
473 },
474 {
475 name: "invalid member: empty",
476 in: "foo=,,bar=",
477 want: baggage.List{
478 "foo": {},
479 "bar": {},
480 },
481 err: errInvalidMember,
482 },
483 {
484 name: "invalid member: no key",
485 in: "=foo",
486 err: errInvalidKey,
487 },
488 {
489 name: "invalid member: no value",
490 in: "foo",
491 err: errInvalidMember,
492 },
493 {
494 name: "invalid member: invalid key",
495 in: "\\=value",
496 err: errInvalidKey,
497 },
498 {
499 name: "invalid member: invalid value",
500 in: "foo=\\",
501 err: errInvalidValue,
502 },
503 {
504 name: "invalid member: improper url encoded value",
505 in: "key1=val%",
506 err: errInvalidValue,
507 },
508 {
509 name: "invalid property: no key",
510 in: "foo=1;=v",
511 err: errInvalidProperty,
512 },
513 {
514 name: "invalid property: invalid key",
515 in: "foo=1;key\\=v",
516 err: errInvalidProperty,
517 },
518 {
519 name: "invalid property: invalid value",
520 in: "foo=1;key=\\",
521 err: errInvalidProperty,
522 },
523 {
524 name: "invalid property: improper url encoded value",
525 in: "foo=1;key=val%",
526 err: errInvalidProperty,
527 },
528 {
529 name: "invalid baggage string: too large",
530 in: tooLarge,
531 // tooLarge is a single key without "=", so parseMember fails
532 err: errInvalidMember,
533 },
534 {
535 name: "baggage string with too many members keeps first 64",
536 in: tooManyMembers,
537 want: func() baggage.List {
538 b := make(baggage.List)
539 for i := range maxMembers {
540 b[fmt.Sprintf("a%d", i)] = baggage.Item{Value: ""}
541 }
542 return b
543 }(),
544 err: errMemberNumber,
545 },
546 {
547 name: "baggage string exceeds byte limit returns partial result",
548 in: func() string {
549 // Create members that collectively exceed maxBytesPerBaggageString.
550 // Each member: "kN=" + value. We use values large enough that
551 // a few members fit but the total exceeds 8192 bytes.
552 var parts []string
553 val := strings.Repeat("v", 2000)
554 for i := range 10 {
555 parts = append(parts, fmt.Sprintf("k%d=%s", i, val))
556 }
557 return strings.Join(parts, ",")
558 }(),
559 want: func() baggage.List {
560 // Only members that fit within 8192 bytes should be kept.
561 // Each member is ~2003 bytes ("kN=" + 2000 "v"s), plus comma.
562 // 4 members = 4*2003 + 3 commas = 8015 bytes (fits).
563 // 5 members = 5*2003 + 4 commas = 10019 bytes (exceeds).
564 b := make(baggage.List)
565 val := strings.Repeat("v", 2000)
566 for i := range 4 {
567 b[fmt.Sprintf("k%d", i)] = baggage.Item{Value: val}
568 }
569 return b
570 }(),
571 err: errBaggageBytes,
572 },
573 {
574 name: "percent-encoded octet sequences do not match the UTF-8 encoding scheme",
575 in: "k=aa%ffcc;p=d%fff",
576 want: baggage.List{
577 "k": {
578 Value: "aa�cc",
579 Properties: []baggage.Property{
580 {Key: "p", Value: "d�f", HasValue: true},
581 },
582 },
583 },
584 },
585 }
586
587 for _, tc := range testcases {
588 t.Run(tc.name, func(t *testing.T) {
589 actual, err := Parse(tc.in)
590 assert.ErrorIs(t, err, tc.err)
591 assert.Equal(t, Baggage{list: tc.want}, actual)
592 })
593 }
594 }
595
596 func TestBaggageParseValue(t *testing.T) {
597 testcases := []struct {
598 name string
599 in string
600 valueWant string
601 valueWantSize int
602 }{
603 {
604 name: "percent encoded octet sequence matches UTF-8 encoding scheme",
605 in: "k=aa%26cc",
606 valueWant: "aa&cc",
607 valueWantSize: 5,
608 },
609 {
610 name: "percent encoded octet sequence doesn't match UTF-8 encoding scheme",
611 in: "k=aa%ffcc",
612 valueWant: "aa�cc",
613 valueWantSize: 7,
614 },
615 {
616 name: "multiple percent encoded octet sequences don't match UTF-8 encoding scheme",
617 in: "k=aa%ffcc%fedd%fa",
618 valueWant: "aa�cc�dd�",
619 valueWantSize: 15,
620 },
621 {
622 name: "raw value",
623 in: "k=aacc",
624 valueWant: "aacc",
625 valueWantSize: 4,
626 },
627 }
628
629 for _, tc := range testcases {
630 t.Run(tc.name, func(t *testing.T) {
631 b, err := Parse(tc.in)
632 assert.NoError(t, err)
633
634 val := b.Members()[0].Value()
635
636 assert.Equal(t, tc.valueWant, val)
637 assert.Equal(t, len(val), tc.valueWantSize)
638 assert.True(t, utf8.ValidString(val))
639 })
640 }
641 }
642
643 func TestBaggageString(t *testing.T) {
644 testcases := []struct {
645 name string
646 out string
647 baggage baggage.List
648 }{
649 {
650 name: "empty value",
651 out: "",
652 baggage: baggage.List(nil),
653 },
654 {
655 name: "single member empty value no properties",
656 out: "foo=",
657 baggage: baggage.List{
658 "foo": {Value: ""},
659 },
660 },
661 {
662 name: "single member no properties",
663 out: "foo=1",
664 baggage: baggage.List{
665 "foo": {Value: "1"},
666 },
667 },
668 {
669 name: "Encoded value",
670 // Allowed value characters are:
671 //
672 // %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
673 //
674 // Meaning, US-ASCII characters excluding CTLs, whitespace,
675 // DQUOTE, comma, semicolon, and backslash. All excluded
676 // characters need to be percent encoded.
677 out: "foo=%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20!%22#$%25&'()*+%2C-./0123456789:%3B<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[%5C]^_`abcdefghijklmnopqrstuvwxyz{|}~%7F",
678 baggage: baggage.List{
679 "foo": {Value: func() string {
680 // All US-ASCII characters.
681 b := [128]byte{}
682 for i := range b {
683 b[i] = byte(i)
684 }
685 return string(b[:])
686 }()},
687 },
688 },
689 {
690 name: "non-ASCII UTF-8 string",
691 out: "foo=%C4%85%C5%9B%C4%87",
692 baggage: baggage.List{
693 "foo": {Value: "ąść"},
694 },
695 },
696 {
697 name: "Encoded property value",
698 out: "foo=;bar=%20",
699 baggage: baggage.List{
700 "foo": {
701 Properties: []baggage.Property{
702 {Key: "bar", Value: " ", HasValue: true},
703 },
704 },
705 },
706 },
707 {
708 name: "plus",
709 out: "foo=1+1",
710 baggage: baggage.List{
711 "foo": {Value: "1+1"},
712 },
713 },
714 {
715 name: "equal",
716 out: "foo=1=1",
717 baggage: baggage.List{
718 "foo": {Value: "1=1"},
719 },
720 },
721 {
722 name: "single member empty value with properties",
723 out: "foo=;red;state=on",
724 baggage: baggage.List{
725 "foo": {
726 Value: "",
727 Properties: []baggage.Property{
728 {Key: "state", Value: "on", HasValue: true},
729 {Key: "red"},
730 },
731 },
732 },
733 },
734 {
735 name: "single member with properties",
736 // Properties are "opaque values" meaning they are sent as they
737 // are set and no encoding is performed.
738 out: "foo=1;red;state=on;z=z=z",
739 baggage: baggage.List{
740 "foo": {
741 Value: "1",
742 Properties: []baggage.Property{
743 {Key: "state", Value: "on", HasValue: true},
744 {Key: "red"},
745 {Key: "z", Value: "z=z", HasValue: true},
746 },
747 },
748 },
749 },
750 {
751 name: "two members with properties",
752 out: "bar=2;yellow,foo=1;red;state=on",
753 baggage: baggage.List{
754 "foo": {
755 Value: "1",
756 Properties: []baggage.Property{
757 {Key: "state", Value: "on", HasValue: true},
758 {Key: "red"},
759 },
760 },
761 "bar": {
762 Value: "2",
763 Properties: []baggage.Property{{Key: "yellow"}},
764 },
765 },
766 },
767 {
768 // W3C does not allow percent-encoded keys.
769 // The baggage that has percent-encoded keys should be ignored.
770 name: "utf-8 key and value",
771 out: "foo=B%25%20%F0%9F%92%BC-2;foo-1=B%25%20%F0%9F%92%BC-4;foo-2",
772 baggage: baggage.List{
773 "ąść": {
774 Value: "B% 💼",
775 Properties: []baggage.Property{
776 {Key: "ąść-1", Value: "B% 💼-1", HasValue: true},
777 {Key: "ąść-2"},
778 },
779 },
780 "foo": {
781 Value: "B% 💼-2",
782 Properties: []baggage.Property{
783 {Key: "ąść", Value: "B% 💼-3", HasValue: true},
784 {Key: "foo-1", Value: "B% 💼-4", HasValue: true},
785 {Key: "foo-2"},
786 },
787 },
788 },
789 },
790 }
791
792 orderer := func(s string) string {
793 members := strings.Split(s, listDelimiter)
794 for i, m := range members {
795 parts := strings.Split(m, propertyDelimiter)
796 if len(parts) > 1 {
797 slices.Sort(parts[1:])
798 members[i] = strings.Join(parts, propertyDelimiter)
799 }
800 }
801 slices.Sort(members)
802 return strings.Join(members, listDelimiter)
803 }
804
805 for _, tc := range testcases {
806 t.Run(tc.name, func(t *testing.T) {
807 b := Baggage{tc.baggage}
808 assert.Equal(t, tc.out, orderer(b.String()))
809 })
810 }
811 }
812
813 func TestBaggageLen(t *testing.T) {
814 b := Baggage{}
815 assert.Equal(t, 0, b.Len())
816
817 b.list = make(baggage.List, 1)
818 assert.Equal(t, 0, b.Len())
819
820 b.list["k"] = baggage.Item{}
821 assert.Equal(t, 1, b.Len())
822 }
823
824 func TestBaggageDeleteMember(t *testing.T) {
825 key := "k"
826
827 b0 := Baggage{}
828 b1 := b0.DeleteMember(key)
829 assert.NotContains(t, b1.list, key)
830
831 b0 = Baggage{list: baggage.List{
832 key: {},
833 "other": {},
834 }}
835 b1 = b0.DeleteMember(key)
836 assert.Contains(t, b0.list, key)
837 assert.NotContains(t, b1.list, key)
838 }
839
840 func TestBaggageSetMemberEmpty(t *testing.T) {
841 _, err := Baggage{}.SetMember(Member{})
842 assert.ErrorIs(t, err, errInvalidMember)
843 }
844
845 func TestBaggageSetMember(t *testing.T) {
846 b0 := Baggage{}
847
848 key := "k"
849 m := Member{key: key, hasData: true}
850 b1, err := b0.SetMember(m)
851 assert.NoError(t, err)
852 assert.NotContains(t, b0.list, key)
853 assert.Equal(t, baggage.Item{}, b1.list[key])
854 assert.Empty(t, b0.list)
855 assert.Len(t, b1.list, 1)
856
857 m.value = "v"
858 b2, err := b1.SetMember(m)
859 assert.NoError(t, err)
860 assert.Equal(t, baggage.Item{}, b1.list[key])
861 assert.Equal(t, baggage.Item{Value: "v"}, b2.list[key])
862 assert.Len(t, b1.list, 1)
863 assert.Len(t, b2.list, 1)
864
865 p := properties{{key: "p"}}
866 m.properties = p
867 b3, err := b2.SetMember(m)
868 assert.NoError(t, err)
869 assert.Equal(t, baggage.Item{Value: "v"}, b2.list[key])
870 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
871 assert.Len(t, b2.list, 1)
872 assert.Len(t, b3.list, 1)
873
874 // The returned baggage needs to be immutable and should use a copy of the
875 // properties slice.
876 p[0] = Property{key: "different"}
877 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
878 // Reset for below.
879 p[0] = Property{key: "p"}
880
881 m = Member{key: "another", hasData: true}
882 b4, err := b3.SetMember(m)
883 assert.NoError(t, err)
884 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
885 assert.NotContains(t, b3.list, m.key)
886 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b4.list[key])
887 assert.Equal(t, baggage.Item{}, b4.list[m.key])
888 assert.Len(t, b3.list, 1)
889 assert.Len(t, b4.list, 2)
890 }
891
892 func TestBaggageSetFalseMember(t *testing.T) {
893 b0 := Baggage{}
894
895 key := "k"
896 m := Member{key: key, hasData: false}
897 b1, err := b0.SetMember(m)
898 assert.Error(t, err)
899 assert.NotContains(t, b0.list, key)
900 assert.Equal(t, baggage.Item{}, b1.list[key])
901 assert.Empty(t, b0.list)
902 assert.Empty(t, b1.list)
903
904 m.value = "v"
905 b2, err := b1.SetMember(m)
906 assert.Error(t, err)
907 assert.Equal(t, baggage.Item{}, b1.list[key])
908 assert.Equal(t, baggage.Item{Value: ""}, b2.list[key])
909 assert.Empty(t, b1.list)
910 assert.Empty(t, b2.list)
911 }
912
913 func TestBaggageSetFalseMembers(t *testing.T) {
914 b0 := Baggage{}
915
916 key := "k"
917 m := Member{key: key, hasData: true}
918 b1, err := b0.SetMember(m)
919 assert.NoError(t, err)
920 assert.NotContains(t, b0.list, key)
921 assert.Equal(t, baggage.Item{}, b1.list[key])
922 assert.Empty(t, b0.list)
923 assert.Len(t, b1.list, 1)
924
925 m.value = "v"
926 b2, err := b1.SetMember(m)
927 assert.NoError(t, err)
928 assert.Equal(t, baggage.Item{}, b1.list[key])
929 assert.Equal(t, baggage.Item{Value: "v"}, b2.list[key])
930 assert.Len(t, b1.list, 1)
931 assert.Len(t, b2.list, 1)
932
933 p := properties{{key: "p"}}
934 m.properties = p
935 b3, err := b2.SetMember(m)
936 assert.NoError(t, err)
937 assert.Equal(t, baggage.Item{Value: "v"}, b2.list[key])
938 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
939 assert.Len(t, b2.list, 1)
940 assert.Len(t, b3.list, 1)
941
942 // The returned baggage needs to be immutable and should use a copy of the
943 // properties slice.
944 p[0] = Property{key: "different"}
945 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
946 // Reset for below.
947 p[0] = Property{key: "p"}
948
949 m = Member{key: "another"}
950 b4, err := b3.SetMember(m)
951 assert.Error(t, err)
952 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b3.list[key])
953 assert.NotContains(t, b3.list, m.key)
954 assert.Equal(t, baggage.Item{Value: "v", Properties: []baggage.Property{{Key: "p"}}}, b4.list[key])
955 assert.Equal(t, baggage.Item{}, b4.list[m.key])
956 assert.Len(t, b3.list, 1)
957 assert.Len(t, b4.list, 1)
958 }
959
960 func TestNilBaggageMembers(t *testing.T) {
961 assert.Nil(t, Baggage{}.Members())
962 }
963
964 func TestBaggageMembers(t *testing.T) {
965 members := []Member{
966 {
967 key: "foo",
968 value: "1",
969 properties: properties{
970 {key: "state", value: "on", hasValue: true},
971 {key: "red"},
972 },
973 hasData: true,
974 },
975 {
976 key: "bar",
977 value: "2",
978 properties: properties{
979 {key: "yellow"},
980 },
981 hasData: true,
982 },
983 }
984
985 bag := Baggage{list: baggage.List{
986 "foo": {
987 Value: "1",
988 Properties: []baggage.Property{
989 {Key: "state", Value: "on", HasValue: true},
990 {Key: "red"},
991 },
992 },
993 "bar": {
994 Value: "2",
995 Properties: []baggage.Property{{Key: "yellow"}},
996 },
997 }}
998
999 assert.ElementsMatch(t, members, bag.Members())
1000 }
1001
1002 func TestBaggageMember(t *testing.T) {
1003 bag := Baggage{list: baggage.List{"foo": {Value: "1"}}}
1004 assert.Equal(t, Member{key: "foo", value: "1", hasData: true}, bag.Member("foo"))
1005 assert.Equal(t, Member{}, bag.Member("bar"))
1006 }
1007
1008 func TestMemberKey(t *testing.T) {
1009 m := Member{}
1010 assert.Empty(t, m.Key(), "even invalid values should be returned")
1011
1012 key := "k"
1013 m.key = key
1014 assert.Equal(t, key, m.Key())
1015 }
1016
1017 func TestMemberValue(t *testing.T) {
1018 m := Member{key: "k", value: "\\"}
1019 assert.Equal(t, "\\", m.Value(), "even invalid values should be returned")
1020
1021 value := "v"
1022 m.value = value
1023 assert.Equal(t, value, m.Value())
1024 }
1025
1026 func TestMemberProperties(t *testing.T) {
1027 m := Member{key: "k", value: "v"}
1028 assert.Nil(t, m.Properties())
1029
1030 p := []Property{{key: "foo"}}
1031 m.properties = properties(p)
1032 got := m.Properties()
1033 assert.Equal(t, p, got)
1034
1035 // Returned slice needs to be a copy so the original is immutable.
1036 got[0] = Property{key: "bar"}
1037 assert.NotEqual(t, m.properties, got)
1038 }
1039
1040 func TestMemberValidation(t *testing.T) {
1041 m := Member{hasData: false}
1042 assert.ErrorIs(t, m.validate(), errInvalidMember)
1043
1044 m.hasData = true
1045 assert.ErrorIs(t, m.validate(), errInvalidKey)
1046
1047 // Invalid UTF-8 in value
1048 m.key, m.value = "k", string([]byte{255})
1049 assert.ErrorIs(t, m.validate(), errInvalidValue)
1050
1051 m.key, m.value = "k", "\\"
1052 assert.NoError(t, m.validate())
1053 }
1054
1055 func TestNewMember(t *testing.T) {
1056 m, err := NewMember("", "")
1057 assert.ErrorIs(t, err, errInvalidKey)
1058 assert.Equal(t, Member{hasData: false}, m)
1059
1060 key, val := "k", "v"
1061 p := Property{key: "foo"}
1062 m, err = NewMember(key, val, p)
1063 assert.NoError(t, err)
1064 expected := Member{
1065 key: key,
1066 value: val,
1067 properties: properties{{key: "foo"}},
1068 hasData: true,
1069 }
1070 assert.Equal(t, expected, m)
1071
1072 // it won't use percent decoding for key
1073 key = "%3B"
1074 m, err = NewMember(key, val, p)
1075 assert.NoError(t, err)
1076 expected = Member{
1077 key: key,
1078 value: val,
1079 properties: properties{{key: "foo"}},
1080 hasData: true,
1081 }
1082 assert.Equal(t, expected, m)
1083
1084 // wrong value with invalid token
1085 key = "k"
1086 val = ";"
1087 _, err = NewMember(key, val, p)
1088 assert.ErrorIs(t, err, errInvalidValue)
1089
1090 // wrong value with wrong decoding
1091 val = "%zzzzz"
1092 _, err = NewMember(key, val, p)
1093 assert.ErrorIs(t, err, errInvalidValue)
1094
1095 // value should be decoded
1096 val = "%3B"
1097 m, err = NewMember(key, val, p)
1098 expected = Member{
1099 key: key,
1100 value: ";",
1101 properties: properties{{key: "foo"}},
1102 hasData: true,
1103 }
1104 assert.NoError(t, err)
1105 assert.Equal(t, expected, m)
1106
1107 // Ensure new member is immutable.
1108 p.key = "bar"
1109 assert.Equal(t, expected, m)
1110 }
1111
1112 func TestNewMemberRaw(t *testing.T) {
1113 m, err := NewMemberRaw("", "")
1114 assert.ErrorIs(t, err, errInvalidKey)
1115 assert.Equal(t, Member{hasData: false}, m)
1116
1117 key, val := "k", "v"
1118 p := Property{key: "foo"}
1119 m, err = NewMemberRaw(key, val, p)
1120 assert.NoError(t, err)
1121 expected := Member{
1122 key: key,
1123 value: val,
1124 properties: properties{{key: "foo"}},
1125 hasData: true,
1126 }
1127 assert.Equal(t, expected, m)
1128
1129 // Ensure new member is immutable.
1130 p.key = "bar"
1131 assert.Equal(t, expected, m)
1132 }
1133
1134 func TestBaggageUTF8(t *testing.T) {
1135 testCases := map[string]string{
1136 "ąść": "B% 💼",
1137
1138 // Case sensitive
1139 "a": "a",
1140 "A": "A",
1141 }
1142
1143 var members []Member
1144 for k, v := range testCases {
1145 m, err := NewMemberRaw(k, v)
1146 require.NoError(t, err)
1147
1148 members = append(members, m)
1149 }
1150
1151 b, err := New(members...)
1152 require.NoError(t, err)
1153
1154 for k, v := range testCases {
1155 assert.Equal(t, v, b.Member(k).Value())
1156 }
1157 }
1158
1159 func TestPropertiesValidate(t *testing.T) {
1160 p := properties{{}}
1161 assert.ErrorIs(t, p.validate(), errInvalidKey)
1162
1163 p[0].key = "foo"
1164 assert.NoError(t, p.validate())
1165
1166 p = append(p, Property{key: "bar"})
1167 assert.NoError(t, p.validate())
1168 }
1169
1170 func TestMemberString(t *testing.T) {
1171 // normal key value pair
1172 member, _ := NewMemberRaw("key", "value")
1173 memberStr := member.String()
1174 assert.Equal(t, "key=value", memberStr)
1175
1176 // encoded value
1177 member, _ = NewMemberRaw("key", "; ")
1178 memberStr = member.String()
1179 assert.Equal(t, "key=%3B%20", memberStr)
1180 }
1181
1182 var benchBaggage Baggage
1183
1184 func BenchmarkNew(b *testing.B) {
1185 mem1, _ := NewMemberRaw("key1", "val1")
1186 mem2, _ := NewMemberRaw("key2", "val2")
1187 mem3, _ := NewMemberRaw("key3", "val3")
1188 mem4, _ := NewMemberRaw("key4", "val4")
1189
1190 b.ReportAllocs()
1191
1192 for b.Loop() {
1193 benchBaggage, _ = New(mem1, mem2, mem3, mem4)
1194 }
1195 }
1196
1197 var benchMember Member
1198
1199 func BenchmarkNewMemberRaw(b *testing.B) {
1200 b.ReportAllocs()
1201
1202 for b.Loop() {
1203 benchMember, _ = NewMemberRaw("key", "value")
1204 }
1205 }
1206
1207 func BenchmarkParse(b *testing.B) {
1208 b.ReportAllocs()
1209
1210 for b.Loop() {
1211 benchBaggage, _ = Parse(
1212 "userId=alice,serverNode = DF28 , isProduction = false,hasProp=stuff;propKey;propWValue=value, invalidUtf8=pr%ffo%ffp%fcValue",
1213 )
1214 }
1215 }
1216
1217 func BenchmarkString(b *testing.B) {
1218 var members []Member
1219 addMember := func(k, v string) {
1220 m, err := NewMemberRaw(k, valueEscape(v))
1221 require.NoError(b, err)
1222 members = append(members, m)
1223 }
1224
1225 addMember("key1", "val1")
1226 addMember("key2", " ;,%")
1227 addMember("B% 💼", "Witaj świecie!")
1228 addMember("key4", strings.Repeat("Hello world!", 10))
1229
1230 bg, err := New(members...)
1231 require.NoError(b, err)
1232
1233 b.ReportAllocs()
1234
1235 for b.Loop() {
1236 _ = bg.String()
1237 }
1238 }
1239
1240 func BenchmarkValueEscape(b *testing.B) {
1241 testCases := []struct {
1242 name string
1243 in string
1244 }{
1245 {name: "nothing to escape", in: "value"},
1246 {name: "requires escaping", in: " ;,%"},
1247 {name: "long value", in: strings.Repeat("Hello world!", 20)},
1248 }
1249
1250 for _, tc := range testCases {
1251 b.Run(tc.name, func(b *testing.B) {
1252 b.ReportAllocs()
1253
1254 for i := 0; i < b.N; i++ {
1255 _ = valueEscape(tc.in)
1256 }
1257 })
1258 }
1259 }
1260
1261 func BenchmarkMemberString(b *testing.B) {
1262 alphabet := "abcdefghijklmnopqrstuvwxyz"
1263 props := make([]Property, len(alphabet))
1264 for i, r := range alphabet {
1265 props[i] = Property{key: string(r)}
1266 }
1267 member, err := NewMember(alphabet, alphabet, props...)
1268 require.NoError(b, err)
1269 b.ReportAllocs()
1270
1271 for b.Loop() {
1272 _ = member.String()
1273 }
1274 }