github.com/projecteru2/core@v0.0.0-20240321043226-06bcc1c23f58/store/mocks/Store.go

// Code generated by mockery v2.33.2. DO NOT EDIT.

package mocks

import (
	context "context"

	lock "github.com/projecteru2/core/lock"
	mock "github.com/stretchr/testify/mock"

	store "github.com/projecteru2/core/store"

	time "time"

	types "github.com/projecteru2/core/types"
)

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

// AddNode provides a mock function with given fields: _a0, _a1
func (_m *Store) AddNode(_a0 context.Context, _a1 *types.AddNodeOptions) (*types.Node, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *types.Node
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.AddNodeOptions) (*types.Node, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.AddNodeOptions) *types.Node); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Node)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.AddNodeOptions) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddPod provides a mock function with given fields: ctx, name, desc
func (_m *Store) AddPod(ctx context.Context, name string, desc string) (*types.Pod, error) {
	ret := _m.Called(ctx, name, desc)

	var r0 *types.Pod
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (*types.Pod, error)); ok {
		return rf(ctx, name, desc)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) *types.Pod); ok {
		r0 = rf(ctx, name, desc)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Pod)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, name, desc)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddWorkload provides a mock function with given fields: _a0, _a1, _a2
func (_m *Store) AddWorkload(_a0 context.Context, _a1 *types.Workload, _a2 *types.Processing) error {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Workload, *types.Processing) error); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// CreateLock provides a mock function with given fields: key, ttl
func (_m *Store) CreateLock(key string, ttl time.Duration) (lock.DistributedLock, error) {
	ret := _m.Called(key, ttl)

	var r0 lock.DistributedLock
	var r1 error
	if rf, ok := ret.Get(0).(func(string, time.Duration) (lock.DistributedLock, error)); ok {
		return rf(key, ttl)
	}
	if rf, ok := ret.Get(0).(func(string, time.Duration) lock.DistributedLock); ok {
		r0 = rf(key, ttl)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(lock.DistributedLock)
		}
	}

	if rf, ok := ret.Get(1).(func(string, time.Duration) error); ok {
		r1 = rf(key, ttl)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateProcessing provides a mock function with given fields: ctx, process, count
func (_m *Store) CreateProcessing(ctx context.Context, process *types.Processing, count int) error {
	ret := _m.Called(ctx, process, count)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Processing, int) error); ok {
		r0 = rf(ctx, process, count)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeleteProcessing provides a mock function with given fields: _a0, _a1
func (_m *Store) DeleteProcessing(_a0 context.Context, _a1 *types.Processing) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Processing) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAllPods provides a mock function with given fields: ctx
func (_m *Store) GetAllPods(ctx context.Context) ([]*types.Pod, error) {
	ret := _m.Called(ctx)

	var r0 []*types.Pod
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*types.Pod, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*types.Pod); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Pod)
		}
	}

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

	return r0, r1
}

// GetDeployStatus provides a mock function with given fields: ctx, appname, entryname
func (_m *Store) GetDeployStatus(ctx context.Context, appname string, entryname string) (map[string]int, error) {
	ret := _m.Called(ctx, appname, entryname)

	var r0 map[string]int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (map[string]int, error)); ok {
		return rf(ctx, appname, entryname)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) map[string]int); ok {
		r0 = rf(ctx, appname, entryname)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]int)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, appname, entryname)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetNode provides a mock function with given fields: ctx, nodename
func (_m *Store) GetNode(ctx context.Context, nodename string) (*types.Node, error) {
	ret := _m.Called(ctx, nodename)

	var r0 *types.Node
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Node, error)); ok {
		return rf(ctx, nodename)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.Node); ok {
		r0 = rf(ctx, nodename)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Node)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, nodename)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetNodeStatus provides a mock function with given fields: ctx, nodename
func (_m *Store) GetNodeStatus(ctx context.Context, nodename string) (*types.NodeStatus, error) {
	ret := _m.Called(ctx, nodename)

	var r0 *types.NodeStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.NodeStatus, error)); ok {
		return rf(ctx, nodename)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.NodeStatus); ok {
		r0 = rf(ctx, nodename)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.NodeStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, nodename)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetNodes provides a mock function with given fields: ctx, nodenames
func (_m *Store) GetNodes(ctx context.Context, nodenames []string) ([]*types.Node, error) {
	ret := _m.Called(ctx, nodenames)

	var r0 []*types.Node
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*types.Node, error)); ok {
		return rf(ctx, nodenames)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []string) []*types.Node); ok {
		r0 = rf(ctx, nodenames)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Node)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, nodenames)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetNodesByPod provides a mock function with given fields: ctx, nodeFilter, opts
func (_m *Store) GetNodesByPod(ctx context.Context, nodeFilter *types.NodeFilter, opts ...store.Option) ([]*types.Node, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, nodeFilter)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 []*types.Node
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.NodeFilter, ...store.Option) ([]*types.Node, error)); ok {
		return rf(ctx, nodeFilter, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *types.NodeFilter, ...store.Option) []*types.Node); ok {
		r0 = rf(ctx, nodeFilter, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Node)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *types.NodeFilter, ...store.Option) error); ok {
		r1 = rf(ctx, nodeFilter, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPod provides a mock function with given fields: ctx, podname
func (_m *Store) GetPod(ctx context.Context, podname string) (*types.Pod, error) {
	ret := _m.Called(ctx, podname)

	var r0 *types.Pod
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Pod, error)); ok {
		return rf(ctx, podname)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.Pod); ok {
		r0 = rf(ctx, podname)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Pod)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, podname)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetWorkload provides a mock function with given fields: ctx, ID
func (_m *Store) GetWorkload(ctx context.Context, ID string) (*types.Workload, error) {
	ret := _m.Called(ctx, ID)

	var r0 *types.Workload
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Workload, error)); ok {
		return rf(ctx, ID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.Workload); ok {
		r0 = rf(ctx, ID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Workload)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, ID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetWorkloadStatus provides a mock function with given fields: ctx, ID
func (_m *Store) GetWorkloadStatus(ctx context.Context, ID string) (*types.StatusMeta, error) {
	ret := _m.Called(ctx, ID)

	var r0 *types.StatusMeta
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.StatusMeta, error)); ok {
		return rf(ctx, ID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.StatusMeta); ok {
		r0 = rf(ctx, ID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.StatusMeta)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, ID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetWorkloads provides a mock function with given fields: ctx, IDs
func (_m *Store) GetWorkloads(ctx context.Context, IDs []string) ([]*types.Workload, error) {
	ret := _m.Called(ctx, IDs)

	var r0 []*types.Workload
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*types.Workload, error)); ok {
		return rf(ctx, IDs)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []string) []*types.Workload); ok {
		r0 = rf(ctx, IDs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Workload)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, IDs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNodeWorkloads provides a mock function with given fields: ctx, nodename, labels
func (_m *Store) ListNodeWorkloads(ctx context.Context, nodename string, labels map[string]string) ([]*types.Workload, error) {
	ret := _m.Called(ctx, nodename, labels)

	var r0 []*types.Workload
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, map[string]string) ([]*types.Workload, error)); ok {
		return rf(ctx, nodename, labels)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, map[string]string) []*types.Workload); ok {
		r0 = rf(ctx, nodename, labels)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Workload)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, map[string]string) error); ok {
		r1 = rf(ctx, nodename, labels)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListWorkloads provides a mock function with given fields: ctx, appname, entrypoint, nodename, limit, labels
func (_m *Store) ListWorkloads(ctx context.Context, appname string, entrypoint string, nodename string, limit int64, labels map[string]string) ([]*types.Workload, error) {
	ret := _m.Called(ctx, appname, entrypoint, nodename, limit, labels)

	var r0 []*types.Workload
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, map[string]string) ([]*types.Workload, error)); ok {
		return rf(ctx, appname, entrypoint, nodename, limit, labels)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, int64, map[string]string) []*types.Workload); ok {
		r0 = rf(ctx, appname, entrypoint, nodename, limit, labels)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Workload)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, int64, map[string]string) error); ok {
		r1 = rf(ctx, appname, entrypoint, nodename, limit, labels)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LoadNodeCert provides a mock function with given fields: ctx, node
func (_m *Store) LoadNodeCert(ctx context.Context, node *types.Node) error {
	ret := _m.Called(ctx, node)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Node) error); ok {
		r0 = rf(ctx, node)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NodeStatusStream provides a mock function with given fields: ctx
func (_m *Store) NodeStatusStream(ctx context.Context) chan *types.NodeStatus {
	ret := _m.Called(ctx)

	var r0 chan *types.NodeStatus
	if rf, ok := ret.Get(0).(func(context.Context) chan *types.NodeStatus); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(chan *types.NodeStatus)
		}
	}

	return r0
}

// RegisterService provides a mock function with given fields: _a0, _a1, _a2
func (_m *Store) RegisterService(_a0 context.Context, _a1 string, _a2 time.Duration) (<-chan struct{}, func(), error) {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 <-chan struct{}
	var r1 func()
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) (<-chan struct{}, func(), error)); ok {
		return rf(_a0, _a1, _a2)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) <-chan struct{}); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration) func()); ok {
		r1 = rf(_a0, _a1, _a2)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(func())
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, time.Duration) error); ok {
		r2 = rf(_a0, _a1, _a2)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// RemoveNode provides a mock function with given fields: ctx, node
func (_m *Store) RemoveNode(ctx context.Context, node *types.Node) error {
	ret := _m.Called(ctx, node)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Node) error); ok {
		r0 = rf(ctx, node)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// RemovePod provides a mock function with given fields: ctx, podname
func (_m *Store) RemovePod(ctx context.Context, podname string) error {
	ret := _m.Called(ctx, podname)

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

	return r0
}

// RemoveWorkload provides a mock function with given fields: ctx, workload
func (_m *Store) RemoveWorkload(ctx context.Context, workload *types.Workload) error {
	ret := _m.Called(ctx, workload)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Workload) error); ok {
		r0 = rf(ctx, workload)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ServiceStatusStream provides a mock function with given fields: _a0
func (_m *Store) ServiceStatusStream(_a0 context.Context) (chan []string, error) {
	ret := _m.Called(_a0)

	var r0 chan []string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (chan []string, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) chan []string); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(chan []string)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetNodeStatus provides a mock function with given fields: ctx, node, ttl
func (_m *Store) SetNodeStatus(ctx context.Context, node *types.Node, ttl int64) error {
	ret := _m.Called(ctx, node, ttl)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Node, int64) error); ok {
		r0 = rf(ctx, node, ttl)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SetWorkloadStatus provides a mock function with given fields: ctx, status, ttl
func (_m *Store) SetWorkloadStatus(ctx context.Context, status *types.StatusMeta, ttl int64) error {
	ret := _m.Called(ctx, status, ttl)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.StatusMeta, int64) error); ok {
		r0 = rf(ctx, status, ttl)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// StartEphemeral provides a mock function with given fields: ctx, path, heartbeat
func (_m *Store) StartEphemeral(ctx context.Context, path string, heartbeat time.Duration) (<-chan struct{}, func(), error) {
	ret := _m.Called(ctx, path, heartbeat)

	var r0 <-chan struct{}
	var r1 func()
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) (<-chan struct{}, func(), error)); ok {
		return rf(ctx, path, heartbeat)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration) <-chan struct{}); ok {
		r0 = rf(ctx, path, heartbeat)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration) func()); ok {
		r1 = rf(ctx, path, heartbeat)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(func())
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, time.Duration) error); ok {
		r2 = rf(ctx, path, heartbeat)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// UpdateNodes provides a mock function with given fields: _a0, _a1
func (_m *Store) UpdateNodes(_a0 context.Context, _a1 ...*types.Node) error {
	_va := make([]interface{}, len(_a1))
	for _i := range _a1 {
		_va[_i] = _a1[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ...*types.Node) error); ok {
		r0 = rf(_a0, _a1...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateWorkload provides a mock function with given fields: ctx, workload
func (_m *Store) UpdateWorkload(ctx context.Context, workload *types.Workload) error {
	ret := _m.Called(ctx, workload)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *types.Workload) error); ok {
		r0 = rf(ctx, workload)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WorkloadStatusStream provides a mock function with given fields: ctx, appname, entrypoint, nodename, labels
func (_m *Store) WorkloadStatusStream(ctx context.Context, appname string, entrypoint string, nodename string, labels map[string]string) chan *types.WorkloadStatus {
	ret := _m.Called(ctx, appname, entrypoint, nodename, labels)

	var r0 chan *types.WorkloadStatus
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, map[string]string) chan *types.WorkloadStatus); ok {
		r0 = rf(ctx, appname, entrypoint, nodename, labels)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(chan *types.WorkloadStatus)
		}
	}

	return r0
}

// NewStore creates a new instance of Store. 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 NewStore(t interface {
	mock.TestingT
	Cleanup(func())
}) *Store {
	mock := &Store{}
	mock.Mock.Test(t)

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

	return mock
}