openbilibili/app/service/main/feed/service/mock_test.go

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

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

import (
	context "context"
	model "go-common/app/interface/openplatform/article/model"
	model0 "go-common/app/service/main/account/model"
	"go-common/app/service/main/archive/api"
	archive "go-common/app/service/main/archive/model/archive"
	model1 "go-common/app/service/main/feed/model"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockArcRPC is a mock of ArcRPC interface
type MockArcRPC struct {
	ctrl     *gomock.Controller
	recorder *MockArcRPCMockRecorder
}

// MockArcRPCMockRecorder is the mock recorder for MockArcRPC
type MockArcRPCMockRecorder struct {
	mock *MockArcRPC
}

// NewMockArcRPC creates a new mock instance
func NewMockArcRPC(ctrl *gomock.Controller) *MockArcRPC {
	mock := &MockArcRPC{ctrl: ctrl}
	mock.recorder = &MockArcRPCMockRecorder{mock}
	return mock
}

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

// Archive3 mocks base method
func (m *MockArcRPC) Archive3(c context.Context, arg *archive.ArgAid2) (*api.Arc, error) {
	ret := m.ctrl.Call(m, "Archive3", c, arg)
	ret0, _ := ret[0].(*api.Arc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Archives3 mocks base method
func (m *MockArcRPC) Archives3(c context.Context, arg *archive.ArgAids2) (map[int64]*api.Arc, error) {
	ret := m.ctrl.Call(m, "Archives3", c, arg)
	ret0, _ := ret[0].(map[int64]*api.Arc)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpsPassed2 mocks base method
func (m *MockArcRPC) UpsPassed2(c context.Context, arg *archive.ArgUpsArcs2) (map[int64][]*archive.AidPubTime, error) {
	ret := m.ctrl.Call(m, "UpsPassed2", c, arg)
	ret0, _ := ret[0].(map[int64][]*archive.AidPubTime)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsPassed2 indicates an expected call of UpsPassed2
func (mr *MockArcRPCMockRecorder) UpsPassed2(c, arg interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsPassed2", reflect.TypeOf((*MockArcRPC)(nil).UpsPassed2), 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
}

// Attentions3 mocks base method
func (m *MockAccRPC) Attentions3(c context.Context, arg *model0.ArgMid) ([]int64, error) {
	ret := m.ctrl.Call(m, "Attentions3", c, arg)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockArtRPC is a mock of ArtRPC interface
type MockArtRPC struct {
	ctrl     *gomock.Controller
	recorder *MockArtRPCMockRecorder
}

// MockArtRPCMockRecorder is the mock recorder for MockArtRPC
type MockArtRPCMockRecorder struct {
	mock *MockArtRPC
}

// NewMockArtRPC creates a new mock instance
func NewMockArtRPC(ctrl *gomock.Controller) *MockArtRPC {
	mock := &MockArtRPC{ctrl: ctrl}
	mock.recorder = &MockArtRPCMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockBangumi is a mock of Bangumi interface
type MockBangumi struct {
	ctrl     *gomock.Controller
	recorder *MockBangumiMockRecorder
}

// MockBangumiMockRecorder is the mock recorder for MockBangumi
type MockBangumiMockRecorder struct {
	mock *MockBangumi
}

// NewMockBangumi creates a new mock instance
func NewMockBangumi(ctrl *gomock.Controller) *MockBangumi {
	mock := &MockBangumi{ctrl: ctrl}
	mock.recorder = &MockBangumiMockRecorder{mock}
	return mock
}

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

// BangumiPull mocks base method
func (m *MockBangumi) BangumiPull(c context.Context, mid int64, ip string) ([]int64, error) {
	ret := m.ctrl.Call(m, "BangumiPull", c, mid, ip)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BangumiPull indicates an expected call of BangumiPull
func (mr *MockBangumiMockRecorder) BangumiPull(c, mid, ip interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BangumiPull", reflect.TypeOf((*MockBangumi)(nil).BangumiPull), c, mid, ip)
}

// BangumiSeasons mocks base method
func (m *MockBangumi) BangumiSeasons(c context.Context, seasonIDs []int64, ip string) (map[int64]*model1.Bangumi, error) {
	ret := m.ctrl.Call(m, "BangumiSeasons", c, seasonIDs, ip)
	ret0, _ := ret[0].(map[int64]*model1.Bangumi)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BangumiSeasons indicates an expected call of BangumiSeasons
func (mr *MockBangumiMockRecorder) BangumiSeasons(c, seasonIDs, ip interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BangumiSeasons", reflect.TypeOf((*MockBangumi)(nil).BangumiSeasons), c, seasonIDs, ip)
}