From e1b6658e26852644e14ad019cdf9582da24823cf Mon Sep 17 00:00:00 2001 From: Sebastian Rivera Date: Wed, 23 Feb 2022 14:57:00 -0500 Subject: [PATCH] Generate mocks with new function definitions --- mocks/agent_token_mocks.go | 30 ++++++------- mocks/organization_mocks.go | 72 +++++++++++++++---------------- mocks/organization_token_mocks.go | 30 ++++++------- mocks/plan_mocks.go | 30 ++++++------- mocks/state_version_mocks.go | 72 +++++++++++++++---------------- mocks/user_mocks.go | 12 +++--- mocks/workspace_mocks.go | 60 +++++++++++++------------- 7 files changed, 153 insertions(+), 153 deletions(-) diff --git a/mocks/agent_token_mocks.go b/mocks/agent_token_mocks.go index b3684bf53..4e1577424 100644 --- a/mocks/agent_token_mocks.go +++ b/mocks/agent_token_mocks.go @@ -35,6 +35,21 @@ func (m *MockAgentTokens) EXPECT() *MockAgentTokensMockRecorder { return m.recorder } +// Create mocks base method. +func (m *MockAgentTokens) Create(ctx context.Context, agentPoolID string, options tfe.AgentTokenCreateOptions) (*tfe.AgentToken, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, agentPoolID, options) + ret0, _ := ret[0].(*tfe.AgentToken) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockAgentTokensMockRecorder) Create(ctx, agentPoolID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAgentTokens)(nil).Create), ctx, agentPoolID, options) +} + // Delete mocks base method. func (m *MockAgentTokens) Delete(ctx context.Context, agentTokenID string) error { m.ctrl.T.Helper() @@ -49,21 +64,6 @@ func (mr *MockAgentTokensMockRecorder) Delete(ctx, agentTokenID interface{}) *go return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAgentTokens)(nil).Delete), ctx, agentTokenID) } -// Generate mocks base method. -func (m *MockAgentTokens) Generate(ctx context.Context, agentPoolID string, options tfe.AgentTokenGenerateOptions) (*tfe.AgentToken, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Generate", ctx, agentPoolID, options) - ret0, _ := ret[0].(*tfe.AgentToken) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Generate indicates an expected call of Generate. -func (mr *MockAgentTokensMockRecorder) Generate(ctx, agentPoolID, options interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockAgentTokens)(nil).Generate), ctx, agentPoolID, options) -} - // List mocks base method. func (m *MockAgentTokens) List(ctx context.Context, agentPoolID string) (*tfe.AgentTokenList, error) { m.ctrl.T.Helper() diff --git a/mocks/organization_mocks.go b/mocks/organization_mocks.go index 78228311b..87361eed7 100644 --- a/mocks/organization_mocks.go +++ b/mocks/organization_mocks.go @@ -35,21 +35,6 @@ func (m *MockOrganizations) EXPECT() *MockOrganizationsMockRecorder { return m.recorder } -// Capacity mocks base method. -func (m *MockOrganizations) Capacity(ctx context.Context, organization string) (*tfe.Capacity, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Capacity", ctx, organization) - ret0, _ := ret[0].(*tfe.Capacity) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Capacity indicates an expected call of Capacity. -func (mr *MockOrganizationsMockRecorder) Capacity(ctx, organization interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capacity", reflect.TypeOf((*MockOrganizations)(nil).Capacity), ctx, organization) -} - // Create mocks base method. func (m *MockOrganizations) Create(ctx context.Context, options tfe.OrganizationCreateOptions) (*tfe.Organization, error) { m.ctrl.T.Helper() @@ -79,21 +64,6 @@ func (mr *MockOrganizationsMockRecorder) Delete(ctx, organization interface{}) * return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizations)(nil).Delete), ctx, organization) } -// Entitlements mocks base method. -func (m *MockOrganizations) Entitlements(ctx context.Context, organization string) (*tfe.Entitlements, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Entitlements", ctx, organization) - ret0, _ := ret[0].(*tfe.Entitlements) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Entitlements indicates an expected call of Entitlements. -func (mr *MockOrganizationsMockRecorder) Entitlements(ctx, organization interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Entitlements", reflect.TypeOf((*MockOrganizations)(nil).Entitlements), ctx, organization) -} - // List mocks base method. func (m *MockOrganizations) List(ctx context.Context, options *tfe.OrganizationListOptions) (*tfe.OrganizationList, error) { m.ctrl.T.Helper() @@ -124,19 +94,49 @@ func (mr *MockOrganizationsMockRecorder) Read(ctx, organization interface{}) *go return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockOrganizations)(nil).Read), ctx, organization) } -// RunQueue mocks base method. -func (m *MockOrganizations) RunQueue(ctx context.Context, organization string, options tfe.RunQueueOptions) (*tfe.RunQueue, error) { +// ReadCapacity mocks base method. +func (m *MockOrganizations) ReadCapacity(ctx context.Context, organization string) (*tfe.Capacity, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadCapacity", ctx, organization) + ret0, _ := ret[0].(*tfe.Capacity) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadCapacity indicates an expected call of ReadCapacity. +func (mr *MockOrganizationsMockRecorder) ReadCapacity(ctx, organization interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCapacity", reflect.TypeOf((*MockOrganizations)(nil).ReadCapacity), ctx, organization) +} + +// ReadEntitlements mocks base method. +func (m *MockOrganizations) ReadEntitlements(ctx context.Context, organization string) (*tfe.Entitlements, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadEntitlements", ctx, organization) + ret0, _ := ret[0].(*tfe.Entitlements) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadEntitlements indicates an expected call of ReadEntitlements. +func (mr *MockOrganizationsMockRecorder) ReadEntitlements(ctx, organization interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadEntitlements", reflect.TypeOf((*MockOrganizations)(nil).ReadEntitlements), ctx, organization) +} + +// ReadRunQueue mocks base method. +func (m *MockOrganizations) ReadRunQueue(ctx context.Context, organization string, options tfe.ReadRunQueueOptions) (*tfe.RunQueue, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunQueue", ctx, organization, options) + ret := m.ctrl.Call(m, "ReadRunQueue", ctx, organization, options) ret0, _ := ret[0].(*tfe.RunQueue) ret1, _ := ret[1].(error) return ret0, ret1 } -// RunQueue indicates an expected call of RunQueue. -func (mr *MockOrganizationsMockRecorder) RunQueue(ctx, organization, options interface{}) *gomock.Call { +// ReadRunQueue indicates an expected call of ReadRunQueue. +func (mr *MockOrganizationsMockRecorder) ReadRunQueue(ctx, organization, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunQueue", reflect.TypeOf((*MockOrganizations)(nil).RunQueue), ctx, organization, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRunQueue", reflect.TypeOf((*MockOrganizations)(nil).ReadRunQueue), ctx, organization, options) } // Update mocks base method. diff --git a/mocks/organization_token_mocks.go b/mocks/organization_token_mocks.go index 8688bb37b..6b33e5796 100644 --- a/mocks/organization_token_mocks.go +++ b/mocks/organization_token_mocks.go @@ -35,6 +35,21 @@ func (m *MockOrganizationTokens) EXPECT() *MockOrganizationTokensMockRecorder { return m.recorder } +// Create mocks base method. +func (m *MockOrganizationTokens) Create(ctx context.Context, organization string) (*tfe.OrganizationToken, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", ctx, organization) + ret0, _ := ret[0].(*tfe.OrganizationToken) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockOrganizationTokensMockRecorder) Create(ctx, organization interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOrganizationTokens)(nil).Create), ctx, organization) +} + // Delete mocks base method. func (m *MockOrganizationTokens) Delete(ctx context.Context, organization string) error { m.ctrl.T.Helper() @@ -49,21 +64,6 @@ func (mr *MockOrganizationTokensMockRecorder) Delete(ctx, organization interface return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizationTokens)(nil).Delete), ctx, organization) } -// Generate mocks base method. -func (m *MockOrganizationTokens) Generate(ctx context.Context, organization string) (*tfe.OrganizationToken, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Generate", ctx, organization) - ret0, _ := ret[0].(*tfe.OrganizationToken) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Generate indicates an expected call of Generate. -func (mr *MockOrganizationTokensMockRecorder) Generate(ctx, organization interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockOrganizationTokens)(nil).Generate), ctx, organization) -} - // Read mocks base method. func (m *MockOrganizationTokens) Read(ctx context.Context, organization string) (*tfe.OrganizationToken, error) { m.ctrl.T.Helper() diff --git a/mocks/plan_mocks.go b/mocks/plan_mocks.go index 232e58bf5..f3b7fe2bc 100644 --- a/mocks/plan_mocks.go +++ b/mocks/plan_mocks.go @@ -36,21 +36,6 @@ func (m *MockPlans) EXPECT() *MockPlansMockRecorder { return m.recorder } -// JSONOutput mocks base method. -func (m *MockPlans) JSONOutput(ctx context.Context, planID string) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "JSONOutput", ctx, planID) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// JSONOutput indicates an expected call of JSONOutput. -func (mr *MockPlansMockRecorder) JSONOutput(ctx, planID interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONOutput", reflect.TypeOf((*MockPlans)(nil).JSONOutput), ctx, planID) -} - // Logs mocks base method. func (m *MockPlans) Logs(ctx context.Context, planID string) (io.Reader, error) { m.ctrl.T.Helper() @@ -80,3 +65,18 @@ func (mr *MockPlansMockRecorder) Read(ctx, planID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockPlans)(nil).Read), ctx, planID) } + +// ReadJSONOutput mocks base method. +func (m *MockPlans) ReadJSONOutput(ctx context.Context, planID string) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadJSONOutput", ctx, planID) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadJSONOutput indicates an expected call of ReadJSONOutput. +func (mr *MockPlansMockRecorder) ReadJSONOutput(ctx, planID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadJSONOutput", reflect.TypeOf((*MockPlans)(nil).ReadJSONOutput), ctx, planID) +} diff --git a/mocks/state_version_mocks.go b/mocks/state_version_mocks.go index ef377413d..fca56ef43 100644 --- a/mocks/state_version_mocks.go +++ b/mocks/state_version_mocks.go @@ -50,36 +50,6 @@ func (mr *MockStateVersionsMockRecorder) Create(ctx, workspaceID, options interf return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStateVersions)(nil).Create), ctx, workspaceID, options) } -// Current mocks base method. -func (m *MockStateVersions) Current(ctx context.Context, workspaceID string) (*tfe.StateVersion, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Current", ctx, workspaceID) - ret0, _ := ret[0].(*tfe.StateVersion) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Current indicates an expected call of Current. -func (mr *MockStateVersionsMockRecorder) Current(ctx, workspaceID interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Current", reflect.TypeOf((*MockStateVersions)(nil).Current), ctx, workspaceID) -} - -// CurrentWithOptions mocks base method. -func (m *MockStateVersions) CurrentWithOptions(ctx context.Context, workspaceID string, options *tfe.StateVersionCurrentOptions) (*tfe.StateVersion, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CurrentWithOptions", ctx, workspaceID, options) - ret0, _ := ret[0].(*tfe.StateVersion) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CurrentWithOptions indicates an expected call of CurrentWithOptions. -func (mr *MockStateVersionsMockRecorder) CurrentWithOptions(ctx, workspaceID, options interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentWithOptions", reflect.TypeOf((*MockStateVersions)(nil).CurrentWithOptions), ctx, workspaceID, options) -} - // Download mocks base method. func (m *MockStateVersions) Download(ctx context.Context, url string) ([]byte, error) { m.ctrl.T.Helper() @@ -110,19 +80,19 @@ func (mr *MockStateVersionsMockRecorder) List(ctx, options interface{}) *gomock. return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStateVersions)(nil).List), ctx, options) } -// Outputs mocks base method. -func (m *MockStateVersions) Outputs(ctx context.Context, svID string, options *tfe.StateVersionOutputsListOptions) (*tfe.StateVersionOutputsList, error) { +// ListOutputs mocks base method. +func (m *MockStateVersions) ListOutputs(ctx context.Context, svID string, options *tfe.StateVersionOutputsListOptions) (*tfe.StateVersionOutputsList, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Outputs", ctx, svID, options) + ret := m.ctrl.Call(m, "ListOutputs", ctx, svID, options) ret0, _ := ret[0].(*tfe.StateVersionOutputsList) ret1, _ := ret[1].(error) return ret0, ret1 } -// Outputs indicates an expected call of Outputs. -func (mr *MockStateVersionsMockRecorder) Outputs(ctx, svID, options interface{}) *gomock.Call { +// ListOutputs indicates an expected call of ListOutputs. +func (mr *MockStateVersionsMockRecorder) ListOutputs(ctx, svID, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Outputs", reflect.TypeOf((*MockStateVersions)(nil).Outputs), ctx, svID, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOutputs", reflect.TypeOf((*MockStateVersions)(nil).ListOutputs), ctx, svID, options) } // Read mocks base method. @@ -140,6 +110,36 @@ func (mr *MockStateVersionsMockRecorder) Read(ctx, svID interface{}) *gomock.Cal return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStateVersions)(nil).Read), ctx, svID) } +// ReadCurrent mocks base method. +func (m *MockStateVersions) ReadCurrent(ctx context.Context, workspaceID string) (*tfe.StateVersion, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadCurrent", ctx, workspaceID) + ret0, _ := ret[0].(*tfe.StateVersion) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadCurrent indicates an expected call of ReadCurrent. +func (mr *MockStateVersionsMockRecorder) ReadCurrent(ctx, workspaceID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCurrent", reflect.TypeOf((*MockStateVersions)(nil).ReadCurrent), ctx, workspaceID) +} + +// ReadCurrentWithOptions mocks base method. +func (m *MockStateVersions) ReadCurrentWithOptions(ctx context.Context, workspaceID string, options *tfe.StateVersionCurrentOptions) (*tfe.StateVersion, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadCurrentWithOptions", ctx, workspaceID, options) + ret0, _ := ret[0].(*tfe.StateVersion) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadCurrentWithOptions indicates an expected call of ReadCurrentWithOptions. +func (mr *MockStateVersionsMockRecorder) ReadCurrentWithOptions(ctx, workspaceID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCurrentWithOptions", reflect.TypeOf((*MockStateVersions)(nil).ReadCurrentWithOptions), ctx, workspaceID, options) +} + // ReadWithOptions mocks base method. func (m *MockStateVersions) ReadWithOptions(ctx context.Context, svID string, options *tfe.StateVersionReadOptions) (*tfe.StateVersion, error) { m.ctrl.T.Helper() diff --git a/mocks/user_mocks.go b/mocks/user_mocks.go index 345143a34..70bae8dfa 100644 --- a/mocks/user_mocks.go +++ b/mocks/user_mocks.go @@ -50,17 +50,17 @@ func (mr *MockUsersMockRecorder) ReadCurrent(ctx interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCurrent", reflect.TypeOf((*MockUsers)(nil).ReadCurrent), ctx) } -// Update mocks base method. -func (m *MockUsers) Update(ctx context.Context, options tfe.UserUpdateOptions) (*tfe.User, error) { +// UpdateCurrent mocks base method. +func (m *MockUsers) UpdateCurrent(ctx context.Context, options tfe.UserUpdateOptions) (*tfe.User, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update", ctx, options) + ret := m.ctrl.Call(m, "UpdateCurrent", ctx, options) ret0, _ := ret[0].(*tfe.User) ret1, _ := ret[1].(error) return ret0, ret1 } -// Update indicates an expected call of Update. -func (mr *MockUsersMockRecorder) Update(ctx, options interface{}) *gomock.Call { +// UpdateCurrent indicates an expected call of UpdateCurrent. +func (mr *MockUsersMockRecorder) UpdateCurrent(ctx, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUsers)(nil).Update), ctx, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCurrent", reflect.TypeOf((*MockUsers)(nil).UpdateCurrent), ctx, options) } diff --git a/mocks/workspace_mocks.go b/mocks/workspace_mocks.go index 23c5601d6..f5fa01ce3 100644 --- a/mocks/workspace_mocks.go +++ b/mocks/workspace_mocks.go @@ -152,6 +152,36 @@ func (mr *MockWorkspacesMockRecorder) List(ctx, organization, options interface{ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockWorkspaces)(nil).List), ctx, organization, options) } +// ListRemoteStateConsumers mocks base method. +func (m *MockWorkspaces) ListRemoteStateConsumers(ctx context.Context, workspaceID string, options *tfe.RemoteStateConsumersListOptions) (*tfe.WorkspaceList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRemoteStateConsumers", ctx, workspaceID, options) + ret0, _ := ret[0].(*tfe.WorkspaceList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRemoteStateConsumers indicates an expected call of ListRemoteStateConsumers. +func (mr *MockWorkspacesMockRecorder) ListRemoteStateConsumers(ctx, workspaceID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRemoteStateConsumers", reflect.TypeOf((*MockWorkspaces)(nil).ListRemoteStateConsumers), ctx, workspaceID, options) +} + +// ListTags mocks base method. +func (m *MockWorkspaces) ListTags(ctx context.Context, workspaceID string, options *tfe.WorkspaceTagListOptions) (*tfe.TagList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTags", ctx, workspaceID, options) + ret0, _ := ret[0].(*tfe.TagList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTags indicates an expected call of ListTags. +func (mr *MockWorkspacesMockRecorder) ListTags(ctx, workspaceID, options interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockWorkspaces)(nil).ListTags), ctx, workspaceID, options) +} + // Lock mocks base method. func (m *MockWorkspaces) Lock(ctx context.Context, workspaceID string, options tfe.WorkspaceLockOptions) (*tfe.Workspace, error) { m.ctrl.T.Helper() @@ -242,21 +272,6 @@ func (mr *MockWorkspacesMockRecorder) Readme(ctx, workspaceID interface{}) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Readme", reflect.TypeOf((*MockWorkspaces)(nil).Readme), ctx, workspaceID) } -// RemoteStateConsumers mocks base method. -func (m *MockWorkspaces) RemoteStateConsumers(ctx context.Context, workspaceID string, options *tfe.RemoteStateConsumersListOptions) (*tfe.WorkspaceList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoteStateConsumers", ctx, workspaceID, options) - ret0, _ := ret[0].(*tfe.WorkspaceList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoteStateConsumers indicates an expected call of RemoteStateConsumers. -func (mr *MockWorkspacesMockRecorder) RemoteStateConsumers(ctx, workspaceID, options interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteStateConsumers", reflect.TypeOf((*MockWorkspaces)(nil).RemoteStateConsumers), ctx, workspaceID, options) -} - // RemoveRemoteStateConsumers mocks base method. func (m *MockWorkspaces) RemoveRemoteStateConsumers(ctx context.Context, workspaceID string, options tfe.WorkspaceRemoveRemoteStateConsumersOptions) error { m.ctrl.T.Helper() @@ -315,21 +330,6 @@ func (mr *MockWorkspacesMockRecorder) RemoveVCSConnectionByID(ctx, workspaceID i return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVCSConnectionByID", reflect.TypeOf((*MockWorkspaces)(nil).RemoveVCSConnectionByID), ctx, workspaceID) } -// Tags mocks base method. -func (m *MockWorkspaces) Tags(ctx context.Context, workspaceID string, options *tfe.WorkspaceTagListOptions) (*tfe.TagList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Tags", ctx, workspaceID, options) - ret0, _ := ret[0].(*tfe.TagList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Tags indicates an expected call of Tags. -func (mr *MockWorkspacesMockRecorder) Tags(ctx, workspaceID, options interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tags", reflect.TypeOf((*MockWorkspaces)(nil).Tags), ctx, workspaceID, options) -} - // UnassignSSHKey mocks base method. func (m *MockWorkspaces) UnassignSSHKey(ctx context.Context, workspaceID string) (*tfe.Workspace, error) { m.ctrl.T.Helper()