489 lines
20 KiB
Go
489 lines
20 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: article.go
|
|
|
|
// Package client is a generated GoMock package.
|
|
package client
|
|
|
|
import (
|
|
context "context"
|
|
gomock "github.com/golang/mock/gomock"
|
|
model "go-common/app/interface/openplatform/article/model"
|
|
reflect "reflect"
|
|
)
|
|
|
|
// MockArticleRPC is a mock of ArticleRPC interface
|
|
type MockArticleRPC struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockArticleRPCMockRecorder
|
|
}
|
|
|
|
// MockArticleRPCMockRecorder is the mock recorder for MockArticleRPC
|
|
type MockArticleRPCMockRecorder struct {
|
|
mock *MockArticleRPC
|
|
}
|
|
|
|
// NewMockArticleRPC creates a new mock instance
|
|
func NewMockArticleRPC(ctrl *gomock.Controller) *MockArticleRPC {
|
|
mock := &MockArticleRPC{ctrl: ctrl}
|
|
mock.recorder = &MockArticleRPCMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockArticleRPC) EXPECT() *MockArticleRPCMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddArticle mocks base method
|
|
func (m *MockArticleRPC) AddArticle(c context.Context, arg *model.ArgArticle) (int64, error) {
|
|
ret := m.ctrl.Call(m, "AddArticle", c, arg)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddArticle indicates an expected call of AddArticle
|
|
func (mr *MockArticleRPCMockRecorder) AddArticle(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArticle", reflect.TypeOf((*MockArticleRPC)(nil).AddArticle), c, arg)
|
|
}
|
|
|
|
// AddArticleCache mocks base method
|
|
func (m *MockArticleRPC) AddArticleCache(c context.Context, arg *model.ArgAid) error {
|
|
ret := m.ctrl.Call(m, "AddArticleCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddArticleCache indicates an expected call of AddArticleCache
|
|
func (mr *MockArticleRPCMockRecorder) AddArticleCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).AddArticleCache), c, arg)
|
|
}
|
|
|
|
// UpdateArticleCache mocks base method
|
|
func (m *MockArticleRPC) UpdateArticleCache(c context.Context, arg *model.ArgAidCid) error {
|
|
ret := m.ctrl.Call(m, "UpdateArticleCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateArticleCache indicates an expected call of UpdateArticleCache
|
|
func (mr *MockArticleRPCMockRecorder) UpdateArticleCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArticleCache), c, arg)
|
|
}
|
|
|
|
// DelArticleCache mocks base method
|
|
func (m *MockArticleRPC) DelArticleCache(c context.Context, arg *model.ArgAidMid) error {
|
|
ret := m.ctrl.Call(m, "DelArticleCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelArticleCache indicates an expected call of DelArticleCache
|
|
func (mr *MockArticleRPCMockRecorder) DelArticleCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).DelArticleCache), c, arg)
|
|
}
|
|
|
|
// UpdateArticle mocks base method
|
|
func (m *MockArticleRPC) UpdateArticle(c context.Context, arg *model.ArgArticle) error {
|
|
ret := m.ctrl.Call(m, "UpdateArticle", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateArticle indicates an expected call of UpdateArticle
|
|
func (mr *MockArticleRPCMockRecorder) UpdateArticle(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArticle", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArticle), c, arg)
|
|
}
|
|
|
|
// CreationWithdrawArticle mocks base method
|
|
func (m *MockArticleRPC) CreationWithdrawArticle(c context.Context, arg *model.ArgAidMid) error {
|
|
ret := m.ctrl.Call(m, "CreationWithdrawArticle", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreationWithdrawArticle indicates an expected call of CreationWithdrawArticle
|
|
func (mr *MockArticleRPCMockRecorder) CreationWithdrawArticle(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationWithdrawArticle", reflect.TypeOf((*MockArticleRPC)(nil).CreationWithdrawArticle), c, arg)
|
|
}
|
|
|
|
// DelArticle mocks base method
|
|
func (m *MockArticleRPC) DelArticle(c context.Context, arg *model.ArgAidMid) error {
|
|
ret := m.ctrl.Call(m, "DelArticle", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelArticle indicates an expected call of DelArticle
|
|
func (mr *MockArticleRPCMockRecorder) DelArticle(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArticle", reflect.TypeOf((*MockArticleRPC)(nil).DelArticle), c, arg)
|
|
}
|
|
|
|
// CreationArticle mocks base method
|
|
func (m *MockArticleRPC) CreationArticle(c context.Context, arg *model.ArgAidMid) (*model.Article, error) {
|
|
ret := m.ctrl.Call(m, "CreationArticle", c, arg)
|
|
ret0, _ := ret[0].(*model.Article)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreationArticle indicates an expected call of CreationArticle
|
|
func (mr *MockArticleRPCMockRecorder) CreationArticle(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationArticle", reflect.TypeOf((*MockArticleRPC)(nil).CreationArticle), c, arg)
|
|
}
|
|
|
|
// CreationUpperArticles mocks base method
|
|
func (m *MockArticleRPC) CreationUpperArticles(c context.Context, arg *model.ArgCreationArts) (*model.CreationArts, error) {
|
|
ret := m.ctrl.Call(m, "CreationUpperArticles", c, arg)
|
|
ret0, _ := ret[0].(*model.CreationArts)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreationUpperArticles indicates an expected call of CreationUpperArticles
|
|
func (mr *MockArticleRPCMockRecorder) CreationUpperArticles(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpperArticles", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpperArticles), c, arg)
|
|
}
|
|
|
|
// Categories mocks base method
|
|
func (m *MockArticleRPC) Categories(c context.Context, arg *model.ArgIP) (*model.Categories, error) {
|
|
ret := m.ctrl.Call(m, "Categories", c, arg)
|
|
ret0, _ := ret[0].(*model.Categories)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Categories indicates an expected call of Categories
|
|
func (mr *MockArticleRPCMockRecorder) Categories(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Categories", reflect.TypeOf((*MockArticleRPC)(nil).Categories), c, arg)
|
|
}
|
|
|
|
// CategoriesMap mocks base method
|
|
func (m *MockArticleRPC) CategoriesMap(c context.Context, arg *model.ArgIP) (map[int64]*model.Category, error) {
|
|
ret := m.ctrl.Call(m, "CategoriesMap", c, arg)
|
|
ret0, _ := ret[0].(map[int64]*model.Category)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CategoriesMap indicates an expected call of CategoriesMap
|
|
func (mr *MockArticleRPCMockRecorder) CategoriesMap(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategoriesMap", reflect.TypeOf((*MockArticleRPC)(nil).CategoriesMap), c, arg)
|
|
}
|
|
|
|
// SetStat mocks base method
|
|
func (m *MockArticleRPC) SetStat(c context.Context, arg *model.ArgStats) error {
|
|
ret := m.ctrl.Call(m, "SetStat", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetStat indicates an expected call of SetStat
|
|
func (mr *MockArticleRPCMockRecorder) SetStat(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStat", reflect.TypeOf((*MockArticleRPC)(nil).SetStat), c, arg)
|
|
}
|
|
|
|
// UpsArtMetas mocks base method
|
|
func (m *MockArticleRPC) 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 *MockArticleRPCMockRecorder) UpsArtMetas(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsArtMetas", reflect.TypeOf((*MockArticleRPC)(nil).UpsArtMetas), c, arg)
|
|
}
|
|
|
|
// ArticleMetas mocks base method
|
|
func (m *MockArticleRPC) 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 *MockArticleRPCMockRecorder) ArticleMetas(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArticleMetas", reflect.TypeOf((*MockArticleRPC)(nil).ArticleMetas), c, arg)
|
|
}
|
|
|
|
// UpdateRecommends mocks base method
|
|
func (m *MockArticleRPC) UpdateRecommends(c context.Context) error {
|
|
ret := m.ctrl.Call(m, "UpdateRecommends", c)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateRecommends indicates an expected call of UpdateRecommends
|
|
func (mr *MockArticleRPCMockRecorder) UpdateRecommends(c interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecommends", reflect.TypeOf((*MockArticleRPC)(nil).UpdateRecommends), c)
|
|
}
|
|
|
|
// Recommends mocks base method
|
|
func (m *MockArticleRPC) Recommends(c context.Context, arg *model.ArgRecommends) ([]*model.Meta, error) {
|
|
ret := m.ctrl.Call(m, "Recommends", c, arg)
|
|
ret0, _ := ret[0].([]*model.Meta)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Recommends indicates an expected call of Recommends
|
|
func (mr *MockArticleRPCMockRecorder) Recommends(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recommends", reflect.TypeOf((*MockArticleRPC)(nil).Recommends), c, arg)
|
|
}
|
|
|
|
// UpArtMetas mocks base method
|
|
func (m *MockArticleRPC) UpArtMetas(c context.Context, arg *model.ArgUpArts) (*model.UpArtMetas, error) {
|
|
ret := m.ctrl.Call(m, "UpArtMetas", c, arg)
|
|
ret0, _ := ret[0].(*model.UpArtMetas)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpArtMetas indicates an expected call of UpArtMetas
|
|
func (mr *MockArticleRPCMockRecorder) UpArtMetas(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpArtMetas", reflect.TypeOf((*MockArticleRPC)(nil).UpArtMetas), c, arg)
|
|
}
|
|
|
|
// AddArtDraft mocks base method
|
|
func (m *MockArticleRPC) AddArtDraft(c context.Context, arg *model.ArgArticle) (int64, error) {
|
|
ret := m.ctrl.Call(m, "AddArtDraft", c, arg)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddArtDraft indicates an expected call of AddArtDraft
|
|
func (mr *MockArticleRPCMockRecorder) AddArtDraft(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).AddArtDraft), c, arg)
|
|
}
|
|
|
|
// UpdateArtDraft mocks base method
|
|
func (m *MockArticleRPC) UpdateArtDraft(c context.Context, arg *model.ArgAidMid) error {
|
|
ret := m.ctrl.Call(m, "UpdateArtDraft", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateArtDraft indicates an expected call of UpdateArtDraft
|
|
func (mr *MockArticleRPCMockRecorder) UpdateArtDraft(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArtDraft), c, arg)
|
|
}
|
|
|
|
// DelArtDraft mocks base method
|
|
func (m *MockArticleRPC) DelArtDraft(c context.Context, arg *model.ArgAidMid) error {
|
|
ret := m.ctrl.Call(m, "DelArtDraft", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelArtDraft indicates an expected call of DelArtDraft
|
|
func (mr *MockArticleRPCMockRecorder) DelArtDraft(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).DelArtDraft), c, arg)
|
|
}
|
|
|
|
// ArtDraft mocks base method
|
|
func (m *MockArticleRPC) ArtDraft(c context.Context, arg *model.ArgAidMid) (*model.Draft, error) {
|
|
ret := m.ctrl.Call(m, "ArtDraft", c, arg)
|
|
ret0, _ := ret[0].(*model.Draft)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ArtDraft indicates an expected call of ArtDraft
|
|
func (mr *MockArticleRPCMockRecorder) ArtDraft(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).ArtDraft), c, arg)
|
|
}
|
|
|
|
// UpperDrafts mocks base method
|
|
func (m *MockArticleRPC) UpperDrafts(c context.Context, arg *model.ArgUpDraft) (*model.Drafts, error) {
|
|
ret := m.ctrl.Call(m, "UpperDrafts", c, arg)
|
|
ret0, _ := ret[0].(*model.Drafts)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpperDrafts indicates an expected call of UpperDrafts
|
|
func (mr *MockArticleRPCMockRecorder) UpperDrafts(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpperDrafts", reflect.TypeOf((*MockArticleRPC)(nil).UpperDrafts), c, arg)
|
|
}
|
|
|
|
// UpdateNewArts mocks base method
|
|
func (m *MockArticleRPC) UpdateNewArts(c context.Context, arg *model.ArgIP) error {
|
|
ret := m.ctrl.Call(m, "UpdateNewArts", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateNewArts indicates an expected call of UpdateNewArts
|
|
func (mr *MockArticleRPCMockRecorder) UpdateNewArts(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNewArts", reflect.TypeOf((*MockArticleRPC)(nil).UpdateNewArts), c, arg)
|
|
}
|
|
|
|
// ArticleRemainCount mocks base method
|
|
func (m *MockArticleRPC) ArticleRemainCount(c context.Context, arg *model.ArgMid) (int, error) {
|
|
ret := m.ctrl.Call(m, "ArticleRemainCount", c, arg)
|
|
ret0, _ := ret[0].(int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ArticleRemainCount indicates an expected call of ArticleRemainCount
|
|
func (mr *MockArticleRPCMockRecorder) ArticleRemainCount(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArticleRemainCount", reflect.TypeOf((*MockArticleRPC)(nil).ArticleRemainCount), c, arg)
|
|
}
|
|
|
|
// DelRecommendArtCache mocks base method
|
|
func (m *MockArticleRPC) DelRecommendArtCache(c context.Context, arg *model.ArgAidCid) error {
|
|
ret := m.ctrl.Call(m, "DelRecommendArtCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DelRecommendArtCache indicates an expected call of DelRecommendArtCache
|
|
func (mr *MockArticleRPCMockRecorder) DelRecommendArtCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelRecommendArtCache", reflect.TypeOf((*MockArticleRPC)(nil).DelRecommendArtCache), c, arg)
|
|
}
|
|
|
|
// CheckPrivilege mocks base method
|
|
func (m *MockArticleRPC) CheckPrivilege(c context.Context, arg *model.ArgMid) error {
|
|
ret := m.ctrl.Call(m, "CheckPrivilege", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CheckPrivilege indicates an expected call of CheckPrivilege
|
|
func (mr *MockArticleRPCMockRecorder) CheckPrivilege(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckPrivilege", reflect.TypeOf((*MockArticleRPC)(nil).CheckPrivilege), c, arg)
|
|
}
|
|
|
|
// Favorites mocks base method
|
|
func (m *MockArticleRPC) Favorites(c context.Context, arg *model.ArgFav) ([]*model.Favorite, error) {
|
|
ret := m.ctrl.Call(m, "Favorites", c, arg)
|
|
ret0, _ := ret[0].([]*model.Favorite)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Favorites indicates an expected call of Favorites
|
|
func (mr *MockArticleRPCMockRecorder) Favorites(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Favorites", reflect.TypeOf((*MockArticleRPC)(nil).Favorites), c, arg)
|
|
}
|
|
|
|
// UpdateAuthorCache mocks base method
|
|
func (m *MockArticleRPC) UpdateAuthorCache(c context.Context, arg *model.ArgAuthor) error {
|
|
ret := m.ctrl.Call(m, "UpdateAuthorCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateAuthorCache indicates an expected call of UpdateAuthorCache
|
|
func (mr *MockArticleRPCMockRecorder) UpdateAuthorCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthorCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateAuthorCache), c, arg)
|
|
}
|
|
|
|
// UpdateSortCache mocks base method
|
|
func (m *MockArticleRPC) UpdateSortCache(c context.Context, arg *model.ArgSort) error {
|
|
ret := m.ctrl.Call(m, "UpdateSortCache", c, arg)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateSortCache indicates an expected call of UpdateSortCache
|
|
func (mr *MockArticleRPCMockRecorder) UpdateSortCache(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSortCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateSortCache), c, arg)
|
|
}
|
|
|
|
// IsAuthor mocks base method
|
|
func (m *MockArticleRPC) IsAuthor(c context.Context, arg *model.ArgMid) (bool, error) {
|
|
ret := m.ctrl.Call(m, "IsAuthor", c, arg)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsAuthor indicates an expected call of IsAuthor
|
|
func (mr *MockArticleRPCMockRecorder) IsAuthor(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthor", reflect.TypeOf((*MockArticleRPC)(nil).IsAuthor), c, arg)
|
|
}
|
|
|
|
// NewArticleCount mocks base method
|
|
func (m *MockArticleRPC) NewArticleCount(c context.Context, arg *model.ArgNewArt) (int64, error) {
|
|
ret := m.ctrl.Call(m, "NewArticleCount", c, arg)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// NewArticleCount indicates an expected call of NewArticleCount
|
|
func (mr *MockArticleRPCMockRecorder) NewArticleCount(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewArticleCount", reflect.TypeOf((*MockArticleRPC)(nil).NewArticleCount), c, arg)
|
|
}
|
|
|
|
// HadLikesByMid mocks base method
|
|
func (m *MockArticleRPC) HadLikesByMid(c context.Context, arg *model.ArgMidAids) (map[int64]int, error) {
|
|
ret := m.ctrl.Call(m, "HadLikesByMid", c, arg)
|
|
ret0, _ := ret[0].(map[int64]int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HadLikesByMid indicates an expected call of HadLikesByMid
|
|
func (mr *MockArticleRPCMockRecorder) HadLikesByMid(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HadLikesByMid", reflect.TypeOf((*MockArticleRPC)(nil).HadLikesByMid), c, arg)
|
|
}
|
|
|
|
// UpMoreArts mocks base method
|
|
func (m *MockArticleRPC) UpMoreArts(c context.Context, arg *model.ArgAid) ([]*model.Meta, error) {
|
|
ret := m.ctrl.Call(m, "UpMoreArts", c, arg)
|
|
ret0, _ := ret[0].([]*model.Meta)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpMoreArts indicates an expected call of UpMoreArts
|
|
func (mr *MockArticleRPCMockRecorder) UpMoreArts(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpMoreArts", reflect.TypeOf((*MockArticleRPC)(nil).UpMoreArts), c, arg)
|
|
}
|
|
|
|
// CreationUpStat mocks base method
|
|
func (m *MockArticleRPC) CreationUpStat(c context.Context, arg *model.ArgMid) (model.UpStat, error) {
|
|
ret := m.ctrl.Call(m, "CreationUpStat", c, arg)
|
|
ret0, _ := ret[0].(model.UpStat)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreationUpStat indicates an expected call of CreationUpStat
|
|
func (mr *MockArticleRPCMockRecorder) CreationUpStat(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpStat", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpStat), c, arg)
|
|
}
|
|
|
|
// CreationUpThirtyDayStat mocks base method
|
|
func (m *MockArticleRPC) CreationUpThirtyDayStat(c context.Context, arg *model.ArgMid) ([]*model.ThirtyDayArticle, error) {
|
|
ret := m.ctrl.Call(m, "CreationUpThirtyDayStat", c, arg)
|
|
ret0, _ := ret[0].([]*model.ThirtyDayArticle)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreationUpThirtyDayStat indicates an expected call of CreationUpThirtyDayStat
|
|
func (mr *MockArticleRPCMockRecorder) CreationUpThirtyDayStat(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpThirtyDayStat", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpThirtyDayStat), c, arg)
|
|
}
|
|
|
|
// UpLists mocks base method
|
|
func (m *MockArticleRPC) UpLists(c context.Context, arg *model.ArgMid) (model.UpLists, error) {
|
|
ret := m.ctrl.Call(m, "UpLists", c, arg)
|
|
ret0, _ := ret[0].(model.UpLists)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpLists indicates an expected call of UpLists
|
|
func (mr *MockArticleRPCMockRecorder) UpLists(c, arg interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpLists", reflect.TypeOf((*MockArticleRPC)(nil).UpLists), c, arg)
|
|
}
|