mocks

package
v0.81.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 19, 2026 License: MIT Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAnalyzedProposal 

type MockAnalyzedProposal struct {
	mock.Mock
}

MockAnalyzedProposal is an autogenerated mock type for the AnalyzedProposal type

func NewMockAnalyzedProposal 

func NewMockAnalyzedProposal(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAnalyzedProposal

NewMockAnalyzedProposal creates a new instance of MockAnalyzedProposal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAnalyzedProposal) Annotations 

func (_mock *MockAnalyzedProposal) Annotations() annotation.Annotations

Annotations provides a mock function for the type MockAnalyzedProposal

func (*MockAnalyzedProposal) BatchOperations 

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

BatchOperations provides a mock function for the type MockAnalyzedProposal

func (*MockAnalyzedProposal) EXPECT 

func (_m *MockAnalyzedProposal) EXPECT() *MockAnalyzedProposal_Expecter

func (*MockAnalyzedProposal) Filter 

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

Filter provides a mock function for the type MockAnalyzedProposal

type MockAnalyzedProposal_Annotations_Call 

type MockAnalyzedProposal_Annotations_Call struct {
	*mock.Call
}

MockAnalyzedProposal_Annotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Annotations'

func (*MockAnalyzedProposal_Annotations_Call) Return 

func (_c *MockAnalyzedProposal_Annotations_Call) Return(annotations annotation.Annotations) *MockAnalyzedProposal_Annotations_Call

func (*MockAnalyzedProposal_Annotations_Call) Run 

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

func (*MockAnalyzedProposal_Annotations_Call) RunAndReturn 

func (_c *MockAnalyzedProposal_Annotations_Call) RunAndReturn(run func() annotation.Annotations) *MockAnalyzedProposal_Annotations_Call

type MockAnalyzedProposal_BatchOperations_Call 

type MockAnalyzedProposal_BatchOperations_Call struct {
	*mock.Call
}

MockAnalyzedProposal_BatchOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchOperations'

func (*MockAnalyzedProposal_BatchOperations_Call) Return 

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

func (*MockAnalyzedProposal_BatchOperations_Call) Run 

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

func (*MockAnalyzedProposal_BatchOperations_Call) RunAndReturn 

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

type MockAnalyzedProposal_Expecter 

type MockAnalyzedProposal_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockAnalyzedProposal_Expecter) Annotations 

func (_e *MockAnalyzedProposal_Expecter) Annotations() *MockAnalyzedProposal_Annotations_Call

Annotations is a helper method to define mock.On call

func (*MockAnalyzedProposal_Expecter) BatchOperations 

func (_e *MockAnalyzedProposal_Expecter) BatchOperations() *MockAnalyzedProposal_BatchOperations_Call

BatchOperations is a helper method to define mock.On call

func (*MockAnalyzedProposal_Expecter) Filter 

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

Filter is a helper method to define mock.On call

  • preds ...annotated.AnnotationPredicate

type MockAnalyzedProposal_Filter_Call 

type MockAnalyzedProposal_Filter_Call struct {
	*mock.Call
}

MockAnalyzedProposal_Filter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Filter'

func (*MockAnalyzedProposal_Filter_Call) Return 

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

func (*MockAnalyzedProposal_Filter_Call) Run 

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

func (*MockAnalyzedProposal_Filter_Call) RunAndReturn 

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

type MockBatchOperationAnalyzer 

type MockBatchOperationAnalyzer struct {
	mock.Mock
}

MockBatchOperationAnalyzer is an autogenerated mock type for the BatchOperationAnalyzer type

func NewMockBatchOperationAnalyzer 

func NewMockBatchOperationAnalyzer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBatchOperationAnalyzer

NewMockBatchOperationAnalyzer creates a new instance of MockBatchOperationAnalyzer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockBatchOperationAnalyzer) Analyze 

func (_mock *MockBatchOperationAnalyzer) Analyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation) (annotation.Annotations, error)

Analyze provides a mock function for the type MockBatchOperationAnalyzer

func (*MockBatchOperationAnalyzer) CanAnalyze 

func (_mock *MockBatchOperationAnalyzer) CanAnalyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation) bool

CanAnalyze provides a mock function for the type MockBatchOperationAnalyzer

func (*MockBatchOperationAnalyzer) Dependencies 

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

Dependencies provides a mock function for the type MockBatchOperationAnalyzer

func (*MockBatchOperationAnalyzer) EXPECT 

func (_m *MockBatchOperationAnalyzer) EXPECT() *MockBatchOperationAnalyzer_Expecter

func (*MockBatchOperationAnalyzer) ID 

func (_mock *MockBatchOperationAnalyzer) ID() string

ID provides a mock function for the type MockBatchOperationAnalyzer

type MockBatchOperationAnalyzer_Analyze_Call 

type MockBatchOperationAnalyzer_Analyze_Call struct {
	*mock.Call
}

MockBatchOperationAnalyzer_Analyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Analyze'

func (*MockBatchOperationAnalyzer_Analyze_Call) Return 

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

func (*MockBatchOperationAnalyzer_Analyze_Call) Run 

func (_c *MockBatchOperationAnalyzer_Analyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation)) *MockBatchOperationAnalyzer_Analyze_Call

func (*MockBatchOperationAnalyzer_Analyze_Call) RunAndReturn 

func (_c *MockBatchOperationAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation) (annotation.Annotations, error)) *MockBatchOperationAnalyzer_Analyze_Call

type MockBatchOperationAnalyzer_CanAnalyze_Call 

type MockBatchOperationAnalyzer_CanAnalyze_Call struct {
	*mock.Call
}

MockBatchOperationAnalyzer_CanAnalyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanAnalyze'

func (*MockBatchOperationAnalyzer_CanAnalyze_Call) Return 

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

func (*MockBatchOperationAnalyzer_CanAnalyze_Call) Run 

func (_c *MockBatchOperationAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation)) *MockBatchOperationAnalyzer_CanAnalyze_Call

func (*MockBatchOperationAnalyzer_CanAnalyze_Call) RunAndReturn 

func (_c *MockBatchOperationAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext], operation decoder.DecodedBatchOperation) bool) *MockBatchOperationAnalyzer_CanAnalyze_Call

type MockBatchOperationAnalyzer_Dependencies_Call 

type MockBatchOperationAnalyzer_Dependencies_Call struct {
	*mock.Call
}

MockBatchOperationAnalyzer_Dependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dependencies'

func (*MockBatchOperationAnalyzer_Dependencies_Call) Return 

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

func (*MockBatchOperationAnalyzer_Dependencies_Call) Run 

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

func (*MockBatchOperationAnalyzer_Dependencies_Call) RunAndReturn 

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

type MockBatchOperationAnalyzer_Expecter 

type MockBatchOperationAnalyzer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockBatchOperationAnalyzer_Expecter) Analyze 

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

Analyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext]
  • operation decoder.DecodedBatchOperation

func (*MockBatchOperationAnalyzer_Expecter) CanAnalyze 

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

CanAnalyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.BatchOperationAnalyzerContext]
  • operation decoder.DecodedBatchOperation

func (*MockBatchOperationAnalyzer_Expecter) Dependencies 

func (_e *MockBatchOperationAnalyzer_Expecter) Dependencies() *MockBatchOperationAnalyzer_Dependencies_Call

Dependencies is a helper method to define mock.On call

func (*MockBatchOperationAnalyzer_Expecter) ID 

func (_e *MockBatchOperationAnalyzer_Expecter) ID() *MockBatchOperationAnalyzer_ID_Call

ID is a helper method to define mock.On call

type MockBatchOperationAnalyzer_ID_Call 

type MockBatchOperationAnalyzer_ID_Call struct {
	*mock.Call
}

MockBatchOperationAnalyzer_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*MockBatchOperationAnalyzer_ID_Call) Return 

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

func (*MockBatchOperationAnalyzer_ID_Call) Run 

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

func (*MockBatchOperationAnalyzer_ID_Call) RunAndReturn 

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

type MockCallAnalyzer 

type MockCallAnalyzer struct {
	mock.Mock
}

MockCallAnalyzer is an autogenerated mock type for the CallAnalyzer type

func NewMockCallAnalyzer 

func NewMockCallAnalyzer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCallAnalyzer

NewMockCallAnalyzer creates a new instance of MockCallAnalyzer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockCallAnalyzer) Analyze 

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

Analyze provides a mock function for the type MockCallAnalyzer

func (*MockCallAnalyzer) CanAnalyze 

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

CanAnalyze provides a mock function for the type MockCallAnalyzer

func (*MockCallAnalyzer) Dependencies 

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

Dependencies provides a mock function for the type MockCallAnalyzer

func (*MockCallAnalyzer) EXPECT 

func (_m *MockCallAnalyzer) EXPECT() *MockCallAnalyzer_Expecter

func (*MockCallAnalyzer) ID 

func (_mock *MockCallAnalyzer) ID() string

ID provides a mock function for the type MockCallAnalyzer

type MockCallAnalyzer_Analyze_Call 

type MockCallAnalyzer_Analyze_Call struct {
	*mock.Call
}

MockCallAnalyzer_Analyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Analyze'

func (*MockCallAnalyzer_Analyze_Call) Return 

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

func (*MockCallAnalyzer_Analyze_Call) Run 

func (_c *MockCallAnalyzer_Analyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], call decoder.DecodedCall)) *MockCallAnalyzer_Analyze_Call

func (*MockCallAnalyzer_Analyze_Call) RunAndReturn 

func (_c *MockCallAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], call decoder.DecodedCall) (annotation.Annotations, error)) *MockCallAnalyzer_Analyze_Call

type MockCallAnalyzer_CanAnalyze_Call 

type MockCallAnalyzer_CanAnalyze_Call struct {
	*mock.Call
}

MockCallAnalyzer_CanAnalyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanAnalyze'

func (*MockCallAnalyzer_CanAnalyze_Call) Return 

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

func (*MockCallAnalyzer_CanAnalyze_Call) Run 

func (_c *MockCallAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], call decoder.DecodedCall)) *MockCallAnalyzer_CanAnalyze_Call

func (*MockCallAnalyzer_CanAnalyze_Call) RunAndReturn 

func (_c *MockCallAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext], call decoder.DecodedCall) bool) *MockCallAnalyzer_CanAnalyze_Call

type MockCallAnalyzer_Dependencies_Call 

type MockCallAnalyzer_Dependencies_Call struct {
	*mock.Call
}

MockCallAnalyzer_Dependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dependencies'

func (*MockCallAnalyzer_Dependencies_Call) Return 

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

func (*MockCallAnalyzer_Dependencies_Call) Run 

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

func (*MockCallAnalyzer_Dependencies_Call) RunAndReturn 

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

type MockCallAnalyzer_Expecter 

type MockCallAnalyzer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockCallAnalyzer_Expecter) Analyze 

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

Analyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext]
  • call decoder.DecodedCall

func (*MockCallAnalyzer_Expecter) CanAnalyze 

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

CanAnalyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.CallAnalyzerContext]
  • call decoder.DecodedCall

func (*MockCallAnalyzer_Expecter) Dependencies 

func (_e *MockCallAnalyzer_Expecter) Dependencies() *MockCallAnalyzer_Dependencies_Call

Dependencies is a helper method to define mock.On call

func (*MockCallAnalyzer_Expecter) ID 

func (_e *MockCallAnalyzer_Expecter) ID() *MockCallAnalyzer_ID_Call

ID is a helper method to define mock.On call

type MockCallAnalyzer_ID_Call 

type MockCallAnalyzer_ID_Call struct {
	*mock.Call
}

MockCallAnalyzer_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*MockCallAnalyzer_ID_Call) Return 

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

func (*MockCallAnalyzer_ID_Call) Run 

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

func (*MockCallAnalyzer_ID_Call) RunAndReturn 

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

type MockParameterAnalyzer 

type MockParameterAnalyzer struct {
	mock.Mock
}

MockParameterAnalyzer is an autogenerated mock type for the ParameterAnalyzer type

func NewMockParameterAnalyzer 

func NewMockParameterAnalyzer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockParameterAnalyzer

NewMockParameterAnalyzer creates a new instance of MockParameterAnalyzer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockParameterAnalyzer) Analyze 

func (_mock *MockParameterAnalyzer) Analyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter) (annotation.Annotations, error)

Analyze provides a mock function for the type MockParameterAnalyzer

func (*MockParameterAnalyzer) CanAnalyze 

func (_mock *MockParameterAnalyzer) CanAnalyze(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter) bool

CanAnalyze provides a mock function for the type MockParameterAnalyzer

func (*MockParameterAnalyzer) Dependencies 

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

Dependencies provides a mock function for the type MockParameterAnalyzer

func (*MockParameterAnalyzer) EXPECT 

func (_m *MockParameterAnalyzer) EXPECT() *MockParameterAnalyzer_Expecter

func (*MockParameterAnalyzer) ID 

func (_mock *MockParameterAnalyzer) ID() string

ID provides a mock function for the type MockParameterAnalyzer

type MockParameterAnalyzer_Analyze_Call 

type MockParameterAnalyzer_Analyze_Call struct {
	*mock.Call
}

MockParameterAnalyzer_Analyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Analyze'

func (*MockParameterAnalyzer_Analyze_Call) Return 

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

func (*MockParameterAnalyzer_Analyze_Call) Run 

func (_c *MockParameterAnalyzer_Analyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter)) *MockParameterAnalyzer_Analyze_Call

func (*MockParameterAnalyzer_Analyze_Call) RunAndReturn 

func (_c *MockParameterAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter) (annotation.Annotations, error)) *MockParameterAnalyzer_Analyze_Call

type MockParameterAnalyzer_CanAnalyze_Call 

type MockParameterAnalyzer_CanAnalyze_Call struct {
	*mock.Call
}

MockParameterAnalyzer_CanAnalyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanAnalyze'

func (*MockParameterAnalyzer_CanAnalyze_Call) Return 

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

func (*MockParameterAnalyzer_CanAnalyze_Call) Run 

func (_c *MockParameterAnalyzer_CanAnalyze_Call) Run(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter)) *MockParameterAnalyzer_CanAnalyze_Call

func (*MockParameterAnalyzer_CanAnalyze_Call) RunAndReturn 

func (_c *MockParameterAnalyzer_CanAnalyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext], param decoder.DecodedParameter) bool) *MockParameterAnalyzer_CanAnalyze_Call

type MockParameterAnalyzer_Dependencies_Call 

type MockParameterAnalyzer_Dependencies_Call struct {
	*mock.Call
}

MockParameterAnalyzer_Dependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dependencies'

func (*MockParameterAnalyzer_Dependencies_Call) Return 

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

func (*MockParameterAnalyzer_Dependencies_Call) Run 

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

func (*MockParameterAnalyzer_Dependencies_Call) RunAndReturn 

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

type MockParameterAnalyzer_Expecter 

type MockParameterAnalyzer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockParameterAnalyzer_Expecter) Analyze 

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

Analyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext]
  • param decoder.DecodedParameter

func (*MockParameterAnalyzer_Expecter) CanAnalyze 

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

CanAnalyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.AnalyzeRequest[analyzer.ParameterAnalyzerContext]
  • param decoder.DecodedParameter

func (*MockParameterAnalyzer_Expecter) Dependencies 

func (_e *MockParameterAnalyzer_Expecter) Dependencies() *MockParameterAnalyzer_Dependencies_Call

Dependencies is a helper method to define mock.On call

func (*MockParameterAnalyzer_Expecter) ID 

func (_e *MockParameterAnalyzer_Expecter) ID() *MockParameterAnalyzer_ID_Call

ID is a helper method to define mock.On call

type MockParameterAnalyzer_ID_Call 

type MockParameterAnalyzer_ID_Call struct {
	*mock.Call
}

MockParameterAnalyzer_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*MockParameterAnalyzer_ID_Call) Return 

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

func (*MockParameterAnalyzer_ID_Call) Run 

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

func (*MockParameterAnalyzer_ID_Call) RunAndReturn 

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

type MockProposalAnalyzer 

type MockProposalAnalyzer struct {
	mock.Mock
}

MockProposalAnalyzer is an autogenerated mock type for the ProposalAnalyzer type

func NewMockProposalAnalyzer 

func NewMockProposalAnalyzer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProposalAnalyzer

NewMockProposalAnalyzer creates a new instance of MockProposalAnalyzer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockProposalAnalyzer) Analyze 

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

Analyze provides a mock function for the type MockProposalAnalyzer

func (*MockProposalAnalyzer) CanAnalyze 

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

CanAnalyze provides a mock function for the type MockProposalAnalyzer

func (*MockProposalAnalyzer) Dependencies 

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

Dependencies provides a mock function for the type MockProposalAnalyzer

func (*MockProposalAnalyzer) EXPECT 

func (_m *MockProposalAnalyzer) EXPECT() *MockProposalAnalyzer_Expecter

func (*MockProposalAnalyzer) ID 

func (_mock *MockProposalAnalyzer) ID() string

ID provides a mock function for the type MockProposalAnalyzer

type MockProposalAnalyzer_Analyze_Call 

type MockProposalAnalyzer_Analyze_Call struct {
	*mock.Call
}

MockProposalAnalyzer_Analyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Analyze'

func (*MockProposalAnalyzer_Analyze_Call) Return 

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

func (*MockProposalAnalyzer_Analyze_Call) Run 

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

func (*MockProposalAnalyzer_Analyze_Call) RunAndReturn 

func (_c *MockProposalAnalyzer_Analyze_Call) RunAndReturn(run func(ctx context.Context, req analyzer.ProposalAnalyzeRequest, proposal decoder.DecodedTimelockProposal) (annotation.Annotations, error)) *MockProposalAnalyzer_Analyze_Call

type MockProposalAnalyzer_CanAnalyze_Call 

type MockProposalAnalyzer_CanAnalyze_Call struct {
	*mock.Call
}

MockProposalAnalyzer_CanAnalyze_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanAnalyze'

func (*MockProposalAnalyzer_CanAnalyze_Call) Return 

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

func (*MockProposalAnalyzer_CanAnalyze_Call) Run 

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

func (*MockProposalAnalyzer_CanAnalyze_Call) RunAndReturn 

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

type MockProposalAnalyzer_Dependencies_Call 

type MockProposalAnalyzer_Dependencies_Call struct {
	*mock.Call
}

MockProposalAnalyzer_Dependencies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dependencies'

func (*MockProposalAnalyzer_Dependencies_Call) Return 

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

func (*MockProposalAnalyzer_Dependencies_Call) Run 

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

func (*MockProposalAnalyzer_Dependencies_Call) RunAndReturn 

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

type MockProposalAnalyzer_Expecter 

type MockProposalAnalyzer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockProposalAnalyzer_Expecter) Analyze 

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

Analyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.ProposalAnalyzeRequest
  • proposal decoder.DecodedTimelockProposal

func (*MockProposalAnalyzer_Expecter) CanAnalyze 

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

CanAnalyze is a helper method to define mock.On call

  • ctx context.Context
  • req analyzer.ProposalAnalyzeRequest
  • proposal decoder.DecodedTimelockProposal

func (*MockProposalAnalyzer_Expecter) Dependencies 

func (_e *MockProposalAnalyzer_Expecter) Dependencies() *MockProposalAnalyzer_Dependencies_Call

Dependencies is a helper method to define mock.On call

func (*MockProposalAnalyzer_Expecter) ID 

func (_e *MockProposalAnalyzer_Expecter) ID() *MockProposalAnalyzer_ID_Call

ID is a helper method to define mock.On call

type MockProposalAnalyzer_ID_Call 

type MockProposalAnalyzer_ID_Call struct {
	*mock.Call
}

MockProposalAnalyzer_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*MockProposalAnalyzer_ID_Call) Return 

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

func (*MockProposalAnalyzer_ID_Call) Run 

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

func (*MockProposalAnalyzer_ID_Call) RunAndReturn 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.