jacob-mathison/query-orchestration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity
Files
007c32a58deb86d113d64bd0a7cd8b326edd22e1
query-orchestration/mocks/textract/mock_TextractClient.go
T

779 lines
31 KiB
Go
Raw Normal View History

Merged in feature/textextraction (pull request #110)
2025-04-02 18:50:03 +00:00
// Code generated by mockery v2.52.3. DO NOT EDIT.
package textractmock
import (
context "context"
mock "github.com/stretchr/testify/mock"
textract "github.com/aws/aws-sdk-go-v2/service/textract"
)
// MockTextractClient is an autogenerated mock type for the TextractClient type
type MockTextractClient struct {
mock.Mock
}
type MockTextractClient_Expecter struct {
mock *mock.Mock
}
func (_m *MockTextractClient) EXPECT() *MockTextractClient_Expecter {
return &MockTextractClient_Expecter{mock: &_m.Mock}
}
// AnalyzeDocument provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeDocument(ctx context.Context, params *textract.AnalyzeDocumentInput, opts ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for AnalyzeDocument")
}
var r0 *textract.AnalyzeDocumentOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) *textract.AnalyzeDocumentOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.AnalyzeDocumentOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_AnalyzeDocument_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeDocument'
type MockTextractClient_AnalyzeDocument_Call struct {
*mock.Call
}
// AnalyzeDocument is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.AnalyzeDocumentInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeDocument(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeDocument_Call {
return &MockTextractClient_AnalyzeDocument_Call{Call: _e.mock.On("AnalyzeDocument",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_AnalyzeDocument_Call) Run(run func(ctx context.Context, params *textract.AnalyzeDocumentInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeDocument_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.AnalyzeDocumentInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_AnalyzeDocument_Call) Return(_a0 *textract.AnalyzeDocumentOutput, _a1 error) *MockTextractClient_AnalyzeDocument_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_AnalyzeDocument_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeDocumentInput, ...func(*textract.Options)) (*textract.AnalyzeDocumentOutput, error)) *MockTextractClient_AnalyzeDocument_Call {
_c.Call.Return(run)
return _c
}
// AnalyzeExpense provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeExpense(ctx context.Context, params *textract.AnalyzeExpenseInput, opts ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for AnalyzeExpense")
}
var r0 *textract.AnalyzeExpenseOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) *textract.AnalyzeExpenseOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.AnalyzeExpenseOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_AnalyzeExpense_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeExpense'
type MockTextractClient_AnalyzeExpense_Call struct {
*mock.Call
}
// AnalyzeExpense is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.AnalyzeExpenseInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeExpense(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeExpense_Call {
return &MockTextractClient_AnalyzeExpense_Call{Call: _e.mock.On("AnalyzeExpense",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_AnalyzeExpense_Call) Run(run func(ctx context.Context, params *textract.AnalyzeExpenseInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeExpense_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.AnalyzeExpenseInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_AnalyzeExpense_Call) Return(_a0 *textract.AnalyzeExpenseOutput, _a1 error) *MockTextractClient_AnalyzeExpense_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_AnalyzeExpense_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeExpenseInput, ...func(*textract.Options)) (*textract.AnalyzeExpenseOutput, error)) *MockTextractClient_AnalyzeExpense_Call {
_c.Call.Return(run)
return _c
}
// AnalyzeID provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) AnalyzeID(ctx context.Context, params *textract.AnalyzeIDInput, opts ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for AnalyzeID")
}
var r0 *textract.AnalyzeIDOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) *textract.AnalyzeIDOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.AnalyzeIDOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_AnalyzeID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AnalyzeID'
type MockTextractClient_AnalyzeID_Call struct {
*mock.Call
}
// AnalyzeID is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.AnalyzeIDInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) AnalyzeID(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_AnalyzeID_Call {
return &MockTextractClient_AnalyzeID_Call{Call: _e.mock.On("AnalyzeID",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_AnalyzeID_Call) Run(run func(ctx context.Context, params *textract.AnalyzeIDInput, opts ...func(*textract.Options))) *MockTextractClient_AnalyzeID_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.AnalyzeIDInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_AnalyzeID_Call) Return(_a0 *textract.AnalyzeIDOutput, _a1 error) *MockTextractClient_AnalyzeID_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_AnalyzeID_Call) RunAndReturn(run func(context.Context, *textract.AnalyzeIDInput, ...func(*textract.Options)) (*textract.AnalyzeIDOutput, error)) *MockTextractClient_AnalyzeID_Call {
_c.Call.Return(run)
return _c
}
// DetectDocumentText provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) DetectDocumentText(ctx context.Context, params *textract.DetectDocumentTextInput, opts ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for DetectDocumentText")
}
var r0 *textract.DetectDocumentTextOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) *textract.DetectDocumentTextOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.DetectDocumentTextOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_DetectDocumentText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectDocumentText'
type MockTextractClient_DetectDocumentText_Call struct {
*mock.Call
}
// DetectDocumentText is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.DetectDocumentTextInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) DetectDocumentText(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_DetectDocumentText_Call {
return &MockTextractClient_DetectDocumentText_Call{Call: _e.mock.On("DetectDocumentText",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_DetectDocumentText_Call) Run(run func(ctx context.Context, params *textract.DetectDocumentTextInput, opts ...func(*textract.Options))) *MockTextractClient_DetectDocumentText_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.DetectDocumentTextInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_DetectDocumentText_Call) Return(_a0 *textract.DetectDocumentTextOutput, _a1 error) *MockTextractClient_DetectDocumentText_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_DetectDocumentText_Call) RunAndReturn(run func(context.Context, *textract.DetectDocumentTextInput, ...func(*textract.Options)) (*textract.DetectDocumentTextOutput, error)) *MockTextractClient_DetectDocumentText_Call {
_c.Call.Return(run)
return _c
}
// GetDocumentAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetDocumentAnalysis(ctx context.Context, params *textract.GetDocumentAnalysisInput, opts ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetDocumentAnalysis")
}
var r0 *textract.GetDocumentAnalysisOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) *textract.GetDocumentAnalysisOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.GetDocumentAnalysisOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_GetDocumentAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDocumentAnalysis'
type MockTextractClient_GetDocumentAnalysis_Call struct {
*mock.Call
}
// GetDocumentAnalysis is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.GetDocumentAnalysisInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetDocumentAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetDocumentAnalysis_Call {
return &MockTextractClient_GetDocumentAnalysis_Call{Call: _e.mock.On("GetDocumentAnalysis",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_GetDocumentAnalysis_Call) Run(run func(ctx context.Context, params *textract.GetDocumentAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_GetDocumentAnalysis_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.GetDocumentAnalysisInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_GetDocumentAnalysis_Call) Return(_a0 *textract.GetDocumentAnalysisOutput, _a1 error) *MockTextractClient_GetDocumentAnalysis_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_GetDocumentAnalysis_Call) RunAndReturn(run func(context.Context, *textract.GetDocumentAnalysisInput, ...func(*textract.Options)) (*textract.GetDocumentAnalysisOutput, error)) *MockTextractClient_GetDocumentAnalysis_Call {
_c.Call.Return(run)
return _c
}
// GetDocumentTextDetection provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetDocumentTextDetection(ctx context.Context, params *textract.GetDocumentTextDetectionInput, opts ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetDocumentTextDetection")
}
var r0 *textract.GetDocumentTextDetectionOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) *textract.GetDocumentTextDetectionOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.GetDocumentTextDetectionOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_GetDocumentTextDetection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDocumentTextDetection'
type MockTextractClient_GetDocumentTextDetection_Call struct {
*mock.Call
}
// GetDocumentTextDetection is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.GetDocumentTextDetectionInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetDocumentTextDetection(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetDocumentTextDetection_Call {
return &MockTextractClient_GetDocumentTextDetection_Call{Call: _e.mock.On("GetDocumentTextDetection",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_GetDocumentTextDetection_Call) Run(run func(ctx context.Context, params *textract.GetDocumentTextDetectionInput, opts ...func(*textract.Options))) *MockTextractClient_GetDocumentTextDetection_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.GetDocumentTextDetectionInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_GetDocumentTextDetection_Call) Return(_a0 *textract.GetDocumentTextDetectionOutput, _a1 error) *MockTextractClient_GetDocumentTextDetection_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_GetDocumentTextDetection_Call) RunAndReturn(run func(context.Context, *textract.GetDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.GetDocumentTextDetectionOutput, error)) *MockTextractClient_GetDocumentTextDetection_Call {
_c.Call.Return(run)
return _c
}
// GetExpenseAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) GetExpenseAnalysis(ctx context.Context, params *textract.GetExpenseAnalysisInput, opts ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetExpenseAnalysis")
}
var r0 *textract.GetExpenseAnalysisOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) *textract.GetExpenseAnalysisOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.GetExpenseAnalysisOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_GetExpenseAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExpenseAnalysis'
type MockTextractClient_GetExpenseAnalysis_Call struct {
*mock.Call
}
// GetExpenseAnalysis is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.GetExpenseAnalysisInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) GetExpenseAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_GetExpenseAnalysis_Call {
return &MockTextractClient_GetExpenseAnalysis_Call{Call: _e.mock.On("GetExpenseAnalysis",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_GetExpenseAnalysis_Call) Run(run func(ctx context.Context, params *textract.GetExpenseAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_GetExpenseAnalysis_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.GetExpenseAnalysisInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_GetExpenseAnalysis_Call) Return(_a0 *textract.GetExpenseAnalysisOutput, _a1 error) *MockTextractClient_GetExpenseAnalysis_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_GetExpenseAnalysis_Call) RunAndReturn(run func(context.Context, *textract.GetExpenseAnalysisInput, ...func(*textract.Options)) (*textract.GetExpenseAnalysisOutput, error)) *MockTextractClient_GetExpenseAnalysis_Call {
_c.Call.Return(run)
return _c
}
// StartDocumentAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartDocumentAnalysis(ctx context.Context, params *textract.StartDocumentAnalysisInput, opts ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for StartDocumentAnalysis")
}
var r0 *textract.StartDocumentAnalysisOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) *textract.StartDocumentAnalysisOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.StartDocumentAnalysisOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_StartDocumentAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartDocumentAnalysis'
type MockTextractClient_StartDocumentAnalysis_Call struct {
*mock.Call
}
// StartDocumentAnalysis is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.StartDocumentAnalysisInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartDocumentAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartDocumentAnalysis_Call {
return &MockTextractClient_StartDocumentAnalysis_Call{Call: _e.mock.On("StartDocumentAnalysis",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_StartDocumentAnalysis_Call) Run(run func(ctx context.Context, params *textract.StartDocumentAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_StartDocumentAnalysis_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.StartDocumentAnalysisInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_StartDocumentAnalysis_Call) Return(_a0 *textract.StartDocumentAnalysisOutput, _a1 error) *MockTextractClient_StartDocumentAnalysis_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_StartDocumentAnalysis_Call) RunAndReturn(run func(context.Context, *textract.StartDocumentAnalysisInput, ...func(*textract.Options)) (*textract.StartDocumentAnalysisOutput, error)) *MockTextractClient_StartDocumentAnalysis_Call {
_c.Call.Return(run)
return _c
}
// StartDocumentTextDetection provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartDocumentTextDetection(ctx context.Context, params *textract.StartDocumentTextDetectionInput, opts ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for StartDocumentTextDetection")
}
var r0 *textract.StartDocumentTextDetectionOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) *textract.StartDocumentTextDetectionOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.StartDocumentTextDetectionOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_StartDocumentTextDetection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartDocumentTextDetection'
type MockTextractClient_StartDocumentTextDetection_Call struct {
*mock.Call
}
// StartDocumentTextDetection is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.StartDocumentTextDetectionInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartDocumentTextDetection(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartDocumentTextDetection_Call {
return &MockTextractClient_StartDocumentTextDetection_Call{Call: _e.mock.On("StartDocumentTextDetection",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_StartDocumentTextDetection_Call) Run(run func(ctx context.Context, params *textract.StartDocumentTextDetectionInput, opts ...func(*textract.Options))) *MockTextractClient_StartDocumentTextDetection_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.StartDocumentTextDetectionInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_StartDocumentTextDetection_Call) Return(_a0 *textract.StartDocumentTextDetectionOutput, _a1 error) *MockTextractClient_StartDocumentTextDetection_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_StartDocumentTextDetection_Call) RunAndReturn(run func(context.Context, *textract.StartDocumentTextDetectionInput, ...func(*textract.Options)) (*textract.StartDocumentTextDetectionOutput, error)) *MockTextractClient_StartDocumentTextDetection_Call {
_c.Call.Return(run)
return _c
}
// StartExpenseAnalysis provides a mock function with given fields: ctx, params, opts
func (_m *MockTextractClient) StartExpenseAnalysis(ctx context.Context, params *textract.StartExpenseAnalysisInput, opts ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error) {
_va := make([]interface{}, len(opts))
for _i := range opts {
_va[_i] = opts[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for StartExpenseAnalysis")
}
var r0 *textract.StartExpenseAnalysisOutput
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error)); ok {
return rf(ctx, params, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) *textract.StartExpenseAnalysisOutput); ok {
r0 = rf(ctx, params, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*textract.StartExpenseAnalysisOutput)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) error); ok {
r1 = rf(ctx, params, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockTextractClient_StartExpenseAnalysis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartExpenseAnalysis'
type MockTextractClient_StartExpenseAnalysis_Call struct {
*mock.Call
}
// StartExpenseAnalysis is a helper method to define mock.On call
// - ctx context.Context
// - params *textract.StartExpenseAnalysisInput
// - opts ...func(*textract.Options)
func (_e *MockTextractClient_Expecter) StartExpenseAnalysis(ctx interface{}, params interface{}, opts ...interface{}) *MockTextractClient_StartExpenseAnalysis_Call {
return &MockTextractClient_StartExpenseAnalysis_Call{Call: _e.mock.On("StartExpenseAnalysis",
append([]interface{}{ctx, params}, opts...)...)}
}
func (_c *MockTextractClient_StartExpenseAnalysis_Call) Run(run func(ctx context.Context, params *textract.StartExpenseAnalysisInput, opts ...func(*textract.Options))) *MockTextractClient_StartExpenseAnalysis_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]func(*textract.Options), len(args)-2)
for i, a := range args[2:] {
if a != nil {
variadicArgs[i] = a.(func(*textract.Options))
}
}
run(args[0].(context.Context), args[1].(*textract.StartExpenseAnalysisInput), variadicArgs...)
})
return _c
}
func (_c *MockTextractClient_StartExpenseAnalysis_Call) Return(_a0 *textract.StartExpenseAnalysisOutput, _a1 error) *MockTextractClient_StartExpenseAnalysis_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockTextractClient_StartExpenseAnalysis_Call) RunAndReturn(run func(context.Context, *textract.StartExpenseAnalysisInput, ...func(*textract.Options)) (*textract.StartExpenseAnalysisOutput, error)) *MockTextractClient_StartExpenseAnalysis_Call {
_c.Call.Return(run)
return _c
}
// NewMockTextractClient creates a new instance of MockTextractClient. 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 NewMockTextractClient(t interface {
mock.TestingT
Cleanup(func())
}) *MockTextractClient {
mock := &MockTextractClient{}
mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) })
return mock
}
Reference in New Issue Copy Permalink