internal/transport/apicheck_test.go

Ref: main v0.0.5   Size: 2.6 KiB   History

package transport

import (
	"context"
	"crypto/tls"
	"errors"
	"testing"
	"time"

	"github.com/quic-go/quic-go"
)

// VERIFIED quic-go API SURFACE — pinned version v0.48.2.
//
// The plan's draft assumed the v0.49+ concrete types (*quic.Conn, *quic.Stream,
// *quic.Listener). In v0.48.2 the connection and stream are still INTERFACES,
// not pointer-to-struct. Later tasks MUST use these verbatim:
//
//	Listen func:   func ListenAddr(addr string, *tls.Config, *quic.Config) (*quic.Listener, error)
//	Dial func:     func DialAddr(ctx context.Context, addr string, *tls.Config, *quic.Config) (quic.Connection, error)
//	Listener type: *quic.Listener (concrete struct)
//	  Accept:      func (*quic.Listener) Accept(ctx context.Context) (quic.Connection, error)
//	Connection:    quic.Connection (INTERFACE — NOT *quic.Conn; there is no quic.Conn in v0.48.2)
//	  OpenStreamSync: OpenStreamSync(ctx context.Context) (quic.Stream, error)
//	  AcceptStream:   AcceptStream(ctx context.Context) (quic.Stream, error)
//	  CloseWithError: CloseWithError(quic.ApplicationErrorCode, string) error
//	Stream:        quic.Stream (INTERFACE — NOT *quic.Stream)
//	Error code:    quic.ApplicationErrorCode (uint64 alias)
//	Client-side error: *quic.ApplicationError (struct, alias of qerr.ApplicationError) with
//	                   fields { Remote bool; ErrorCode quic.ApplicationErrorCode; ErrorMessage string }.
//	                   Read the peer's close code via errors.As(err, &appErr); appErr.ErrorCode.
//	Config fields:  quic.Config{KeepAlivePeriod, MaxIdleTimeout} — confirmed present.

// TestQUICAPISurface is a compile-time check that the pinned quic-go version
// exposes exactly the symbols this plan targets.
func TestQUICAPISurface(t *testing.T) {
	var _ func(string, *tls.Config, *quic.Config) (*quic.Listener, error) = quic.ListenAddr
	var _ func(context.Context, string, *tls.Config, *quic.Config) (quic.Connection, error) = quic.DialAddr
	cfg := &quic.Config{KeepAlivePeriod: 15 * time.Second, MaxIdleTimeout: 30 * time.Second}
	_ = cfg
	var conn quic.Connection
	if conn != nil {
		var _ func(context.Context) (quic.Stream, error) = conn.OpenStreamSync
		var _ func(context.Context) (quic.Stream, error) = conn.AcceptStream
		var _ func(quic.ApplicationErrorCode, string) error = conn.CloseWithError
	}
	var lis *quic.Listener
	if lis != nil {
		var _ func(context.Context) (quic.Connection, error) = lis.Accept
	}
	// Client-side: reading the peer's application close code.
	if appErr, ok := errors.AsType[*quic.ApplicationError](error(nil)); ok {
		var _ quic.ApplicationErrorCode = appErr.ErrorCode
	}
}