github.com/cloudwego/kitex@v0.9.0/internal/mocks/proxy/proxy.go

/*
 * Copyright 2022 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/


// Code generated by MockGen. DO NOT EDIT.
// Source: ../../pkg/proxy/proxy.go

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

import (
	context "context"
	net "net"
	reflect "reflect"

	endpoint "github.com/cloudwego/kitex/pkg/endpoint"
	proxy "github.com/cloudwego/kitex/pkg/proxy"
	gomock "github.com/golang/mock/gomock"
)

// MockForwardProxy is a mock of ForwardProxy interface.
type MockForwardProxy struct {
	ctrl     *gomock.Controller
	recorder *MockForwardProxyMockRecorder
}

// MockForwardProxyMockRecorder is the mock recorder for MockForwardProxy.
type MockForwardProxyMockRecorder struct {
	mock *MockForwardProxy
}

// NewMockForwardProxy creates a new mock instance.
func NewMockForwardProxy(ctrl *gomock.Controller) *MockForwardProxy {
	mock := &MockForwardProxy{ctrl: ctrl}
	mock.recorder = &MockForwardProxyMockRecorder{mock}
	return mock
}

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

// Configure mocks base method.
func (m *MockForwardProxy) Configure(arg0 *proxy.Config) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configure", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Configure indicates an expected call of Configure.
func (mr *MockForwardProxyMockRecorder) Configure(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Configure", reflect.TypeOf((*MockForwardProxy)(nil).Configure), arg0)
}

// ResolveProxyInstance mocks base method.
func (m *MockForwardProxy) ResolveProxyInstance(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveProxyInstance", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResolveProxyInstance indicates an expected call of ResolveProxyInstance.
func (mr *MockForwardProxyMockRecorder) ResolveProxyInstance(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveProxyInstance", reflect.TypeOf((*MockForwardProxy)(nil).ResolveProxyInstance), ctx)
}

// MockWithMiddleware is a mock of WithMiddleware interface.
type MockWithMiddleware struct {
	ctrl     *gomock.Controller
	recorder *MockWithMiddlewareMockRecorder
}

// MockWithMiddlewareMockRecorder is the mock recorder for MockWithMiddleware.
type MockWithMiddlewareMockRecorder struct {
	mock *MockWithMiddleware
}

// NewMockWithMiddleware creates a new mock instance.
func NewMockWithMiddleware(ctrl *gomock.Controller) *MockWithMiddleware {
	mock := &MockWithMiddleware{ctrl: ctrl}
	mock.recorder = &MockWithMiddlewareMockRecorder{mock}
	return mock
}

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

// ProxyMiddleware mocks base method.
func (m *MockWithMiddleware) ProxyMiddleware() endpoint.Middleware {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProxyMiddleware")
	ret0, _ := ret[0].(endpoint.Middleware)
	return ret0
}

// ProxyMiddleware indicates an expected call of ProxyMiddleware.
func (mr *MockWithMiddlewareMockRecorder) ProxyMiddleware() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProxyMiddleware", reflect.TypeOf((*MockWithMiddleware)(nil).ProxyMiddleware))
}

// MockReverseProxy is a mock of ReverseProxy interface.
type MockReverseProxy struct {
	ctrl     *gomock.Controller
	recorder *MockReverseProxyMockRecorder
}

// MockReverseProxyMockRecorder is the mock recorder for MockReverseProxy.
type MockReverseProxyMockRecorder struct {
	mock *MockReverseProxy
}

// NewMockReverseProxy creates a new mock instance.
func NewMockReverseProxy(ctrl *gomock.Controller) *MockReverseProxy {
	mock := &MockReverseProxy{ctrl: ctrl}
	mock.recorder = &MockReverseProxyMockRecorder{mock}
	return mock
}

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

// Replace mocks base method.
func (m *MockReverseProxy) Replace(arg0 net.Addr) (net.Addr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replace", arg0)
	ret0, _ := ret[0].(net.Addr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Replace indicates an expected call of Replace.
func (mr *MockReverseProxyMockRecorder) Replace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replace", reflect.TypeOf((*MockReverseProxy)(nil).Replace), arg0)
}

// MockContextHandler is a mock of ContextHandler interface.
type MockContextHandler struct {
	ctrl     *gomock.Controller
	recorder *MockContextHandlerMockRecorder
}

// MockContextHandlerMockRecorder is the mock recorder for MockContextHandler.
type MockContextHandlerMockRecorder struct {
	mock *MockContextHandler
}

// NewMockContextHandler creates a new mock instance.
func NewMockContextHandler(ctrl *gomock.Controller) *MockContextHandler {
	mock := &MockContextHandler{ctrl: ctrl}
	mock.recorder = &MockContextHandlerMockRecorder{mock}
	return mock
}

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

// HandleContext mocks base method.
func (m *MockContextHandler) HandleContext(arg0 context.Context) context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleContext", arg0)
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// HandleContext indicates an expected call of HandleContext.
func (mr *MockContextHandlerMockRecorder) HandleContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleContext", reflect.TypeOf((*MockContextHandler)(nil).HandleContext), arg0)
}