cloudflared/mocks/mock_resolvers.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../prechecks/resolvers.go
//
// Generated by this command:
//
//	mockgen -typed -build_flags=-tags=gomock -package mocks -destination mock_resolvers.go -source=../prechecks/resolvers.go
//

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	tls "crypto/tls"
	net "net"
	netip "net/netip"
	reflect "reflect"
	time "time"

	quic "github.com/quic-go/quic-go"
	zerolog "github.com/rs/zerolog"
	gomock "go.uber.org/mock/gomock"

	dialopts "github.com/cloudflare/cloudflared/connection/dialopts"
	allregions "github.com/cloudflare/cloudflared/edgediscovery/allregions"
)

// MockDNSResolver is a mock of DNSResolver interface.
type MockDNSResolver struct {
	ctrl     *gomock.Controller
	recorder *MockDNSResolverMockRecorder
	isgomock struct{}
}

// MockDNSResolverMockRecorder is the mock recorder for MockDNSResolver.
type MockDNSResolverMockRecorder struct {
	mock *MockDNSResolver
}

// NewMockDNSResolver creates a new mock instance.
func NewMockDNSResolver(ctrl *gomock.Controller) *MockDNSResolver {
	mock := &MockDNSResolver{ctrl: ctrl}
	mock.recorder = &MockDNSResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDNSResolver) EXPECT() *MockDNSResolverMockRecorder {
	return m.recorder
}

// Resolve mocks base method.
func (m *MockDNSResolver) Resolve(region string) ([][]*allregions.EdgeAddr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resolve", region)
	ret0, _ := ret[0].([][]*allregions.EdgeAddr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockDNSResolverMockRecorder) Resolve(region any) *MockDNSResolverResolveCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockDNSResolver)(nil).Resolve), region)
	return &MockDNSResolverResolveCall{Call: call}
}

// MockDNSResolverResolveCall wrap *gomock.Call
type MockDNSResolverResolveCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockDNSResolverResolveCall) Return(arg0 [][]*allregions.EdgeAddr, arg1 error) *MockDNSResolverResolveCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockDNSResolverResolveCall) Do(f func(string) ([][]*allregions.EdgeAddr, error)) *MockDNSResolverResolveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDNSResolverResolveCall) DoAndReturn(f func(string) ([][]*allregions.EdgeAddr, error)) *MockDNSResolverResolveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockTCPDialer is a mock of TCPDialer interface.
type MockTCPDialer struct {
	ctrl     *gomock.Controller
	recorder *MockTCPDialerMockRecorder
	isgomock struct{}
}

// MockTCPDialerMockRecorder is the mock recorder for MockTCPDialer.
type MockTCPDialerMockRecorder struct {
	mock *MockTCPDialer
}

// NewMockTCPDialer creates a new mock instance.
func NewMockTCPDialer(ctrl *gomock.Controller) *MockTCPDialer {
	mock := &MockTCPDialer{ctrl: ctrl}
	mock.recorder = &MockTCPDialerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTCPDialer) EXPECT() *MockTCPDialerMockRecorder {
	return m.recorder
}

// DialEdge mocks base method.
func (m *MockTCPDialer) DialEdge(ctx context.Context, timeout time.Duration, tlsConfig *tls.Config, addr *net.TCPAddr, localIP net.IP) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DialEdge", ctx, timeout, tlsConfig, addr, localIP)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DialEdge indicates an expected call of DialEdge.
func (mr *MockTCPDialerMockRecorder) DialEdge(ctx, timeout, tlsConfig, addr, localIP any) *MockTCPDialerDialEdgeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialEdge", reflect.TypeOf((*MockTCPDialer)(nil).DialEdge), ctx, timeout, tlsConfig, addr, localIP)
	return &MockTCPDialerDialEdgeCall{Call: call}
}

// MockTCPDialerDialEdgeCall wrap *gomock.Call
type MockTCPDialerDialEdgeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockTCPDialerDialEdgeCall) Return(arg0 net.Conn, arg1 error) *MockTCPDialerDialEdgeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockTCPDialerDialEdgeCall) Do(f func(context.Context, time.Duration, *tls.Config, *net.TCPAddr, net.IP) (net.Conn, error)) *MockTCPDialerDialEdgeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockTCPDialerDialEdgeCall) DoAndReturn(f func(context.Context, time.Duration, *tls.Config, *net.TCPAddr, net.IP) (net.Conn, error)) *MockTCPDialerDialEdgeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockQUICDialer is a mock of QUICDialer interface.
type MockQUICDialer struct {
	ctrl     *gomock.Controller
	recorder *MockQUICDialerMockRecorder
	isgomock struct{}
}

// MockQUICDialerMockRecorder is the mock recorder for MockQUICDialer.
type MockQUICDialerMockRecorder struct {
	mock *MockQUICDialer
}

// NewMockQUICDialer creates a new mock instance.
func NewMockQUICDialer(ctrl *gomock.Controller) *MockQUICDialer {
	mock := &MockQUICDialer{ctrl: ctrl}
	mock.recorder = &MockQUICDialerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockQUICDialer) EXPECT() *MockQUICDialerMockRecorder {
	return m.recorder
}

// DialQuic mocks base method.
func (m *MockQUICDialer) DialQuic(ctx context.Context, quicConfig *quic.Config, tlsConfig *tls.Config, addr netip.AddrPort, localAddr net.IP, connIndex uint8, logger *zerolog.Logger, opts dialopts.DialOpts) (quic.Connection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DialQuic", ctx, quicConfig, tlsConfig, addr, localAddr, connIndex, logger, opts)
	ret0, _ := ret[0].(quic.Connection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DialQuic indicates an expected call of DialQuic.
func (mr *MockQUICDialerMockRecorder) DialQuic(ctx, quicConfig, tlsConfig, addr, localAddr, connIndex, logger, opts any) *MockQUICDialerDialQuicCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialQuic", reflect.TypeOf((*MockQUICDialer)(nil).DialQuic), ctx, quicConfig, tlsConfig, addr, localAddr, connIndex, logger, opts)
	return &MockQUICDialerDialQuicCall{Call: call}
}

// MockQUICDialerDialQuicCall wrap *gomock.Call
type MockQUICDialerDialQuicCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQUICDialerDialQuicCall) Return(arg0 quic.Connection, arg1 error) *MockQUICDialerDialQuicCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQUICDialerDialQuicCall) Do(f func(context.Context, *quic.Config, *tls.Config, netip.AddrPort, net.IP, uint8, *zerolog.Logger, dialopts.DialOpts) (quic.Connection, error)) *MockQUICDialerDialQuicCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQUICDialerDialQuicCall) DoAndReturn(f func(context.Context, *quic.Config, *tls.Config, netip.AddrPort, net.IP, uint8, *zerolog.Logger, dialopts.DialOpts) (quic.Connection, error)) *MockQUICDialerDialQuicCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockManagementDialer is a mock of ManagementDialer interface.
type MockManagementDialer struct {
	ctrl     *gomock.Controller
	recorder *MockManagementDialerMockRecorder
	isgomock struct{}
}

// MockManagementDialerMockRecorder is the mock recorder for MockManagementDialer.
type MockManagementDialerMockRecorder struct {
	mock *MockManagementDialer
}

// NewMockManagementDialer creates a new mock instance.
func NewMockManagementDialer(ctrl *gomock.Controller) *MockManagementDialer {
	mock := &MockManagementDialer{ctrl: ctrl}
	mock.recorder = &MockManagementDialerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManagementDialer) EXPECT() *MockManagementDialerMockRecorder {
	return m.recorder
}

// DialContext mocks base method.
func (m *MockManagementDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DialContext", ctx, network, addr)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DialContext indicates an expected call of DialContext.
func (mr *MockManagementDialerMockRecorder) DialContext(ctx, network, addr any) *MockManagementDialerDialContextCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialContext", reflect.TypeOf((*MockManagementDialer)(nil).DialContext), ctx, network, addr)
	return &MockManagementDialerDialContextCall{Call: call}
}

// MockManagementDialerDialContextCall wrap *gomock.Call
type MockManagementDialerDialContextCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockManagementDialerDialContextCall) Return(arg0 net.Conn, arg1 error) *MockManagementDialerDialContextCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockManagementDialerDialContextCall) Do(f func(context.Context, string, string) (net.Conn, error)) *MockManagementDialerDialContextCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockManagementDialerDialContextCall) DoAndReturn(f func(context.Context, string, string) (net.Conn, error)) *MockManagementDialerDialContextCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}