all/mocks: update

9 files changed, 1043 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 {
diff --git a/pkg/covermerger/mocks/FileVersProvider.go b/pkg/covermerger/mocks/FileVersProvider.go
index 0ff02cc07..4e07532bd 100644
--- a/pkg/covermerger/mocks/FileVersProvider.go
+++ b/pkg/covermerger/mocks/FileVersProvider.go
@@ -12,6 +12,14 @@ type FileVersProvider struct {
 	mock.Mock
 }
 
+type FileVersProvider_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *FileVersProvider) EXPECT() *FileVersProvider_Expecter {
+	return &FileVersProvider_Expecter{mock: &_m.Mock}
+}
+
 // GetFileVersions provides a mock function with given fields: targetFilePath, repoCommits
 func (_m *FileVersProvider) GetFileVersions(targetFilePath string, repoCommits ...covermerger.RepoCommit) (covermerger.FileVersions, error) {
 	_va := make([]interface{}, len(repoCommits))
@@ -49,6 +57,42 @@ func (_m *FileVersProvider) GetFileVersions(targetFilePath string, repoCommits .
 	return r0, r1
 }
 
+// FileVersProvider_GetFileVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFileVersions'
+type FileVersProvider_GetFileVersions_Call struct {
+	*mock.Call
+}
+
+// GetFileVersions is a helper method to define mock.On call
+//   - targetFilePath string
+//   - repoCommits ...covermerger.RepoCommit
+func (_e *FileVersProvider_Expecter) GetFileVersions(targetFilePath interface{}, repoCommits ...interface{}) *FileVersProvider_GetFileVersions_Call {
+	return &FileVersProvider_GetFileVersions_Call{Call: _e.mock.On("GetFileVersions",
+		append([]interface{}{targetFilePath}, repoCommits...)...)}
+}
+
+func (_c *FileVersProvider_GetFileVersions_Call) Run(run func(targetFilePath string, repoCommits ...covermerger.RepoCommit)) *FileVersProvider_GetFileVersions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]covermerger.RepoCommit, len(args)-1)
+		for i, a := range args[1:] {
+			if a != nil {
+				variadicArgs[i] = a.(covermerger.RepoCommit)
+			}
+		}
+		run(args[0].(string), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *FileVersProvider_GetFileVersions_Call) Return(_a0 covermerger.FileVersions, _a1 error) *FileVersProvider_GetFileVersions_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *FileVersProvider_GetFileVersions_Call) RunAndReturn(run func(string, ...covermerger.RepoCommit) (covermerger.FileVersions, error)) *FileVersProvider_GetFileVersions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewFileVersProvider creates a new instance of FileVersProvider. 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 NewFileVersProvider(t interface {
diff --git a/pkg/gcs/mocks/Client.go b/pkg/gcs/mocks/Client.go
index a6c1351ad..fff5dddd7 100644
--- a/pkg/gcs/mocks/Client.go
+++ b/pkg/gcs/mocks/Client.go
@@ -15,6 +15,14 @@ type Client struct {
 	mock.Mock
 }
 
+type Client_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Client) EXPECT() *Client_Expecter {
+	return &Client_Expecter{mock: &_m.Mock}
+}
+
 // Close provides a mock function with no fields
 func (_m *Client) Close() error {
 	ret := _m.Called()
@@ -33,6 +41,33 @@ func (_m *Client) Close() error {
 	return r0
 }
 
+// Client_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type Client_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+func (_e *Client_Expecter) Close() *Client_Close_Call {
+	return &Client_Close_Call{Call: _e.mock.On("Close")}
+}
+
+func (_c *Client_Close_Call) Run(run func()) *Client_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Client_Close_Call) Return(_a0 error) *Client_Close_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Client_Close_Call) RunAndReturn(run func() error) *Client_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // DeleteFile provides a mock function with given fields: path
 func (_m *Client) DeleteFile(path string) error {
 	ret := _m.Called(path)
@@ -51,6 +86,34 @@ func (_m *Client) DeleteFile(path string) error {
 	return r0
 }
 
+// Client_DeleteFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFile'
+type Client_DeleteFile_Call struct {
+	*mock.Call
+}
+
+// DeleteFile is a helper method to define mock.On call
+//   - path string
+func (_e *Client_Expecter) DeleteFile(path interface{}) *Client_DeleteFile_Call {
+	return &Client_DeleteFile_Call{Call: _e.mock.On("DeleteFile", path)}
+}
+
+func (_c *Client_DeleteFile_Call) Run(run func(path string)) *Client_DeleteFile_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_DeleteFile_Call) Return(_a0 error) *Client_DeleteFile_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Client_DeleteFile_Call) RunAndReturn(run func(string) error) *Client_DeleteFile_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // FileExists provides a mock function with given fields: path
 func (_m *Client) FileExists(path string) (bool, error) {
 	ret := _m.Called(path)
@@ -79,6 +142,34 @@ func (_m *Client) FileExists(path string) (bool, error) {
 	return r0, r1
 }
 
+// Client_FileExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FileExists'
+type Client_FileExists_Call struct {
+	*mock.Call
+}
+
+// FileExists is a helper method to define mock.On call
+//   - path string
+func (_e *Client_Expecter) FileExists(path interface{}) *Client_FileExists_Call {
+	return &Client_FileExists_Call{Call: _e.mock.On("FileExists", path)}
+}
+
+func (_c *Client_FileExists_Call) Run(run func(path string)) *Client_FileExists_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_FileExists_Call) Return(_a0 bool, _a1 error) *Client_FileExists_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_FileExists_Call) RunAndReturn(run func(string) (bool, error)) *Client_FileExists_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // FileWriter provides a mock function with given fields: path, contentType, contentEncoding
 func (_m *Client) FileWriter(path string, contentType string, contentEncoding string) (io.WriteCloser, error) {
 	ret := _m.Called(path, contentType, contentEncoding)
@@ -109,6 +200,36 @@ func (_m *Client) FileWriter(path string, contentType string, contentEncoding st
 	return r0, r1
 }
 
+// Client_FileWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FileWriter'
+type Client_FileWriter_Call struct {
+	*mock.Call
+}
+
+// FileWriter is a helper method to define mock.On call
+//   - path string
+//   - contentType string
+//   - contentEncoding string
+func (_e *Client_Expecter) FileWriter(path interface{}, contentType interface{}, contentEncoding interface{}) *Client_FileWriter_Call {
+	return &Client_FileWriter_Call{Call: _e.mock.On("FileWriter", path, contentType, contentEncoding)}
+}
+
+func (_c *Client_FileWriter_Call) Run(run func(path string, contentType string, contentEncoding string)) *Client_FileWriter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string), args[1].(string), args[2].(string))
+	})
+	return _c
+}
+
+func (_c *Client_FileWriter_Call) Return(_a0 io.WriteCloser, _a1 error) *Client_FileWriter_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_FileWriter_Call) RunAndReturn(run func(string, string, string) (io.WriteCloser, error)) *Client_FileWriter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // ListObjects provides a mock function with given fields: path
 func (_m *Client) ListObjects(path string) ([]*gcs.Object, error) {
 	ret := _m.Called(path)
@@ -139,6 +260,34 @@ func (_m *Client) ListObjects(path string) ([]*gcs.Object, error) {
 	return r0, r1
 }
 
+// Client_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects'
+type Client_ListObjects_Call struct {
+	*mock.Call
+}
+
+// ListObjects is a helper method to define mock.On call
+//   - path string
+func (_e *Client_Expecter) ListObjects(path interface{}) *Client_ListObjects_Call {
+	return &Client_ListObjects_Call{Call: _e.mock.On("ListObjects", path)}
+}
+
+func (_c *Client_ListObjects_Call) Run(run func(path string)) *Client_ListObjects_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_ListObjects_Call) Return(_a0 []*gcs.Object, _a1 error) *Client_ListObjects_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_ListObjects_Call) RunAndReturn(run func(string) ([]*gcs.Object, error)) *Client_ListObjects_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Publish provides a mock function with given fields: path
 func (_m *Client) Publish(path string) error {
 	ret := _m.Called(path)
@@ -157,6 +306,34 @@ func (_m *Client) Publish(path string) error {
 	return r0
 }
 
+// Client_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish'
+type Client_Publish_Call struct {
+	*mock.Call
+}
+
+// Publish is a helper method to define mock.On call
+//   - path string
+func (_e *Client_Expecter) Publish(path interface{}) *Client_Publish_Call {
+	return &Client_Publish_Call{Call: _e.mock.On("Publish", path)}
+}
+
+func (_c *Client_Publish_Call) Run(run func(path string)) *Client_Publish_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_Publish_Call) Return(_a0 error) *Client_Publish_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Client_Publish_Call) RunAndReturn(run func(string) error) *Client_Publish_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Read provides a mock function with given fields: path
 func (_m *Client) Read(path string) (*gcs.File, error) {
 	ret := _m.Called(path)
@@ -187,6 +364,34 @@ func (_m *Client) Read(path string) (*gcs.File, error) {
 	return r0, r1
 }
 
+// Client_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
+type Client_Read_Call struct {
+	*mock.Call
+}
+
+// Read is a helper method to define mock.On call
+//   - path string
+func (_e *Client_Expecter) Read(path interface{}) *Client_Read_Call {
+	return &Client_Read_Call{Call: _e.mock.On("Read", path)}
+}
+
+func (_c *Client_Read_Call) Run(run func(path string)) *Client_Read_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *Client_Read_Call) Return(_a0 *gcs.File, _a1 error) *Client_Read_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Client_Read_Call) RunAndReturn(run func(string) (*gcs.File, error)) *Client_Read_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewClient creates a new instance of Client. 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 NewClient(t interface {
diff --git a/pkg/rpcserver/mocks/Manager.go b/pkg/rpcserver/mocks/Manager.go
index 55980151d..717205338 100644
--- a/pkg/rpcserver/mocks/Manager.go
+++ b/pkg/rpcserver/mocks/Manager.go
@@ -20,6 +20,14 @@ type Manager struct {
 	mock.Mock
 }
 
+type Manager_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *Manager) EXPECT() *Manager_Expecter {
+	return &Manager_Expecter{mock: &_m.Mock}
+}
+
 // BugFrames provides a mock function with no fields
 func (_m *Manager) BugFrames() ([]string, []string) {
 	ret := _m.Called()
@@ -52,6 +60,33 @@ func (_m *Manager) BugFrames() ([]string, []string) {
 	return r0, r1
 }
 
+// Manager_BugFrames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BugFrames'
+type Manager_BugFrames_Call struct {
+	*mock.Call
+}
+
+// BugFrames is a helper method to define mock.On call
+func (_e *Manager_Expecter) BugFrames() *Manager_BugFrames_Call {
+	return &Manager_BugFrames_Call{Call: _e.mock.On("BugFrames")}
+}
+
+func (_c *Manager_BugFrames_Call) Run(run func()) *Manager_BugFrames_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Manager_BugFrames_Call) Return(leaks []string, races []string) *Manager_BugFrames_Call {
+	_c.Call.Return(leaks, races)
+	return _c
+}
+
+func (_c *Manager_BugFrames_Call) RunAndReturn(run func() ([]string, []string)) *Manager_BugFrames_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // CoverageFilter provides a mock function with given fields: modules
 func (_m *Manager) CoverageFilter(modules []*vminfo.KernelModule) ([]uint64, error) {
 	ret := _m.Called(modules)
@@ -82,6 +117,34 @@ func (_m *Manager) CoverageFilter(modules []*vminfo.KernelModule) ([]uint64, err
 	return r0, r1
 }
 
+// Manager_CoverageFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoverageFilter'
+type Manager_CoverageFilter_Call struct {
+	*mock.Call
+}
+
+// CoverageFilter is a helper method to define mock.On call
+//   - modules []*vminfo.KernelModule
+func (_e *Manager_Expecter) CoverageFilter(modules interface{}) *Manager_CoverageFilter_Call {
+	return &Manager_CoverageFilter_Call{Call: _e.mock.On("CoverageFilter", modules)}
+}
+
+func (_c *Manager_CoverageFilter_Call) Run(run func(modules []*vminfo.KernelModule)) *Manager_CoverageFilter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].([]*vminfo.KernelModule))
+	})
+	return _c
+}
+
+func (_c *Manager_CoverageFilter_Call) Return(_a0 []uint64, _a1 error) *Manager_CoverageFilter_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Manager_CoverageFilter_Call) RunAndReturn(run func([]*vminfo.KernelModule) ([]uint64, error)) *Manager_CoverageFilter_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // MachineChecked provides a mock function with given fields: features, syscalls
 func (_m *Manager) MachineChecked(features flatrpc.Feature, syscalls map[*prog.Syscall]bool) (queue.Source, error) {
 	ret := _m.Called(features, syscalls)
@@ -112,6 +175,35 @@ func (_m *Manager) MachineChecked(features flatrpc.Feature, syscalls map[*prog.S
 	return r0, r1
 }
 
+// Manager_MachineChecked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MachineChecked'
+type Manager_MachineChecked_Call struct {
+	*mock.Call
+}
+
+// MachineChecked is a helper method to define mock.On call
+//   - features flatrpc.Feature
+//   - syscalls map[*prog.Syscall]bool
+func (_e *Manager_Expecter) MachineChecked(features interface{}, syscalls interface{}) *Manager_MachineChecked_Call {
+	return &Manager_MachineChecked_Call{Call: _e.mock.On("MachineChecked", features, syscalls)}
+}
+
+func (_c *Manager_MachineChecked_Call) Run(run func(features flatrpc.Feature, syscalls map[*prog.Syscall]bool)) *Manager_MachineChecked_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(flatrpc.Feature), args[1].(map[*prog.Syscall]bool))
+	})
+	return _c
+}
+
+func (_c *Manager_MachineChecked_Call) Return(_a0 queue.Source, _a1 error) *Manager_MachineChecked_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *Manager_MachineChecked_Call) RunAndReturn(run func(flatrpc.Feature, map[*prog.Syscall]bool) (queue.Source, error)) *Manager_MachineChecked_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // MaxSignal provides a mock function with no fields
 func (_m *Manager) MaxSignal() signal.Signal {
 	ret := _m.Called()
@@ -132,6 +224,33 @@ func (_m *Manager) MaxSignal() signal.Signal {
 	return r0
 }
 
+// Manager_MaxSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxSignal'
+type Manager_MaxSignal_Call struct {
+	*mock.Call
+}
+
+// MaxSignal is a helper method to define mock.On call
+func (_e *Manager_Expecter) MaxSignal() *Manager_MaxSignal_Call {
+	return &Manager_MaxSignal_Call{Call: _e.mock.On("MaxSignal")}
+}
+
+func (_c *Manager_MaxSignal_Call) Run(run func()) *Manager_MaxSignal_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *Manager_MaxSignal_Call) Return(_a0 signal.Signal) *Manager_MaxSignal_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *Manager_MaxSignal_Call) RunAndReturn(run func() signal.Signal) *Manager_MaxSignal_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewManager creates a new instance of Manager. 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 NewManager(t interface {
diff --git a/vm/proxyapp/mocks/ProxyAppInterface.go b/vm/proxyapp/mocks/ProxyAppInterface.go
index 78bf08fbc..a79afbb0e 100644
--- a/vm/proxyapp/mocks/ProxyAppInterface.go
+++ b/vm/proxyapp/mocks/ProxyAppInterface.go
@@ -12,6 +12,14 @@ type ProxyAppInterface struct {
 	mock.Mock
 }
 
+type ProxyAppInterface_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ProxyAppInterface) EXPECT() *ProxyAppInterface_Expecter {
+	return &ProxyAppInterface_Expecter{mock: &_m.Mock}
+}
+
 // Close provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error {
 	ret := _m.Called(in, out)
@@ -30,6 +38,35 @@ func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseR
 	return r0
 }
 
+// ProxyAppInterface_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+type ProxyAppInterface_Close_Call struct {
+	*mock.Call
+}
+
+// Close is a helper method to define mock.On call
+//   - in proxyrpc.CloseParams
+//   - out *proxyrpc.CloseReply
+func (_e *ProxyAppInterface_Expecter) Close(in interface{}, out interface{}) *ProxyAppInterface_Close_Call {
+	return &ProxyAppInterface_Close_Call{Call: _e.mock.On("Close", in, out)}
+}
+
+func (_c *ProxyAppInterface_Close_Call) Run(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply)) *ProxyAppInterface_Close_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.CloseParams), args[1].(*proxyrpc.CloseReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_Close_Call) Return(_a0 error) *ProxyAppInterface_Close_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_Close_Call) RunAndReturn(run func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Copy provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error {
 	ret := _m.Called(in, out)
@@ -48,6 +85,35 @@ func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResu
 	return r0
 }
 
+// ProxyAppInterface_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy'
+type ProxyAppInterface_Copy_Call struct {
+	*mock.Call
+}
+
+// Copy is a helper method to define mock.On call
+//   - in proxyrpc.CopyParams
+//   - out *proxyrpc.CopyResult
+func (_e *ProxyAppInterface_Expecter) Copy(in interface{}, out interface{}) *ProxyAppInterface_Copy_Call {
+	return &ProxyAppInterface_Copy_Call{Call: _e.mock.On("Copy", in, out)}
+}
+
+func (_c *ProxyAppInterface_Copy_Call) Run(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult)) *ProxyAppInterface_Copy_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.CopyParams), args[1].(*proxyrpc.CopyResult))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_Copy_Call) Return(_a0 error) *ProxyAppInterface_Copy_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_Copy_Call) RunAndReturn(run func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // CreateInstance provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error {
 	ret := _m.Called(in, out)
@@ -66,6 +132,35 @@ func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, ou
 	return r0
 }
 
+// ProxyAppInterface_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance'
+type ProxyAppInterface_CreateInstance_Call struct {
+	*mock.Call
+}
+
+// CreateInstance is a helper method to define mock.On call
+//   - in proxyrpc.CreateInstanceParams
+//   - out *proxyrpc.CreateInstanceResult
+func (_e *ProxyAppInterface_Expecter) CreateInstance(in interface{}, out interface{}) *ProxyAppInterface_CreateInstance_Call {
+	return &ProxyAppInterface_CreateInstance_Call{Call: _e.mock.On("CreateInstance", in, out)}
+}
+
+func (_c *ProxyAppInterface_CreateInstance_Call) Run(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult)) *ProxyAppInterface_CreateInstance_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.CreateInstanceParams), args[1].(*proxyrpc.CreateInstanceResult))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_CreateInstance_Call) Return(_a0 error) *ProxyAppInterface_CreateInstance_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_CreateInstance_Call) RunAndReturn(run func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // CreatePool provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error {
 	ret := _m.Called(in, out)
@@ -84,6 +179,35 @@ func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxy
 	return r0
 }
 
+// ProxyAppInterface_CreatePool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePool'
+type ProxyAppInterface_CreatePool_Call struct {
+	*mock.Call
+}
+
+// CreatePool is a helper method to define mock.On call
+//   - in proxyrpc.CreatePoolParams
+//   - out *proxyrpc.CreatePoolResult
+func (_e *ProxyAppInterface_Expecter) CreatePool(in interface{}, out interface{}) *ProxyAppInterface_CreatePool_Call {
+	return &ProxyAppInterface_CreatePool_Call{Call: _e.mock.On("CreatePool", in, out)}
+}
+
+func (_c *ProxyAppInterface_CreatePool_Call) Run(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult)) *ProxyAppInterface_CreatePool_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.CreatePoolParams), args[1].(*proxyrpc.CreatePoolResult))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_CreatePool_Call) Return(_a0 error) *ProxyAppInterface_CreatePool_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_CreatePool_Call) RunAndReturn(run func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Diagnose provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error {
 	ret := _m.Called(in, out)
@@ -102,6 +226,35 @@ func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.
 	return r0
 }
 
+// ProxyAppInterface_Diagnose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Diagnose'
+type ProxyAppInterface_Diagnose_Call struct {
+	*mock.Call
+}
+
+// Diagnose is a helper method to define mock.On call
+//   - in proxyrpc.DiagnoseParams
+//   - out *proxyrpc.DiagnoseReply
+func (_e *ProxyAppInterface_Expecter) Diagnose(in interface{}, out interface{}) *ProxyAppInterface_Diagnose_Call {
+	return &ProxyAppInterface_Diagnose_Call{Call: _e.mock.On("Diagnose", in, out)}
+}
+
+func (_c *ProxyAppInterface_Diagnose_Call) Run(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply)) *ProxyAppInterface_Diagnose_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.DiagnoseParams), args[1].(*proxyrpc.DiagnoseReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_Diagnose_Call) Return(_a0 error) *ProxyAppInterface_Diagnose_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_Diagnose_Call) RunAndReturn(run func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Forward provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error {
 	ret := _m.Called(in, out)
@@ -120,6 +273,35 @@ func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.Fo
 	return r0
 }
 
+// ProxyAppInterface_Forward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Forward'
+type ProxyAppInterface_Forward_Call struct {
+	*mock.Call
+}
+
+// Forward is a helper method to define mock.On call
+//   - in proxyrpc.ForwardParams
+//   - out *proxyrpc.ForwardResult
+func (_e *ProxyAppInterface_Expecter) Forward(in interface{}, out interface{}) *ProxyAppInterface_Forward_Call {
+	return &ProxyAppInterface_Forward_Call{Call: _e.mock.On("Forward", in, out)}
+}
+
+func (_c *ProxyAppInterface_Forward_Call) Run(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult)) *ProxyAppInterface_Forward_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.ForwardParams), args[1].(*proxyrpc.ForwardResult))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_Forward_Call) Return(_a0 error) *ProxyAppInterface_Forward_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_Forward_Call) RunAndReturn(run func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // PoolLogs provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error {
 	ret := _m.Called(in, out)
@@ -138,6 +320,35 @@ func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.P
 	return r0
 }
 
+// ProxyAppInterface_PoolLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PoolLogs'
+type ProxyAppInterface_PoolLogs_Call struct {
+	*mock.Call
+}
+
+// PoolLogs is a helper method to define mock.On call
+//   - in proxyrpc.PoolLogsParam
+//   - out *proxyrpc.PoolLogsReply
+func (_e *ProxyAppInterface_Expecter) PoolLogs(in interface{}, out interface{}) *ProxyAppInterface_PoolLogs_Call {
+	return &ProxyAppInterface_PoolLogs_Call{Call: _e.mock.On("PoolLogs", in, out)}
+}
+
+func (_c *ProxyAppInterface_PoolLogs_Call) Run(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply)) *ProxyAppInterface_PoolLogs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.PoolLogsParam), args[1].(*proxyrpc.PoolLogsReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_PoolLogs_Call) Return(_a0 error) *ProxyAppInterface_PoolLogs_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_PoolLogs_Call) RunAndReturn(run func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RunReadProgress provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error {
 	ret := _m.Called(in, out)
@@ -156,6 +367,35 @@ func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams,
 	return r0
 }
 
+// ProxyAppInterface_RunReadProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunReadProgress'
+type ProxyAppInterface_RunReadProgress_Call struct {
+	*mock.Call
+}
+
+// RunReadProgress is a helper method to define mock.On call
+//   - in proxyrpc.RunReadProgressParams
+//   - out *proxyrpc.RunReadProgressReply
+func (_e *ProxyAppInterface_Expecter) RunReadProgress(in interface{}, out interface{}) *ProxyAppInterface_RunReadProgress_Call {
+	return &ProxyAppInterface_RunReadProgress_Call{Call: _e.mock.On("RunReadProgress", in, out)}
+}
+
+func (_c *ProxyAppInterface_RunReadProgress_Call) Run(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply)) *ProxyAppInterface_RunReadProgress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.RunReadProgressParams), args[1].(*proxyrpc.RunReadProgressReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunReadProgress_Call) Return(_a0 error) *ProxyAppInterface_RunReadProgress_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunReadProgress_Call) RunAndReturn(run func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RunStart provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error {
 	ret := _m.Called(in, out)
@@ -174,6 +414,35 @@ func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.
 	return r0
 }
 
+// ProxyAppInterface_RunStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStart'
+type ProxyAppInterface_RunStart_Call struct {
+	*mock.Call
+}
+
+// RunStart is a helper method to define mock.On call
+//   - in proxyrpc.RunStartParams
+//   - out *proxyrpc.RunStartReply
+func (_e *ProxyAppInterface_Expecter) RunStart(in interface{}, out interface{}) *ProxyAppInterface_RunStart_Call {
+	return &ProxyAppInterface_RunStart_Call{Call: _e.mock.On("RunStart", in, out)}
+}
+
+func (_c *ProxyAppInterface_RunStart_Call) Run(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply)) *ProxyAppInterface_RunStart_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.RunStartParams), args[1].(*proxyrpc.RunStartReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunStart_Call) Return(_a0 error) *ProxyAppInterface_RunStart_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunStart_Call) RunAndReturn(run func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RunStop provides a mock function with given fields: in, out
 func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error {
 	ret := _m.Called(in, out)
@@ -192,6 +461,35 @@ func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.Ru
 	return r0
 }
 
+// ProxyAppInterface_RunStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStop'
+type ProxyAppInterface_RunStop_Call struct {
+	*mock.Call
+}
+
+// RunStop is a helper method to define mock.On call
+//   - in proxyrpc.RunStopParams
+//   - out *proxyrpc.RunStopReply
+func (_e *ProxyAppInterface_Expecter) RunStop(in interface{}, out interface{}) *ProxyAppInterface_RunStop_Call {
+	return &ProxyAppInterface_RunStop_Call{Call: _e.mock.On("RunStop", in, out)}
+}
+
+func (_c *ProxyAppInterface_RunStop_Call) Run(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply)) *ProxyAppInterface_RunStop_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(proxyrpc.RunStopParams), args[1].(*proxyrpc.RunStopReply))
+	})
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunStop_Call) Return(_a0 error) *ProxyAppInterface_RunStop_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewProxyAppInterface creates a new instance of ProxyAppInterface. 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 NewProxyAppInterface(t interface {
diff --git a/vm/proxyapp/mocks/subProcessCmd.go b/vm/proxyapp/mocks/subProcessCmd.go
index 7402ee1a6..50961fe0d 100644
--- a/vm/proxyapp/mocks/subProcessCmd.go
+++ b/vm/proxyapp/mocks/subProcessCmd.go
@@ -13,6 +13,14 @@ type SubProcessCmd struct {
 	mock.Mock
 }
 
+type SubProcessCmd_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SubProcessCmd) EXPECT() *SubProcessCmd_Expecter {
+	return &SubProcessCmd_Expecter{mock: &_m.Mock}
+}
+
 // Start provides a mock function with no fields
 func (_m *SubProcessCmd) Start() error {
 	ret := _m.Called()
@@ -31,6 +39,33 @@ func (_m *SubProcessCmd) Start() error {
 	return r0
 }
 
+// SubProcessCmd_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
+type SubProcessCmd_Start_Call struct {
+	*mock.Call
+}
+
+// Start is a helper method to define mock.On call
+func (_e *SubProcessCmd_Expecter) Start() *SubProcessCmd_Start_Call {
+	return &SubProcessCmd_Start_Call{Call: _e.mock.On("Start")}
+}
+
+func (_c *SubProcessCmd_Start_Call) Run(run func()) *SubProcessCmd_Start_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SubProcessCmd_Start_Call) Return(_a0 error) *SubProcessCmd_Start_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *SubProcessCmd_Start_Call) RunAndReturn(run func() error) *SubProcessCmd_Start_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // StderrPipe provides a mock function with no fields
 func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) {
 	ret := _m.Called()
@@ -61,6 +96,33 @@ func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) {
 	return r0, r1
 }
 
+// SubProcessCmd_StderrPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StderrPipe'
+type SubProcessCmd_StderrPipe_Call struct {
+	*mock.Call
+}
+
+// StderrPipe is a helper method to define mock.On call
+func (_e *SubProcessCmd_Expecter) StderrPipe() *SubProcessCmd_StderrPipe_Call {
+	return &SubProcessCmd_StderrPipe_Call{Call: _e.mock.On("StderrPipe")}
+}
+
+func (_c *SubProcessCmd_StderrPipe_Call) Run(run func()) *SubProcessCmd_StderrPipe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SubProcessCmd_StderrPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StderrPipe_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *SubProcessCmd_StderrPipe_Call) RunAndReturn(run func() (io.ReadCloser, error)) *SubProcessCmd_StderrPipe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // StdinPipe provides a mock function with no fields
 func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) {
 	ret := _m.Called()
@@ -91,6 +153,33 @@ func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) {
 	return r0, r1
 }
 
+// SubProcessCmd_StdinPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StdinPipe'
+type SubProcessCmd_StdinPipe_Call struct {
+	*mock.Call
+}
+
+// StdinPipe is a helper method to define mock.On call
+func (_e *SubProcessCmd_Expecter) StdinPipe() *SubProcessCmd_StdinPipe_Call {
+	return &SubProcessCmd_StdinPipe_Call{Call: _e.mock.On("StdinPipe")}
+}
+
+func (_c *SubProcessCmd_StdinPipe_Call) Run(run func()) *SubProcessCmd_StdinPipe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SubProcessCmd_StdinPipe_Call) Return(_a0 io.WriteCloser, _a1 error) *SubProcessCmd_StdinPipe_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *SubProcessCmd_StdinPipe_Call) RunAndReturn(run func() (io.WriteCloser, error)) *SubProcessCmd_StdinPipe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // StdoutPipe provides a mock function with no fields
 func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) {
 	ret := _m.Called()
@@ -121,6 +210,33 @@ func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) {
 	return r0, r1
 }
 
+// SubProcessCmd_StdoutPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StdoutPipe'
+type SubProcessCmd_StdoutPipe_Call struct {
+	*mock.Call
+}
+
+// StdoutPipe is a helper method to define mock.On call
+func (_e *SubProcessCmd_Expecter) StdoutPipe() *SubProcessCmd_StdoutPipe_Call {
+	return &SubProcessCmd_StdoutPipe_Call{Call: _e.mock.On("StdoutPipe")}
+}
+
+func (_c *SubProcessCmd_StdoutPipe_Call) Run(run func()) *SubProcessCmd_StdoutPipe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SubProcessCmd_StdoutPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StdoutPipe_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *SubProcessCmd_StdoutPipe_Call) RunAndReturn(run func() (io.ReadCloser, error)) *SubProcessCmd_StdoutPipe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Wait provides a mock function with no fields
 func (_m *SubProcessCmd) Wait() error {
 	ret := _m.Called()
@@ -139,6 +255,33 @@ func (_m *SubProcessCmd) Wait() error {
 	return r0
 }
 
+// SubProcessCmd_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
+type SubProcessCmd_Wait_Call struct {
+	*mock.Call
+}
+
+// Wait is a helper method to define mock.On call
+func (_e *SubProcessCmd_Expecter) Wait() *SubProcessCmd_Wait_Call {
+	return &SubProcessCmd_Wait_Call{Call: _e.mock.On("Wait")}
+}
+
+func (_c *SubProcessCmd_Wait_Call) Run(run func()) *SubProcessCmd_Wait_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SubProcessCmd_Wait_Call) Return(_a0 error) *SubProcessCmd_Wait_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *SubProcessCmd_Wait_Call) RunAndReturn(run func() error) *SubProcessCmd_Wait_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewSubProcessCmd creates a new instance of SubProcessCmd. 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 NewSubProcessCmd(t interface {