Debian Codegraph @

konnectivity-client/pkg/client/client_test.go

raw
1 /*
2 Copyright 2019 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package client
18
19 import (
20 "bytes"
21 "context"
22 "errors"
23 "flag"
24 "io"
25 "sync"
26 "testing"
27 "time"
28
29 "github.com/prometheus/client_golang/prometheus"
30 "go.uber.org/goleak"
31 "google.golang.org/grpc"
32 "k8s.io/klog/v2"
33 "sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/metrics"
34 metricstest "sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/common/metrics/testing"
35 "sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client"
36 )
37
38 func TestMain(m *testing.M) {
39 fs := flag.NewFlagSet("test", flag.PanicOnError)
40 klog.InitFlags(fs)
41 fs.Set("v", "9")
42 metrics.Metrics.RegisterMetrics(prometheus.DefaultRegisterer)
43
44 m.Run()
45 }
46
47 func TestDial(t *testing.T) {
48 expectCleanShutdown(t)
49
50 ctx := context.Background()
51 s, ps := pipe()
52 ts := testServer(ps, 100)
53
54 defer ps.Close()
55 defer s.Close()
56
57 tunnel := newUnstartedTunnel(s, s.conn())
58
59 if err := metricstest.ExpectClientConnection(metrics.ClientConnectionStatusCreated, 1); err != nil {
60 t.Error(err)
61 }
62
63 go tunnel.serve(ctx)
64 go ts.serve()
65
66 _, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
67 if err != nil {
68 t.Fatalf("expect nil; got %v", err)
69 }
70
71 if ts.packets[0].Type != client.PacketType_DIAL_REQ {
72 t.Fatalf("expect packet.type %v; got %v", client.PacketType_DIAL_REQ, ts.packets[0].Type)
73 }
74
75 if ts.packets[0].GetDialRequest().Address != "127.0.0.1:80" {
76 t.Errorf("expect packet.address %v; got %v", "127.0.0.1:80", ts.packets[0].GetDialRequest().Address)
77 }
78
79 if err := metricstest.ExpectClientConnections(map[metrics.ClientConnectionStatus]int{
80 metrics.ClientConnectionStatusCreated: 0,
81 metrics.ClientConnectionStatusDialing: 0,
82 metrics.ClientConnectionStatusOk: 1,
83 }); err != nil {
84 t.Error(err)
85 }
86 if err := metricstest.ExpectClientDialFailures(nil); err != nil {
87 t.Error(err)
88 }
89 metrics.Metrics.Reset() // For clean shutdown.
90 }
91
92 // TestDialRace exercises the scenario where serve() observes and handles DIAL_RSP
93 // before DialContext() does any work after sending the DIAL_REQ.
94 func TestDialRace(t *testing.T) {
95 expectCleanShutdown(t)
96
97 ctx := context.Background()
98 s, ps := pipe()
99 ts := testServer(ps, 100)
100
101 defer ps.Close()
102 defer s.Close()
103
104 // artificially delay after calling Send, ensure handoff of result from serve to DialContext still works
105 slowStream := fakeSlowSend{s}
106 tunnel := newUnstartedTunnel(slowStream, &fakeConn{})
107
108 go tunnel.serve(ctx)
109 go ts.serve()
110
111 _, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
112 if err != nil {
113 t.Fatalf("expect nil; got %v", err)
114 }
115
116 if ts.packets[0].Type != client.PacketType_DIAL_REQ {
117 t.Fatalf("expect packet.type %v; got %v", client.PacketType_DIAL_REQ, ts.packets[0].Type)
118 }
119
120 if ts.packets[0].GetDialRequest().Address != "127.0.0.1:80" {
121 t.Errorf("expect packet.address %v; got %v", "127.0.0.1:80", ts.packets[0].GetDialRequest().Address)
122 }
123
124 if err := metricstest.ExpectClientDialFailures(nil); err != nil {
125 t.Error(err)
126 }
127 }
128
129 // fakeSlowSend wraps ProxyService_ProxyClient and adds an artificial 1 second delay after calling Send
130 type fakeSlowSend struct {
131 client.ProxyService_ProxyClient
132 }
133
134 func (s fakeSlowSend) Send(p *client.Packet) error {
135 // send the request so it can start being processed immediately
136 err := s.ProxyService_ProxyClient.Send(p)
137 // delay returning to simulate slowness on the client side,
138 // to exercise serve() observing/handling the DIAL_RSP before
139 // the client does any post-Send() work
140 time.Sleep(time.Second)
141 return err
142 }
143
144 func TestAlreadyDialed(t *testing.T) {
145 expectCleanShutdown(t)
146
147 ctx := context.Background()
148 s, ps := pipe()
149 ts := testServer(ps, 100)
150
151 defer ps.Close()
152 defer s.Close()
153
154 // artificially delay after calling Send, ensure handoff of result from serve to DialContext still works
155 slowStream := fakeSlowSend{s}
156 tunnel := newUnstartedTunnel(slowStream, &fakeConn{})
157
158 go tunnel.serve(ctx)
159 go ts.serve()
160
161 _, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
162 if err != nil {
163 t.Fatalf("expect nil; got %v", err)
164 }
165
166 // Duplicate
167 _, err = tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
168 if err == nil {
169 t.Fatalf("expect duplicate dial error, got nil")
170 }
171
172 if err := metricstest.ExpectClientDialFailure(metrics.DialFailureAlreadyStarted, 1); err != nil {
173 t.Error(err)
174 }
175 metrics.Metrics.Reset() // For clean shutdown.
176 }
177
178 func TestData(t *testing.T) {
179 expectCleanShutdown(t)
180
181 ctx := context.Background()
182 s, ps := pipe()
183 ts := testServer(ps, 100)
184
185 defer ps.Close()
186 defer s.Close()
187
188 tunnel := newUnstartedTunnel(s, s.conn())
189
190 go tunnel.serve(ctx)
191 go ts.serve()
192
193 conn, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
194 if err != nil {
195 t.Fatalf("expect nil; got %v", err)
196 }
197
198 datas := [][]byte{
199 []byte("hello"),
200 []byte(", "),
201 []byte("world."),
202 }
203
204 // send data using conn.Write
205 for _, data := range datas {
206 n, err := conn.Write(data)
207 if err != nil {
208 t.Error(err)
209 }
210 if n != len(data) {
211 t.Errorf("expect n=%d len(%q); got %d", len(data), string(data), n)
212 }
213 }
214
215 // test server should echo data back
216 var buf [64]byte
217 for _, data := range datas {
218 n, err := conn.Read(buf[:])
219 if err != nil {
220 t.Error(err)
221 }
222
223 if string(buf[:n]) != "echo: "+string(data) {
224 t.Errorf("expect 'echo: %s'; got %s", string(data), string(buf[:n]))
225 }
226 }
227
228 // verify test server received data
229 if ts.data.String() != "hello, world." {
230 t.Errorf("expect server received %v; got %v", "hello, world.", ts.data.String())
231 }
232 }
233
234 func TestClose(t *testing.T) {
235 expectCleanShutdown(t)
236
237 ctx := context.Background()
238 s, ps := pipe()
239 ts := testServer(ps, 100)
240
241 defer ps.Close()
242 defer s.Close()
243
244 tunnel := newUnstartedTunnel(s, s.conn())
245
246 go tunnel.serve(ctx)
247 go ts.serve()
248
249 conn, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
250 if err != nil {
251 t.Fatalf("expect nil; got %v", err)
252 }
253
254 if err := metricstest.ExpectClientConnections(map[metrics.ClientConnectionStatus]int{
255 metrics.ClientConnectionStatusCreated: 0,
256 metrics.ClientConnectionStatusDialing: 0,
257 metrics.ClientConnectionStatusOk: 1,
258 }); err != nil {
259 t.Error(err)
260 }
261
262 if err := conn.Close(); err != nil {
263 t.Error(err)
264 }
265
266 if ts.packets[1].Type != client.PacketType_CLOSE_REQ {
267 t.Fatalf("expect packet.type %v; got %v", client.PacketType_CLOSE_REQ, ts.packets[1].Type)
268 }
269 if ts.packets[1].GetCloseRequest().ConnectID != 100 {
270 t.Errorf("expect connectID=100; got %d", ts.packets[1].GetCloseRequest().ConnectID)
271 }
272
273 <-tunnel.Done()
274 if err := metricstest.ExpectClientConnections(map[metrics.ClientConnectionStatus]int{
275 metrics.ClientConnectionStatusCreated: 0,
276 metrics.ClientConnectionStatusDialing: 0,
277 metrics.ClientConnectionStatusOk: 0,
278 }); err != nil {
279 t.Error(err)
280 }
281 metrics.Metrics.Reset() // For clean shutdown.
282 }
283
284 func TestCloseTimeout(t *testing.T) {
285 if testing.Short() {
286 t.Skip()
287 }
288 expectCleanShutdown(t)
289
290 ctx := context.Background()
291 s, ps := pipe()
292 ts := testServer(ps, 100)
293
294 // sending a nil response for close handler should trigger the timeout
295 // since we never receive CLOSE_RSP
296 ts.handlers[client.PacketType_CLOSE_REQ] = func(pkt *client.Packet) *client.Packet {
297 return nil
298 }
299
300 defer ps.Close()
301 defer s.Close()
302
303 tunnel := newUnstartedTunnel(s, s.conn())
304
305 go tunnel.serve(ctx)
306 go ts.serve()
307
308 conn, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
309 if err != nil {
310 t.Fatalf("expect nil; got %v", err)
311 }
312
313 go func() {
314 buf := make([]byte, 10)
315 _, err = conn.Read(buf)
316 if err != io.EOF {
317 t.Errorf("expected %v: got %v", io.EOF, err)
318 }
319 }()
320
321 if err := conn.Close(); err != errConnCloseTimeout {
322 t.Errorf("expected %v but got %v", errConnCloseTimeout, err)
323 }
324
325 <-tunnel.Done()
326 if err := metricstest.ExpectClientConnections(map[metrics.ClientConnectionStatus]int{
327 metrics.ClientConnectionStatusCreated: 0,
328 metrics.ClientConnectionStatusDialing: 0,
329 metrics.ClientConnectionStatusOk: 0,
330 }); err != nil {
331 t.Error(err)
332 }
333 metrics.Metrics.Reset() // For clean shutdown.
334 }
335
336 func TestCreateSingleUseGrpcTunnel_NoLeakOnFailure(t *testing.T) {
337 defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
338
339 tunnel, err := CreateSingleUseGrpcTunnel(context.Background(), "127.0.0.1:12345", grpc.WithInsecure())
340 if tunnel != nil {
341 t.Fatal("expected nil tunnel when calling CreateSingleUseGrpcTunnel")
342 }
343 if err == nil {
344 t.Fatal("expected error when calling CreateSingleUseGrpcTunnel")
345 }
346 }
347
348 func TestCreateSingleUseGrpcTunnelWithContext_NoLeakOnFailure(t *testing.T) {
349 defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
350
351 tunnel, err := CreateSingleUseGrpcTunnelWithContext(context.Background(), context.Background(), "127.0.0.1:12345", grpc.WithInsecure())
352 if tunnel != nil {
353 t.Fatal("expected nil tunnel when calling CreateSingleUseGrpcTunnelWithContext")
354 }
355 if err == nil {
356 t.Fatal("expected error when calling CreateSingleUseGrpcTunnelWithContext")
357 }
358 }
359
360 func TestDialAfterTunnelCancelled(t *testing.T) {
361 expectCleanShutdown(t)
362
363 ctx, cancel := context.WithCancel(context.Background())
364 cancel()
365 s, ps := pipeWithContext(ctx)
366 ts := testServer(ps, 100)
367
368 defer ps.Close()
369 defer s.Close()
370
371 tunnel := newUnstartedTunnel(s, s.conn())
372
373 go tunnel.serve(ctx)
374 go ts.serve()
375
376 _, err := tunnel.DialContext(ctx, "tcp", "127.0.0.1:80")
377 if err == nil {
378 t.Fatalf("expect err when dialing after tunnel closed")
379 }
380
381 // TODO(jkh52): verify dial failure metric.
382 metrics.Metrics.Reset() // For clean shutdown.
383
384 select {
385 case <-tunnel.Done():
386 case <-time.After(30 * time.Second):
387 t.Errorf("Timed out waiting for tunnel to close")
388 }
389 }
390
391 func TestDial_RequestContextCancelled(t *testing.T) {
392 expectCleanShutdown(t)
393
394 s, ps := pipe()
395 defer ps.Close()
396 defer s.Close()
397
398 ts := testServer(ps, 100)
399 reqCtx, reqCancel := context.WithCancel(context.Background())
400 ts.handlers[client.PacketType_DIAL_REQ] = func(*client.Packet) *client.Packet {
401 reqCancel()
402 return nil // don't respond
403 }
404 closeCh := make(chan struct{})
405 ts.handlers[client.PacketType_DIAL_CLS] = func(*client.Packet) *client.Packet {
406 close(closeCh)
407 return nil // don't respond
408 }
409 go ts.serve()
410
411 func() {
412 tunnel := newUnstartedTunnel(s, s.conn())
413 go tunnel.serve(context.Background())
414
415 _, err := tunnel.DialContext(reqCtx, "tcp", "127.0.0.1:80")
416 if err == nil {
417 t.Fatalf("Expected dial error, got none")
418 }
419
420 isDialFailure, reason := GetDialFailureReason(err)
421 if !isDialFailure {
422 t.Errorf("Unexpected non-dial failure error: %v", err)
423 } else if reason != metrics.DialFailureContext {
424 t.Errorf("Expected DialFailureContext, got %v", reason)
425 }
426
427 if err := metricstest.ExpectClientDialFailure(metrics.DialFailureContext, 1); err != nil {
428 t.Error(err)
429 }
430 metrics.Metrics.Reset() // For clean shutdown.
431
432 ts.assertPacketType(0, client.PacketType_DIAL_REQ)
433 waitForDialClsStart := time.Now()
434 select {
435 case <-closeCh:
436 t.Logf("Dial closed after %#v", time.Since(waitForDialClsStart).String())
437 ts.assertPacketType(1, client.PacketType_DIAL_CLS)
438 case <-time.After(30 * time.Second):
439 t.Fatal("Timed out waiting for DIAL_CLS packet")
440 }
441
442 waitForTunnelCloseStart := time.Now()
443 select {
444 case <-tunnel.Done():
445 t.Logf("Tunnel closed after %#v", time.Since(waitForTunnelCloseStart).String())
446 case <-time.After(30 * time.Second):
447 t.Errorf("Timed out waiting for tunnel to close")
448 }
449 }()
450 }
451
452 func TestDial_BackendError(t *testing.T) {
453 expectCleanShutdown(t)
454
455 s, ps := pipe()
456 ts := testServer(ps, 100)
457 ts.handlers[client.PacketType_DIAL_REQ] = func(pkt *client.Packet) *client.Packet {
458 return &client.Packet{
459 Type: client.PacketType_DIAL_RSP,
460 Payload: &client.Packet_DialResponse{
461 DialResponse: &client.DialResponse{
462 Random: pkt.GetDialRequest().Random,
463 Error: "fake backend error",
464 },
465 },
466 }
467 }
468
469 defer ps.Close()
470 defer s.Close()
471
472 tunnel := newUnstartedTunnel(s, s.conn())
473
474 go tunnel.serve(context.Background())
475 go ts.serve()
476
477 _, err := tunnel.DialContext(context.Background(), "tcp", "127.0.0.1:80")
478 if err == nil {
479 t.Fatalf("Expected dial error, got none")
480 }
481
482 isDialFailure, reason := GetDialFailureReason(err)
483 if !isDialFailure {
484 t.Errorf("Unexpected non-dial failure error: %v", err)
485 } else if reason != metrics.DialFailureEndpoint {
486 t.Errorf("Expected DialFailureEndpoint, got %v", reason)
487 }
488
489 ts.assertPacketType(0, client.PacketType_DIAL_REQ)
490
491 if err := metricstest.ExpectClientDialFailure(metrics.DialFailureEndpoint, 1); err != nil {
492 t.Error(err)
493 }
494 metrics.Metrics.Reset() // For clean shutdown.
495 }
496
497 func TestDial_Closed(t *testing.T) {
498 expectCleanShutdown(t)
499
500 s, ps := pipe()
501 defer ps.Close()
502 defer s.Close()
503
504 ts := testServer(ps, 100)
505 ts.handlers[client.PacketType_DIAL_REQ] = func(pkt *client.Packet) *client.Packet {
506 return &client.Packet{
507 Type: client.PacketType_DIAL_CLS,
508 Payload: &client.Packet_CloseDial{
509 CloseDial: &client.CloseDial{
510 Random: pkt.GetDialRequest().Random,
511 },
512 },
513 }
514 }
515 go ts.serve()
516
517 func() {
518 // Verify that the tunnel goroutines are not leaked before cleaning up the test server.
519 goleak.VerifyNone(t, goleak.IgnoreCurrent())
520
521 tunnel := newUnstartedTunnel(s, s.conn())
522 go tunnel.serve(context.Background())
523
524 _, err := tunnel.DialContext(context.Background(), "tcp", "127.0.0.1:80")
525 if err == nil {
526 t.Fatalf("Expected dial error, got none")
527 }
528
529 isDialFailure, reason := GetDialFailureReason(err)
530 if !isDialFailure {
531 t.Errorf("Unexpected non-dial failure error: %v", err)
532 } else if reason != metrics.DialFailureDialClosed {
533 t.Errorf("Expected DialFailureDialClosed, got %v", reason)
534 }
535
536 ts.assertPacketType(0, client.PacketType_DIAL_REQ)
537
538 if err := metricstest.ExpectClientDialFailure(metrics.DialFailureDialClosed, 1); err != nil {
539 t.Error(err)
540 }
541 metrics.Metrics.Reset() // For clean shutdown.
542
543 select {
544 case <-tunnel.Done():
545 case <-time.After(30 * time.Second):
546 t.Errorf("Timed out waiting for tunnel to close")
547 }
548 }()
549 }
550
551 func TestRegisterMetrics(t *testing.T) {
552 Metrics.RegisterMetrics(prometheus.DefaultRegisterer)
553 }
554
555 func TestLegacyRegisterMetrics(t *testing.T) {
556 Metrics.LegacyRegisterMetrics(prometheus.MustRegister)
557 }
558
559 // TODO: Move to common testing library
560
561 // fakeStream implements ProxyService_ProxyClient
562 type fakeStream struct {
563 grpc.ClientStream
564 r <-chan *client.Packet
565 w chan<- *client.Packet
566 done <-chan struct{}
567 closed chan struct{}
568 }
569
570 type fakeConn struct {
571 stream *fakeStream
572 }
573
574 func (f *fakeConn) Close() error {
575 if f.stream != nil {
576 f.stream.Close()
577 }
578 return nil
579 }
580
581 var _ clientConn = &fakeConn{}
582
583 var _ client.ProxyService_ProxyClient = &fakeStream{}
584
585 func pipe() (*fakeStream, *fakeStream) {
586 return pipeWithContext(context.Background())
587 }
588
589 func pipeWithContext(context context.Context) (*fakeStream, *fakeStream) {
590 r, w := make(chan *client.Packet, 2), make(chan *client.Packet, 2)
591 s1 := &fakeStream{done: context.Done(), closed: make(chan struct{})}
592 s2 := &fakeStream{done: context.Done(), closed: make(chan struct{})}
593 s1.r, s1.w = r, w
594 s2.r, s2.w = w, r
595 return s1, s2
596 }
597
598 func (s *fakeStream) Send(packet *client.Packet) error {
599 klog.V(4).InfoS("[DEBUG] send", "packet", packet)
600 if packet == nil {
601 return nil
602 }
603 select {
604 case <-s.done:
605 return errors.New("Send on cancelled stream")
606 case <-s.closed:
607 return errors.New("Send on closed stream")
608 case s.w <- packet:
609 return nil
610 }
611 }
612
613 func (s *fakeStream) Recv() (*client.Packet, error) {
614 select {
615 case <-s.done:
616 return nil, errors.New("Recv on cancelled stream")
617 case <-s.closed:
618 return nil, errors.New("Recv on closed stream")
619 case pkt := <-s.r:
620 klog.V(4).InfoS("[DEBUG] recv", "packet", pkt)
621 return pkt, nil
622 case <-time.After(30 * time.Second):
623 return nil, errors.New("timeout recv")
624 }
625 }
626
627 func (s *fakeStream) Close() {
628 select {
629 case <-s.closed: // Avoid double-closing
630 default:
631 close(s.closed)
632 }
633 }
634
635 func (s *fakeStream) conn() *fakeConn {
636 return &fakeConn{s}
637 }
638
639 type proxyServer struct {
640 t testing.T
641 s client.ProxyService_ProxyClient
642 handlers map[client.PacketType]handler
643 connid int64
644 data bytes.Buffer
645
646 packets []*client.Packet
647 packetsLock sync.Mutex
648 }
649
650 func testServer(s client.ProxyService_ProxyClient, connid int64) *proxyServer {
651 server := &proxyServer{
652 s: s,
653 connid: connid,
654 handlers: make(map[client.PacketType]handler),
655 packets: []*client.Packet{},
656 }
657
658 server.handlers[client.PacketType_CLOSE_REQ] = server.handleClose
659 server.handlers[client.PacketType_DIAL_REQ] = server.handleDial
660 server.handlers[client.PacketType_DATA] = server.handleData
661
662 return server
663 }
664
665 func (s *proxyServer) serve() {
666 for {
667 pkt, err := s.s.Recv()
668 if err != nil {
669 s.t.Error(err)
670 return
671 }
672
673 if pkt == nil {
674 return
675 }
676
677 func() {
678 s.packetsLock.Lock()
679 defer s.packetsLock.Unlock()
680 s.packets = append(s.packets, pkt)
681 }()
682
683 if handler, ok := s.handlers[pkt.Type]; ok {
684 req := handler(pkt)
685 if req != nil {
686 if err := s.s.Send(req); err != nil {
687 s.t.Error(err)
688 }
689 }
690 }
691 }
692 }
693
694 func (s *proxyServer) assertPacketType(index int, expectedType client.PacketType) {
695 s.packetsLock.Lock()
696 defer s.packetsLock.Unlock()
697
698 if index >= len(s.packets) {
699 s.t.Fatalf("Expected %v packet[%d], but have only received %d packets", expectedType, index, len(s.packets))
700 }
701 actual := s.packets[index].Type
702 if actual != expectedType {
703 s.t.Errorf("Unexpected packet[%d].type: got %v, expected %v", index, actual, expectedType)
704 }
705 }
706
707 type handler func(pkt *client.Packet) *client.Packet
708
709 func (s *proxyServer) handleDial(pkt *client.Packet) *client.Packet {
710 return &client.Packet{
711 Type: client.PacketType_DIAL_RSP,
712 Payload: &client.Packet_DialResponse{
713 DialResponse: &client.DialResponse{
714 Random: pkt.GetDialRequest().Random,
715 ConnectID: s.connid,
716 },
717 },
718 }
719 }
720
721 func (s *proxyServer) handleClose(pkt *client.Packet) *client.Packet {
722 return &client.Packet{
723 Type: client.PacketType_CLOSE_RSP,
724 Payload: &client.Packet_CloseResponse{
725 CloseResponse: &client.CloseResponse{
726 ConnectID: pkt.GetCloseRequest().ConnectID,
727 },
728 },
729 }
730 }
731
732 func (s *proxyServer) handleData(pkt *client.Packet) *client.Packet {
733 s.data.Write(pkt.GetData().Data)
734
735 return &client.Packet{
736 Type: client.PacketType_DATA,
737 Payload: &client.Packet_Data{
738 Data: &client.Data{
739 ConnectID: pkt.GetData().ConnectID,
740 Data: append([]byte("echo: "), pkt.GetData().Data...),
741 },
742 },
743 }
744 }
745
746 func assertNoClientDialFailures(t testing.TB) {
747 t.Helper()
748 if err := metricstest.ExpectClientDialFailures(nil); err != nil {
749 t.Errorf("Unexpected %s metric: %v", "dial_failure_total", err)
750 }
751 }
752
753 func expectCleanShutdown(t testing.TB) {
754 metrics.Metrics.Reset()
755 currentGoRoutines := goleak.IgnoreCurrent()
756 t.Cleanup(func() {
757 goleak.VerifyNone(t, currentGoRoutines)
758 assertNoClientDialFailures(t)
759 // The tunnels gauge metric is intentionally not included here, to avoid
760 // brittle gauge assertions. Tests should directly verify it.
761 metrics.Metrics.Reset()
762 })
763 }