github.com/cloudwego/kitex@v0.9.0/internal/mocks/loadbalance/loadbalancer.go (about) 1 /* 2 * Copyright 2022 CloudWeGo 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 18 // Code generated by MockGen. DO NOT EDIT. 19 // Source: ../../pkg/loadbalance/loadbalancer.go 20 21 // Package loadbalance is a generated GoMock package. 22 package loadbalance 23 24 import ( 25 context "context" 26 reflect "reflect" 27 28 discovery "github.com/cloudwego/kitex/pkg/discovery" 29 loadbalance "github.com/cloudwego/kitex/pkg/loadbalance" 30 gomock "github.com/golang/mock/gomock" 31 ) 32 33 // MockPicker is a mock of Picker interface. 34 type MockPicker struct { 35 ctrl *gomock.Controller 36 recorder *MockPickerMockRecorder 37 } 38 39 // MockPickerMockRecorder is the mock recorder for MockPicker. 40 type MockPickerMockRecorder struct { 41 mock *MockPicker 42 } 43 44 // NewMockPicker creates a new mock instance. 45 func NewMockPicker(ctrl *gomock.Controller) *MockPicker { 46 mock := &MockPicker{ctrl: ctrl} 47 mock.recorder = &MockPickerMockRecorder{mock} 48 return mock 49 } 50 51 // EXPECT returns an object that allows the caller to indicate expected use. 52 func (m *MockPicker) EXPECT() *MockPickerMockRecorder { 53 return m.recorder 54 } 55 56 // Next mocks base method. 57 func (m *MockPicker) Next(ctx context.Context, request interface{}) discovery.Instance { 58 m.ctrl.T.Helper() 59 ret := m.ctrl.Call(m, "Next", ctx, request) 60 ret0, _ := ret[0].(discovery.Instance) 61 return ret0 62 } 63 64 // Next indicates an expected call of Next. 65 func (mr *MockPickerMockRecorder) Next(ctx, request interface{}) *gomock.Call { 66 mr.mock.ctrl.T.Helper() 67 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockPicker)(nil).Next), ctx, request) 68 } 69 70 // MockLoadbalancer is a mock of Loadbalancer interface. 71 type MockLoadbalancer struct { 72 ctrl *gomock.Controller 73 recorder *MockLoadbalancerMockRecorder 74 } 75 76 // MockLoadbalancerMockRecorder is the mock recorder for MockLoadbalancer. 77 type MockLoadbalancerMockRecorder struct { 78 mock *MockLoadbalancer 79 } 80 81 // NewMockLoadbalancer creates a new mock instance. 82 func NewMockLoadbalancer(ctrl *gomock.Controller) *MockLoadbalancer { 83 mock := &MockLoadbalancer{ctrl: ctrl} 84 mock.recorder = &MockLoadbalancerMockRecorder{mock} 85 return mock 86 } 87 88 // EXPECT returns an object that allows the caller to indicate expected use. 89 func (m *MockLoadbalancer) EXPECT() *MockLoadbalancerMockRecorder { 90 return m.recorder 91 } 92 93 // GetPicker mocks base method. 94 func (m *MockLoadbalancer) GetPicker(arg0 discovery.Result) loadbalance.Picker { 95 m.ctrl.T.Helper() 96 ret := m.ctrl.Call(m, "GetPicker", arg0) 97 ret0, _ := ret[0].(loadbalance.Picker) 98 return ret0 99 } 100 101 // GetPicker indicates an expected call of GetPicker. 102 func (mr *MockLoadbalancerMockRecorder) GetPicker(arg0 interface{}) *gomock.Call { 103 mr.mock.ctrl.T.Helper() 104 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPicker", reflect.TypeOf((*MockLoadbalancer)(nil).GetPicker), arg0) 105 } 106 107 // Name mocks base method. 108 func (m *MockLoadbalancer) Name() string { 109 m.ctrl.T.Helper() 110 ret := m.ctrl.Call(m, "Name") 111 ret0, _ := ret[0].(string) 112 return ret0 113 } 114 115 // Name indicates an expected call of Name. 116 func (mr *MockLoadbalancerMockRecorder) Name() *gomock.Call { 117 mr.mock.ctrl.T.Helper() 118 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockLoadbalancer)(nil).Name)) 119 } 120 121 // MockRebalancer is a mock of Rebalancer interface. 122 type MockRebalancer struct { 123 ctrl *gomock.Controller 124 recorder *MockRebalancerMockRecorder 125 } 126 127 // MockRebalancerMockRecorder is the mock recorder for MockRebalancer. 128 type MockRebalancerMockRecorder struct { 129 mock *MockRebalancer 130 } 131 132 // NewMockRebalancer creates a new mock instance. 133 func NewMockRebalancer(ctrl *gomock.Controller) *MockRebalancer { 134 mock := &MockRebalancer{ctrl: ctrl} 135 mock.recorder = &MockRebalancerMockRecorder{mock} 136 return mock 137 } 138 139 // EXPECT returns an object that allows the caller to indicate expected use. 140 func (m *MockRebalancer) EXPECT() *MockRebalancerMockRecorder { 141 return m.recorder 142 } 143 144 // Delete mocks base method. 145 func (m *MockRebalancer) Delete(arg0 discovery.Change) { 146 m.ctrl.T.Helper() 147 m.ctrl.Call(m, "Delete", arg0) 148 } 149 150 // Delete indicates an expected call of Delete. 151 func (mr *MockRebalancerMockRecorder) Delete(arg0 interface{}) *gomock.Call { 152 mr.mock.ctrl.T.Helper() 153 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRebalancer)(nil).Delete), arg0) 154 } 155 156 // Rebalance mocks base method. 157 func (m *MockRebalancer) Rebalance(arg0 discovery.Change) { 158 m.ctrl.T.Helper() 159 m.ctrl.Call(m, "Rebalance", arg0) 160 } 161 162 // Rebalance indicates an expected call of Rebalance. 163 func (mr *MockRebalancerMockRecorder) Rebalance(arg0 interface{}) *gomock.Call { 164 mr.mock.ctrl.T.Helper() 165 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebalance", reflect.TypeOf((*MockRebalancer)(nil).Rebalance), arg0) 166 }