1286 lines
28 KiB
Go
1286 lines
28 KiB
Go
// Package mocks Code generated by mockery v1.0.0. DO NOT EDIT.
|
|
// mockery -recursive -dir=vendor/github.com/gambol99/ -name=Marathon -output=provider/marathon/mocks
|
|
package mocks
|
|
|
|
import (
|
|
"net/url"
|
|
"time"
|
|
|
|
"github.com/gambol99/go-marathon"
|
|
"github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// Marathon is an autogenerated mock type for the Marathon type
|
|
type Marathon struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// AbdicateLeader provides a mock function with given fields:
|
|
func (_m *Marathon) AbdicateLeader() (string, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddEventsListener provides a mock function with given fields: filter
|
|
func (_m *Marathon) AddEventsListener(filter int) (marathon.EventsChannel, error) {
|
|
ret := _m.Called(filter)
|
|
|
|
var r0 marathon.EventsChannel
|
|
if rf, ok := ret.Get(0).(func(int) marathon.EventsChannel); ok {
|
|
r0 = rf(filter)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(marathon.EventsChannel)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(int) error); ok {
|
|
r1 = rf(filter)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AllTasks provides a mock function with given fields: opts
|
|
func (_m *Marathon) AllTasks(opts *marathon.AllTasksOpts) (*marathon.Tasks, error) {
|
|
ret := _m.Called(opts)
|
|
|
|
var r0 *marathon.Tasks
|
|
if rf, ok := ret.Get(0).(func(*marathon.AllTasksOpts) *marathon.Tasks); ok {
|
|
r0 = rf(opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Tasks)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.AllTasksOpts) error); ok {
|
|
r1 = rf(opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Application provides a mock function with given fields: name
|
|
func (_m *Marathon) Application(name string) (*marathon.Application, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 *marathon.Application
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.Application); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Application)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ApplicationBy provides a mock function with given fields: name, opts
|
|
func (_m *Marathon) ApplicationBy(name string, opts *marathon.GetAppOpts) (*marathon.Application, error) {
|
|
ret := _m.Called(name, opts)
|
|
|
|
var r0 *marathon.Application
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.GetAppOpts) *marathon.Application); ok {
|
|
r0 = rf(name, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Application)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.GetAppOpts) error); ok {
|
|
r1 = rf(name, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ApplicationByVersion provides a mock function with given fields: name, version
|
|
func (_m *Marathon) ApplicationByVersion(name string, version string) (*marathon.Application, error) {
|
|
ret := _m.Called(name, version)
|
|
|
|
var r0 *marathon.Application
|
|
if rf, ok := ret.Get(0).(func(string, string) *marathon.Application); ok {
|
|
r0 = rf(name, version)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Application)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, string) error); ok {
|
|
r1 = rf(name, version)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ApplicationDeployments provides a mock function with given fields: name
|
|
func (_m *Marathon) ApplicationDeployments(name string) ([]*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 []*marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string) []*marathon.DeploymentID); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ApplicationOK provides a mock function with given fields: name
|
|
func (_m *Marathon) ApplicationOK(name string) (bool, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string) bool); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ApplicationVersions provides a mock function with given fields: name
|
|
func (_m *Marathon) ApplicationVersions(name string) (*marathon.ApplicationVersions, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 *marathon.ApplicationVersions
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.ApplicationVersions); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.ApplicationVersions)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Applications provides a mock function with given fields: _a0
|
|
func (_m *Marathon) Applications(_a0 url.Values) (*marathon.Applications, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *marathon.Applications
|
|
if rf, ok := ret.Get(0).(func(url.Values) *marathon.Applications); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Applications)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(url.Values) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateApplication provides a mock function with given fields: application
|
|
func (_m *Marathon) CreateApplication(application *marathon.Application) (*marathon.Application, error) {
|
|
ret := _m.Called(application)
|
|
|
|
var r0 *marathon.Application
|
|
if rf, ok := ret.Get(0).(func(*marathon.Application) *marathon.Application); ok {
|
|
r0 = rf(application)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Application)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.Application) error); ok {
|
|
r1 = rf(application)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateGroup provides a mock function with given fields: group
|
|
func (_m *Marathon) CreateGroup(group *marathon.Group) error {
|
|
ret := _m.Called(group)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*marathon.Group) error); ok {
|
|
r0 = rf(group)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// CreatePod provides a mock function with given fields: pod
|
|
func (_m *Marathon) CreatePod(pod *marathon.Pod) (*marathon.Pod, error) {
|
|
ret := _m.Called(pod)
|
|
|
|
var r0 *marathon.Pod
|
|
if rf, ok := ret.Get(0).(func(*marathon.Pod) *marathon.Pod); ok {
|
|
r0 = rf(pod)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Pod)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.Pod) error); ok {
|
|
r1 = rf(pod)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteApplication provides a mock function with given fields: name, force
|
|
func (_m *Marathon) DeleteApplication(name string, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
|
|
r1 = rf(name, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteDeployment provides a mock function with given fields: id, force
|
|
func (_m *Marathon) DeleteDeployment(id string, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(id, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(id, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
|
|
r1 = rf(id, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteGroup provides a mock function with given fields: name, force
|
|
func (_m *Marathon) DeleteGroup(name string, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
|
|
r1 = rf(name, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeletePod provides a mock function with given fields: name, force
|
|
func (_m *Marathon) DeletePod(name string, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
|
|
r1 = rf(name, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeletePodInstance provides a mock function with given fields: name, instance
|
|
func (_m *Marathon) DeletePodInstance(name string, instance string) (*marathon.PodInstance, error) {
|
|
ret := _m.Called(name, instance)
|
|
|
|
var r0 *marathon.PodInstance
|
|
if rf, ok := ret.Get(0).(func(string, string) *marathon.PodInstance); ok {
|
|
r0 = rf(name, instance)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.PodInstance)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, string) error); ok {
|
|
r1 = rf(name, instance)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeletePodInstances provides a mock function with given fields: name, instances
|
|
func (_m *Marathon) DeletePodInstances(name string, instances []string) ([]*marathon.PodInstance, error) {
|
|
ret := _m.Called(name, instances)
|
|
|
|
var r0 []*marathon.PodInstance
|
|
if rf, ok := ret.Get(0).(func(string, []string) []*marathon.PodInstance); ok {
|
|
r0 = rf(name, instances)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*marathon.PodInstance)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
|
|
r1 = rf(name, instances)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteQueueDelay provides a mock function with given fields: appID
|
|
func (_m *Marathon) DeleteQueueDelay(appID string) error {
|
|
ret := _m.Called(appID)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(appID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Deployments provides a mock function with given fields:
|
|
func (_m *Marathon) Deployments() ([]*marathon.Deployment, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 []*marathon.Deployment
|
|
if rf, ok := ret.Get(0).(func() []*marathon.Deployment); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*marathon.Deployment)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetMarathonURL provides a mock function with given fields:
|
|
func (_m *Marathon) GetMarathonURL() string {
|
|
ret := _m.Called()
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Group provides a mock function with given fields: name
|
|
func (_m *Marathon) Group(name string) (*marathon.Group, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 *marathon.Group
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.Group); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Group)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GroupBy provides a mock function with given fields: name, opts
|
|
func (_m *Marathon) GroupBy(name string, opts *marathon.GetGroupOpts) (*marathon.Group, error) {
|
|
ret := _m.Called(name, opts)
|
|
|
|
var r0 *marathon.Group
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.GetGroupOpts) *marathon.Group); ok {
|
|
r0 = rf(name, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Group)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.GetGroupOpts) error); ok {
|
|
r1 = rf(name, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Groups provides a mock function with given fields:
|
|
func (_m *Marathon) Groups() (*marathon.Groups, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 *marathon.Groups
|
|
if rf, ok := ret.Get(0).(func() *marathon.Groups); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Groups)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GroupsBy provides a mock function with given fields: opts
|
|
func (_m *Marathon) GroupsBy(opts *marathon.GetGroupOpts) (*marathon.Groups, error) {
|
|
ret := _m.Called(opts)
|
|
|
|
var r0 *marathon.Groups
|
|
if rf, ok := ret.Get(0).(func(*marathon.GetGroupOpts) *marathon.Groups); ok {
|
|
r0 = rf(opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Groups)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.GetGroupOpts) error); ok {
|
|
r1 = rf(opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// HasApplicationVersion provides a mock function with given fields: name, version
|
|
func (_m *Marathon) HasApplicationVersion(name string, version string) (bool, error) {
|
|
ret := _m.Called(name, version)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string, string) bool); ok {
|
|
r0 = rf(name, version)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, string) error); ok {
|
|
r1 = rf(name, version)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// HasDeployment provides a mock function with given fields: id
|
|
func (_m *Marathon) HasDeployment(id string) (bool, error) {
|
|
ret := _m.Called(id)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string) bool); ok {
|
|
r0 = rf(id)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// HasGroup provides a mock function with given fields: name
|
|
func (_m *Marathon) HasGroup(name string) (bool, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string) bool); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Info provides a mock function with given fields:
|
|
func (_m *Marathon) Info() (*marathon.Info, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 *marathon.Info
|
|
if rf, ok := ret.Get(0).(func() *marathon.Info); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Info)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// KillApplicationTasks provides a mock function with given fields: applicationID, opts
|
|
func (_m *Marathon) KillApplicationTasks(applicationID string, opts *marathon.KillApplicationTasksOpts) (*marathon.Tasks, error) {
|
|
ret := _m.Called(applicationID, opts)
|
|
|
|
var r0 *marathon.Tasks
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.KillApplicationTasksOpts) *marathon.Tasks); ok {
|
|
r0 = rf(applicationID, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Tasks)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.KillApplicationTasksOpts) error); ok {
|
|
r1 = rf(applicationID, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// KillTask provides a mock function with given fields: taskID, opts
|
|
func (_m *Marathon) KillTask(taskID string, opts *marathon.KillTaskOpts) (*marathon.Task, error) {
|
|
ret := _m.Called(taskID, opts)
|
|
|
|
var r0 *marathon.Task
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.KillTaskOpts) *marathon.Task); ok {
|
|
r0 = rf(taskID, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Task)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.KillTaskOpts) error); ok {
|
|
r1 = rf(taskID, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// KillTasks provides a mock function with given fields: taskIDs, opts
|
|
func (_m *Marathon) KillTasks(taskIDs []string, opts *marathon.KillTaskOpts) error {
|
|
ret := _m.Called(taskIDs, opts)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func([]string, *marathon.KillTaskOpts) error); ok {
|
|
r0 = rf(taskIDs, opts)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Leader provides a mock function with given fields:
|
|
func (_m *Marathon) Leader() (string, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListApplications provides a mock function with given fields: _a0
|
|
func (_m *Marathon) ListApplications(_a0 url.Values) ([]string, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 []string
|
|
if rf, ok := ret.Get(0).(func(url.Values) []string); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(url.Values) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Ping provides a mock function with given fields:
|
|
func (_m *Marathon) Ping() (bool, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func() bool); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Pod provides a mock function with given fields: name
|
|
func (_m *Marathon) Pod(name string) (*marathon.Pod, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 *marathon.Pod
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.Pod); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Pod)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PodByVersion provides a mock function with given fields: name, version
|
|
func (_m *Marathon) PodByVersion(name string, version string) (*marathon.Pod, error) {
|
|
ret := _m.Called(name, version)
|
|
|
|
var r0 *marathon.Pod
|
|
if rf, ok := ret.Get(0).(func(string, string) *marathon.Pod); ok {
|
|
r0 = rf(name, version)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Pod)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, string) error); ok {
|
|
r1 = rf(name, version)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PodIsRunning provides a mock function with given fields: name
|
|
func (_m *Marathon) PodIsRunning(name string) bool {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(string) bool); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// PodStatus provides a mock function with given fields: name
|
|
func (_m *Marathon) PodStatus(name string) (*marathon.PodStatus, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 *marathon.PodStatus
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.PodStatus); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.PodStatus)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PodStatuses provides a mock function with given fields:
|
|
func (_m *Marathon) PodStatuses() ([]*marathon.PodStatus, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 []*marathon.PodStatus
|
|
if rf, ok := ret.Get(0).(func() []*marathon.PodStatus); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*marathon.PodStatus)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PodVersions provides a mock function with given fields: name
|
|
func (_m *Marathon) PodVersions(name string) ([]string, error) {
|
|
ret := _m.Called(name)
|
|
|
|
var r0 []string
|
|
if rf, ok := ret.Get(0).(func(string) []string); ok {
|
|
r0 = rf(name)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Pods provides a mock function with given fields:
|
|
func (_m *Marathon) Pods() ([]marathon.Pod, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 []marathon.Pod
|
|
if rf, ok := ret.Get(0).(func() []marathon.Pod); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]marathon.Pod)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Queue provides a mock function with given fields:
|
|
func (_m *Marathon) Queue() (*marathon.Queue, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 *marathon.Queue
|
|
if rf, ok := ret.Get(0).(func() *marathon.Queue); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Queue)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemoveEventsListener provides a mock function with given fields: channel
|
|
func (_m *Marathon) RemoveEventsListener(channel marathon.EventsChannel) {
|
|
_m.Called(channel)
|
|
}
|
|
|
|
// RestartApplication provides a mock function with given fields: name, force
|
|
func (_m *Marathon) RestartApplication(name string, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
|
|
r1 = rf(name, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ScaleApplicationInstances provides a mock function with given fields: name, instances, force
|
|
func (_m *Marathon) ScaleApplicationInstances(name string, instances int, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, instances, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, int, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, instances, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, int, bool) error); ok {
|
|
r1 = rf(name, instances, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SetApplicationVersion provides a mock function with given fields: name, version
|
|
func (_m *Marathon) SetApplicationVersion(name string, version *marathon.ApplicationVersion) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(name, version)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.ApplicationVersion) *marathon.DeploymentID); ok {
|
|
r0 = rf(name, version)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.ApplicationVersion) error); ok {
|
|
r1 = rf(name, version)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Subscribe provides a mock function with given fields: _a0
|
|
func (_m *Marathon) Subscribe(_a0 string) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Subscriptions provides a mock function with given fields:
|
|
func (_m *Marathon) Subscriptions() (*marathon.Subscriptions, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 *marathon.Subscriptions
|
|
if rf, ok := ret.Get(0).(func() *marathon.Subscriptions); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Subscriptions)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// SupportsPods provides a mock function with given fields:
|
|
func (_m *Marathon) SupportsPods() (bool, error) {
|
|
ret := _m.Called()
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func() bool); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// TaskEndpoints provides a mock function with given fields: name, port, healthCheck
|
|
func (_m *Marathon) TaskEndpoints(name string, port int, healthCheck bool) ([]string, error) {
|
|
ret := _m.Called(name, port, healthCheck)
|
|
|
|
var r0 []string
|
|
if rf, ok := ret.Get(0).(func(string, int, bool) []string); ok {
|
|
r0 = rf(name, port, healthCheck)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, int, bool) error); ok {
|
|
r1 = rf(name, port, healthCheck)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Tasks provides a mock function with given fields: application
|
|
func (_m *Marathon) Tasks(application string) (*marathon.Tasks, error) {
|
|
ret := _m.Called(application)
|
|
|
|
var r0 *marathon.Tasks
|
|
if rf, ok := ret.Get(0).(func(string) *marathon.Tasks); ok {
|
|
r0 = rf(application)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Tasks)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(application)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Unsubscribe provides a mock function with given fields: _a0
|
|
func (_m *Marathon) Unsubscribe(_a0 string) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// UpdateApplication provides a mock function with given fields: application, force
|
|
func (_m *Marathon) UpdateApplication(application *marathon.Application, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(application, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(*marathon.Application, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(application, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.Application, bool) error); ok {
|
|
r1 = rf(application, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateGroup provides a mock function with given fields: id, group, force
|
|
func (_m *Marathon) UpdateGroup(id string, group *marathon.Group, force bool) (*marathon.DeploymentID, error) {
|
|
ret := _m.Called(id, group, force)
|
|
|
|
var r0 *marathon.DeploymentID
|
|
if rf, ok := ret.Get(0).(func(string, *marathon.Group, bool) *marathon.DeploymentID); ok {
|
|
r0 = rf(id, group, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.DeploymentID)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(string, *marathon.Group, bool) error); ok {
|
|
r1 = rf(id, group, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdatePod provides a mock function with given fields: pod, force
|
|
func (_m *Marathon) UpdatePod(pod *marathon.Pod, force bool) (*marathon.Pod, error) {
|
|
ret := _m.Called(pod, force)
|
|
|
|
var r0 *marathon.Pod
|
|
if rf, ok := ret.Get(0).(func(*marathon.Pod, bool) *marathon.Pod); ok {
|
|
r0 = rf(pod, force)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*marathon.Pod)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*marathon.Pod, bool) error); ok {
|
|
r1 = rf(pod, force)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// WaitOnApplication provides a mock function with given fields: name, timeout
|
|
func (_m *Marathon) WaitOnApplication(name string, timeout time.Duration) error {
|
|
ret := _m.Called(name, timeout)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
|
|
r0 = rf(name, timeout)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitOnDeployment provides a mock function with given fields: id, timeout
|
|
func (_m *Marathon) WaitOnDeployment(id string, timeout time.Duration) error {
|
|
ret := _m.Called(id, timeout)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
|
|
r0 = rf(id, timeout)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitOnGroup provides a mock function with given fields: name, timeout
|
|
func (_m *Marathon) WaitOnGroup(name string, timeout time.Duration) error {
|
|
ret := _m.Called(name, timeout)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
|
|
r0 = rf(name, timeout)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitOnPod provides a mock function with given fields: name, timeout
|
|
func (_m *Marathon) WaitOnPod(name string, timeout time.Duration) error {
|
|
ret := _m.Called(name, timeout)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
|
|
r0 = rf(name, timeout)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|