mocks

package

Go to main page

Versions in this module

v0

v0.85.1

Mar 5, 2026

v0.85.0

Mar 3, 2026

v0.84.0

Mar 3, 2026

Changes in this version

type MockAnalyzedProposal

+ func (_mock *MockAnalyzedProposal) Filter(preds ...annotated.AnnotationPredicate) annotation.Annotations

type MockAnalyzedProposal_Expecter

+ func (_e *MockAnalyzedProposal_Expecter) Filter(preds ...interface{}) *MockAnalyzedProposal_Filter_Call

+ type MockAnalyzedProposal_Filter_Call struct

+ func (_c *MockAnalyzedProposal_Filter_Call) Return(annotations annotation.Annotations) *MockAnalyzedProposal_Filter_Call

+ func (_c *MockAnalyzedProposal_Filter_Call) Run(run func(preds ...annotated.AnnotationPredicate)) *MockAnalyzedProposal_Filter_Call

+ func (_c *MockAnalyzedProposal_Filter_Call) RunAndReturn(run func(preds ...annotated.AnnotationPredicate) annotation.Annotations) *MockAnalyzedProposal_Filter_Call

+ type MockBatchOperationAnalyzer struct

+ func NewMockBatchOperationAnalyzer(t interface{ ... }) *MockBatchOperationAnalyzer

+ func (_m *MockBatchOperationAnalyzer) EXPECT() *MockBatchOperationAnalyzer_Expecter

+ func (_mock *MockBatchOperationAnalyzer) Analyze(ctx context.Context, ...) (annotation.Annotations, error)

+ func (_mock *MockBatchOperationAnalyzer) CanAnalyze(ctx context.Context, ...) bool

+ func (_mock *MockBatchOperationAnalyzer) Dependencies() []string

+ func (_mock *MockBatchOperationAnalyzer) ID() string

+ type MockBatchOperationAnalyzer_Analyze_Call struct

+ func (_c *MockBatchOperationAnalyzer_Analyze_Call) Return(annotations annotation.Annotations, err error) *MockBatchOperationAnalyzer_Analyze_Call

+ func (_c *MockBatchOperationAnalyzer_Analyze_Call) Run(run func(ctx context.Context, ...)) *MockBatchOperationAnalyzer_Analyze_Call

+ func (_c *MockBatchOperationAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, ...) (annotation.Annotations, error)) *MockBatchOperationAnalyzer_Analyze_Call

+ type MockBatchOperationAnalyzer_CanAnalyze_Call struct

+ func (_c *MockBatchOperationAnalyzer_CanAnalyze_Call) Return(b bool) *MockBatchOperationAnalyzer_CanAnalyze_Call

+ func (_c *MockBatchOperationAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, ...)) *MockBatchOperationAnalyzer_CanAnalyze_Call

+ func (_c *MockBatchOperationAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, ...) bool) *MockBatchOperationAnalyzer_CanAnalyze_Call

+ type MockBatchOperationAnalyzer_Dependencies_Call struct

+ func (_c *MockBatchOperationAnalyzer_Dependencies_Call) Return(strings []string) *MockBatchOperationAnalyzer_Dependencies_Call

+ func (_c *MockBatchOperationAnalyzer_Dependencies_Call) Run(run func()) *MockBatchOperationAnalyzer_Dependencies_Call

+ func (_c *MockBatchOperationAnalyzer_Dependencies_Call) RunAndReturn(run func() []string) *MockBatchOperationAnalyzer_Dependencies_Call

+ type MockBatchOperationAnalyzer_Expecter struct

+ func (_e *MockBatchOperationAnalyzer_Expecter) Analyze(ctx interface{}, req interface{}, operation interface{}) *MockBatchOperationAnalyzer_Analyze_Call

+ func (_e *MockBatchOperationAnalyzer_Expecter) CanAnalyze(ctx interface{}, req interface{}, operation interface{}) *MockBatchOperationAnalyzer_CanAnalyze_Call

+ func (_e *MockBatchOperationAnalyzer_Expecter) Dependencies() *MockBatchOperationAnalyzer_Dependencies_Call

+ func (_e *MockBatchOperationAnalyzer_Expecter) ID() *MockBatchOperationAnalyzer_ID_Call

+ type MockBatchOperationAnalyzer_ID_Call struct

+ func (_c *MockBatchOperationAnalyzer_ID_Call) Return(s string) *MockBatchOperationAnalyzer_ID_Call

+ func (_c *MockBatchOperationAnalyzer_ID_Call) Run(run func()) *MockBatchOperationAnalyzer_ID_Call

+ func (_c *MockBatchOperationAnalyzer_ID_Call) RunAndReturn(run func() string) *MockBatchOperationAnalyzer_ID_Call

+ type MockCallAnalyzer struct

+ func NewMockCallAnalyzer(t interface{ ... }) *MockCallAnalyzer

+ func (_m *MockCallAnalyzer) EXPECT() *MockCallAnalyzer_Expecter

+ func (_mock *MockCallAnalyzer) Analyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], ...) (annotation.Annotations, error)

+ func (_mock *MockCallAnalyzer) CanAnalyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], ...) bool

+ func (_mock *MockCallAnalyzer) Dependencies() []string

+ func (_mock *MockCallAnalyzer) ID() string

+ type MockCallAnalyzer_Analyze_Call struct

+ func (_c *MockCallAnalyzer_Analyze_Call) Return(annotations annotation.Annotations, err error) *MockCallAnalyzer_Analyze_Call

+ func (_c *MockCallAnalyzer_Analyze_Call) Run(...) *MockCallAnalyzer_Analyze_Call

+ func (_c *MockCallAnalyzer_Analyze_Call) RunAndReturn(...) *MockCallAnalyzer_Analyze_Call

+ type MockCallAnalyzer_CanAnalyze_Call struct

+ func (_c *MockCallAnalyzer_CanAnalyze_Call) Return(b bool) *MockCallAnalyzer_CanAnalyze_Call

+ func (_c *MockCallAnalyzer_CanAnalyze_Call) Run(...) *MockCallAnalyzer_CanAnalyze_Call

+ func (_c *MockCallAnalyzer_CanAnalyze_Call) RunAndReturn(...) *MockCallAnalyzer_CanAnalyze_Call

+ type MockCallAnalyzer_Dependencies_Call struct

+ func (_c *MockCallAnalyzer_Dependencies_Call) Return(strings []string) *MockCallAnalyzer_Dependencies_Call

+ func (_c *MockCallAnalyzer_Dependencies_Call) Run(run func()) *MockCallAnalyzer_Dependencies_Call

+ func (_c *MockCallAnalyzer_Dependencies_Call) RunAndReturn(run func() []string) *MockCallAnalyzer_Dependencies_Call

+ type MockCallAnalyzer_Expecter struct

+ func (_e *MockCallAnalyzer_Expecter) Analyze(ctx interface{}, req interface{}, call interface{}) *MockCallAnalyzer_Analyze_Call

+ func (_e *MockCallAnalyzer_Expecter) CanAnalyze(ctx interface{}, req interface{}, call interface{}) *MockCallAnalyzer_CanAnalyze_Call

+ func (_e *MockCallAnalyzer_Expecter) Dependencies() *MockCallAnalyzer_Dependencies_Call

+ func (_e *MockCallAnalyzer_Expecter) ID() *MockCallAnalyzer_ID_Call

+ type MockCallAnalyzer_ID_Call struct

+ func (_c *MockCallAnalyzer_ID_Call) Return(s string) *MockCallAnalyzer_ID_Call

+ func (_c *MockCallAnalyzer_ID_Call) Run(run func()) *MockCallAnalyzer_ID_Call

+ func (_c *MockCallAnalyzer_ID_Call) RunAndReturn(run func() string) *MockCallAnalyzer_ID_Call

+ type MockParameterAnalyzer struct

+ func NewMockParameterAnalyzer(t interface{ ... }) *MockParameterAnalyzer

+ func (_m *MockParameterAnalyzer) EXPECT() *MockParameterAnalyzer_Expecter

+ func (_mock *MockParameterAnalyzer) Analyze(ctx context.Context, ...) (annotation.Annotations, error)

+ func (_mock *MockParameterAnalyzer) CanAnalyze(ctx context.Context, ...) bool

+ func (_mock *MockParameterAnalyzer) Dependencies() []string

+ func (_mock *MockParameterAnalyzer) ID() string

+ type MockParameterAnalyzer_Analyze_Call struct

+ func (_c *MockParameterAnalyzer_Analyze_Call) Return(annotations annotation.Annotations, err error) *MockParameterAnalyzer_Analyze_Call

+ func (_c *MockParameterAnalyzer_Analyze_Call) Run(run func(ctx context.Context, ...)) *MockParameterAnalyzer_Analyze_Call

+ func (_c *MockParameterAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, ...) (annotation.Annotations, error)) *MockParameterAnalyzer_Analyze_Call

+ type MockParameterAnalyzer_CanAnalyze_Call struct

+ func (_c *MockParameterAnalyzer_CanAnalyze_Call) Return(b bool) *MockParameterAnalyzer_CanAnalyze_Call

+ func (_c *MockParameterAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, ...)) *MockParameterAnalyzer_CanAnalyze_Call

+ func (_c *MockParameterAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, ...) bool) *MockParameterAnalyzer_CanAnalyze_Call

+ type MockParameterAnalyzer_Dependencies_Call struct

+ func (_c *MockParameterAnalyzer_Dependencies_Call) Return(strings []string) *MockParameterAnalyzer_Dependencies_Call

+ func (_c *MockParameterAnalyzer_Dependencies_Call) Run(run func()) *MockParameterAnalyzer_Dependencies_Call

+ func (_c *MockParameterAnalyzer_Dependencies_Call) RunAndReturn(run func() []string) *MockParameterAnalyzer_Dependencies_Call

+ type MockParameterAnalyzer_Expecter struct

+ func (_e *MockParameterAnalyzer_Expecter) Analyze(ctx interface{}, req interface{}, param interface{}) *MockParameterAnalyzer_Analyze_Call

+ func (_e *MockParameterAnalyzer_Expecter) CanAnalyze(ctx interface{}, req interface{}, param interface{}) *MockParameterAnalyzer_CanAnalyze_Call

+ func (_e *MockParameterAnalyzer_Expecter) Dependencies() *MockParameterAnalyzer_Dependencies_Call

+ func (_e *MockParameterAnalyzer_Expecter) ID() *MockParameterAnalyzer_ID_Call

+ type MockParameterAnalyzer_ID_Call struct

+ func (_c *MockParameterAnalyzer_ID_Call) Return(s string) *MockParameterAnalyzer_ID_Call

+ func (_c *MockParameterAnalyzer_ID_Call) Run(run func()) *MockParameterAnalyzer_ID_Call

+ func (_c *MockParameterAnalyzer_ID_Call) RunAndReturn(run func() string) *MockParameterAnalyzer_ID_Call

+ type MockProposalAnalyzer struct

+ func NewMockProposalAnalyzer(t interface{ ... }) *MockProposalAnalyzer

+ func (_m *MockProposalAnalyzer) EXPECT() *MockProposalAnalyzer_Expecter

+ func (_mock *MockProposalAnalyzer) Analyze(ctx context.Context, req analyzer.ProposalAnalyzeRequest, ...) (annotation.Annotations, error)

+ func (_mock *MockProposalAnalyzer) CanAnalyze(ctx context.Context, req analyzer.ProposalAnalyzeRequest, ...) bool

+ func (_mock *MockProposalAnalyzer) Dependencies() []string

+ func (_mock *MockProposalAnalyzer) ID() string

+ type MockProposalAnalyzer_Analyze_Call struct

+ func (_c *MockProposalAnalyzer_Analyze_Call) Return(annotations annotation.Annotations, err error) *MockProposalAnalyzer_Analyze_Call

+ func (_c *MockProposalAnalyzer_Analyze_Call) Run(run func(ctx context.Context, req analyzer.ProposalAnalyzeRequest, ...)) *MockProposalAnalyzer_Analyze_Call

+ func (_c *MockProposalAnalyzer_Analyze_Call) RunAndReturn(...) *MockProposalAnalyzer_Analyze_Call

+ type MockProposalAnalyzer_CanAnalyze_Call struct

+ func (_c *MockProposalAnalyzer_CanAnalyze_Call) Return(b bool) *MockProposalAnalyzer_CanAnalyze_Call

+ func (_c *MockProposalAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, req analyzer.ProposalAnalyzeRequest, ...)) *MockProposalAnalyzer_CanAnalyze_Call

+ func (_c *MockProposalAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.ProposalAnalyzeRequest, ...) bool) *MockProposalAnalyzer_CanAnalyze_Call

+ type MockProposalAnalyzer_Dependencies_Call struct

+ func (_c *MockProposalAnalyzer_Dependencies_Call) Return(strings []string) *MockProposalAnalyzer_Dependencies_Call

+ func (_c *MockProposalAnalyzer_Dependencies_Call) Run(run func()) *MockProposalAnalyzer_Dependencies_Call

+ func (_c *MockProposalAnalyzer_Dependencies_Call) RunAndReturn(run func() []string) *MockProposalAnalyzer_Dependencies_Call

+ type MockProposalAnalyzer_Expecter struct

+ func (_e *MockProposalAnalyzer_Expecter) Analyze(ctx interface{}, req interface{}, proposal interface{}) *MockProposalAnalyzer_Analyze_Call

+ func (_e *MockProposalAnalyzer_Expecter) CanAnalyze(ctx interface{}, req interface{}, proposal interface{}) *MockProposalAnalyzer_CanAnalyze_Call

+ func (_e *MockProposalAnalyzer_Expecter) Dependencies() *MockProposalAnalyzer_Dependencies_Call

+ func (_e *MockProposalAnalyzer_Expecter) ID() *MockProposalAnalyzer_ID_Call

+ type MockProposalAnalyzer_ID_Call struct

+ func (_c *MockProposalAnalyzer_ID_Call) Return(s string) *MockProposalAnalyzer_ID_Call

+ func (_c *MockProposalAnalyzer_ID_Call) Run(run func()) *MockProposalAnalyzer_ID_Call

+ func (_c *MockProposalAnalyzer_ID_Call) RunAndReturn(run func() string) *MockProposalAnalyzer_ID_Call

v0.81.0

Feb 18, 2026

Changes in this version

+ type MockAnalyzedProposal struct

+ func NewMockAnalyzedProposal(t interface{ ... }) *MockAnalyzedProposal

+ func (_m *MockAnalyzedProposal) EXPECT() *MockAnalyzedProposal_Expecter

+ func (_mock *MockAnalyzedProposal) AddAnnotations(annotations ...analyzer.Annotation)

+ func (_mock *MockAnalyzedProposal) Annotations() analyzer.Annotations

+ func (_mock *MockAnalyzedProposal) BatchOperations() analyzer.AnalyzedBatchOperations

+ type MockAnalyzedProposal_AddAnnotations_Call struct

+ func (_c *MockAnalyzedProposal_AddAnnotations_Call) Return() *MockAnalyzedProposal_AddAnnotations_Call

+ func (_c *MockAnalyzedProposal_AddAnnotations_Call) Run(run func(annotations ...analyzer.Annotation)) *MockAnalyzedProposal_AddAnnotations_Call

+ func (_c *MockAnalyzedProposal_AddAnnotations_Call) RunAndReturn(run func(annotations ...analyzer.Annotation)) *MockAnalyzedProposal_AddAnnotations_Call

+ type MockAnalyzedProposal_Annotations_Call struct

+ func (_c *MockAnalyzedProposal_Annotations_Call) Return(annotations analyzer.Annotations) *MockAnalyzedProposal_Annotations_Call

+ func (_c *MockAnalyzedProposal_Annotations_Call) Run(run func()) *MockAnalyzedProposal_Annotations_Call

+ func (_c *MockAnalyzedProposal_Annotations_Call) RunAndReturn(run func() analyzer.Annotations) *MockAnalyzedProposal_Annotations_Call

+ type MockAnalyzedProposal_BatchOperations_Call struct

+ func (_c *MockAnalyzedProposal_BatchOperations_Call) Return(analyzedBatchOperations analyzer.AnalyzedBatchOperations) *MockAnalyzedProposal_BatchOperations_Call

+ func (_c *MockAnalyzedProposal_BatchOperations_Call) Run(run func()) *MockAnalyzedProposal_BatchOperations_Call

+ func (_c *MockAnalyzedProposal_BatchOperations_Call) RunAndReturn(run func() analyzer.AnalyzedBatchOperations) *MockAnalyzedProposal_BatchOperations_Call

+ type MockAnalyzedProposal_Expecter struct

+ func (_e *MockAnalyzedProposal_Expecter) AddAnnotations(annotations ...interface{}) *MockAnalyzedProposal_AddAnnotations_Call

+ func (_e *MockAnalyzedProposal_Expecter) Annotations() *MockAnalyzedProposal_Annotations_Call

+ func (_e *MockAnalyzedProposal_Expecter) BatchOperations() *MockAnalyzedProposal_BatchOperations_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL