pulumi-docker-build/provider/internal/mockclient_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: client.go
//
// Generated by this command:
//
//	mockgen -typed -package internal -source client.go -destination mockclient_test.go --self_package github.com/pulumi/pulumi-docker-build/provider/internal
//
// Package internal is a generated GoMock package.
package internal

import (
	context "context"
	reflect "reflect"

	pb "github.com/docker/buildx/controller/pb"
	client "github.com/moby/buildkit/client"
	session "github.com/moby/buildkit/session"
	provider "github.com/pulumi/pulumi-go-provider"
	descriptor "github.com/regclient/regclient/types/descriptor"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}

// Build mocks base method.
func (m *MockClient) Build(ctx provider.Context, b Build) (*client.SolveResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Build", ctx, b)
	ret0, _ := ret[0].(*client.SolveResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Build indicates an expected call of Build.
func (mr *MockClientMockRecorder) Build(ctx, b any) *ClientBuildCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockClient)(nil).Build), ctx, b)
	return &ClientBuildCall{Call: call}
}

// ClientBuildCall wrap *gomock.Call
type ClientBuildCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientBuildCall) Return(arg0 *client.SolveResponse, arg1 error) *ClientBuildCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientBuildCall) Do(f func(provider.Context, Build) (*client.SolveResponse, error)) *ClientBuildCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientBuildCall) DoAndReturn(f func(provider.Context, Build) (*client.SolveResponse, error)) *ClientBuildCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// BuildKitEnabled mocks base method.
func (m *MockClient) BuildKitEnabled() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildKitEnabled")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildKitEnabled indicates an expected call of BuildKitEnabled.
func (mr *MockClientMockRecorder) BuildKitEnabled() *ClientBuildKitEnabledCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildKitEnabled", reflect.TypeOf((*MockClient)(nil).BuildKitEnabled))
	return &ClientBuildKitEnabledCall{Call: call}
}

// ClientBuildKitEnabledCall wrap *gomock.Call
type ClientBuildKitEnabledCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientBuildKitEnabledCall) Return(arg0 bool, arg1 error) *ClientBuildKitEnabledCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientBuildKitEnabledCall) Do(f func() (bool, error)) *ClientBuildKitEnabledCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientBuildKitEnabledCall) DoAndReturn(f func() (bool, error)) *ClientBuildKitEnabledCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Delete mocks base method.
func (m *MockClient) Delete(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockClientMockRecorder) Delete(ctx, id any) *ClientDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), ctx, id)
	return &ClientDeleteCall{Call: call}
}

// ClientDeleteCall wrap *gomock.Call
type ClientDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientDeleteCall) Return(arg0 error) *ClientDeleteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientDeleteCall) Do(f func(context.Context, string) error) *ClientDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientDeleteCall) DoAndReturn(f func(context.Context, string) error) *ClientDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Inspect mocks base method.
func (m *MockClient) Inspect(ctx context.Context, id string) ([]descriptor.Descriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Inspect", ctx, id)
	ret0, _ := ret[0].([]descriptor.Descriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Inspect indicates an expected call of Inspect.
func (mr *MockClientMockRecorder) Inspect(ctx, id any) *ClientInspectCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Inspect", reflect.TypeOf((*MockClient)(nil).Inspect), ctx, id)
	return &ClientInspectCall{Call: call}
}

// ClientInspectCall wrap *gomock.Call
type ClientInspectCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientInspectCall) Return(arg0 []descriptor.Descriptor, arg1 error) *ClientInspectCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientInspectCall) Do(f func(context.Context, string) ([]descriptor.Descriptor, error)) *ClientInspectCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientInspectCall) DoAndReturn(f func(context.Context, string) ([]descriptor.Descriptor, error)) *ClientInspectCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ManifestCreate mocks base method.
func (m *MockClient) ManifestCreate(ctx provider.Context, push bool, target string, refs ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, push, target}
	for _, a := range refs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ManifestCreate", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ManifestCreate indicates an expected call of ManifestCreate.
func (mr *MockClientMockRecorder) ManifestCreate(ctx, push, target any, refs ...any) *ClientManifestCreateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, push, target}, refs...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManifestCreate", reflect.TypeOf((*MockClient)(nil).ManifestCreate), varargs...)
	return &ClientManifestCreateCall{Call: call}
}

// ClientManifestCreateCall wrap *gomock.Call
type ClientManifestCreateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientManifestCreateCall) Return(arg0 error) *ClientManifestCreateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientManifestCreateCall) Do(f func(provider.Context, bool, string, ...string) error) *ClientManifestCreateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientManifestCreateCall) DoAndReturn(f func(provider.Context, bool, string, ...string) error) *ClientManifestCreateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ManifestDelete mocks base method.
func (m *MockClient) ManifestDelete(ctx provider.Context, target string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ManifestDelete", ctx, target)
	ret0, _ := ret[0].(error)
	return ret0
}

// ManifestDelete indicates an expected call of ManifestDelete.
func (mr *MockClientMockRecorder) ManifestDelete(ctx, target any) *ClientManifestDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManifestDelete", reflect.TypeOf((*MockClient)(nil).ManifestDelete), ctx, target)
	return &ClientManifestDeleteCall{Call: call}
}

// ClientManifestDeleteCall wrap *gomock.Call
type ClientManifestDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientManifestDeleteCall) Return(arg0 error) *ClientManifestDeleteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientManifestDeleteCall) Do(f func(provider.Context, string) error) *ClientManifestDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientManifestDeleteCall) DoAndReturn(f func(provider.Context, string) error) *ClientManifestDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ManifestInspect mocks base method.
func (m *MockClient) ManifestInspect(ctx provider.Context, target string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ManifestInspect", ctx, target)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ManifestInspect indicates an expected call of ManifestInspect.
func (mr *MockClientMockRecorder) ManifestInspect(ctx, target any) *ClientManifestInspectCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManifestInspect", reflect.TypeOf((*MockClient)(nil).ManifestInspect), ctx, target)
	return &ClientManifestInspectCall{Call: call}
}

// ClientManifestInspectCall wrap *gomock.Call
type ClientManifestInspectCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *ClientManifestInspectCall) Return(arg0 string, arg1 error) *ClientManifestInspectCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *ClientManifestInspectCall) Do(f func(provider.Context, string) (string, error)) *ClientManifestInspectCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *ClientManifestInspectCall) DoAndReturn(f func(provider.Context, string) (string, error)) *ClientManifestInspectCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockBuild is a mock of Build interface.
type MockBuild struct {
	ctrl     *gomock.Controller
	recorder *MockBuildMockRecorder
}

// MockBuildMockRecorder is the mock recorder for MockBuild.
type MockBuildMockRecorder struct {
	mock *MockBuild
}

// NewMockBuild creates a new mock instance.
func NewMockBuild(ctrl *gomock.Controller) *MockBuild {
	mock := &MockBuild{ctrl: ctrl}
	mock.recorder = &MockBuildMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBuild) EXPECT() *MockBuildMockRecorder {
	return m.recorder
}

// BuildOptions mocks base method.
func (m *MockBuild) BuildOptions() pb.BuildOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildOptions")
	ret0, _ := ret[0].(pb.BuildOptions)
	return ret0
}

// BuildOptions indicates an expected call of BuildOptions.
func (mr *MockBuildMockRecorder) BuildOptions() *BuildBuildOptionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildOptions", reflect.TypeOf((*MockBuild)(nil).BuildOptions))
	return &BuildBuildOptionsCall{Call: call}
}

// BuildBuildOptionsCall wrap *gomock.Call
type BuildBuildOptionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *BuildBuildOptionsCall) Return(arg0 pb.BuildOptions) *BuildBuildOptionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *BuildBuildOptionsCall) Do(f func() pb.BuildOptions) *BuildBuildOptionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *BuildBuildOptionsCall) DoAndReturn(f func() pb.BuildOptions) *BuildBuildOptionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Inline mocks base method.
func (m *MockBuild) Inline() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Inline")
	ret0, _ := ret[0].(string)
	return ret0
}

// Inline indicates an expected call of Inline.
func (mr *MockBuildMockRecorder) Inline() *BuildInlineCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Inline", reflect.TypeOf((*MockBuild)(nil).Inline))
	return &BuildInlineCall{Call: call}
}

// BuildInlineCall wrap *gomock.Call
type BuildInlineCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *BuildInlineCall) Return(arg0 string) *BuildInlineCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *BuildInlineCall) Do(f func() string) *BuildInlineCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *BuildInlineCall) DoAndReturn(f func() string) *BuildInlineCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Secrets mocks base method.
func (m *MockBuild) Secrets() session.Attachable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Secrets")
	ret0, _ := ret[0].(session.Attachable)
	return ret0
}

// Secrets indicates an expected call of Secrets.
func (mr *MockBuildMockRecorder) Secrets() *BuildSecretsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Secrets", reflect.TypeOf((*MockBuild)(nil).Secrets))
	return &BuildSecretsCall{Call: call}
}

// BuildSecretsCall wrap *gomock.Call
type BuildSecretsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *BuildSecretsCall) Return(arg0 session.Attachable) *BuildSecretsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *BuildSecretsCall) Do(f func() session.Attachable) *BuildSecretsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *BuildSecretsCall) DoAndReturn(f func() session.Attachable) *BuildSecretsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ShouldExec mocks base method.
func (m *MockBuild) ShouldExec() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShouldExec")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ShouldExec indicates an expected call of ShouldExec.
func (mr *MockBuildMockRecorder) ShouldExec() *BuildShouldExecCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldExec", reflect.TypeOf((*MockBuild)(nil).ShouldExec))
	return &BuildShouldExecCall{Call: call}
}

// BuildShouldExecCall wrap *gomock.Call
type BuildShouldExecCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *BuildShouldExecCall) Return(arg0 bool) *BuildShouldExecCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *BuildShouldExecCall) Do(f func() bool) *BuildShouldExecCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *BuildShouldExecCall) DoAndReturn(f func() bool) *BuildShouldExecCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}