backend/pkg/permission/mock/usecase/token.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/permission/domain/usecase/token.go
//
// Generated by this command:
//
//	mockgen -source=./pkg/permission/domain/usecase/token.go -destination=./pkg/permission/mock/usecase/token.go -package=mock
//

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

import (
	entity "backend/pkg/permission/domain/entity"
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockTokenUseCase is a mock of TokenUseCase interface.
type MockTokenUseCase struct {
	ctrl     *gomock.Controller
	recorder *MockTokenUseCaseMockRecorder
	isgomock struct{}
}

// MockTokenUseCaseMockRecorder is the mock recorder for MockTokenUseCase.
type MockTokenUseCaseMockRecorder struct {
	mock *MockTokenUseCase
}

// NewMockTokenUseCase creates a new mock instance.
func NewMockTokenUseCase(ctrl *gomock.Controller) *MockTokenUseCase {
	mock := &MockTokenUseCase{ctrl: ctrl}
	mock.recorder = &MockTokenUseCaseMockRecorder{mock}
	return mock
}

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

// BlacklistAllUserTokens mocks base method.
func (m *MockTokenUseCase) BlacklistAllUserTokens(ctx context.Context, uid, reason string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlacklistAllUserTokens", ctx, uid, reason)
	ret0, _ := ret[0].(error)
	return ret0
}

// BlacklistAllUserTokens indicates an expected call of BlacklistAllUserTokens.
func (mr *MockTokenUseCaseMockRecorder) BlacklistAllUserTokens(ctx, uid, reason any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistAllUserTokens", reflect.TypeOf((*MockTokenUseCase)(nil).BlacklistAllUserTokens), ctx, uid, reason)
}

// BlacklistToken mocks base method.
func (m *MockTokenUseCase) BlacklistToken(ctx context.Context, token, reason string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlacklistToken", ctx, token, reason)
	ret0, _ := ret[0].(error)
	return ret0
}

// BlacklistToken indicates an expected call of BlacklistToken.
func (mr *MockTokenUseCaseMockRecorder) BlacklistToken(ctx, token, reason any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistToken", reflect.TypeOf((*MockTokenUseCase)(nil).BlacklistToken), ctx, token, reason)
}

// CancelOneTimeToken mocks base method.
func (m *MockTokenUseCase) CancelOneTimeToken(ctx context.Context, req entity.CancelOneTimeTokenReq) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOneTimeToken", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelOneTimeToken indicates an expected call of CancelOneTimeToken.
func (mr *MockTokenUseCaseMockRecorder) CancelOneTimeToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelOneTimeToken", reflect.TypeOf((*MockTokenUseCase)(nil).CancelOneTimeToken), ctx, req)
}

// CancelToken mocks base method.
func (m *MockTokenUseCase) CancelToken(ctx context.Context, req entity.CancelTokenReq) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelToken", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelToken indicates an expected call of CancelToken.
func (mr *MockTokenUseCaseMockRecorder) CancelToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelToken", reflect.TypeOf((*MockTokenUseCase)(nil).CancelToken), ctx, req)
}

// CancelTokenByDeviceID mocks base method.
func (m *MockTokenUseCase) CancelTokenByDeviceID(ctx context.Context, req entity.DoTokenByDeviceIDReq) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelTokenByDeviceID", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelTokenByDeviceID indicates an expected call of CancelTokenByDeviceID.
func (mr *MockTokenUseCaseMockRecorder) CancelTokenByDeviceID(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTokenByDeviceID", reflect.TypeOf((*MockTokenUseCase)(nil).CancelTokenByDeviceID), ctx, req)
}

// CancelTokens mocks base method.
func (m *MockTokenUseCase) CancelTokens(ctx context.Context, req entity.DoTokenByUIDReq) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelTokens", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// CancelTokens indicates an expected call of CancelTokens.
func (mr *MockTokenUseCaseMockRecorder) CancelTokens(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTokens", reflect.TypeOf((*MockTokenUseCase)(nil).CancelTokens), ctx, req)
}

// GetUserTokensByDeviceID mocks base method.
func (m *MockTokenUseCase) GetUserTokensByDeviceID(ctx context.Context, req entity.DoTokenByDeviceIDReq) ([]*entity.TokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserTokensByDeviceID", ctx, req)
	ret0, _ := ret[0].([]*entity.TokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserTokensByDeviceID indicates an expected call of GetUserTokensByDeviceID.
func (mr *MockTokenUseCaseMockRecorder) GetUserTokensByDeviceID(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserTokensByDeviceID", reflect.TypeOf((*MockTokenUseCase)(nil).GetUserTokensByDeviceID), ctx, req)
}

// GetUserTokensByUID mocks base method.
func (m *MockTokenUseCase) GetUserTokensByUID(ctx context.Context, req entity.QueryTokenByUIDReq) ([]*entity.TokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserTokensByUID", ctx, req)
	ret0, _ := ret[0].([]*entity.TokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserTokensByUID indicates an expected call of GetUserTokensByUID.
func (mr *MockTokenUseCaseMockRecorder) GetUserTokensByUID(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserTokensByUID", reflect.TypeOf((*MockTokenUseCase)(nil).GetUserTokensByUID), ctx, req)
}

// IsTokenBlacklisted mocks base method.
func (m *MockTokenUseCase) IsTokenBlacklisted(ctx context.Context, jti string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsTokenBlacklisted", ctx, jti)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsTokenBlacklisted indicates an expected call of IsTokenBlacklisted.
func (mr *MockTokenUseCaseMockRecorder) IsTokenBlacklisted(ctx, jti any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTokenBlacklisted", reflect.TypeOf((*MockTokenUseCase)(nil).IsTokenBlacklisted), ctx, jti)
}

// NewOneTimeToken mocks base method.
func (m *MockTokenUseCase) NewOneTimeToken(ctx context.Context, req entity.CreateOneTimeTokenReq) (entity.CreateOneTimeTokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewOneTimeToken", ctx, req)
	ret0, _ := ret[0].(entity.CreateOneTimeTokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewOneTimeToken indicates an expected call of NewOneTimeToken.
func (mr *MockTokenUseCaseMockRecorder) NewOneTimeToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewOneTimeToken", reflect.TypeOf((*MockTokenUseCase)(nil).NewOneTimeToken), ctx, req)
}

// NewToken mocks base method.
func (m *MockTokenUseCase) NewToken(ctx context.Context, req entity.AuthorizationReq) (entity.TokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewToken", ctx, req)
	ret0, _ := ret[0].(entity.TokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewToken indicates an expected call of NewToken.
func (mr *MockTokenUseCaseMockRecorder) NewToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewToken", reflect.TypeOf((*MockTokenUseCase)(nil).NewToken), ctx, req)
}

// ReadTokenBasicData mocks base method.
func (m *MockTokenUseCase) ReadTokenBasicData(ctx context.Context, token string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadTokenBasicData", ctx, token)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadTokenBasicData indicates an expected call of ReadTokenBasicData.
func (mr *MockTokenUseCaseMockRecorder) ReadTokenBasicData(ctx, token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadTokenBasicData", reflect.TypeOf((*MockTokenUseCase)(nil).ReadTokenBasicData), ctx, token)
}

// RefreshToken mocks base method.
func (m *MockTokenUseCase) RefreshToken(ctx context.Context, req entity.RefreshTokenReq) (entity.RefreshTokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshToken", ctx, req)
	ret0, _ := ret[0].(entity.RefreshTokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RefreshToken indicates an expected call of RefreshToken.
func (mr *MockTokenUseCaseMockRecorder) RefreshToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshToken", reflect.TypeOf((*MockTokenUseCase)(nil).RefreshToken), ctx, req)
}

// ValidationToken mocks base method.
func (m *MockTokenUseCase) ValidationToken(ctx context.Context, req entity.ValidationTokenReq) (entity.ValidationTokenResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidationToken", ctx, req)
	ret0, _ := ret[0].(entity.ValidationTokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidationToken indicates an expected call of ValidationToken.
func (mr *MockTokenUseCaseMockRecorder) ValidationToken(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidationToken", reflect.TypeOf((*MockTokenUseCase)(nil).ValidationToken), ctx, req)
}