You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@rocketmq.apache.org by di...@apache.org on 2019/07/24 03:21:05 UTC
[rocketmq-client-go] branch native updated: [ISSUE #128]update
mockgen command line
This is an automated email from the ASF dual-hosted git repository.
dinglei pushed a commit to branch native
in repository https://gitbox.apache.org/repos/asf/rocketmq-client-go.git
The following commit(s) were added to refs/heads/native by this push:
new 86498ea [ISSUE #128]update mockgen command line
86498ea is described below
commit 86498eafde1bbc70b5bdb2b0445c89d5a84ca138
Author: cloes <wa...@163.com>
AuthorDate: Wed Jul 24 11:21:00 2019 +0800
[ISSUE #128]update mockgen command line
#128
---
internal/client.go | 2 +-
internal/mock_client.go | 91 +++++++++++++++++++++++++++++++++----------------
2 files changed, 63 insertions(+), 30 deletions(-)
diff --git a/internal/client.go b/internal/client.go
index ff4157d..558c28d 100644
--- a/internal/client.go
+++ b/internal/client.go
@@ -119,7 +119,7 @@ func (opt *ClientOptions) String() string {
opt.InstanceName, opt.UnitMode, opt.UnitName, opt.VIPChannelEnabled, opt.ACLEnabled)
}
-//go:generate mockgen -source client.go -destination mock_client.go --package internal RMQClient
+//go:generate mockgen -source client.go -destination mock_client.go -self_package github.com/apache/rocketmq-client-go/internal --package internal RMQClient
type RMQClient interface {
Start()
Shutdown()
diff --git a/internal/mock_client.go b/internal/mock_client.go
index 3ee3f50..825c9e4 100644
--- a/internal/mock_client.go
+++ b/internal/mock_client.go
@@ -38,6 +38,7 @@ func (m *MockInnerProducer) EXPECT() *MockInnerProducerMockRecorder {
// PublishTopicList mocks base method
func (m *MockInnerProducer) PublishTopicList() []string {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PublishTopicList")
ret0, _ := ret[0].([]string)
return ret0
@@ -45,21 +46,25 @@ func (m *MockInnerProducer) PublishTopicList() []string {
// PublishTopicList indicates an expected call of PublishTopicList
func (mr *MockInnerProducerMockRecorder) PublishTopicList() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishTopicList", reflect.TypeOf((*MockInnerProducer)(nil).PublishTopicList))
}
// UpdateTopicPublishInfo mocks base method
func (m *MockInnerProducer) UpdateTopicPublishInfo(topic string, info *TopicPublishInfo) {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdateTopicPublishInfo", topic, info)
}
// UpdateTopicPublishInfo indicates an expected call of UpdateTopicPublishInfo
func (mr *MockInnerProducerMockRecorder) UpdateTopicPublishInfo(topic, info interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicPublishInfo", reflect.TypeOf((*MockInnerProducer)(nil).UpdateTopicPublishInfo), topic, info)
}
// IsPublishTopicNeedUpdate mocks base method
func (m *MockInnerProducer) IsPublishTopicNeedUpdate(topic string) bool {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsPublishTopicNeedUpdate", topic)
ret0, _ := ret[0].(bool)
return ret0
@@ -67,11 +72,13 @@ func (m *MockInnerProducer) IsPublishTopicNeedUpdate(topic string) bool {
// IsPublishTopicNeedUpdate indicates an expected call of IsPublishTopicNeedUpdate
func (mr *MockInnerProducerMockRecorder) IsPublishTopicNeedUpdate(topic interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPublishTopicNeedUpdate", reflect.TypeOf((*MockInnerProducer)(nil).IsPublishTopicNeedUpdate), topic)
}
// IsUnitMode mocks base method
func (m *MockInnerProducer) IsUnitMode() bool {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsUnitMode")
ret0, _ := ret[0].(bool)
return ret0
@@ -79,6 +86,7 @@ func (m *MockInnerProducer) IsUnitMode() bool {
// IsUnitMode indicates an expected call of IsUnitMode
func (mr *MockInnerProducerMockRecorder) IsUnitMode() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnitMode", reflect.TypeOf((*MockInnerProducer)(nil).IsUnitMode))
}
@@ -106,27 +114,34 @@ func (m *MockInnerConsumer) EXPECT() *MockInnerConsumerMockRecorder {
}
// PersistConsumerOffset mocks base method
-func (m *MockInnerConsumer) PersistConsumerOffset() {
- m.ctrl.Call(m, "PersistConsumerOffset")
+func (m *MockInnerConsumer) PersistConsumerOffset() error {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "PersistConsumerOffset")
+ ret0, _ := ret[0].(error)
+ return ret0
}
// PersistConsumerOffset indicates an expected call of PersistConsumerOffset
func (mr *MockInnerConsumerMockRecorder) PersistConsumerOffset() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistConsumerOffset", reflect.TypeOf((*MockInnerConsumer)(nil).PersistConsumerOffset))
}
// UpdateTopicSubscribeInfo mocks base method
func (m *MockInnerConsumer) UpdateTopicSubscribeInfo(topic string, mqs []*primitive.MessageQueue) {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdateTopicSubscribeInfo", topic, mqs)
}
// UpdateTopicSubscribeInfo indicates an expected call of UpdateTopicSubscribeInfo
func (mr *MockInnerConsumerMockRecorder) UpdateTopicSubscribeInfo(topic, mqs interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicSubscribeInfo", reflect.TypeOf((*MockInnerConsumer)(nil).UpdateTopicSubscribeInfo), topic, mqs)
}
// IsSubscribeTopicNeedUpdate mocks base method
func (m *MockInnerConsumer) IsSubscribeTopicNeedUpdate(topic string) bool {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsSubscribeTopicNeedUpdate", topic)
ret0, _ := ret[0].(bool)
return ret0
@@ -134,11 +149,13 @@ func (m *MockInnerConsumer) IsSubscribeTopicNeedUpdate(topic string) bool {
// IsSubscribeTopicNeedUpdate indicates an expected call of IsSubscribeTopicNeedUpdate
func (mr *MockInnerConsumerMockRecorder) IsSubscribeTopicNeedUpdate(topic interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSubscribeTopicNeedUpdate", reflect.TypeOf((*MockInnerConsumer)(nil).IsSubscribeTopicNeedUpdate), topic)
}
// SubscriptionDataList mocks base method
func (m *MockInnerConsumer) SubscriptionDataList() []*SubscriptionData {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SubscriptionDataList")
ret0, _ := ret[0].([]*SubscriptionData)
return ret0
@@ -146,21 +163,25 @@ func (m *MockInnerConsumer) SubscriptionDataList() []*SubscriptionData {
// SubscriptionDataList indicates an expected call of SubscriptionDataList
func (mr *MockInnerConsumerMockRecorder) SubscriptionDataList() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscriptionDataList", reflect.TypeOf((*MockInnerConsumer)(nil).SubscriptionDataList))
}
// Rebalance mocks base method
func (m *MockInnerConsumer) Rebalance() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "Rebalance")
}
// Rebalance indicates an expected call of Rebalance
func (mr *MockInnerConsumerMockRecorder) Rebalance() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebalance", reflect.TypeOf((*MockInnerConsumer)(nil).Rebalance))
}
// IsUnitMode mocks base method
func (m *MockInnerConsumer) IsUnitMode() bool {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsUnitMode")
ret0, _ := ret[0].(bool)
return ret0
@@ -168,6 +189,7 @@ func (m *MockInnerConsumer) IsUnitMode() bool {
// IsUnitMode indicates an expected call of IsUnitMode
func (mr *MockInnerConsumerMockRecorder) IsUnitMode() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnitMode", reflect.TypeOf((*MockInnerConsumer)(nil).IsUnitMode))
}
@@ -196,26 +218,31 @@ func (m *MockRMQClient) EXPECT() *MockRMQClientMockRecorder {
// Start mocks base method
func (m *MockRMQClient) Start() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "Start")
}
// Start indicates an expected call of Start
func (mr *MockRMQClientMockRecorder) Start() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockRMQClient)(nil).Start))
}
// Shutdown mocks base method
func (m *MockRMQClient) Shutdown() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "Shutdown")
}
// Shutdown indicates an expected call of Shutdown
func (mr *MockRMQClientMockRecorder) Shutdown() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockRMQClient)(nil).Shutdown))
}
// ClientID mocks base method
func (m *MockRMQClient) ClientID() string {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ClientID")
ret0, _ := ret[0].(string)
return ret0
@@ -223,21 +250,25 @@ func (m *MockRMQClient) ClientID() string {
// ClientID indicates an expected call of ClientID
func (mr *MockRMQClientMockRecorder) ClientID() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockRMQClient)(nil).ClientID))
}
// RegisterProducer mocks base method
func (m *MockRMQClient) RegisterProducer(group string, producer InnerProducer) {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "RegisterProducer", group, producer)
}
// RegisterProducer indicates an expected call of RegisterProducer
func (mr *MockRMQClientMockRecorder) RegisterProducer(group, producer interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterProducer", reflect.TypeOf((*MockRMQClient)(nil).RegisterProducer), group, producer)
}
// InvokeSync mocks base method
func (m *MockRMQClient) InvokeSync(addr string, request *remote.RemotingCommand, timeoutMillis time.Duration) (*remote.RemotingCommand, error) {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InvokeSync", addr, request, timeoutMillis)
ret0, _ := ret[0].(*remote.RemotingCommand)
ret1, _ := ret[1].(error)
@@ -246,11 +277,13 @@ func (m *MockRMQClient) InvokeSync(addr string, request *remote.RemotingCommand,
// InvokeSync indicates an expected call of InvokeSync
func (mr *MockRMQClientMockRecorder) InvokeSync(addr, request, timeoutMillis interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeSync", reflect.TypeOf((*MockRMQClient)(nil).InvokeSync), addr, request, timeoutMillis)
}
// InvokeAsync mocks base method
func (m *MockRMQClient) InvokeAsync(addr string, request *remote.RemotingCommand, timeoutMillis time.Duration, f func(*remote.RemotingCommand, error)) error {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InvokeAsync", addr, request, timeoutMillis, f)
ret0, _ := ret[0].(error)
return ret0
@@ -258,11 +291,13 @@ func (m *MockRMQClient) InvokeAsync(addr string, request *remote.RemotingCommand
// InvokeAsync indicates an expected call of InvokeAsync
func (mr *MockRMQClientMockRecorder) InvokeAsync(addr, request, timeoutMillis, f interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeAsync", reflect.TypeOf((*MockRMQClient)(nil).InvokeAsync), addr, request, timeoutMillis, f)
}
// InvokeOneWay mocks base method
func (m *MockRMQClient) InvokeOneWay(addr string, request *remote.RemotingCommand, timeoutMillis time.Duration) error {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InvokeOneWay", addr, request, timeoutMillis)
ret0, _ := ret[0].(error)
return ret0
@@ -270,81 +305,68 @@ func (m *MockRMQClient) InvokeOneWay(addr string, request *remote.RemotingComman
// InvokeOneWay indicates an expected call of InvokeOneWay
func (mr *MockRMQClientMockRecorder) InvokeOneWay(addr, request, timeoutMillis interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOneWay", reflect.TypeOf((*MockRMQClient)(nil).InvokeOneWay), addr, request, timeoutMillis)
}
// CheckClientInBroker mocks base method
func (m *MockRMQClient) CheckClientInBroker() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "CheckClientInBroker")
}
// CheckClientInBroker indicates an expected call of CheckClientInBroker
func (mr *MockRMQClientMockRecorder) CheckClientInBroker() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckClientInBroker", reflect.TypeOf((*MockRMQClient)(nil).CheckClientInBroker))
}
// SendHeartbeatToAllBrokerWithLock mocks base method
func (m *MockRMQClient) SendHeartbeatToAllBrokerWithLock() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "SendHeartbeatToAllBrokerWithLock")
}
// SendHeartbeatToAllBrokerWithLock indicates an expected call of SendHeartbeatToAllBrokerWithLock
func (mr *MockRMQClientMockRecorder) SendHeartbeatToAllBrokerWithLock() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeartbeatToAllBrokerWithLock", reflect.TypeOf((*MockRMQClient)(nil).SendHeartbeatToAllBrokerWithLock))
}
// UpdateTopicRouteInfo mocks base method
func (m *MockRMQClient) UpdateTopicRouteInfo() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdateTopicRouteInfo")
}
// UpdateTopicRouteInfo indicates an expected call of UpdateTopicRouteInfo
func (mr *MockRMQClientMockRecorder) UpdateTopicRouteInfo() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicRouteInfo", reflect.TypeOf((*MockRMQClient)(nil).UpdateTopicRouteInfo))
}
-// SendMessageAsync mocks base method
-func (m *MockRMQClient) SendMessageAsync(ctx context.Context, brokerAddrs, brokerName string, request *SendMessageRequest, msgs []*primitive.Message, f func(*primitive.SendResult)) error {
- ret := m.ctrl.Call(m, "SendMessageAsync", ctx, brokerAddrs, brokerName, request, msgs, f)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// SendMessageAsync indicates an expected call of SendMessageAsync
-func (mr *MockRMQClientMockRecorder) SendMessageAsync(ctx, brokerAddrs, brokerName, request, msgs, f interface{}) *gomock.Call {
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageAsync", reflect.TypeOf((*MockRMQClient)(nil).SendMessageAsync), ctx, brokerAddrs, brokerName, request, msgs, f)
-}
-
-// SendMessageOneWay mocks base method
-func (m *MockRMQClient) SendMessageOneWay(ctx context.Context, brokerAddrs string, request *SendMessageRequest, msgs []*primitive.Message) (*primitive.SendResult, error) {
- ret := m.ctrl.Call(m, "SendMessageOneWay", ctx, brokerAddrs, request, msgs)
- ret0, _ := ret[0].(*primitive.SendResult)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// SendMessageOneWay indicates an expected call of SendMessageOneWay
-func (mr *MockRMQClientMockRecorder) SendMessageOneWay(ctx, brokerAddrs, request, msgs interface{}) *gomock.Call {
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageOneWay", reflect.TypeOf((*MockRMQClient)(nil).SendMessageOneWay), ctx, brokerAddrs, request, msgs)
-}
-
// ProcessSendResponse mocks base method
-func (m *MockRMQClient) ProcessSendResponse(brokerName string, cmd *remote.RemotingCommand, resp *primitive.SendResult, msgs ...*primitive.Message) {
+func (m *MockRMQClient) ProcessSendResponse(brokerName string, cmd *remote.RemotingCommand, resp *primitive.SendResult, msgs ...*primitive.Message) error {
+ m.ctrl.T.Helper()
varargs := []interface{}{brokerName, cmd, resp}
for _, a := range msgs {
varargs = append(varargs, a)
}
- m.ctrl.Call(m, "ProcessSendResponse", varargs...)
+ ret := m.ctrl.Call(m, "ProcessSendResponse", varargs...)
+ ret0, _ := ret[0].(error)
+ return ret0
}
// ProcessSendResponse indicates an expected call of ProcessSendResponse
func (mr *MockRMQClientMockRecorder) ProcessSendResponse(brokerName, cmd, resp interface{}, msgs ...interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{brokerName, cmd, resp}, msgs...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessSendResponse", reflect.TypeOf((*MockRMQClient)(nil).ProcessSendResponse), varargs...)
}
// RegisterConsumer mocks base method
func (m *MockRMQClient) RegisterConsumer(group string, consumer InnerConsumer) error {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RegisterConsumer", group, consumer)
ret0, _ := ret[0].(error)
return ret0
@@ -352,21 +374,25 @@ func (m *MockRMQClient) RegisterConsumer(group string, consumer InnerConsumer) e
// RegisterConsumer indicates an expected call of RegisterConsumer
func (mr *MockRMQClientMockRecorder) RegisterConsumer(group, consumer interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterConsumer", reflect.TypeOf((*MockRMQClient)(nil).RegisterConsumer), group, consumer)
}
// UnregisterConsumer mocks base method
func (m *MockRMQClient) UnregisterConsumer(group string) {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "UnregisterConsumer", group)
}
// UnregisterConsumer indicates an expected call of UnregisterConsumer
func (mr *MockRMQClientMockRecorder) UnregisterConsumer(group interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterConsumer", reflect.TypeOf((*MockRMQClient)(nil).UnregisterConsumer), group)
}
// PullMessage mocks base method
func (m *MockRMQClient) PullMessage(ctx context.Context, brokerAddrs string, request *PullMessageRequest) (*primitive.PullResult, error) {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PullMessage", ctx, brokerAddrs, request)
ret0, _ := ret[0].(*primitive.PullResult)
ret1, _ := ret[1].(error)
@@ -375,11 +401,13 @@ func (m *MockRMQClient) PullMessage(ctx context.Context, brokerAddrs string, req
// PullMessage indicates an expected call of PullMessage
func (mr *MockRMQClientMockRecorder) PullMessage(ctx, brokerAddrs, request interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullMessage", reflect.TypeOf((*MockRMQClient)(nil).PullMessage), ctx, brokerAddrs, request)
}
// PullMessageAsync mocks base method
func (m *MockRMQClient) PullMessageAsync(ctx context.Context, brokerAddrs string, request *PullMessageRequest, f func(*primitive.PullResult)) error {
+ m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PullMessageAsync", ctx, brokerAddrs, request, f)
ret0, _ := ret[0].(error)
return ret0
@@ -387,25 +415,30 @@ func (m *MockRMQClient) PullMessageAsync(ctx context.Context, brokerAddrs string
// PullMessageAsync indicates an expected call of PullMessageAsync
func (mr *MockRMQClientMockRecorder) PullMessageAsync(ctx, brokerAddrs, request, f interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullMessageAsync", reflect.TypeOf((*MockRMQClient)(nil).PullMessageAsync), ctx, brokerAddrs, request, f)
}
// RebalanceImmediately mocks base method
func (m *MockRMQClient) RebalanceImmediately() {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "RebalanceImmediately")
}
// RebalanceImmediately indicates an expected call of RebalanceImmediately
func (mr *MockRMQClientMockRecorder) RebalanceImmediately() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebalanceImmediately", reflect.TypeOf((*MockRMQClient)(nil).RebalanceImmediately))
}
// UpdatePublishInfo mocks base method
func (m *MockRMQClient) UpdatePublishInfo(topic string, data *TopicRouteData) {
+ m.ctrl.T.Helper()
m.ctrl.Call(m, "UpdatePublishInfo", topic, data)
}
// UpdatePublishInfo indicates an expected call of UpdatePublishInfo
func (mr *MockRMQClientMockRecorder) UpdatePublishInfo(topic, data interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePublishInfo", reflect.TypeOf((*MockRMQClient)(nil).UpdatePublishInfo), topic, data)
}