mocks

package

Go to main page

Versions in this module

v0

v0.86.3

Mar 13, 2026

v0.86.2

Mar 13, 2026

v0.86.1

Mar 11, 2026

v0.86.0

Mar 10, 2026

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