go/cas/rbe/mocks/RBEClient.go

// Code generated by mockery v0.0.0-dev. DO NOT EDIT.

package mocks

import (
	chunker "github.com/bazelbuild/remote-apis-sdks/go/pkg/chunker"
	client "github.com/bazelbuild/remote-apis-sdks/go/pkg/client"

	command "github.com/bazelbuild/remote-apis-sdks/go/pkg/command"

	context "context"

	digest "github.com/bazelbuild/remote-apis-sdks/go/pkg/digest"

	filemetadata "github.com/bazelbuild/remote-apis-sdks/go/pkg/filemetadata"

	mock "github.com/stretchr/testify/mock"

	remoteexecution "github.com/bazelbuild/remote-apis/build/bazel/remote/execution/v2"

	testing "testing"
)

// RBEClient is an autogenerated mock type for the RBEClient type
type RBEClient struct {
	mock.Mock
}

// Close provides a mock function with given fields:
func (_m *RBEClient) Close() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ComputeMerkleTree provides a mock function with given fields: execRoot, is, chunkSize, cache
func (_m *RBEClient) ComputeMerkleTree(execRoot string, is *command.InputSpec, chunkSize int, cache filemetadata.Cache) (digest.Digest, []*chunker.Chunker, *client.TreeStats, error) {
	ret := _m.Called(execRoot, is, chunkSize, cache)

	var r0 digest.Digest
	if rf, ok := ret.Get(0).(func(string, *command.InputSpec, int, filemetadata.Cache) digest.Digest); ok {
		r0 = rf(execRoot, is, chunkSize, cache)
	} else {
		r0 = ret.Get(0).(digest.Digest)
	}

	var r1 []*chunker.Chunker
	if rf, ok := ret.Get(1).(func(string, *command.InputSpec, int, filemetadata.Cache) []*chunker.Chunker); ok {
		r1 = rf(execRoot, is, chunkSize, cache)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]*chunker.Chunker)
		}
	}

	var r2 *client.TreeStats
	if rf, ok := ret.Get(2).(func(string, *command.InputSpec, int, filemetadata.Cache) *client.TreeStats); ok {
		r2 = rf(execRoot, is, chunkSize, cache)
	} else {
		if ret.Get(2) != nil {
			r2 = ret.Get(2).(*client.TreeStats)
		}
	}

	var r3 error
	if rf, ok := ret.Get(3).(func(string, *command.InputSpec, int, filemetadata.Cache) error); ok {
		r3 = rf(execRoot, is, chunkSize, cache)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

// DownloadDirectory provides a mock function with given fields: ctx, d, execRoot, cache
func (_m *RBEClient) DownloadDirectory(ctx context.Context, d digest.Digest, execRoot string, cache filemetadata.Cache) (map[string]*client.TreeOutput, error) {
	ret := _m.Called(ctx, d, execRoot, cache)

	var r0 map[string]*client.TreeOutput
	if rf, ok := ret.Get(0).(func(context.Context, digest.Digest, string, filemetadata.Cache) map[string]*client.TreeOutput); ok {
		r0 = rf(ctx, d, execRoot, cache)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*client.TreeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, digest.Digest, string, filemetadata.Cache) error); ok {
		r1 = rf(ctx, d, execRoot, cache)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetDirectoryTree provides a mock function with given fields: ctx, d
func (_m *RBEClient) GetDirectoryTree(ctx context.Context, d *remoteexecution.Digest) ([]*remoteexecution.Directory, error) {
	ret := _m.Called(ctx, d)

	var r0 []*remoteexecution.Directory
	if rf, ok := ret.Get(0).(func(context.Context, *remoteexecution.Digest) []*remoteexecution.Directory); ok {
		r0 = rf(ctx, d)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*remoteexecution.Directory)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *remoteexecution.Digest) error); ok {
		r1 = rf(ctx, d)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadIfMissing provides a mock function with given fields: ctx, data
func (_m *RBEClient) UploadIfMissing(ctx context.Context, data ...*chunker.Chunker) ([]digest.Digest, error) {
	_va := make([]interface{}, len(data))
	for _i := range data {
		_va[_i] = data[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 []digest.Digest
	if rf, ok := ret.Get(0).(func(context.Context, ...*chunker.Chunker) []digest.Digest); ok {
		r0 = rf(ctx, data...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]digest.Digest)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, ...*chunker.Chunker) error); ok {
		r1 = rf(ctx, data...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NewRBEClient creates a new instance of RBEClient. It also registers a cleanup function to assert the mocks expectations.
func NewRBEClient(t testing.TB) *RBEClient {
	mock := &RBEClient{}

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}