Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

mocks

package

Go to main page

Versions in this module

v0

v0.0.3

Jul 27, 2025

v0.0.2

Jul 27, 2025

v0.0.1

Jul 26, 2025

v0.0.0

Jul 24, 2025

Changes in this version

+ type MockAuthenticator struct

+ func NewMockAuthenticator(t interface{ ... }) *MockAuthenticator

+ func (_m *MockAuthenticator) Authenticate(addr net.Addr, auth string, tx uint64) (bool, string)

+ func (_m *MockAuthenticator) EXPECT() *MockAuthenticator_Expecter

+ type MockAuthenticator_Authenticate_Call struct

+ func (_c *MockAuthenticator_Authenticate_Call) Return(ok bool, id string) *MockAuthenticator_Authenticate_Call

+ func (_c *MockAuthenticator_Authenticate_Call) Run(run func(addr net.Addr, auth string, tx uint64)) *MockAuthenticator_Authenticate_Call

+ func (_c *MockAuthenticator_Authenticate_Call) RunAndReturn(run func(net.Addr, string, uint64) (bool, string)) *MockAuthenticator_Authenticate_Call

+ type MockAuthenticator_Expecter struct

+ func (_e *MockAuthenticator_Expecter) Authenticate(addr interface{}, auth interface{}, tx interface{}) *MockAuthenticator_Authenticate_Call

+ type MockConn struct

+ func NewMockConn(t interface{ ... }) *MockConn

+ func (_m *MockConn) Close() error

+ func (_m *MockConn) EXPECT() *MockConn_Expecter

+ func (_m *MockConn) LocalAddr() net.Addr

+ func (_m *MockConn) Read(b []byte) (int, error)

+ func (_m *MockConn) RemoteAddr() net.Addr

+ func (_m *MockConn) SetDeadline(t time.Time) error

+ func (_m *MockConn) SetReadDeadline(t time.Time) error

+ func (_m *MockConn) SetWriteDeadline(t time.Time) error

+ func (_m *MockConn) Write(b []byte) (int, error)

+ type MockConn_Close_Call struct

+ func (_c *MockConn_Close_Call) Return(_a0 error) *MockConn_Close_Call

+ func (_c *MockConn_Close_Call) Run(run func()) *MockConn_Close_Call

+ func (_c *MockConn_Close_Call) RunAndReturn(run func() error) *MockConn_Close_Call

+ type MockConn_Expecter struct

+ func (_e *MockConn_Expecter) Close() *MockConn_Close_Call

+ func (_e *MockConn_Expecter) LocalAddr() *MockConn_LocalAddr_Call

+ func (_e *MockConn_Expecter) Read(b interface{}) *MockConn_Read_Call

+ func (_e *MockConn_Expecter) RemoteAddr() *MockConn_RemoteAddr_Call

+ func (_e *MockConn_Expecter) SetDeadline(t interface{}) *MockConn_SetDeadline_Call

+ func (_e *MockConn_Expecter) SetReadDeadline(t interface{}) *MockConn_SetReadDeadline_Call

+ func (_e *MockConn_Expecter) SetWriteDeadline(t interface{}) *MockConn_SetWriteDeadline_Call

+ func (_e *MockConn_Expecter) Write(b interface{}) *MockConn_Write_Call

+ type MockConn_LocalAddr_Call struct

+ func (_c *MockConn_LocalAddr_Call) Return(_a0 net.Addr) *MockConn_LocalAddr_Call

+ func (_c *MockConn_LocalAddr_Call) Run(run func()) *MockConn_LocalAddr_Call

+ func (_c *MockConn_LocalAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_LocalAddr_Call

+ type MockConn_Read_Call struct

+ func (_c *MockConn_Read_Call) Return(n int, err error) *MockConn_Read_Call

+ func (_c *MockConn_Read_Call) Run(run func(b []byte)) *MockConn_Read_Call

+ func (_c *MockConn_Read_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Read_Call

+ type MockConn_RemoteAddr_Call struct

+ func (_c *MockConn_RemoteAddr_Call) Return(_a0 net.Addr) *MockConn_RemoteAddr_Call

+ func (_c *MockConn_RemoteAddr_Call) Run(run func()) *MockConn_RemoteAddr_Call

+ func (_c *MockConn_RemoteAddr_Call) RunAndReturn(run func() net.Addr) *MockConn_RemoteAddr_Call

+ type MockConn_SetDeadline_Call struct

+ func (_c *MockConn_SetDeadline_Call) Return(_a0 error) *MockConn_SetDeadline_Call

+ func (_c *MockConn_SetDeadline_Call) Run(run func(t time.Time)) *MockConn_SetDeadline_Call

+ func (_c *MockConn_SetDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetDeadline_Call

+ type MockConn_SetReadDeadline_Call struct

+ func (_c *MockConn_SetReadDeadline_Call) Return(_a0 error) *MockConn_SetReadDeadline_Call

+ func (_c *MockConn_SetReadDeadline_Call) Run(run func(t time.Time)) *MockConn_SetReadDeadline_Call

+ func (_c *MockConn_SetReadDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetReadDeadline_Call

+ type MockConn_SetWriteDeadline_Call struct

+ func (_c *MockConn_SetWriteDeadline_Call) Return(_a0 error) *MockConn_SetWriteDeadline_Call

+ func (_c *MockConn_SetWriteDeadline_Call) Run(run func(t time.Time)) *MockConn_SetWriteDeadline_Call

+ func (_c *MockConn_SetWriteDeadline_Call) RunAndReturn(run func(time.Time) error) *MockConn_SetWriteDeadline_Call

+ type MockConn_Write_Call struct

+ func (_c *MockConn_Write_Call) Return(n int, err error) *MockConn_Write_Call

+ func (_c *MockConn_Write_Call) Run(run func(b []byte)) *MockConn_Write_Call

+ func (_c *MockConn_Write_Call) RunAndReturn(run func([]byte) (int, error)) *MockConn_Write_Call

+ type MockEventLogger struct

+ func NewMockEventLogger(t interface{ ... }) *MockEventLogger

+ func (_m *MockEventLogger) Connect(addr net.Addr, id string, tx uint64)

+ func (_m *MockEventLogger) Disconnect(addr net.Addr, id string, err error)

+ func (_m *MockEventLogger) EXPECT() *MockEventLogger_Expecter

+ func (_m *MockEventLogger) TCPError(addr net.Addr, id string, reqAddr string, err error)

+ func (_m *MockEventLogger) TCPRequest(addr net.Addr, id string, reqAddr string)

+ func (_m *MockEventLogger) UDPError(addr net.Addr, id string, sessionID uint32, err error)

+ func (_m *MockEventLogger) UDPRequest(addr net.Addr, id string, sessionID uint32, reqAddr string)

+ type MockEventLogger_Connect_Call struct

+ func (_c *MockEventLogger_Connect_Call) Return() *MockEventLogger_Connect_Call

+ func (_c *MockEventLogger_Connect_Call) Run(run func(addr net.Addr, id string, tx uint64)) *MockEventLogger_Connect_Call

+ func (_c *MockEventLogger_Connect_Call) RunAndReturn(run func(net.Addr, string, uint64)) *MockEventLogger_Connect_Call

+ type MockEventLogger_Disconnect_Call struct

+ func (_c *MockEventLogger_Disconnect_Call) Return() *MockEventLogger_Disconnect_Call

+ func (_c *MockEventLogger_Disconnect_Call) Run(run func(addr net.Addr, id string, err error)) *MockEventLogger_Disconnect_Call

+ func (_c *MockEventLogger_Disconnect_Call) RunAndReturn(run func(net.Addr, string, error)) *MockEventLogger_Disconnect_Call

+ type MockEventLogger_Expecter struct

+ func (_e *MockEventLogger_Expecter) Connect(addr interface{}, id interface{}, tx interface{}) *MockEventLogger_Connect_Call

+ func (_e *MockEventLogger_Expecter) Disconnect(addr interface{}, id interface{}, err interface{}) *MockEventLogger_Disconnect_Call

+ func (_e *MockEventLogger_Expecter) TCPError(addr interface{}, id interface{}, reqAddr interface{}, err interface{}) *MockEventLogger_TCPError_Call

+ func (_e *MockEventLogger_Expecter) TCPRequest(addr interface{}, id interface{}, reqAddr interface{}) *MockEventLogger_TCPRequest_Call

+ func (_e *MockEventLogger_Expecter) UDPError(addr interface{}, id interface{}, sessionID interface{}, err interface{}) *MockEventLogger_UDPError_Call

+ func (_e *MockEventLogger_Expecter) UDPRequest(addr interface{}, id interface{}, sessionID interface{}, reqAddr interface{}) *MockEventLogger_UDPRequest_Call

+ type MockEventLogger_TCPError_Call struct

+ func (_c *MockEventLogger_TCPError_Call) Return() *MockEventLogger_TCPError_Call

+ func (_c *MockEventLogger_TCPError_Call) Run(run func(addr net.Addr, id string, reqAddr string, err error)) *MockEventLogger_TCPError_Call

+ func (_c *MockEventLogger_TCPError_Call) RunAndReturn(run func(net.Addr, string, string, error)) *MockEventLogger_TCPError_Call

+ type MockEventLogger_TCPRequest_Call struct

+ func (_c *MockEventLogger_TCPRequest_Call) Return() *MockEventLogger_TCPRequest_Call

+ func (_c *MockEventLogger_TCPRequest_Call) Run(run func(addr net.Addr, id string, reqAddr string)) *MockEventLogger_TCPRequest_Call

+ func (_c *MockEventLogger_TCPRequest_Call) RunAndReturn(run func(net.Addr, string, string)) *MockEventLogger_TCPRequest_Call

+ type MockEventLogger_UDPError_Call struct

+ func (_c *MockEventLogger_UDPError_Call) Return() *MockEventLogger_UDPError_Call

+ func (_c *MockEventLogger_UDPError_Call) Run(run func(addr net.Addr, id string, sessionID uint32, err error)) *MockEventLogger_UDPError_Call

+ func (_c *MockEventLogger_UDPError_Call) RunAndReturn(run func(net.Addr, string, uint32, error)) *MockEventLogger_UDPError_Call

+ type MockEventLogger_UDPRequest_Call struct

+ func (_c *MockEventLogger_UDPRequest_Call) Return() *MockEventLogger_UDPRequest_Call

+ func (_c *MockEventLogger_UDPRequest_Call) Run(run func(addr net.Addr, id string, sessionID uint32, reqAddr string)) *MockEventLogger_UDPRequest_Call

+ func (_c *MockEventLogger_UDPRequest_Call) RunAndReturn(run func(net.Addr, string, uint32, string)) *MockEventLogger_UDPRequest_Call

+ type MockOutbound struct

+ func NewMockOutbound(t interface{ ... }) *MockOutbound

+ func (_m *MockOutbound) EXPECT() *MockOutbound_Expecter

+ func (_m *MockOutbound) TCP(reqAddr string) (net.Conn, error)

+ func (_m *MockOutbound) UDP(reqAddr string) (server.UDPConn, error)

+ type MockOutbound_Expecter struct

+ func (_e *MockOutbound_Expecter) TCP(reqAddr interface{}) *MockOutbound_TCP_Call

+ func (_e *MockOutbound_Expecter) UDP(reqAddr interface{}) *MockOutbound_UDP_Call

+ type MockOutbound_TCP_Call struct

+ func (_c *MockOutbound_TCP_Call) Return(_a0 net.Conn, _a1 error) *MockOutbound_TCP_Call

+ func (_c *MockOutbound_TCP_Call) Run(run func(reqAddr string)) *MockOutbound_TCP_Call

+ func (_c *MockOutbound_TCP_Call) RunAndReturn(run func(string) (net.Conn, error)) *MockOutbound_TCP_Call

+ type MockOutbound_UDP_Call struct

+ func (_c *MockOutbound_UDP_Call) Return(_a0 server.UDPConn, _a1 error) *MockOutbound_UDP_Call

+ func (_c *MockOutbound_UDP_Call) Run(run func(reqAddr string)) *MockOutbound_UDP_Call

+ func (_c *MockOutbound_UDP_Call) RunAndReturn(run func(string) (server.UDPConn, error)) *MockOutbound_UDP_Call

+ type MockRequestHook struct

+ func NewMockRequestHook(t interface{ ... }) *MockRequestHook

+ func (_m *MockRequestHook) Check(isUDP bool, reqAddr string) bool

+ func (_m *MockRequestHook) EXPECT() *MockRequestHook_Expecter

+ func (_m *MockRequestHook) TCP(stream quic.Stream, reqAddr *string) ([]byte, error)

+ func (_m *MockRequestHook) UDP(data []byte, reqAddr *string) error

+ type MockRequestHook_Check_Call struct

+ func (_c *MockRequestHook_Check_Call) Return(_a0 bool) *MockRequestHook_Check_Call

+ func (_c *MockRequestHook_Check_Call) Run(run func(isUDP bool, reqAddr string)) *MockRequestHook_Check_Call

+ func (_c *MockRequestHook_Check_Call) RunAndReturn(run func(bool, string) bool) *MockRequestHook_Check_Call

+ type MockRequestHook_Expecter struct

+ func (_e *MockRequestHook_Expecter) Check(isUDP interface{}, reqAddr interface{}) *MockRequestHook_Check_Call

+ func (_e *MockRequestHook_Expecter) TCP(stream interface{}, reqAddr interface{}) *MockRequestHook_TCP_Call

+ func (_e *MockRequestHook_Expecter) UDP(data interface{}, reqAddr interface{}) *MockRequestHook_UDP_Call

+ type MockRequestHook_TCP_Call struct

+ func (_c *MockRequestHook_TCP_Call) Return(_a0 []byte, _a1 error) *MockRequestHook_TCP_Call

+ func (_c *MockRequestHook_TCP_Call) Run(run func(stream quic.Stream, reqAddr *string)) *MockRequestHook_TCP_Call

+ func (_c *MockRequestHook_TCP_Call) RunAndReturn(run func(quic.Stream, *string) ([]byte, error)) *MockRequestHook_TCP_Call

+ type MockRequestHook_UDP_Call struct

+ func (_c *MockRequestHook_UDP_Call) Return(_a0 error) *MockRequestHook_UDP_Call

+ func (_c *MockRequestHook_UDP_Call) Run(run func(data []byte, reqAddr *string)) *MockRequestHook_UDP_Call

+ func (_c *MockRequestHook_UDP_Call) RunAndReturn(run func([]byte, *string) error) *MockRequestHook_UDP_Call

+ type MockTrafficLogger struct

+ func NewMockTrafficLogger(t interface{ ... }) *MockTrafficLogger

+ func (_m *MockTrafficLogger) EXPECT() *MockTrafficLogger_Expecter

+ func (_m *MockTrafficLogger) LogOnlineState(id string, online bool)

+ func (_m *MockTrafficLogger) LogTraffic(id string, tx uint64, rx uint64) bool

+ func (_m *MockTrafficLogger) TraceStream(stream quic.Stream, stats *server.StreamStats)

+ func (_m *MockTrafficLogger) UntraceStream(stream quic.Stream)

+ type MockTrafficLogger_Expecter struct

+ func (_e *MockTrafficLogger_Expecter) LogOnlineState(id interface{}, online interface{}) *MockTrafficLogger_LogOnlineState_Call

+ func (_e *MockTrafficLogger_Expecter) LogTraffic(id interface{}, tx interface{}, rx interface{}) *MockTrafficLogger_LogTraffic_Call

+ func (_e *MockTrafficLogger_Expecter) TraceStream(stream interface{}, stats interface{}) *MockTrafficLogger_TraceStream_Call

+ func (_e *MockTrafficLogger_Expecter) UntraceStream(stream interface{}) *MockTrafficLogger_UntraceStream_Call

+ type MockTrafficLogger_LogOnlineState_Call struct

+ func (_c *MockTrafficLogger_LogOnlineState_Call) Return() *MockTrafficLogger_LogOnlineState_Call

+ func (_c *MockTrafficLogger_LogOnlineState_Call) Run(run func(id string, online bool)) *MockTrafficLogger_LogOnlineState_Call

+ func (_c *MockTrafficLogger_LogOnlineState_Call) RunAndReturn(run func(string, bool)) *MockTrafficLogger_LogOnlineState_Call

+ type MockTrafficLogger_LogTraffic_Call struct

+ func (_c *MockTrafficLogger_LogTraffic_Call) Return(ok bool) *MockTrafficLogger_LogTraffic_Call

+ func (_c *MockTrafficLogger_LogTraffic_Call) Run(run func(id string, tx uint64, rx uint64)) *MockTrafficLogger_LogTraffic_Call

+ func (_c *MockTrafficLogger_LogTraffic_Call) RunAndReturn(run func(string, uint64, uint64) bool) *MockTrafficLogger_LogTraffic_Call

+ type MockTrafficLogger_TraceStream_Call struct

+ func (_c *MockTrafficLogger_TraceStream_Call) Return() *MockTrafficLogger_TraceStream_Call

+ func (_c *MockTrafficLogger_TraceStream_Call) Run(run func(stream quic.Stream, stats *server.StreamStats)) *MockTrafficLogger_TraceStream_Call

+ func (_c *MockTrafficLogger_TraceStream_Call) RunAndReturn(run func(quic.Stream, *server.StreamStats)) *MockTrafficLogger_TraceStream_Call

+ type MockTrafficLogger_UntraceStream_Call struct

+ func (_c *MockTrafficLogger_UntraceStream_Call) Return() *MockTrafficLogger_UntraceStream_Call

+ func (_c *MockTrafficLogger_UntraceStream_Call) Run(run func(stream quic.Stream)) *MockTrafficLogger_UntraceStream_Call

+ func (_c *MockTrafficLogger_UntraceStream_Call) RunAndReturn(run func(quic.Stream)) *MockTrafficLogger_UntraceStream_Call

+ type MockUDPConn struct

+ func NewMockUDPConn(t interface{ ... }) *MockUDPConn

+ func (_m *MockUDPConn) Close() error

+ func (_m *MockUDPConn) EXPECT() *MockUDPConn_Expecter

+ func (_m *MockUDPConn) ReadFrom(b []byte) (int, string, error)

+ func (_m *MockUDPConn) WriteTo(b []byte, addr string) (int, error)

+ type MockUDPConn_Close_Call struct

+ func (_c *MockUDPConn_Close_Call) Return(_a0 error) *MockUDPConn_Close_Call

+ func (_c *MockUDPConn_Close_Call) Run(run func()) *MockUDPConn_Close_Call

+ func (_c *MockUDPConn_Close_Call) RunAndReturn(run func() error) *MockUDPConn_Close_Call

+ type MockUDPConn_Expecter struct

+ func (_e *MockUDPConn_Expecter) Close() *MockUDPConn_Close_Call

+ func (_e *MockUDPConn_Expecter) ReadFrom(b interface{}) *MockUDPConn_ReadFrom_Call

+ func (_e *MockUDPConn_Expecter) WriteTo(b interface{}, addr interface{}) *MockUDPConn_WriteTo_Call

+ type MockUDPConn_ReadFrom_Call struct

+ func (_c *MockUDPConn_ReadFrom_Call) Return(_a0 int, _a1 string, _a2 error) *MockUDPConn_ReadFrom_Call

+ func (_c *MockUDPConn_ReadFrom_Call) Run(run func(b []byte)) *MockUDPConn_ReadFrom_Call

+ func (_c *MockUDPConn_ReadFrom_Call) RunAndReturn(run func([]byte) (int, string, error)) *MockUDPConn_ReadFrom_Call

+ type MockUDPConn_WriteTo_Call struct

+ func (_c *MockUDPConn_WriteTo_Call) Return(_a0 int, _a1 error) *MockUDPConn_WriteTo_Call

+ func (_c *MockUDPConn_WriteTo_Call) Run(run func(b []byte, addr string)) *MockUDPConn_WriteTo_Call

+ func (_c *MockUDPConn_WriteTo_Call) RunAndReturn(run func([]byte, string) (int, error)) *MockUDPConn_WriteTo_Call