mirror of
https://github.com/gitpod-io/gitpod.git
synced 2025-12-08 17:36:30 +00:00
62c573a453
* [server] update getDefaultWorkspaceImage api * [dashboard] api usage update * [protocol] add go definition * [papi] add getDefaultWorkspaceImage method * fixup * [dashboard] add org image warning to start workspace page * fix error wrap * Update supervisor to use publicApi * [dashboard] always show default image and remove tag width limit * fixup * move new warning to StartPage * Update components/dashboard/src/teams/TeamSettings.tsx Co-authored-by: George Tsiolis <tsiolis.g@gmail.com> * Address feedback --------- Co-authored-by: George Tsiolis <tsiolis.g@gmail.com>
1110 lines
45 KiB
Go
1110 lines
45 KiB
Go
// Copyright (c) 2023 Gitpod GmbH. All rights reserved.
|
|
// Licensed under the GNU Affero General Public License (AGPL).
|
|
// See License.AGPL.txt in the project root for license information.
|
|
|
|
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: gitpod-service.go
|
|
|
|
// Package protocol is a generated GoMock package.
|
|
package protocol
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
gomock "github.com/golang/mock/gomock"
|
|
)
|
|
|
|
// MockAPIInterface is a mock of APIInterface interface.
|
|
type MockAPIInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockAPIInterfaceMockRecorder
|
|
}
|
|
|
|
// MockAPIInterfaceMockRecorder is the mock recorder for MockAPIInterface.
|
|
type MockAPIInterfaceMockRecorder struct {
|
|
mock *MockAPIInterface
|
|
}
|
|
|
|
// NewMockAPIInterface creates a new mock instance.
|
|
func NewMockAPIInterface(ctrl *gomock.Controller) *MockAPIInterface {
|
|
mock := &MockAPIInterface{ctrl: ctrl}
|
|
mock.recorder = &MockAPIInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockAPIInterface) EXPECT() *MockAPIInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddSSHPublicKey mocks base method.
|
|
func (m *MockAPIInterface) AddSSHPublicKey(ctx context.Context, value *SSHPublicKeyValue) (*UserSSHPublicKeyValue, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddSSHPublicKey", ctx, value)
|
|
ret0, _ := ret[0].(*UserSSHPublicKeyValue)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddSSHPublicKey indicates an expected call of AddSSHPublicKey.
|
|
func (mr *MockAPIInterfaceMockRecorder) AddSSHPublicKey(ctx, value interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).AddSSHPublicKey), ctx, value)
|
|
}
|
|
|
|
// AdminBlockUser mocks base method.
|
|
func (m *MockAPIInterface) AdminBlockUser(ctx context.Context, req *AdminBlockUserRequest) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AdminBlockUser", ctx, req)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AdminBlockUser indicates an expected call of AdminBlockUser.
|
|
func (mr *MockAPIInterfaceMockRecorder) AdminBlockUser(ctx, req interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminBlockUser", reflect.TypeOf((*MockAPIInterface)(nil).AdminBlockUser), ctx, req)
|
|
}
|
|
|
|
// Close mocks base method.
|
|
func (m *MockAPIInterface) Close() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Close")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Close indicates an expected call of Close.
|
|
func (mr *MockAPIInterfaceMockRecorder) Close() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockAPIInterface)(nil).Close))
|
|
}
|
|
|
|
// ClosePort mocks base method.
|
|
func (m *MockAPIInterface) ClosePort(ctx context.Context, workspaceID string, port float32) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ClosePort", ctx, workspaceID, port)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ClosePort indicates an expected call of ClosePort.
|
|
func (mr *MockAPIInterfaceMockRecorder) ClosePort(ctx, workspaceID, port interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosePort", reflect.TypeOf((*MockAPIInterface)(nil).ClosePort), ctx, workspaceID, port)
|
|
}
|
|
|
|
// ControlAdmission mocks base method.
|
|
func (m *MockAPIInterface) ControlAdmission(ctx context.Context, id string, level *AdmissionLevel) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ControlAdmission", ctx, id, level)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ControlAdmission indicates an expected call of ControlAdmission.
|
|
func (mr *MockAPIInterfaceMockRecorder) ControlAdmission(ctx, id, level interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControlAdmission", reflect.TypeOf((*MockAPIInterface)(nil).ControlAdmission), ctx, id, level)
|
|
}
|
|
|
|
// CreateProject mocks base method.
|
|
func (m *MockAPIInterface) CreateProject(ctx context.Context, options *CreateProjectOptions) (*Project, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateProject", ctx, options)
|
|
ret0, _ := ret[0].(*Project)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateProject indicates an expected call of CreateProject.
|
|
func (mr *MockAPIInterfaceMockRecorder) CreateProject(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockAPIInterface)(nil).CreateProject), ctx, options)
|
|
}
|
|
|
|
// CreateTeam mocks base method.
|
|
func (m *MockAPIInterface) CreateTeam(ctx context.Context, teamName string) (*Team, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateTeam", ctx, teamName)
|
|
ret0, _ := ret[0].(*Team)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateTeam indicates an expected call of CreateTeam.
|
|
func (mr *MockAPIInterfaceMockRecorder) CreateTeam(ctx, teamName interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockAPIInterface)(nil).CreateTeam), ctx, teamName)
|
|
}
|
|
|
|
// CreateWorkspace mocks base method.
|
|
func (m *MockAPIInterface) CreateWorkspace(ctx context.Context, options *CreateWorkspaceOptions) (*WorkspaceCreationResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateWorkspace", ctx, options)
|
|
ret0, _ := ret[0].(*WorkspaceCreationResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateWorkspace indicates an expected call of CreateWorkspace.
|
|
func (mr *MockAPIInterfaceMockRecorder) CreateWorkspace(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).CreateWorkspace), ctx, options)
|
|
}
|
|
|
|
// DeleteAccount mocks base method.
|
|
func (m *MockAPIInterface) DeleteAccount(ctx context.Context) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteAccount", ctx)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteAccount indicates an expected call of DeleteAccount.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteAccount(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccount", reflect.TypeOf((*MockAPIInterface)(nil).DeleteAccount), ctx)
|
|
}
|
|
|
|
// DeleteEnvVar mocks base method.
|
|
func (m *MockAPIInterface) DeleteEnvVar(ctx context.Context, variable *UserEnvVarValue) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteEnvVar", ctx, variable)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteEnvVar indicates an expected call of DeleteEnvVar.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteEnvVar(ctx, variable interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEnvVar", reflect.TypeOf((*MockAPIInterface)(nil).DeleteEnvVar), ctx, variable)
|
|
}
|
|
|
|
// DeleteGitpodToken mocks base method.
|
|
func (m *MockAPIInterface) DeleteGitpodToken(ctx context.Context, tokenHash string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteGitpodToken", ctx, tokenHash)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteGitpodToken indicates an expected call of DeleteGitpodToken.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteGitpodToken(ctx, tokenHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGitpodToken", reflect.TypeOf((*MockAPIInterface)(nil).DeleteGitpodToken), ctx, tokenHash)
|
|
}
|
|
|
|
// DeleteOwnAuthProvider mocks base method.
|
|
func (m *MockAPIInterface) DeleteOwnAuthProvider(ctx context.Context, params *DeleteOwnAuthProviderParams) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteOwnAuthProvider", ctx, params)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteOwnAuthProvider indicates an expected call of DeleteOwnAuthProvider.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteOwnAuthProvider(ctx, params interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOwnAuthProvider", reflect.TypeOf((*MockAPIInterface)(nil).DeleteOwnAuthProvider), ctx, params)
|
|
}
|
|
|
|
// DeleteProject mocks base method.
|
|
func (m *MockAPIInterface) DeleteProject(ctx context.Context, projectID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteProject", ctx, projectID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteProject indicates an expected call of DeleteProject.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteProject(ctx, projectID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProject", reflect.TypeOf((*MockAPIInterface)(nil).DeleteProject), ctx, projectID)
|
|
}
|
|
|
|
// DeleteSSHPublicKey mocks base method.
|
|
func (m *MockAPIInterface) DeleteSSHPublicKey(ctx context.Context, id string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteSSHPublicKey", ctx, id)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteSSHPublicKey indicates an expected call of DeleteSSHPublicKey.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteSSHPublicKey(ctx, id interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).DeleteSSHPublicKey), ctx, id)
|
|
}
|
|
|
|
// DeleteTeam mocks base method.
|
|
func (m *MockAPIInterface) DeleteTeam(ctx context.Context, teamID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteTeam", ctx, teamID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteTeam indicates an expected call of DeleteTeam.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteTeam(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeam", reflect.TypeOf((*MockAPIInterface)(nil).DeleteTeam), ctx, teamID)
|
|
}
|
|
|
|
// DeleteWorkspace mocks base method.
|
|
func (m *MockAPIInterface) DeleteWorkspace(ctx context.Context, id string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteWorkspace", ctx, id)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteWorkspace indicates an expected call of DeleteWorkspace.
|
|
func (mr *MockAPIInterfaceMockRecorder) DeleteWorkspace(ctx, id interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).DeleteWorkspace), ctx, id)
|
|
}
|
|
|
|
// GenerateNewGitpodToken mocks base method.
|
|
func (m *MockAPIInterface) GenerateNewGitpodToken(ctx context.Context, options *GenerateNewGitpodTokenOptions) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GenerateNewGitpodToken", ctx, options)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GenerateNewGitpodToken indicates an expected call of GenerateNewGitpodToken.
|
|
func (mr *MockAPIInterfaceMockRecorder) GenerateNewGitpodToken(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateNewGitpodToken", reflect.TypeOf((*MockAPIInterface)(nil).GenerateNewGitpodToken), ctx, options)
|
|
}
|
|
|
|
// GetAuthProviders mocks base method.
|
|
func (m *MockAPIInterface) GetAuthProviders(ctx context.Context) ([]*AuthProviderInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAuthProviders", ctx)
|
|
ret0, _ := ret[0].([]*AuthProviderInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetAuthProviders indicates an expected call of GetAuthProviders.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetAuthProviders(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthProviders", reflect.TypeOf((*MockAPIInterface)(nil).GetAuthProviders), ctx)
|
|
}
|
|
|
|
// GetClientRegion mocks base method.
|
|
func (m *MockAPIInterface) GetClientRegion(ctx context.Context) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetClientRegion", ctx)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetClientRegion indicates an expected call of GetClientRegion.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetClientRegion(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientRegion", reflect.TypeOf((*MockAPIInterface)(nil).GetClientRegion), ctx)
|
|
}
|
|
|
|
// GetConfiguration mocks base method.
|
|
func (m *MockAPIInterface) GetConfiguration(ctx context.Context) (*Configuration, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetConfiguration", ctx)
|
|
ret0, _ := ret[0].(*Configuration)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetConfiguration indicates an expected call of GetConfiguration.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetConfiguration(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfiguration", reflect.TypeOf((*MockAPIInterface)(nil).GetConfiguration), ctx)
|
|
}
|
|
|
|
// GetEnvVars mocks base method.
|
|
func (m *MockAPIInterface) GetEnvVars(ctx context.Context) ([]*EnvVar, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetEnvVars", ctx)
|
|
ret0, _ := ret[0].([]*EnvVar)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetEnvVars indicates an expected call of GetEnvVars.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetEnvVars(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnvVars", reflect.TypeOf((*MockAPIInterface)(nil).GetEnvVars), ctx)
|
|
}
|
|
|
|
// GetFeaturedRepositories mocks base method.
|
|
func (m *MockAPIInterface) GetFeaturedRepositories(ctx context.Context) ([]*WhitelistedRepository, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetFeaturedRepositories", ctx)
|
|
ret0, _ := ret[0].([]*WhitelistedRepository)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetFeaturedRepositories indicates an expected call of GetFeaturedRepositories.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetFeaturedRepositories(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeaturedRepositories", reflect.TypeOf((*MockAPIInterface)(nil).GetFeaturedRepositories), ctx)
|
|
}
|
|
|
|
// GetGenericInvite mocks base method.
|
|
func (m *MockAPIInterface) GetGenericInvite(ctx context.Context, teamID string) (*TeamMembershipInvite, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetGenericInvite", ctx, teamID)
|
|
ret0, _ := ret[0].(*TeamMembershipInvite)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetGenericInvite indicates an expected call of GetGenericInvite.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetGenericInvite(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenericInvite", reflect.TypeOf((*MockAPIInterface)(nil).GetGenericInvite), ctx, teamID)
|
|
}
|
|
|
|
// GetGitpodTokenScopes mocks base method.
|
|
func (m *MockAPIInterface) GetGitpodTokenScopes(ctx context.Context, tokenHash string) ([]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetGitpodTokenScopes", ctx, tokenHash)
|
|
ret0, _ := ret[0].([]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetGitpodTokenScopes indicates an expected call of GetGitpodTokenScopes.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetGitpodTokenScopes(ctx, tokenHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGitpodTokenScopes", reflect.TypeOf((*MockAPIInterface)(nil).GetGitpodTokenScopes), ctx, tokenHash)
|
|
}
|
|
|
|
// GetGitpodTokens mocks base method.
|
|
func (m *MockAPIInterface) GetGitpodTokens(ctx context.Context) ([]*APIToken, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetGitpodTokens", ctx)
|
|
ret0, _ := ret[0].([]*APIToken)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetGitpodTokens indicates an expected call of GetGitpodTokens.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetGitpodTokens(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGitpodTokens", reflect.TypeOf((*MockAPIInterface)(nil).GetGitpodTokens), ctx)
|
|
}
|
|
|
|
// GetIDEOptions mocks base method.
|
|
func (m *MockAPIInterface) GetIDEOptions(ctx context.Context) (*IDEOptions, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIDEOptions", ctx)
|
|
ret0, _ := ret[0].(*IDEOptions)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetIDEOptions indicates an expected call of GetIDEOptions.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetIDEOptions(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDEOptions", reflect.TypeOf((*MockAPIInterface)(nil).GetIDEOptions), ctx)
|
|
}
|
|
|
|
// GetIDToken mocks base method.
|
|
func (m *MockAPIInterface) GetIDToken(ctx context.Context) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetIDToken", ctx)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// GetIDToken indicates an expected call of GetIDToken.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetIDToken(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDToken", reflect.TypeOf((*MockAPIInterface)(nil).GetIDToken), ctx)
|
|
}
|
|
|
|
// GetLoggedInUser mocks base method.
|
|
func (m *MockAPIInterface) GetLoggedInUser(ctx context.Context) (*User, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLoggedInUser", ctx)
|
|
ret0, _ := ret[0].(*User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLoggedInUser indicates an expected call of GetLoggedInUser.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetLoggedInUser(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoggedInUser", reflect.TypeOf((*MockAPIInterface)(nil).GetLoggedInUser), ctx)
|
|
}
|
|
|
|
// GetOpenPorts mocks base method.
|
|
func (m *MockAPIInterface) GetOpenPorts(ctx context.Context, workspaceID string) ([]*WorkspaceInstancePort, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOpenPorts", ctx, workspaceID)
|
|
ret0, _ := ret[0].([]*WorkspaceInstancePort)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOpenPorts indicates an expected call of GetOpenPorts.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetOpenPorts(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenPorts", reflect.TypeOf((*MockAPIInterface)(nil).GetOpenPorts), ctx, workspaceID)
|
|
}
|
|
|
|
// GetOwnAuthProviders mocks base method.
|
|
func (m *MockAPIInterface) GetOwnAuthProviders(ctx context.Context) ([]*AuthProviderEntry, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOwnAuthProviders", ctx)
|
|
ret0, _ := ret[0].([]*AuthProviderEntry)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOwnAuthProviders indicates an expected call of GetOwnAuthProviders.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetOwnAuthProviders(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnAuthProviders", reflect.TypeOf((*MockAPIInterface)(nil).GetOwnAuthProviders), ctx)
|
|
}
|
|
|
|
// GetOwnerToken mocks base method.
|
|
func (m *MockAPIInterface) GetOwnerToken(ctx context.Context, workspaceID string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOwnerToken", ctx, workspaceID)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOwnerToken indicates an expected call of GetOwnerToken.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetOwnerToken(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnerToken", reflect.TypeOf((*MockAPIInterface)(nil).GetOwnerToken), ctx, workspaceID)
|
|
}
|
|
|
|
// GetSSHPublicKeys mocks base method.
|
|
func (m *MockAPIInterface) GetSSHPublicKeys(ctx context.Context) ([]*UserSSHPublicKeyValue, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSSHPublicKeys", ctx)
|
|
ret0, _ := ret[0].([]*UserSSHPublicKeyValue)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSSHPublicKeys indicates an expected call of GetSSHPublicKeys.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetSSHPublicKeys(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSHPublicKeys", reflect.TypeOf((*MockAPIInterface)(nil).GetSSHPublicKeys), ctx)
|
|
}
|
|
|
|
// GetSnapshots mocks base method.
|
|
func (m *MockAPIInterface) GetSnapshots(ctx context.Context, workspaceID string) ([]*string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSnapshots", ctx, workspaceID)
|
|
ret0, _ := ret[0].([]*string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSnapshots indicates an expected call of GetSnapshots.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetSnapshots(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshots", reflect.TypeOf((*MockAPIInterface)(nil).GetSnapshots), ctx, workspaceID)
|
|
}
|
|
|
|
// GetSuggestedContextURLs mocks base method.
|
|
func (m *MockAPIInterface) GetSuggestedContextURLs(ctx context.Context) ([]*string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSuggestedContextURLs", ctx)
|
|
ret0, _ := ret[0].([]*string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSuggestedContextURLs indicates an expected call of GetSuggestedContextURLs.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetSuggestedContextURLs(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSuggestedContextURLs", reflect.TypeOf((*MockAPIInterface)(nil).GetSuggestedContextURLs), ctx)
|
|
}
|
|
|
|
// GetSupportedWorkspaceClasses mocks base method.
|
|
func (m *MockAPIInterface) GetSupportedWorkspaceClasses(ctx context.Context) ([]*SupportedWorkspaceClass, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSupportedWorkspaceClasses", ctx)
|
|
ret0, _ := ret[0].([]*SupportedWorkspaceClass)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSupportedWorkspaceClasses indicates an expected call of GetSupportedWorkspaceClasses.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetSupportedWorkspaceClasses(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSupportedWorkspaceClasses", reflect.TypeOf((*MockAPIInterface)(nil).GetSupportedWorkspaceClasses), ctx)
|
|
}
|
|
|
|
// GetTeam mocks base method.
|
|
func (m *MockAPIInterface) GetTeam(ctx context.Context, teamID string) (*Team, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTeam", ctx, teamID)
|
|
ret0, _ := ret[0].(*Team)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTeam indicates an expected call of GetTeam.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetTeam(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeam", reflect.TypeOf((*MockAPIInterface)(nil).GetTeam), ctx, teamID)
|
|
}
|
|
|
|
// GetTeamMembers mocks base method.
|
|
func (m *MockAPIInterface) GetTeamMembers(ctx context.Context, teamID string) ([]*TeamMemberInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTeamMembers", ctx, teamID)
|
|
ret0, _ := ret[0].([]*TeamMemberInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTeamMembers indicates an expected call of GetTeamMembers.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetTeamMembers(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamMembers", reflect.TypeOf((*MockAPIInterface)(nil).GetTeamMembers), ctx, teamID)
|
|
}
|
|
|
|
// GetTeamProjects mocks base method.
|
|
func (m *MockAPIInterface) GetTeamProjects(ctx context.Context, teamID string) ([]*Project, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTeamProjects", ctx, teamID)
|
|
ret0, _ := ret[0].([]*Project)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTeamProjects indicates an expected call of GetTeamProjects.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetTeamProjects(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamProjects", reflect.TypeOf((*MockAPIInterface)(nil).GetTeamProjects), ctx, teamID)
|
|
}
|
|
|
|
// GetTeams mocks base method.
|
|
func (m *MockAPIInterface) GetTeams(ctx context.Context) ([]*Team, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTeams", ctx)
|
|
ret0, _ := ret[0].([]*Team)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTeams indicates an expected call of GetTeams.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetTeams(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeams", reflect.TypeOf((*MockAPIInterface)(nil).GetTeams), ctx)
|
|
}
|
|
|
|
// GetToken mocks base method.
|
|
func (m *MockAPIInterface) GetToken(ctx context.Context, query *GetTokenSearchOptions) (*Token, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetToken", ctx, query)
|
|
ret0, _ := ret[0].(*Token)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetToken indicates an expected call of GetToken.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetToken(ctx, query interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetToken", reflect.TypeOf((*MockAPIInterface)(nil).GetToken), ctx, query)
|
|
}
|
|
|
|
// GetWorkspace mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspace(ctx context.Context, id string) (*WorkspaceInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspace", ctx, id)
|
|
ret0, _ := ret[0].(*WorkspaceInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspace indicates an expected call of GetWorkspace.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspace(ctx, id interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspace), ctx, id)
|
|
}
|
|
|
|
// GetWorkspaceEnvVars mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspaceEnvVars(ctx context.Context, workspaceID string) ([]*EnvVar, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspaceEnvVars", ctx, workspaceID)
|
|
ret0, _ := ret[0].([]*EnvVar)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspaceEnvVars indicates an expected call of GetWorkspaceEnvVars.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceEnvVars(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceEnvVars", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceEnvVars), ctx, workspaceID)
|
|
}
|
|
|
|
// GetWorkspaceOwner mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspaceOwner(ctx context.Context, workspaceID string) (*UserInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspaceOwner", ctx, workspaceID)
|
|
ret0, _ := ret[0].(*UserInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspaceOwner indicates an expected call of GetWorkspaceOwner.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceOwner(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceOwner", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceOwner), ctx, workspaceID)
|
|
}
|
|
|
|
// GetWorkspaceTimeout mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspaceTimeout(ctx context.Context, workspaceID string) (*GetWorkspaceTimeoutResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspaceTimeout", ctx, workspaceID)
|
|
ret0, _ := ret[0].(*GetWorkspaceTimeoutResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspaceTimeout indicates an expected call of GetWorkspaceTimeout.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceTimeout(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceTimeout", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceTimeout), ctx, workspaceID)
|
|
}
|
|
|
|
// GetWorkspaceUsers mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspaceUsers(ctx context.Context, workspaceID string) ([]*WorkspaceInstanceUser, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspaceUsers", ctx, workspaceID)
|
|
ret0, _ := ret[0].([]*WorkspaceInstanceUser)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspaceUsers indicates an expected call of GetWorkspaceUsers.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaceUsers(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceUsers", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaceUsers), ctx, workspaceID)
|
|
}
|
|
|
|
// GetWorkspaces mocks base method.
|
|
func (m *MockAPIInterface) GetWorkspaces(ctx context.Context, options *GetWorkspacesOptions) ([]*WorkspaceInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkspaces", ctx, options)
|
|
ret0, _ := ret[0].([]*WorkspaceInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkspaces indicates an expected call of GetWorkspaces.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetWorkspaces(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaces", reflect.TypeOf((*MockAPIInterface)(nil).GetWorkspaces), ctx, options)
|
|
}
|
|
|
|
// GuessGitTokenScopes mocks base method.
|
|
func (m *MockAPIInterface) GuessGitTokenScopes(ctx context.Context, params *GuessGitTokenScopesParams) (*GuessedGitTokenScopes, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GuessGitTokenScopes", ctx, params)
|
|
ret0, _ := ret[0].(*GuessedGitTokenScopes)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GuessGitTokenScopes indicates an expected call of GuessGitTokenScopes.
|
|
func (mr *MockAPIInterfaceMockRecorder) GuessGitTokenScopes(ctx, params interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GuessGitTokenScopes", reflect.TypeOf((*MockAPIInterface)(nil).GuessGitTokenScopes), ctx, params)
|
|
}
|
|
|
|
// HasSSHPublicKey mocks base method.
|
|
func (m *MockAPIInterface) HasSSHPublicKey(ctx context.Context) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HasSSHPublicKey", ctx)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HasSSHPublicKey indicates an expected call of HasSSHPublicKey.
|
|
func (mr *MockAPIInterfaceMockRecorder) HasSSHPublicKey(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasSSHPublicKey", reflect.TypeOf((*MockAPIInterface)(nil).HasSSHPublicKey), ctx)
|
|
}
|
|
|
|
// IsPrebuildDone mocks base method.
|
|
func (m *MockAPIInterface) IsPrebuildDone(ctx context.Context, pwsid string) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsPrebuildDone", ctx, pwsid)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsPrebuildDone indicates an expected call of IsPrebuildDone.
|
|
func (mr *MockAPIInterfaceMockRecorder) IsPrebuildDone(ctx, pwsid interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPrebuildDone", reflect.TypeOf((*MockAPIInterface)(nil).IsPrebuildDone), ctx, pwsid)
|
|
}
|
|
|
|
// IsWorkspaceOwner mocks base method.
|
|
func (m *MockAPIInterface) IsWorkspaceOwner(ctx context.Context, workspaceID string) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsWorkspaceOwner", ctx, workspaceID)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsWorkspaceOwner indicates an expected call of IsWorkspaceOwner.
|
|
func (mr *MockAPIInterfaceMockRecorder) IsWorkspaceOwner(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsWorkspaceOwner", reflect.TypeOf((*MockAPIInterface)(nil).IsWorkspaceOwner), ctx, workspaceID)
|
|
}
|
|
|
|
// JoinTeam mocks base method.
|
|
func (m *MockAPIInterface) JoinTeam(ctx context.Context, teamID string) (*Team, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "JoinTeam", ctx, teamID)
|
|
ret0, _ := ret[0].(*Team)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// JoinTeam indicates an expected call of JoinTeam.
|
|
func (mr *MockAPIInterfaceMockRecorder) JoinTeam(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinTeam", reflect.TypeOf((*MockAPIInterface)(nil).JoinTeam), ctx, teamID)
|
|
}
|
|
|
|
// OpenPort mocks base method.
|
|
func (m *MockAPIInterface) OpenPort(ctx context.Context, workspaceID string, port *WorkspaceInstancePort) (*WorkspaceInstancePort, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "OpenPort", ctx, workspaceID, port)
|
|
ret0, _ := ret[0].(*WorkspaceInstancePort)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// OpenPort indicates an expected call of OpenPort.
|
|
func (mr *MockAPIInterfaceMockRecorder) OpenPort(ctx, workspaceID, port interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenPort", reflect.TypeOf((*MockAPIInterface)(nil).OpenPort), ctx, workspaceID, port)
|
|
}
|
|
|
|
// RegisterGithubApp mocks base method.
|
|
func (m *MockAPIInterface) RegisterGithubApp(ctx context.Context, installationID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RegisterGithubApp", ctx, installationID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RegisterGithubApp indicates an expected call of RegisterGithubApp.
|
|
func (mr *MockAPIInterfaceMockRecorder) RegisterGithubApp(ctx, installationID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGithubApp", reflect.TypeOf((*MockAPIInterface)(nil).RegisterGithubApp), ctx, installationID)
|
|
}
|
|
|
|
// RemoveTeamMember mocks base method.
|
|
func (m *MockAPIInterface) RemoveTeamMember(ctx context.Context, teamID, userID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RemoveTeamMember", ctx, teamID, userID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RemoveTeamMember indicates an expected call of RemoveTeamMember.
|
|
func (mr *MockAPIInterfaceMockRecorder) RemoveTeamMember(ctx, teamID, userID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTeamMember", reflect.TypeOf((*MockAPIInterface)(nil).RemoveTeamMember), ctx, teamID, userID)
|
|
}
|
|
|
|
// GetOrgSettings mocks base method.
|
|
func (m *MockAPIInterface) GetOrgSettings(ctx context.Context, orgID string) (*OrganizationSettings, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrgSettings", ctx, orgID)
|
|
ret0, _ := ret[0].(*OrganizationSettings)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetOrgSettings indicates an expected call of GetOrgSettings.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetOrgSettings(ctx, orgID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgSettings", reflect.TypeOf((*MockAPIInterface)(nil).GetOrgSettings), ctx, orgID)
|
|
}
|
|
|
|
// GetDefaultWorkspaceImage mocks base method.
|
|
func (m *MockAPIInterface) GetDefaultWorkspaceImage(ctx context.Context, params *GetDefaultWorkspaceImageParams) (*GetDefaultWorkspaceImageResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDefaultWorkspaceImage", ctx)
|
|
ret0, _ := ret[0].(*GetDefaultWorkspaceImageResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetDefaultWorkspaceImage indicates an expected call of GetDefaultWorkspaceImage.
|
|
func (mr *MockAPIInterfaceMockRecorder) GetDefaultWorkspaceImage(ctx, params *GetDefaultWorkspaceImageParams) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultWorkspaceImage", reflect.TypeOf((*MockAPIInterface)(nil).GetDefaultWorkspaceImage), ctx, params)
|
|
}
|
|
|
|
// ResetGenericInvite mocks base method.
|
|
func (m *MockAPIInterface) ResetGenericInvite(ctx context.Context, teamID string) (*TeamMembershipInvite, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ResetGenericInvite", ctx, teamID)
|
|
ret0, _ := ret[0].(*TeamMembershipInvite)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ResetGenericInvite indicates an expected call of ResetGenericInvite.
|
|
func (mr *MockAPIInterfaceMockRecorder) ResetGenericInvite(ctx, teamID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetGenericInvite", reflect.TypeOf((*MockAPIInterface)(nil).ResetGenericInvite), ctx, teamID)
|
|
}
|
|
|
|
// SendHeartBeat mocks base method.
|
|
func (m *MockAPIInterface) SendHeartBeat(ctx context.Context, options *SendHeartBeatOptions) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendHeartBeat", ctx, options)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendHeartBeat indicates an expected call of SendHeartBeat.
|
|
func (mr *MockAPIInterfaceMockRecorder) SendHeartBeat(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeartBeat", reflect.TypeOf((*MockAPIInterface)(nil).SendHeartBeat), ctx, options)
|
|
}
|
|
|
|
// SetEnvVar mocks base method.
|
|
func (m *MockAPIInterface) SetEnvVar(ctx context.Context, variable *UserEnvVarValue) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetEnvVar", ctx, variable)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetEnvVar indicates an expected call of SetEnvVar.
|
|
func (mr *MockAPIInterfaceMockRecorder) SetEnvVar(ctx, variable interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnvVar", reflect.TypeOf((*MockAPIInterface)(nil).SetEnvVar), ctx, variable)
|
|
}
|
|
|
|
// SetTeamMemberRole mocks base method.
|
|
func (m *MockAPIInterface) SetTeamMemberRole(ctx context.Context, teamID, userID string, role TeamMemberRole) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetTeamMemberRole", ctx, teamID, userID, role)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetTeamMemberRole indicates an expected call of SetTeamMemberRole.
|
|
func (mr *MockAPIInterfaceMockRecorder) SetTeamMemberRole(ctx, teamID, userID, role interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTeamMemberRole", reflect.TypeOf((*MockAPIInterface)(nil).SetTeamMemberRole), ctx, teamID, userID, role)
|
|
}
|
|
|
|
// SetWorkspaceDescription mocks base method.
|
|
func (m *MockAPIInterface) SetWorkspaceDescription(ctx context.Context, id, desc string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetWorkspaceDescription", ctx, id, desc)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetWorkspaceDescription indicates an expected call of SetWorkspaceDescription.
|
|
func (mr *MockAPIInterfaceMockRecorder) SetWorkspaceDescription(ctx, id, desc interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceDescription", reflect.TypeOf((*MockAPIInterface)(nil).SetWorkspaceDescription), ctx, id, desc)
|
|
}
|
|
|
|
// SetWorkspaceTimeout mocks base method.
|
|
func (m *MockAPIInterface) SetWorkspaceTimeout(ctx context.Context, workspaceID string, duration time.Duration) (*SetWorkspaceTimeoutResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetWorkspaceTimeout", ctx, workspaceID, duration)
|
|
ret0, _ := ret[0].(*SetWorkspaceTimeoutResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetWorkspaceTimeout indicates an expected call of SetWorkspaceTimeout.
|
|
func (mr *MockAPIInterfaceMockRecorder) SetWorkspaceTimeout(ctx, workspaceID, duration interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkspaceTimeout", reflect.TypeOf((*MockAPIInterface)(nil).SetWorkspaceTimeout), ctx, workspaceID, duration)
|
|
}
|
|
|
|
// StartWorkspace mocks base method.
|
|
func (m *MockAPIInterface) StartWorkspace(ctx context.Context, id string, options *StartWorkspaceOptions) (*StartWorkspaceResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StartWorkspace", ctx, id, options)
|
|
ret0, _ := ret[0].(*StartWorkspaceResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StartWorkspace indicates an expected call of StartWorkspace.
|
|
func (mr *MockAPIInterfaceMockRecorder) StartWorkspace(ctx, id, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).StartWorkspace), ctx, id, options)
|
|
}
|
|
|
|
// StopWorkspace mocks base method.
|
|
func (m *MockAPIInterface) StopWorkspace(ctx context.Context, id string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StopWorkspace", ctx, id)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StopWorkspace indicates an expected call of StopWorkspace.
|
|
func (mr *MockAPIInterfaceMockRecorder) StopWorkspace(ctx, id interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopWorkspace", reflect.TypeOf((*MockAPIInterface)(nil).StopWorkspace), ctx, id)
|
|
}
|
|
|
|
// TakeSnapshot mocks base method.
|
|
func (m *MockAPIInterface) TakeSnapshot(ctx context.Context, options *TakeSnapshotOptions) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TakeSnapshot", ctx, options)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TakeSnapshot indicates an expected call of TakeSnapshot.
|
|
func (mr *MockAPIInterfaceMockRecorder) TakeSnapshot(ctx, options interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TakeSnapshot", reflect.TypeOf((*MockAPIInterface)(nil).TakeSnapshot), ctx, options)
|
|
}
|
|
|
|
// TrackEvent mocks base method.
|
|
func (m *MockAPIInterface) TrackEvent(ctx context.Context, event *RemoteTrackMessage) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TrackEvent", ctx, event)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// TrackEvent indicates an expected call of TrackEvent.
|
|
func (mr *MockAPIInterfaceMockRecorder) TrackEvent(ctx, event interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrackEvent", reflect.TypeOf((*MockAPIInterface)(nil).TrackEvent), ctx, event)
|
|
}
|
|
|
|
// UpdateGitStatus mocks base method.
|
|
func (m *MockAPIInterface) UpdateGitStatus(ctx context.Context, workspaceID string, status *WorkspaceInstanceRepoStatus) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateGitStatus", ctx, workspaceID, status)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateGitStatus indicates an expected call of UpdateGitStatus.
|
|
func (mr *MockAPIInterfaceMockRecorder) UpdateGitStatus(ctx, workspaceID, status interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGitStatus", reflect.TypeOf((*MockAPIInterface)(nil).UpdateGitStatus), ctx, workspaceID, status)
|
|
}
|
|
|
|
// UpdateLoggedInUser mocks base method.
|
|
func (m *MockAPIInterface) UpdateLoggedInUser(ctx context.Context, user *User) (*User, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateLoggedInUser", ctx, user)
|
|
ret0, _ := ret[0].(*User)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateLoggedInUser indicates an expected call of UpdateLoggedInUser.
|
|
func (mr *MockAPIInterfaceMockRecorder) UpdateLoggedInUser(ctx, user interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoggedInUser", reflect.TypeOf((*MockAPIInterface)(nil).UpdateLoggedInUser), ctx, user)
|
|
}
|
|
|
|
// UpdateOwnAuthProvider mocks base method.
|
|
func (m *MockAPIInterface) UpdateOwnAuthProvider(ctx context.Context, params *UpdateOwnAuthProviderParams) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateOwnAuthProvider", ctx, params)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateOwnAuthProvider indicates an expected call of UpdateOwnAuthProvider.
|
|
func (mr *MockAPIInterfaceMockRecorder) UpdateOwnAuthProvider(ctx, params interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOwnAuthProvider", reflect.TypeOf((*MockAPIInterface)(nil).UpdateOwnAuthProvider), ctx, params)
|
|
}
|
|
|
|
// UpdateWorkspaceUserPin mocks base method.
|
|
func (m *MockAPIInterface) UpdateWorkspaceUserPin(ctx context.Context, id string, action *PinAction) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateWorkspaceUserPin", ctx, id, action)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateWorkspaceUserPin indicates an expected call of UpdateWorkspaceUserPin.
|
|
func (mr *MockAPIInterfaceMockRecorder) UpdateWorkspaceUserPin(ctx, id, action interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceUserPin", reflect.TypeOf((*MockAPIInterface)(nil).UpdateWorkspaceUserPin), ctx, id, action)
|
|
}
|
|
|
|
// WaitForSnapshot mocks base method.
|
|
func (m *MockAPIInterface) WaitForSnapshot(ctx context.Context, snapshotId string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WaitForSnapshot", ctx, snapshotId)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WaitForSnapshot indicates an expected call of WaitForSnapshot.
|
|
func (mr *MockAPIInterfaceMockRecorder) WaitForSnapshot(ctx, snapshotId interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForSnapshot", reflect.TypeOf((*MockAPIInterface)(nil).WaitForSnapshot), ctx, snapshotId)
|
|
}
|
|
|
|
// WatchWorkspaceImageBuildLogs mocks base method.
|
|
func (m *MockAPIInterface) WatchWorkspaceImageBuildLogs(ctx context.Context, workspaceID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WatchWorkspaceImageBuildLogs", ctx, workspaceID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WatchWorkspaceImageBuildLogs indicates an expected call of WatchWorkspaceImageBuildLogs.
|
|
func (mr *MockAPIInterfaceMockRecorder) WatchWorkspaceImageBuildLogs(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchWorkspaceImageBuildLogs", reflect.TypeOf((*MockAPIInterface)(nil).WatchWorkspaceImageBuildLogs), ctx, workspaceID)
|
|
}
|
|
|
|
// WorkspaceUpdates mocks base method.
|
|
func (m *MockAPIInterface) WorkspaceUpdates(ctx context.Context, workspaceID string) (<-chan *WorkspaceInstance, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkspaceUpdates", ctx, workspaceID)
|
|
ret0, _ := ret[0].(<-chan *WorkspaceInstance)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkspaceUpdates indicates an expected call of WorkspaceUpdates.
|
|
func (mr *MockAPIInterfaceMockRecorder) WorkspaceUpdates(ctx, workspaceID interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkspaceUpdates", reflect.TypeOf((*MockAPIInterface)(nil).WorkspaceUpdates), ctx, workspaceID)
|
|
}
|