openbilibili/app/admin/main/aegis/dao/rpc/rpc_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: /Users/danbeiti/go/src/go-common/app/admin/main/aegis/dao/rpc/dao.go

// Package mock is a generated GoMock package.
package rpc

import (
	context "context"
	reflect "reflect"

	api "go-common/app/service/main/account/api"
	model "go-common/app/service/main/relation/model"
	v1 "go-common/app/service/main/up/api/v1"

	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockRelationRPC is a mock of RelationRPC interface
type MockRelationRPC struct {
	ctrl     *gomock.Controller
	recorder *MockRelationRPCMockRecorder
}

// MockRelationRPCMockRecorder is the mock recorder for MockRelationRPC
type MockRelationRPCMockRecorder struct {
	mock *MockRelationRPC
}

// NewMockRelationRPC creates a new mock instance
func NewMockRelationRPC(ctrl *gomock.Controller) *MockRelationRPC {
	mock := &MockRelationRPC{ctrl: ctrl}
	mock.recorder = &MockRelationRPCMockRecorder{mock}
	return mock
}

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

// Stats mocks base method
func (m *MockRelationRPC) Stats(c context.Context, arg *model.ArgMids) (map[int64]*model.Stat, error) {
	ret := m.ctrl.Call(m, "Stats", c, arg)
	ret0, _ := ret[0].(map[int64]*model.Stat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stats indicates an expected call of Stats
func (mr *MockRelationRPCMockRecorder) Stats(c, arg interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockRelationRPC)(nil).Stats), c, arg)
}

// MockAccRPC is a mock of AccRPC interface
type MockAccRPC struct {
	ctrl     *gomock.Controller
	recorder *MockAccRPCMockRecorder
}

// MockAccRPCMockRecorder is the mock recorder for MockAccRPC
type MockAccRPCMockRecorder struct {
	mock *MockAccRPC
}

// NewMockAccRPC creates a new mock instance
func NewMockAccRPC(ctrl *gomock.Controller) *MockAccRPC {
	mock := &MockAccRPC{ctrl: ctrl}
	mock.recorder = &MockAccRPCMockRecorder{mock}
	return mock
}

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

// Info3 mocks base method
func (m *MockAccRPC) Info3(ctx context.Context, in *api.MidReq, opts ...grpc.CallOption) (*api.InfoReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Info3", varargs...)
	ret0, _ := ret[0].(*api.InfoReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Info3 indicates an expected call of Info3
func (mr *MockAccRPCMockRecorder) Info3(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info3", reflect.TypeOf((*MockAccRPC)(nil).Info3), varargs...)
}

// Cards3 mocks base method
func (m *MockAccRPC) Cards3(ctx context.Context, in *api.MidsReq, opts ...grpc.CallOption) (*api.CardsReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Cards3", varargs...)
	ret0, _ := ret[0].(*api.CardsReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Cards3 indicates an expected call of Cards3
func (mr *MockAccRPCMockRecorder) Cards3(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cards3", reflect.TypeOf((*MockAccRPC)(nil).Cards3), varargs...)
}

// ProfileWithStat3 mocks base method
func (m *MockAccRPC) ProfileWithStat3(ctx context.Context, in *api.MidReq, opts ...grpc.CallOption) (*api.ProfileStatReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProfileWithStat3", varargs...)
	ret0, _ := ret[0].(*api.ProfileStatReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProfileWithStat3 indicates an expected call of ProfileWithStat3
func (mr *MockAccRPCMockRecorder) ProfileWithStat3(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProfileWithStat3", reflect.TypeOf((*MockAccRPC)(nil).ProfileWithStat3), varargs...)
}

// MockUpRPC is a mock of UpRPC interface
type MockUpRPC struct {
	ctrl     *gomock.Controller
	recorder *MockUpRPCMockRecorder
}

// MockUpRPCMockRecorder is the mock recorder for MockUpRPC
type MockUpRPCMockRecorder struct {
	mock *MockUpRPC
}

// NewMockUpRPC creates a new mock instance
func NewMockUpRPC(ctrl *gomock.Controller) *MockUpRPC {
	mock := &MockUpRPC{ctrl: ctrl}
	mock.recorder = &MockUpRPCMockRecorder{mock}
	return mock
}

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

// UpSpecial mocks base method
func (m *MockUpRPC) UpSpecial(ctx context.Context, in *v1.UpSpecialReq, opts ...grpc.CallOption) (*v1.UpSpecialReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpSpecial", varargs...)
	ret0, _ := ret[0].(*v1.UpSpecialReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpSpecial indicates an expected call of UpSpecial
func (mr *MockUpRPCMockRecorder) UpSpecial(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpSpecial", reflect.TypeOf((*MockUpRPC)(nil).UpSpecial), varargs...)
}

// UpsSpecial mocks base method
func (m *MockUpRPC) UpsSpecial(ctx context.Context, in *v1.UpsSpecialReq, opts ...grpc.CallOption) (*v1.UpsSpecialReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsSpecial", varargs...)
	ret0, _ := ret[0].(*v1.UpsSpecialReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsSpecial indicates an expected call of UpsSpecial
func (mr *MockUpRPCMockRecorder) UpsSpecial(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsSpecial", reflect.TypeOf((*MockUpRPC)(nil).UpsSpecial), varargs...)
}

// UpGroups mocks base method
func (m *MockUpRPC) UpGroups(ctx context.Context, in *v1.NoArgReq, opts ...grpc.CallOption) (*v1.UpGroupsReply, error) {
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpGroups", varargs...)
	ret0, _ := ret[0].(*v1.UpGroupsReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpGroups indicates an expected call of UpGroups
func (mr *MockUpRPCMockRecorder) UpGroups(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpGroups", reflect.TypeOf((*MockUpRPC)(nil).UpGroups), varargs...)
}