all/mocks: update

4 files changed, 234 insertions, 0 deletions

diff --git a/pkg/coveragedb/mocks/ReadOnlyTransaction.go b/pkg/coveragedb/mocks/ReadOnlyTransaction.go
index 82238027e..1a4eecfb8 100644
--- a/pkg/coveragedb/mocks/ReadOnlyTransaction.go
+++ b/pkg/coveragedb/mocks/ReadOnlyTransaction.go
@@ -16,6 +16,14 @@ type ReadOnlyTransaction struct {
 	mock.Mock
 }
 
+type ReadOnlyTransaction_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ReadOnlyTransaction) EXPECT() *ReadOnlyTransaction_Expecter {
+	return &ReadOnlyTransaction_Expecter{mock: &_m.Mock}
+}
+
 // Query provides a mock function with given fields: ctx, statement
 func (_m *ReadOnlyTransaction) Query(ctx context.Context, statement spanner.Statement) spannerclient.RowIterator {
 	ret := _m.Called(ctx, statement)
@@ -36,6 +44,35 @@ func (_m *ReadOnlyTransaction) Query(ctx context.Context, statement spanner.Stat
 	return r0
 }
 
+// ReadOnlyTransaction_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query'
+type ReadOnlyTransaction_Query_Call struct {
+	*mock.Call
+}
+
+// Query is a helper method to define mock.On call
+//   - ctx context.Context
+//   - statement spanner.Statement
+func (_e *ReadOnlyTransaction_Expecter) Query(ctx interface{}, statement interface{}) *ReadOnlyTransaction_Query_Call {
+	return &ReadOnlyTransaction_Query_Call{Call: _e.mock.On("Query", ctx, statement)}
+}
+
+func (_c *ReadOnlyTransaction_Query_Call) Run(run func(ctx context.Context, statement spanner.Statement)) *ReadOnlyTransaction_Query_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(spanner.Statement))
+	})
+	return _c
+}
+
+func (_c *ReadOnlyTransaction_Query_Call) Return(_a0 spannerclient.RowIterator) *ReadOnlyTransaction_Query_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ReadOnlyTransaction_Query_Call) RunAndReturn(run func(context.Context, spanner.Statement) spannerclient.RowIterator) *ReadOnlyTransaction_Query_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewReadOnlyTransaction creates a new instance of ReadOnlyTransaction. 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 NewReadOnlyTransaction(t interface {
diff --git a/pkg/coveragedb/mocks/Row.go b/pkg/coveragedb/mocks/Row.go
index 1a34552aa..549e7d214 100644
--- a/pkg/coveragedb/mocks/Row.go
+++ b/pkg/coveragedb/mocks/Row.go
@@ -9,6 +9,14 @@ type Row struct {
 	mock.Mock
 }
 
+type Row_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Row) EXPECT() *Row_Expecter {
+	return &Row_Expecter{mock: &_m.Mock}
+}
+
 // ToStruct provides a mock function with given fields: p
 func (_m *Row) ToStruct(p interface{}) error {
 	ret := _m.Called(p)
@@ -27,6 +35,34 @@ func (_m *Row) ToStruct(p interface{}) error {
 	return r0
 }
 
+// Row_ToStruct_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToStruct'
+type Row_ToStruct_Call struct {
+	*mock.Call
+}
+
+// ToStruct is a helper method to define mock.On call
+//   - p interface{}
+func (_e *Row_Expecter) ToStruct(p interface{}) *Row_ToStruct_Call {
+	return &Row_ToStruct_Call{Call: _e.mock.On("ToStruct", p)}
+}
+
+func (_c *Row_ToStruct_Call) Run(run func(p interface{})) *Row_ToStruct_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(interface{}))
+	})
+	return _c
+}
+
+func (_c *Row_ToStruct_Call) Return(_a0 error) *Row_ToStruct_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Row_ToStruct_Call) RunAndReturn(run func(interface{}) error) *Row_ToStruct_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewRow creates a new instance of Row. 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 NewRow(t interface {
diff --git a/pkg/coveragedb/mocks/RowIterator.go b/pkg/coveragedb/mocks/RowIterator.go
index 83e442b01..7bea62355 100644
--- a/pkg/coveragedb/mocks/RowIterator.go
+++ b/pkg/coveragedb/mocks/RowIterator.go
@@ -12,6 +12,14 @@ type RowIterator struct {
 	mock.Mock
 }
 
+type RowIterator_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *RowIterator) EXPECT() *RowIterator_Expecter {
+	return &RowIterator_Expecter{mock: &_m.Mock}
+}
+
 // Next provides a mock function with no fields
 func (_m *RowIterator) Next() (spannerclient.Row, error) {
 	ret := _m.Called()
@@ -42,11 +50,65 @@ func (_m *RowIterator) Next() (spannerclient.Row, error) {
 	return r0, r1
 }
 
+// RowIterator_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next'
+type RowIterator_Next_Call struct {
+	*mock.Call
+}
+
+// Next is a helper method to define mock.On call
+func (_e *RowIterator_Expecter) Next() *RowIterator_Next_Call {
+	return &RowIterator_Next_Call{Call: _e.mock.On("Next")}
+}
+
+func (_c *RowIterator_Next_Call) Run(run func()) *RowIterator_Next_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *RowIterator_Next_Call) Return(_a0 spannerclient.Row, _a1 error) *RowIterator_Next_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *RowIterator_Next_Call) RunAndReturn(run func() (spannerclient.Row, error)) *RowIterator_Next_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Stop provides a mock function with no fields
 func (_m *RowIterator) Stop() {
 	_m.Called()
 }
 
+// RowIterator_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
+type RowIterator_Stop_Call struct {
+	*mock.Call
+}
+
+// Stop is a helper method to define mock.On call
+func (_e *RowIterator_Expecter) Stop() *RowIterator_Stop_Call {
+	return &RowIterator_Stop_Call{Call: _e.mock.On("Stop")}
+}
+
+func (_c *RowIterator_Stop_Call) Run(run func()) *RowIterator_Stop_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *RowIterator_Stop_Call) Return() *RowIterator_Stop_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *RowIterator_Stop_Call) RunAndReturn(run func()) *RowIterator_Stop_Call {
+	_c.Run(run)
+	return _c
+}
+
 // NewRowIterator creates a new instance of RowIterator. 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 NewRowIterator(t interface {
diff --git a/pkg/coveragedb/mocks/SpannerClient.go b/pkg/coveragedb/mocks/SpannerClient.go
index 516fadca7..0919b57cc 100644
--- a/pkg/coveragedb/mocks/SpannerClient.go
+++ b/pkg/coveragedb/mocks/SpannerClient.go
@@ -18,6 +18,14 @@ type SpannerClient struct {
 	mock.Mock
 }
 
+type SpannerClient_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SpannerClient) EXPECT() *SpannerClient_Expecter {
+	return &SpannerClient_Expecter{mock: &_m.Mock}
+}
+
 // Apply provides a mock function with given fields: ctx, ms, opts
 func (_m *SpannerClient) Apply(ctx context.Context, ms []*spanner.Mutation, opts ...spanner.ApplyOption) (time.Time, error) {
 	_va := make([]interface{}, len(opts))
@@ -53,11 +61,75 @@ func (_m *SpannerClient) Apply(ctx context.Context, ms []*spanner.Mutation, opts
 	return r0, r1
 }
 
+// SpannerClient_Apply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Apply'
+type SpannerClient_Apply_Call struct {
+	*mock.Call
+}
+
+// Apply is a helper method to define mock.On call
+//   - ctx context.Context
+//   - ms []*spanner.Mutation
+//   - opts ...spanner.ApplyOption
+func (_e *SpannerClient_Expecter) Apply(ctx interface{}, ms interface{}, opts ...interface{}) *SpannerClient_Apply_Call {
+	return &SpannerClient_Apply_Call{Call: _e.mock.On("Apply",
+		append([]interface{}{ctx, ms}, opts...)...)}
+}
+
+func (_c *SpannerClient_Apply_Call) Run(run func(ctx context.Context, ms []*spanner.Mutation, opts ...spanner.ApplyOption)) *SpannerClient_Apply_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]spanner.ApplyOption, len(args)-2)
+		for i, a := range args[2:] {
+			if a != nil {
+				variadicArgs[i] = a.(spanner.ApplyOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].([]*spanner.Mutation), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *SpannerClient_Apply_Call) Return(commitTimestamp time.Time, err error) *SpannerClient_Apply_Call {
+	_c.Call.Return(commitTimestamp, err)
+	return _c
+}
+
+func (_c *SpannerClient_Apply_Call) RunAndReturn(run func(context.Context, []*spanner.Mutation, ...spanner.ApplyOption) (time.Time, error)) *SpannerClient_Apply_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Close provides a mock function with no fields
 func (_m *SpannerClient) Close() {
 	_m.Called()
 }
 
+// SpannerClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type SpannerClient_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *SpannerClient_Expecter) Close() *SpannerClient_Close_Call {
+	return &SpannerClient_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *SpannerClient_Close_Call) Run(run func()) *SpannerClient_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpannerClient_Close_Call) Return() *SpannerClient_Close_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *SpannerClient_Close_Call) RunAndReturn(run func()) *SpannerClient_Close_Call {
+	_c.Run(run)
+	return _c
+}
+
 // Single provides a mock function with no fields
 func (_m *SpannerClient) Single() spannerclient.ReadOnlyTransaction {
 	ret := _m.Called()
@@ -78,6 +150,33 @@ func (_m *SpannerClient) Single() spannerclient.ReadOnlyTransaction {
 	return r0
 }
 
+// SpannerClient_Single_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Single'
+type SpannerClient_Single_Call struct {
+	*mock.Call
+}
+
+// Single is a helper method to define mock.On call
+func (_e *SpannerClient_Expecter) Single() *SpannerClient_Single_Call {
+	return &SpannerClient_Single_Call{Call: _e.mock.On("Single")}
+}
+
+func (_c *SpannerClient_Single_Call) Run(run func()) *SpannerClient_Single_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SpannerClient_Single_Call) Return(_a0 spannerclient.ReadOnlyTransaction) *SpannerClient_Single_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *SpannerClient_Single_Call) RunAndReturn(run func() spannerclient.ReadOnlyTransaction) *SpannerClient_Single_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewSpannerClient creates a new instance of SpannerClient. 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 NewSpannerClient(t interface {