diff --git a/.github/workflows/integration-test.yml b/.github/workflows/integration-test.yml index e5109b6..8cffd57 100644 --- a/.github/workflows/integration-test.yml +++ b/.github/workflows/integration-test.yml @@ -32,7 +32,7 @@ jobs: run: | echo "Cleaning up any orphaned test workspaces..." # List all workspaces and delete any with test name prefixes - ./cs list workspaces -t $CS_TEAM_ID | grep -E "cli-(test|git-test|pipeline-test|log-test|sync-test|open-test|setenv-test|edge-test)-" | awk '{print $2}' | while read ws_id; do + ./cs list workspaces -t $CS_TEAM_ID | grep -E "cli-(test|git-test|pipeline-test|log-test|sync-test|open-test|setenv-test|edge-test|wakeup-test|curl-test)-" | awk '{print $2}' | while read ws_id; do if [ ! -z "$ws_id" ]; then echo "Deleting orphaned workspace: $ws_id" ./cs delete workspace -w $ws_id --yes || true diff --git a/.mockery.yml b/.mockery.yml index 17a686d..c1fe4a6 100644 --- a/.mockery.yml +++ b/.mockery.yml @@ -25,7 +25,6 @@ packages: github.com/codesphere-cloud/cs-go/api/openapi_client: config: all: true - include-auto-generated: true interfaces: github.com/codesphere-cloud/cs-go/api: config: diff --git a/api/openapi_client/mocks.go b/api/openapi_client/mocks.go index 9b0a61b..8e1cd3b 100644 --- a/api/openapi_client/mocks.go +++ b/api/openapi_client/mocks.go @@ -60,32 +60,16 @@ type MockDomainsAPI_DomainsCreateDomain_Call struct { } // DomainsCreateDomain is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsCreateDomain(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsCreateDomain_Call { return &MockDomainsAPI_DomainsCreateDomain_Call{Call: _e.mock.On("DomainsCreateDomain", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsCreateDomain_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsCreateDomain_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -142,20 +126,14 @@ type MockDomainsAPI_DomainsCreateDomainExecute_Call struct { } // DomainsCreateDomainExecute is a helper method to define mock.On call -// - r ApiDomainsCreateDomainRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsCreateDomainExecute(r interface{}) *MockDomainsAPI_DomainsCreateDomainExecute_Call { return &MockDomainsAPI_DomainsCreateDomainExecute_Call{Call: _e.mock.On("DomainsCreateDomainExecute", r)} } func (_c *MockDomainsAPI_DomainsCreateDomainExecute_Call) Run(run func(r ApiDomainsCreateDomainRequest)) *MockDomainsAPI_DomainsCreateDomainExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsCreateDomainRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsCreateDomainRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsCreateDomainRequest)) }) return _c } @@ -193,32 +171,16 @@ type MockDomainsAPI_DomainsDeleteDomain_Call struct { } // DomainsDeleteDomain is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsDeleteDomain(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsDeleteDomain_Call { return &MockDomainsAPI_DomainsDeleteDomain_Call{Call: _e.mock.On("DomainsDeleteDomain", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsDeleteDomain_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsDeleteDomain_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -267,20 +229,14 @@ type MockDomainsAPI_DomainsDeleteDomainExecute_Call struct { } // DomainsDeleteDomainExecute is a helper method to define mock.On call -// - r ApiDomainsDeleteDomainRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsDeleteDomainExecute(r interface{}) *MockDomainsAPI_DomainsDeleteDomainExecute_Call { return &MockDomainsAPI_DomainsDeleteDomainExecute_Call{Call: _e.mock.On("DomainsDeleteDomainExecute", r)} } func (_c *MockDomainsAPI_DomainsDeleteDomainExecute_Call) Run(run func(r ApiDomainsDeleteDomainRequest)) *MockDomainsAPI_DomainsDeleteDomainExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsDeleteDomainRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsDeleteDomainRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsDeleteDomainRequest)) }) return _c } @@ -318,32 +274,16 @@ type MockDomainsAPI_DomainsGetDomain_Call struct { } // DomainsGetDomain is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsGetDomain(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsGetDomain_Call { return &MockDomainsAPI_DomainsGetDomain_Call{Call: _e.mock.On("DomainsGetDomain", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsGetDomain_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsGetDomain_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -400,20 +340,14 @@ type MockDomainsAPI_DomainsGetDomainExecute_Call struct { } // DomainsGetDomainExecute is a helper method to define mock.On call -// - r ApiDomainsGetDomainRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsGetDomainExecute(r interface{}) *MockDomainsAPI_DomainsGetDomainExecute_Call { return &MockDomainsAPI_DomainsGetDomainExecute_Call{Call: _e.mock.On("DomainsGetDomainExecute", r)} } func (_c *MockDomainsAPI_DomainsGetDomainExecute_Call) Run(run func(r ApiDomainsGetDomainRequest)) *MockDomainsAPI_DomainsGetDomainExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsGetDomainRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsGetDomainRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsGetDomainRequest)) }) return _c } @@ -451,26 +385,15 @@ type MockDomainsAPI_DomainsListDomains_Call struct { } // DomainsListDomains is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 +// - ctx +// - teamId func (_e *MockDomainsAPI_Expecter) DomainsListDomains(ctx interface{}, teamId interface{}) *MockDomainsAPI_DomainsListDomains_Call { return &MockDomainsAPI_DomainsListDomains_Call{Call: _e.mock.On("DomainsListDomains", ctx, teamId)} } func (_c *MockDomainsAPI_DomainsListDomains_Call) Run(run func(ctx context.Context, teamId float32)) *MockDomainsAPI_DomainsListDomains_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -527,20 +450,14 @@ type MockDomainsAPI_DomainsListDomainsExecute_Call struct { } // DomainsListDomainsExecute is a helper method to define mock.On call -// - r ApiDomainsListDomainsRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsListDomainsExecute(r interface{}) *MockDomainsAPI_DomainsListDomainsExecute_Call { return &MockDomainsAPI_DomainsListDomainsExecute_Call{Call: _e.mock.On("DomainsListDomainsExecute", r)} } func (_c *MockDomainsAPI_DomainsListDomainsExecute_Call) Run(run func(r ApiDomainsListDomainsRequest)) *MockDomainsAPI_DomainsListDomainsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsListDomainsRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsListDomainsRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsListDomainsRequest)) }) return _c } @@ -578,32 +495,16 @@ type MockDomainsAPI_DomainsUpdateDomain_Call struct { } // DomainsUpdateDomain is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsUpdateDomain(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsUpdateDomain_Call { return &MockDomainsAPI_DomainsUpdateDomain_Call{Call: _e.mock.On("DomainsUpdateDomain", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsUpdateDomain_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsUpdateDomain_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -660,20 +561,14 @@ type MockDomainsAPI_DomainsUpdateDomainExecute_Call struct { } // DomainsUpdateDomainExecute is a helper method to define mock.On call -// - r ApiDomainsUpdateDomainRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsUpdateDomainExecute(r interface{}) *MockDomainsAPI_DomainsUpdateDomainExecute_Call { return &MockDomainsAPI_DomainsUpdateDomainExecute_Call{Call: _e.mock.On("DomainsUpdateDomainExecute", r)} } func (_c *MockDomainsAPI_DomainsUpdateDomainExecute_Call) Run(run func(r ApiDomainsUpdateDomainRequest)) *MockDomainsAPI_DomainsUpdateDomainExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsUpdateDomainRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsUpdateDomainRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsUpdateDomainRequest)) }) return _c } @@ -711,32 +606,16 @@ type MockDomainsAPI_DomainsUpdateWorkspaceConnections_Call struct { } // DomainsUpdateWorkspaceConnections is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsUpdateWorkspaceConnections(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsUpdateWorkspaceConnections_Call { return &MockDomainsAPI_DomainsUpdateWorkspaceConnections_Call{Call: _e.mock.On("DomainsUpdateWorkspaceConnections", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsUpdateWorkspaceConnections_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsUpdateWorkspaceConnections_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -793,20 +672,14 @@ type MockDomainsAPI_DomainsUpdateWorkspaceConnectionsExecute_Call struct { } // DomainsUpdateWorkspaceConnectionsExecute is a helper method to define mock.On call -// - r ApiDomainsUpdateWorkspaceConnectionsRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsUpdateWorkspaceConnectionsExecute(r interface{}) *MockDomainsAPI_DomainsUpdateWorkspaceConnectionsExecute_Call { return &MockDomainsAPI_DomainsUpdateWorkspaceConnectionsExecute_Call{Call: _e.mock.On("DomainsUpdateWorkspaceConnectionsExecute", r)} } func (_c *MockDomainsAPI_DomainsUpdateWorkspaceConnectionsExecute_Call) Run(run func(r ApiDomainsUpdateWorkspaceConnectionsRequest)) *MockDomainsAPI_DomainsUpdateWorkspaceConnectionsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsUpdateWorkspaceConnectionsRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsUpdateWorkspaceConnectionsRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsUpdateWorkspaceConnectionsRequest)) }) return _c } @@ -844,32 +717,16 @@ type MockDomainsAPI_DomainsVerifyDomain_Call struct { } // DomainsVerifyDomain is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - domainName string +// - ctx +// - teamId +// - domainName func (_e *MockDomainsAPI_Expecter) DomainsVerifyDomain(ctx interface{}, teamId interface{}, domainName interface{}) *MockDomainsAPI_DomainsVerifyDomain_Call { return &MockDomainsAPI_DomainsVerifyDomain_Call{Call: _e.mock.On("DomainsVerifyDomain", ctx, teamId, domainName)} } func (_c *MockDomainsAPI_DomainsVerifyDomain_Call) Run(run func(ctx context.Context, teamId float32, domainName string)) *MockDomainsAPI_DomainsVerifyDomain_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -926,20 +783,14 @@ type MockDomainsAPI_DomainsVerifyDomainExecute_Call struct { } // DomainsVerifyDomainExecute is a helper method to define mock.On call -// - r ApiDomainsVerifyDomainRequest +// - r func (_e *MockDomainsAPI_Expecter) DomainsVerifyDomainExecute(r interface{}) *MockDomainsAPI_DomainsVerifyDomainExecute_Call { return &MockDomainsAPI_DomainsVerifyDomainExecute_Call{Call: _e.mock.On("DomainsVerifyDomainExecute", r)} } func (_c *MockDomainsAPI_DomainsVerifyDomainExecute_Call) Run(run func(r ApiDomainsVerifyDomainRequest)) *MockDomainsAPI_DomainsVerifyDomainExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiDomainsVerifyDomainRequest - if args[0] != nil { - arg0 = args[0].(ApiDomainsVerifyDomainRequest) - } - run( - arg0, - ) + run(args[0].(ApiDomainsVerifyDomainRequest)) }) return _c } @@ -1004,20 +855,14 @@ type MockMetadataAPI_MetadataGetDatacenters_Call struct { } // MetadataGetDatacenters is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockMetadataAPI_Expecter) MetadataGetDatacenters(ctx interface{}) *MockMetadataAPI_MetadataGetDatacenters_Call { return &MockMetadataAPI_MetadataGetDatacenters_Call{Call: _e.mock.On("MetadataGetDatacenters", ctx)} } func (_c *MockMetadataAPI_MetadataGetDatacenters_Call) Run(run func(ctx context.Context)) *MockMetadataAPI_MetadataGetDatacenters_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -1074,20 +919,14 @@ type MockMetadataAPI_MetadataGetDatacentersExecute_Call struct { } // MetadataGetDatacentersExecute is a helper method to define mock.On call -// - r ApiMetadataGetDatacentersRequest +// - r func (_e *MockMetadataAPI_Expecter) MetadataGetDatacentersExecute(r interface{}) *MockMetadataAPI_MetadataGetDatacentersExecute_Call { return &MockMetadataAPI_MetadataGetDatacentersExecute_Call{Call: _e.mock.On("MetadataGetDatacentersExecute", r)} } func (_c *MockMetadataAPI_MetadataGetDatacentersExecute_Call) Run(run func(r ApiMetadataGetDatacentersRequest)) *MockMetadataAPI_MetadataGetDatacentersExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiMetadataGetDatacentersRequest - if args[0] != nil { - arg0 = args[0].(ApiMetadataGetDatacentersRequest) - } - run( - arg0, - ) + run(args[0].(ApiMetadataGetDatacentersRequest)) }) return _c } @@ -1125,20 +964,14 @@ type MockMetadataAPI_MetadataGetWorkspaceBaseImages_Call struct { } // MetadataGetWorkspaceBaseImages is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockMetadataAPI_Expecter) MetadataGetWorkspaceBaseImages(ctx interface{}) *MockMetadataAPI_MetadataGetWorkspaceBaseImages_Call { return &MockMetadataAPI_MetadataGetWorkspaceBaseImages_Call{Call: _e.mock.On("MetadataGetWorkspaceBaseImages", ctx)} } func (_c *MockMetadataAPI_MetadataGetWorkspaceBaseImages_Call) Run(run func(ctx context.Context)) *MockMetadataAPI_MetadataGetWorkspaceBaseImages_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -1195,20 +1028,14 @@ type MockMetadataAPI_MetadataGetWorkspaceBaseImagesExecute_Call struct { } // MetadataGetWorkspaceBaseImagesExecute is a helper method to define mock.On call -// - r ApiMetadataGetWorkspaceBaseImagesRequest +// - r func (_e *MockMetadataAPI_Expecter) MetadataGetWorkspaceBaseImagesExecute(r interface{}) *MockMetadataAPI_MetadataGetWorkspaceBaseImagesExecute_Call { return &MockMetadataAPI_MetadataGetWorkspaceBaseImagesExecute_Call{Call: _e.mock.On("MetadataGetWorkspaceBaseImagesExecute", r)} } func (_c *MockMetadataAPI_MetadataGetWorkspaceBaseImagesExecute_Call) Run(run func(r ApiMetadataGetWorkspaceBaseImagesRequest)) *MockMetadataAPI_MetadataGetWorkspaceBaseImagesExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiMetadataGetWorkspaceBaseImagesRequest - if args[0] != nil { - arg0 = args[0].(ApiMetadataGetWorkspaceBaseImagesRequest) - } - run( - arg0, - ) + run(args[0].(ApiMetadataGetWorkspaceBaseImagesRequest)) }) return _c } @@ -1246,20 +1073,14 @@ type MockMetadataAPI_MetadataGetWorkspacePlans_Call struct { } // MetadataGetWorkspacePlans is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockMetadataAPI_Expecter) MetadataGetWorkspacePlans(ctx interface{}) *MockMetadataAPI_MetadataGetWorkspacePlans_Call { return &MockMetadataAPI_MetadataGetWorkspacePlans_Call{Call: _e.mock.On("MetadataGetWorkspacePlans", ctx)} } func (_c *MockMetadataAPI_MetadataGetWorkspacePlans_Call) Run(run func(ctx context.Context)) *MockMetadataAPI_MetadataGetWorkspacePlans_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -1316,20 +1137,14 @@ type MockMetadataAPI_MetadataGetWorkspacePlansExecute_Call struct { } // MetadataGetWorkspacePlansExecute is a helper method to define mock.On call -// - r ApiMetadataGetWorkspacePlansRequest +// - r func (_e *MockMetadataAPI_Expecter) MetadataGetWorkspacePlansExecute(r interface{}) *MockMetadataAPI_MetadataGetWorkspacePlansExecute_Call { return &MockMetadataAPI_MetadataGetWorkspacePlansExecute_Call{Call: _e.mock.On("MetadataGetWorkspacePlansExecute", r)} } func (_c *MockMetadataAPI_MetadataGetWorkspacePlansExecute_Call) Run(run func(r ApiMetadataGetWorkspacePlansRequest)) *MockMetadataAPI_MetadataGetWorkspacePlansExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiMetadataGetWorkspacePlansRequest - if args[0] != nil { - arg0 = args[0].(ApiMetadataGetWorkspacePlansRequest) - } - run( - arg0, - ) + run(args[0].(ApiMetadataGetWorkspacePlansRequest)) }) return _c } @@ -1394,20 +1209,14 @@ type MockTeamsAPI_TeamsCreateTeam_Call struct { } // TeamsCreateTeam is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockTeamsAPI_Expecter) TeamsCreateTeam(ctx interface{}) *MockTeamsAPI_TeamsCreateTeam_Call { return &MockTeamsAPI_TeamsCreateTeam_Call{Call: _e.mock.On("TeamsCreateTeam", ctx)} } func (_c *MockTeamsAPI_TeamsCreateTeam_Call) Run(run func(ctx context.Context)) *MockTeamsAPI_TeamsCreateTeam_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -1464,20 +1273,14 @@ type MockTeamsAPI_TeamsCreateTeamExecute_Call struct { } // TeamsCreateTeamExecute is a helper method to define mock.On call -// - r ApiTeamsCreateTeamRequest +// - r func (_e *MockTeamsAPI_Expecter) TeamsCreateTeamExecute(r interface{}) *MockTeamsAPI_TeamsCreateTeamExecute_Call { return &MockTeamsAPI_TeamsCreateTeamExecute_Call{Call: _e.mock.On("TeamsCreateTeamExecute", r)} } func (_c *MockTeamsAPI_TeamsCreateTeamExecute_Call) Run(run func(r ApiTeamsCreateTeamRequest)) *MockTeamsAPI_TeamsCreateTeamExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiTeamsCreateTeamRequest - if args[0] != nil { - arg0 = args[0].(ApiTeamsCreateTeamRequest) - } - run( - arg0, - ) + run(args[0].(ApiTeamsCreateTeamRequest)) }) return _c } @@ -1515,26 +1318,15 @@ type MockTeamsAPI_TeamsDeleteTeam_Call struct { } // TeamsDeleteTeam is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 +// - ctx +// - teamId func (_e *MockTeamsAPI_Expecter) TeamsDeleteTeam(ctx interface{}, teamId interface{}) *MockTeamsAPI_TeamsDeleteTeam_Call { return &MockTeamsAPI_TeamsDeleteTeam_Call{Call: _e.mock.On("TeamsDeleteTeam", ctx, teamId)} } func (_c *MockTeamsAPI_TeamsDeleteTeam_Call) Run(run func(ctx context.Context, teamId float32)) *MockTeamsAPI_TeamsDeleteTeam_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -1583,20 +1375,14 @@ type MockTeamsAPI_TeamsDeleteTeamExecute_Call struct { } // TeamsDeleteTeamExecute is a helper method to define mock.On call -// - r ApiTeamsDeleteTeamRequest +// - r func (_e *MockTeamsAPI_Expecter) TeamsDeleteTeamExecute(r interface{}) *MockTeamsAPI_TeamsDeleteTeamExecute_Call { return &MockTeamsAPI_TeamsDeleteTeamExecute_Call{Call: _e.mock.On("TeamsDeleteTeamExecute", r)} } func (_c *MockTeamsAPI_TeamsDeleteTeamExecute_Call) Run(run func(r ApiTeamsDeleteTeamRequest)) *MockTeamsAPI_TeamsDeleteTeamExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiTeamsDeleteTeamRequest - if args[0] != nil { - arg0 = args[0].(ApiTeamsDeleteTeamRequest) - } - run( - arg0, - ) + run(args[0].(ApiTeamsDeleteTeamRequest)) }) return _c } @@ -1634,26 +1420,15 @@ type MockTeamsAPI_TeamsGetTeam_Call struct { } // TeamsGetTeam is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 +// - ctx +// - teamId func (_e *MockTeamsAPI_Expecter) TeamsGetTeam(ctx interface{}, teamId interface{}) *MockTeamsAPI_TeamsGetTeam_Call { return &MockTeamsAPI_TeamsGetTeam_Call{Call: _e.mock.On("TeamsGetTeam", ctx, teamId)} } func (_c *MockTeamsAPI_TeamsGetTeam_Call) Run(run func(ctx context.Context, teamId float32)) *MockTeamsAPI_TeamsGetTeam_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -1710,20 +1485,14 @@ type MockTeamsAPI_TeamsGetTeamExecute_Call struct { } // TeamsGetTeamExecute is a helper method to define mock.On call -// - r ApiTeamsGetTeamRequest +// - r func (_e *MockTeamsAPI_Expecter) TeamsGetTeamExecute(r interface{}) *MockTeamsAPI_TeamsGetTeamExecute_Call { return &MockTeamsAPI_TeamsGetTeamExecute_Call{Call: _e.mock.On("TeamsGetTeamExecute", r)} } func (_c *MockTeamsAPI_TeamsGetTeamExecute_Call) Run(run func(r ApiTeamsGetTeamRequest)) *MockTeamsAPI_TeamsGetTeamExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiTeamsGetTeamRequest - if args[0] != nil { - arg0 = args[0].(ApiTeamsGetTeamRequest) - } - run( - arg0, - ) + run(args[0].(ApiTeamsGetTeamRequest)) }) return _c } @@ -1761,20 +1530,14 @@ type MockTeamsAPI_TeamsListTeams_Call struct { } // TeamsListTeams is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockTeamsAPI_Expecter) TeamsListTeams(ctx interface{}) *MockTeamsAPI_TeamsListTeams_Call { return &MockTeamsAPI_TeamsListTeams_Call{Call: _e.mock.On("TeamsListTeams", ctx)} } func (_c *MockTeamsAPI_TeamsListTeams_Call) Run(run func(ctx context.Context)) *MockTeamsAPI_TeamsListTeams_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -1831,20 +1594,14 @@ type MockTeamsAPI_TeamsListTeamsExecute_Call struct { } // TeamsListTeamsExecute is a helper method to define mock.On call -// - r ApiTeamsListTeamsRequest +// - r func (_e *MockTeamsAPI_Expecter) TeamsListTeamsExecute(r interface{}) *MockTeamsAPI_TeamsListTeamsExecute_Call { return &MockTeamsAPI_TeamsListTeamsExecute_Call{Call: _e.mock.On("TeamsListTeamsExecute", r)} } func (_c *MockTeamsAPI_TeamsListTeamsExecute_Call) Run(run func(r ApiTeamsListTeamsRequest)) *MockTeamsAPI_TeamsListTeamsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiTeamsListTeamsRequest - if args[0] != nil { - arg0 = args[0].(ApiTeamsListTeamsRequest) - } - run( - arg0, - ) + run(args[0].(ApiTeamsListTeamsRequest)) }) return _c } @@ -1909,32 +1666,16 @@ type MockUsageAPI_UsageGetLandscapeServiceEvents_Call struct { } // UsageGetLandscapeServiceEvents is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 -// - resourceId string +// - ctx +// - teamId +// - resourceId func (_e *MockUsageAPI_Expecter) UsageGetLandscapeServiceEvents(ctx interface{}, teamId interface{}, resourceId interface{}) *MockUsageAPI_UsageGetLandscapeServiceEvents_Call { return &MockUsageAPI_UsageGetLandscapeServiceEvents_Call{Call: _e.mock.On("UsageGetLandscapeServiceEvents", ctx, teamId, resourceId)} } func (_c *MockUsageAPI_UsageGetLandscapeServiceEvents_Call) Run(run func(ctx context.Context, teamId float32, resourceId string)) *MockUsageAPI_UsageGetLandscapeServiceEvents_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -1991,20 +1732,14 @@ type MockUsageAPI_UsageGetLandscapeServiceEventsExecute_Call struct { } // UsageGetLandscapeServiceEventsExecute is a helper method to define mock.On call -// - r ApiUsageGetLandscapeServiceEventsRequest +// - r func (_e *MockUsageAPI_Expecter) UsageGetLandscapeServiceEventsExecute(r interface{}) *MockUsageAPI_UsageGetLandscapeServiceEventsExecute_Call { return &MockUsageAPI_UsageGetLandscapeServiceEventsExecute_Call{Call: _e.mock.On("UsageGetLandscapeServiceEventsExecute", r)} } func (_c *MockUsageAPI_UsageGetLandscapeServiceEventsExecute_Call) Run(run func(r ApiUsageGetLandscapeServiceEventsRequest)) *MockUsageAPI_UsageGetLandscapeServiceEventsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiUsageGetLandscapeServiceEventsRequest - if args[0] != nil { - arg0 = args[0].(ApiUsageGetLandscapeServiceEventsRequest) - } - run( - arg0, - ) + run(args[0].(ApiUsageGetLandscapeServiceEventsRequest)) }) return _c } @@ -2042,26 +1777,15 @@ type MockUsageAPI_UsageGetUsageSummaryLandscape_Call struct { } // UsageGetUsageSummaryLandscape is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 +// - ctx +// - teamId func (_e *MockUsageAPI_Expecter) UsageGetUsageSummaryLandscape(ctx interface{}, teamId interface{}) *MockUsageAPI_UsageGetUsageSummaryLandscape_Call { return &MockUsageAPI_UsageGetUsageSummaryLandscape_Call{Call: _e.mock.On("UsageGetUsageSummaryLandscape", ctx, teamId)} } func (_c *MockUsageAPI_UsageGetUsageSummaryLandscape_Call) Run(run func(ctx context.Context, teamId float32)) *MockUsageAPI_UsageGetUsageSummaryLandscape_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -2118,20 +1842,14 @@ type MockUsageAPI_UsageGetUsageSummaryLandscapeExecute_Call struct { } // UsageGetUsageSummaryLandscapeExecute is a helper method to define mock.On call -// - r ApiUsageGetUsageSummaryLandscapeRequest +// - r func (_e *MockUsageAPI_Expecter) UsageGetUsageSummaryLandscapeExecute(r interface{}) *MockUsageAPI_UsageGetUsageSummaryLandscapeExecute_Call { return &MockUsageAPI_UsageGetUsageSummaryLandscapeExecute_Call{Call: _e.mock.On("UsageGetUsageSummaryLandscapeExecute", r)} } func (_c *MockUsageAPI_UsageGetUsageSummaryLandscapeExecute_Call) Run(run func(r ApiUsageGetUsageSummaryLandscapeRequest)) *MockUsageAPI_UsageGetUsageSummaryLandscapeExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiUsageGetUsageSummaryLandscapeRequest - if args[0] != nil { - arg0 = args[0].(ApiUsageGetUsageSummaryLandscapeRequest) - } - run( - arg0, - ) + run(args[0].(ApiUsageGetUsageSummaryLandscapeRequest)) }) return _c } @@ -2196,20 +1914,14 @@ type MockWorkspacesAPI_WorkspacesCreateWorkspace_Call struct { } // WorkspacesCreateWorkspace is a helper method to define mock.On call -// - ctx context.Context +// - ctx func (_e *MockWorkspacesAPI_Expecter) WorkspacesCreateWorkspace(ctx interface{}) *MockWorkspacesAPI_WorkspacesCreateWorkspace_Call { return &MockWorkspacesAPI_WorkspacesCreateWorkspace_Call{Call: _e.mock.On("WorkspacesCreateWorkspace", ctx)} } func (_c *MockWorkspacesAPI_WorkspacesCreateWorkspace_Call) Run(run func(ctx context.Context)) *MockWorkspacesAPI_WorkspacesCreateWorkspace_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - run( - arg0, - ) + run(args[0].(context.Context)) }) return _c } @@ -2266,20 +1978,14 @@ type MockWorkspacesAPI_WorkspacesCreateWorkspaceExecute_Call struct { } // WorkspacesCreateWorkspaceExecute is a helper method to define mock.On call -// - r ApiWorkspacesCreateWorkspaceRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesCreateWorkspaceExecute(r interface{}) *MockWorkspacesAPI_WorkspacesCreateWorkspaceExecute_Call { return &MockWorkspacesAPI_WorkspacesCreateWorkspaceExecute_Call{Call: _e.mock.On("WorkspacesCreateWorkspaceExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesCreateWorkspaceExecute_Call) Run(run func(r ApiWorkspacesCreateWorkspaceRequest)) *MockWorkspacesAPI_WorkspacesCreateWorkspaceExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesCreateWorkspaceRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesCreateWorkspaceRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesCreateWorkspaceRequest)) }) return _c } @@ -2317,26 +2023,15 @@ type MockWorkspacesAPI_WorkspacesDeleteEnvVar_Call struct { } // WorkspacesDeleteEnvVar is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeleteEnvVar(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesDeleteEnvVar_Call { return &MockWorkspacesAPI_WorkspacesDeleteEnvVar_Call{Call: _e.mock.On("WorkspacesDeleteEnvVar", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesDeleteEnvVar_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesDeleteEnvVar_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -2385,20 +2080,14 @@ type MockWorkspacesAPI_WorkspacesDeleteEnvVarExecute_Call struct { } // WorkspacesDeleteEnvVarExecute is a helper method to define mock.On call -// - r ApiWorkspacesDeleteEnvVarRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeleteEnvVarExecute(r interface{}) *MockWorkspacesAPI_WorkspacesDeleteEnvVarExecute_Call { return &MockWorkspacesAPI_WorkspacesDeleteEnvVarExecute_Call{Call: _e.mock.On("WorkspacesDeleteEnvVarExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesDeleteEnvVarExecute_Call) Run(run func(r ApiWorkspacesDeleteEnvVarRequest)) *MockWorkspacesAPI_WorkspacesDeleteEnvVarExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesDeleteEnvVarRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesDeleteEnvVarRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesDeleteEnvVarRequest)) }) return _c } @@ -2436,26 +2125,15 @@ type MockWorkspacesAPI_WorkspacesDeleteWorkspace_Call struct { } // WorkspacesDeleteWorkspace is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeleteWorkspace(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesDeleteWorkspace_Call { return &MockWorkspacesAPI_WorkspacesDeleteWorkspace_Call{Call: _e.mock.On("WorkspacesDeleteWorkspace", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesDeleteWorkspace_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesDeleteWorkspace_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -2504,20 +2182,14 @@ type MockWorkspacesAPI_WorkspacesDeleteWorkspaceExecute_Call struct { } // WorkspacesDeleteWorkspaceExecute is a helper method to define mock.On call -// - r ApiWorkspacesDeleteWorkspaceRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeleteWorkspaceExecute(r interface{}) *MockWorkspacesAPI_WorkspacesDeleteWorkspaceExecute_Call { return &MockWorkspacesAPI_WorkspacesDeleteWorkspaceExecute_Call{Call: _e.mock.On("WorkspacesDeleteWorkspaceExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesDeleteWorkspaceExecute_Call) Run(run func(r ApiWorkspacesDeleteWorkspaceRequest)) *MockWorkspacesAPI_WorkspacesDeleteWorkspaceExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesDeleteWorkspaceRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesDeleteWorkspaceRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesDeleteWorkspaceRequest)) }) return _c } @@ -2555,26 +2227,15 @@ type MockWorkspacesAPI_WorkspacesDeployLandscape_Call struct { } // WorkspacesDeployLandscape is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeployLandscape(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesDeployLandscape_Call { return &MockWorkspacesAPI_WorkspacesDeployLandscape_Call{Call: _e.mock.On("WorkspacesDeployLandscape", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesDeployLandscape_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesDeployLandscape_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -2612,32 +2273,16 @@ type MockWorkspacesAPI_WorkspacesDeployLandscape1_Call struct { } // WorkspacesDeployLandscape1 is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - profile string +// - ctx +// - workspaceId +// - profile func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeployLandscape1(ctx interface{}, workspaceId interface{}, profile interface{}) *MockWorkspacesAPI_WorkspacesDeployLandscape1_Call { return &MockWorkspacesAPI_WorkspacesDeployLandscape1_Call{Call: _e.mock.On("WorkspacesDeployLandscape1", ctx, workspaceId, profile)} } func (_c *MockWorkspacesAPI_WorkspacesDeployLandscape1_Call) Run(run func(ctx context.Context, workspaceId float32, profile string)) *MockWorkspacesAPI_WorkspacesDeployLandscape1_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -2686,20 +2331,14 @@ type MockWorkspacesAPI_WorkspacesDeployLandscape1Execute_Call struct { } // WorkspacesDeployLandscape1Execute is a helper method to define mock.On call -// - r ApiWorkspacesDeployLandscape1Request +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeployLandscape1Execute(r interface{}) *MockWorkspacesAPI_WorkspacesDeployLandscape1Execute_Call { return &MockWorkspacesAPI_WorkspacesDeployLandscape1Execute_Call{Call: _e.mock.On("WorkspacesDeployLandscape1Execute", r)} } func (_c *MockWorkspacesAPI_WorkspacesDeployLandscape1Execute_Call) Run(run func(r ApiWorkspacesDeployLandscape1Request)) *MockWorkspacesAPI_WorkspacesDeployLandscape1Execute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesDeployLandscape1Request - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesDeployLandscape1Request) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesDeployLandscape1Request)) }) return _c } @@ -2748,20 +2387,14 @@ type MockWorkspacesAPI_WorkspacesDeployLandscapeExecute_Call struct { } // WorkspacesDeployLandscapeExecute is a helper method to define mock.On call -// - r ApiWorkspacesDeployLandscapeRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesDeployLandscapeExecute(r interface{}) *MockWorkspacesAPI_WorkspacesDeployLandscapeExecute_Call { return &MockWorkspacesAPI_WorkspacesDeployLandscapeExecute_Call{Call: _e.mock.On("WorkspacesDeployLandscapeExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesDeployLandscapeExecute_Call) Run(run func(r ApiWorkspacesDeployLandscapeRequest)) *MockWorkspacesAPI_WorkspacesDeployLandscapeExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesDeployLandscapeRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesDeployLandscapeRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesDeployLandscapeRequest)) }) return _c } @@ -2799,26 +2432,15 @@ type MockWorkspacesAPI_WorkspacesExecuteCommand_Call struct { } // WorkspacesExecuteCommand is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesExecuteCommand(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesExecuteCommand_Call { return &MockWorkspacesAPI_WorkspacesExecuteCommand_Call{Call: _e.mock.On("WorkspacesExecuteCommand", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesExecuteCommand_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesExecuteCommand_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -2875,20 +2497,14 @@ type MockWorkspacesAPI_WorkspacesExecuteCommandExecute_Call struct { } // WorkspacesExecuteCommandExecute is a helper method to define mock.On call -// - r ApiWorkspacesExecuteCommandRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesExecuteCommandExecute(r interface{}) *MockWorkspacesAPI_WorkspacesExecuteCommandExecute_Call { return &MockWorkspacesAPI_WorkspacesExecuteCommandExecute_Call{Call: _e.mock.On("WorkspacesExecuteCommandExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesExecuteCommandExecute_Call) Run(run func(r ApiWorkspacesExecuteCommandRequest)) *MockWorkspacesAPI_WorkspacesExecuteCommandExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesExecuteCommandRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesExecuteCommandRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesExecuteCommandRequest)) }) return _c } @@ -2926,26 +2542,15 @@ type MockWorkspacesAPI_WorkspacesGetWorkspace_Call struct { } // WorkspacesGetWorkspace is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesGetWorkspace(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesGetWorkspace_Call { return &MockWorkspacesAPI_WorkspacesGetWorkspace_Call{Call: _e.mock.On("WorkspacesGetWorkspace", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesGetWorkspace_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesGetWorkspace_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3002,20 +2607,14 @@ type MockWorkspacesAPI_WorkspacesGetWorkspaceExecute_Call struct { } // WorkspacesGetWorkspaceExecute is a helper method to define mock.On call -// - r ApiWorkspacesGetWorkspaceRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGetWorkspaceExecute(r interface{}) *MockWorkspacesAPI_WorkspacesGetWorkspaceExecute_Call { return &MockWorkspacesAPI_WorkspacesGetWorkspaceExecute_Call{Call: _e.mock.On("WorkspacesGetWorkspaceExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGetWorkspaceExecute_Call) Run(run func(r ApiWorkspacesGetWorkspaceRequest)) *MockWorkspacesAPI_WorkspacesGetWorkspaceExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGetWorkspaceRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGetWorkspaceRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGetWorkspaceRequest)) }) return _c } @@ -3053,26 +2652,15 @@ type MockWorkspacesAPI_WorkspacesGetWorkspaceStatus_Call struct { } // WorkspacesGetWorkspaceStatus is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesGetWorkspaceStatus(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesGetWorkspaceStatus_Call { return &MockWorkspacesAPI_WorkspacesGetWorkspaceStatus_Call{Call: _e.mock.On("WorkspacesGetWorkspaceStatus", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesGetWorkspaceStatus_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesGetWorkspaceStatus_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3129,20 +2717,14 @@ type MockWorkspacesAPI_WorkspacesGetWorkspaceStatusExecute_Call struct { } // WorkspacesGetWorkspaceStatusExecute is a helper method to define mock.On call -// - r ApiWorkspacesGetWorkspaceStatusRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGetWorkspaceStatusExecute(r interface{}) *MockWorkspacesAPI_WorkspacesGetWorkspaceStatusExecute_Call { return &MockWorkspacesAPI_WorkspacesGetWorkspaceStatusExecute_Call{Call: _e.mock.On("WorkspacesGetWorkspaceStatusExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGetWorkspaceStatusExecute_Call) Run(run func(r ApiWorkspacesGetWorkspaceStatusRequest)) *MockWorkspacesAPI_WorkspacesGetWorkspaceStatusExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGetWorkspaceStatusRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGetWorkspaceStatusRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGetWorkspaceStatusRequest)) }) return _c } @@ -3180,26 +2762,15 @@ type MockWorkspacesAPI_WorkspacesGitHead_Call struct { } // WorkspacesGitHead is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitHead(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesGitHead_Call { return &MockWorkspacesAPI_WorkspacesGitHead_Call{Call: _e.mock.On("WorkspacesGitHead", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesGitHead_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesGitHead_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3256,20 +2827,14 @@ type MockWorkspacesAPI_WorkspacesGitHeadExecute_Call struct { } // WorkspacesGitHeadExecute is a helper method to define mock.On call -// - r ApiWorkspacesGitHeadRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitHeadExecute(r interface{}) *MockWorkspacesAPI_WorkspacesGitHeadExecute_Call { return &MockWorkspacesAPI_WorkspacesGitHeadExecute_Call{Call: _e.mock.On("WorkspacesGitHeadExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGitHeadExecute_Call) Run(run func(r ApiWorkspacesGitHeadRequest)) *MockWorkspacesAPI_WorkspacesGitHeadExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGitHeadRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGitHeadRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGitHeadRequest)) }) return _c } @@ -3307,26 +2872,15 @@ type MockWorkspacesAPI_WorkspacesGitPull_Call struct { } // WorkspacesGitPull is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPull(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesGitPull_Call { return &MockWorkspacesAPI_WorkspacesGitPull_Call{Call: _e.mock.On("WorkspacesGitPull", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesGitPull_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesGitPull_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3364,32 +2918,16 @@ type MockWorkspacesAPI_WorkspacesGitPull1_Call struct { } // WorkspacesGitPull1 is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - remote string +// - ctx +// - workspaceId +// - remote func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPull1(ctx interface{}, workspaceId interface{}, remote interface{}) *MockWorkspacesAPI_WorkspacesGitPull1_Call { return &MockWorkspacesAPI_WorkspacesGitPull1_Call{Call: _e.mock.On("WorkspacesGitPull1", ctx, workspaceId, remote)} } func (_c *MockWorkspacesAPI_WorkspacesGitPull1_Call) Run(run func(ctx context.Context, workspaceId float32, remote string)) *MockWorkspacesAPI_WorkspacesGitPull1_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -3438,20 +2976,14 @@ type MockWorkspacesAPI_WorkspacesGitPull1Execute_Call struct { } // WorkspacesGitPull1Execute is a helper method to define mock.On call -// - r ApiWorkspacesGitPull1Request +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPull1Execute(r interface{}) *MockWorkspacesAPI_WorkspacesGitPull1Execute_Call { return &MockWorkspacesAPI_WorkspacesGitPull1Execute_Call{Call: _e.mock.On("WorkspacesGitPull1Execute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGitPull1Execute_Call) Run(run func(r ApiWorkspacesGitPull1Request)) *MockWorkspacesAPI_WorkspacesGitPull1Execute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGitPull1Request - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGitPull1Request) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGitPull1Request)) }) return _c } @@ -3489,38 +3021,17 @@ type MockWorkspacesAPI_WorkspacesGitPull2_Call struct { } // WorkspacesGitPull2 is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - remote string -// - branch string +// - ctx +// - workspaceId +// - remote +// - branch func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPull2(ctx interface{}, workspaceId interface{}, remote interface{}, branch interface{}) *MockWorkspacesAPI_WorkspacesGitPull2_Call { return &MockWorkspacesAPI_WorkspacesGitPull2_Call{Call: _e.mock.On("WorkspacesGitPull2", ctx, workspaceId, remote, branch)} } func (_c *MockWorkspacesAPI_WorkspacesGitPull2_Call) Run(run func(ctx context.Context, workspaceId float32, remote string, branch string)) *MockWorkspacesAPI_WorkspacesGitPull2_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - var arg3 string - if args[3] != nil { - arg3 = args[3].(string) - } - run( - arg0, - arg1, - arg2, - arg3, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string), args[3].(string)) }) return _c } @@ -3569,20 +3080,14 @@ type MockWorkspacesAPI_WorkspacesGitPull2Execute_Call struct { } // WorkspacesGitPull2Execute is a helper method to define mock.On call -// - r ApiWorkspacesGitPull2Request +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPull2Execute(r interface{}) *MockWorkspacesAPI_WorkspacesGitPull2Execute_Call { return &MockWorkspacesAPI_WorkspacesGitPull2Execute_Call{Call: _e.mock.On("WorkspacesGitPull2Execute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGitPull2Execute_Call) Run(run func(r ApiWorkspacesGitPull2Request)) *MockWorkspacesAPI_WorkspacesGitPull2Execute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGitPull2Request - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGitPull2Request) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGitPull2Request)) }) return _c } @@ -3631,20 +3136,14 @@ type MockWorkspacesAPI_WorkspacesGitPullExecute_Call struct { } // WorkspacesGitPullExecute is a helper method to define mock.On call -// - r ApiWorkspacesGitPullRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesGitPullExecute(r interface{}) *MockWorkspacesAPI_WorkspacesGitPullExecute_Call { return &MockWorkspacesAPI_WorkspacesGitPullExecute_Call{Call: _e.mock.On("WorkspacesGitPullExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesGitPullExecute_Call) Run(run func(r ApiWorkspacesGitPullRequest)) *MockWorkspacesAPI_WorkspacesGitPullExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesGitPullRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesGitPullRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesGitPullRequest)) }) return _c } @@ -3682,26 +3181,15 @@ type MockWorkspacesAPI_WorkspacesListEnvVars_Call struct { } // WorkspacesListEnvVars is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesListEnvVars(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesListEnvVars_Call { return &MockWorkspacesAPI_WorkspacesListEnvVars_Call{Call: _e.mock.On("WorkspacesListEnvVars", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesListEnvVars_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesListEnvVars_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3758,20 +3246,14 @@ type MockWorkspacesAPI_WorkspacesListEnvVarsExecute_Call struct { } // WorkspacesListEnvVarsExecute is a helper method to define mock.On call -// - r ApiWorkspacesListEnvVarsRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesListEnvVarsExecute(r interface{}) *MockWorkspacesAPI_WorkspacesListEnvVarsExecute_Call { return &MockWorkspacesAPI_WorkspacesListEnvVarsExecute_Call{Call: _e.mock.On("WorkspacesListEnvVarsExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesListEnvVarsExecute_Call) Run(run func(r ApiWorkspacesListEnvVarsRequest)) *MockWorkspacesAPI_WorkspacesListEnvVarsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesListEnvVarsRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesListEnvVarsRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesListEnvVarsRequest)) }) return _c } @@ -3809,26 +3291,15 @@ type MockWorkspacesAPI_WorkspacesListWorkspaces_Call struct { } // WorkspacesListWorkspaces is a helper method to define mock.On call -// - ctx context.Context -// - teamId float32 +// - ctx +// - teamId func (_e *MockWorkspacesAPI_Expecter) WorkspacesListWorkspaces(ctx interface{}, teamId interface{}) *MockWorkspacesAPI_WorkspacesListWorkspaces_Call { return &MockWorkspacesAPI_WorkspacesListWorkspaces_Call{Call: _e.mock.On("WorkspacesListWorkspaces", ctx, teamId)} } func (_c *MockWorkspacesAPI_WorkspacesListWorkspaces_Call) Run(run func(ctx context.Context, teamId float32)) *MockWorkspacesAPI_WorkspacesListWorkspaces_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -3885,20 +3356,14 @@ type MockWorkspacesAPI_WorkspacesListWorkspacesExecute_Call struct { } // WorkspacesListWorkspacesExecute is a helper method to define mock.On call -// - r ApiWorkspacesListWorkspacesRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesListWorkspacesExecute(r interface{}) *MockWorkspacesAPI_WorkspacesListWorkspacesExecute_Call { return &MockWorkspacesAPI_WorkspacesListWorkspacesExecute_Call{Call: _e.mock.On("WorkspacesListWorkspacesExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesListWorkspacesExecute_Call) Run(run func(r ApiWorkspacesListWorkspacesRequest)) *MockWorkspacesAPI_WorkspacesListWorkspacesExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesListWorkspacesRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesListWorkspacesRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesListWorkspacesRequest)) }) return _c } @@ -3936,38 +3401,17 @@ type MockWorkspacesAPI_WorkspacesLogs_Call struct { } // WorkspacesLogs is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - stage string -// - step float32 +// - ctx +// - workspaceId +// - stage +// - step func (_e *MockWorkspacesAPI_Expecter) WorkspacesLogs(ctx interface{}, workspaceId interface{}, stage interface{}, step interface{}) *MockWorkspacesAPI_WorkspacesLogs_Call { return &MockWorkspacesAPI_WorkspacesLogs_Call{Call: _e.mock.On("WorkspacesLogs", ctx, workspaceId, stage, step)} } func (_c *MockWorkspacesAPI_WorkspacesLogs_Call) Run(run func(ctx context.Context, workspaceId float32, stage string, step float32)) *MockWorkspacesAPI_WorkspacesLogs_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - var arg3 float32 - if args[3] != nil { - arg3 = args[3].(float32) - } - run( - arg0, - arg1, - arg2, - arg3, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string), args[3].(float32)) }) return _c } @@ -4024,20 +3468,14 @@ type MockWorkspacesAPI_WorkspacesLogsExecute_Call struct { } // WorkspacesLogsExecute is a helper method to define mock.On call -// - r ApiWorkspacesLogsRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesLogsExecute(r interface{}) *MockWorkspacesAPI_WorkspacesLogsExecute_Call { return &MockWorkspacesAPI_WorkspacesLogsExecute_Call{Call: _e.mock.On("WorkspacesLogsExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesLogsExecute_Call) Run(run func(r ApiWorkspacesLogsRequest)) *MockWorkspacesAPI_WorkspacesLogsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesLogsRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesLogsRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesLogsRequest)) }) return _c } @@ -4075,32 +3513,16 @@ type MockWorkspacesAPI_WorkspacesPipelineStatus_Call struct { } // WorkspacesPipelineStatus is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - stage string +// - ctx +// - workspaceId +// - stage func (_e *MockWorkspacesAPI_Expecter) WorkspacesPipelineStatus(ctx interface{}, workspaceId interface{}, stage interface{}) *MockWorkspacesAPI_WorkspacesPipelineStatus_Call { return &MockWorkspacesAPI_WorkspacesPipelineStatus_Call{Call: _e.mock.On("WorkspacesPipelineStatus", ctx, workspaceId, stage)} } func (_c *MockWorkspacesAPI_WorkspacesPipelineStatus_Call) Run(run func(ctx context.Context, workspaceId float32, stage string)) *MockWorkspacesAPI_WorkspacesPipelineStatus_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -4157,20 +3579,14 @@ type MockWorkspacesAPI_WorkspacesPipelineStatusExecute_Call struct { } // WorkspacesPipelineStatusExecute is a helper method to define mock.On call -// - r ApiWorkspacesPipelineStatusRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesPipelineStatusExecute(r interface{}) *MockWorkspacesAPI_WorkspacesPipelineStatusExecute_Call { return &MockWorkspacesAPI_WorkspacesPipelineStatusExecute_Call{Call: _e.mock.On("WorkspacesPipelineStatusExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesPipelineStatusExecute_Call) Run(run func(r ApiWorkspacesPipelineStatusRequest)) *MockWorkspacesAPI_WorkspacesPipelineStatusExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesPipelineStatusRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesPipelineStatusRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesPipelineStatusRequest)) }) return _c } @@ -4208,38 +3624,17 @@ type MockWorkspacesAPI_WorkspacesReplicaLogs_Call struct { } // WorkspacesReplicaLogs is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - step float32 -// - replica string +// - ctx +// - workspaceId +// - step +// - replica func (_e *MockWorkspacesAPI_Expecter) WorkspacesReplicaLogs(ctx interface{}, workspaceId interface{}, step interface{}, replica interface{}) *MockWorkspacesAPI_WorkspacesReplicaLogs_Call { return &MockWorkspacesAPI_WorkspacesReplicaLogs_Call{Call: _e.mock.On("WorkspacesReplicaLogs", ctx, workspaceId, step, replica)} } func (_c *MockWorkspacesAPI_WorkspacesReplicaLogs_Call) Run(run func(ctx context.Context, workspaceId float32, step float32, replica string)) *MockWorkspacesAPI_WorkspacesReplicaLogs_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 float32 - if args[2] != nil { - arg2 = args[2].(float32) - } - var arg3 string - if args[3] != nil { - arg3 = args[3].(string) - } - run( - arg0, - arg1, - arg2, - arg3, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(float32), args[3].(string)) }) return _c } @@ -4296,20 +3691,14 @@ type MockWorkspacesAPI_WorkspacesReplicaLogsExecute_Call struct { } // WorkspacesReplicaLogsExecute is a helper method to define mock.On call -// - r ApiWorkspacesReplicaLogsRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesReplicaLogsExecute(r interface{}) *MockWorkspacesAPI_WorkspacesReplicaLogsExecute_Call { return &MockWorkspacesAPI_WorkspacesReplicaLogsExecute_Call{Call: _e.mock.On("WorkspacesReplicaLogsExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesReplicaLogsExecute_Call) Run(run func(r ApiWorkspacesReplicaLogsRequest)) *MockWorkspacesAPI_WorkspacesReplicaLogsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesReplicaLogsRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesReplicaLogsRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesReplicaLogsRequest)) }) return _c } @@ -4347,26 +3736,15 @@ type MockWorkspacesAPI_WorkspacesScaleLandscapeServices_Call struct { } // WorkspacesScaleLandscapeServices is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesScaleLandscapeServices(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesScaleLandscapeServices_Call { return &MockWorkspacesAPI_WorkspacesScaleLandscapeServices_Call{Call: _e.mock.On("WorkspacesScaleLandscapeServices", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesScaleLandscapeServices_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesScaleLandscapeServices_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -4415,20 +3793,14 @@ type MockWorkspacesAPI_WorkspacesScaleLandscapeServicesExecute_Call struct { } // WorkspacesScaleLandscapeServicesExecute is a helper method to define mock.On call -// - r ApiWorkspacesScaleLandscapeServicesRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesScaleLandscapeServicesExecute(r interface{}) *MockWorkspacesAPI_WorkspacesScaleLandscapeServicesExecute_Call { return &MockWorkspacesAPI_WorkspacesScaleLandscapeServicesExecute_Call{Call: _e.mock.On("WorkspacesScaleLandscapeServicesExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesScaleLandscapeServicesExecute_Call) Run(run func(r ApiWorkspacesScaleLandscapeServicesRequest)) *MockWorkspacesAPI_WorkspacesScaleLandscapeServicesExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesScaleLandscapeServicesRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesScaleLandscapeServicesRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesScaleLandscapeServicesRequest)) }) return _c } @@ -4466,38 +3838,17 @@ type MockWorkspacesAPI_WorkspacesServerLogs_Call struct { } // WorkspacesServerLogs is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - step float32 -// - server string +// - ctx +// - workspaceId +// - step +// - server func (_e *MockWorkspacesAPI_Expecter) WorkspacesServerLogs(ctx interface{}, workspaceId interface{}, step interface{}, server interface{}) *MockWorkspacesAPI_WorkspacesServerLogs_Call { return &MockWorkspacesAPI_WorkspacesServerLogs_Call{Call: _e.mock.On("WorkspacesServerLogs", ctx, workspaceId, step, server)} } func (_c *MockWorkspacesAPI_WorkspacesServerLogs_Call) Run(run func(ctx context.Context, workspaceId float32, step float32, server string)) *MockWorkspacesAPI_WorkspacesServerLogs_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 float32 - if args[2] != nil { - arg2 = args[2].(float32) - } - var arg3 string - if args[3] != nil { - arg3 = args[3].(string) - } - run( - arg0, - arg1, - arg2, - arg3, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(float32), args[3].(string)) }) return _c } @@ -4554,20 +3905,14 @@ type MockWorkspacesAPI_WorkspacesServerLogsExecute_Call struct { } // WorkspacesServerLogsExecute is a helper method to define mock.On call -// - r ApiWorkspacesServerLogsRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesServerLogsExecute(r interface{}) *MockWorkspacesAPI_WorkspacesServerLogsExecute_Call { return &MockWorkspacesAPI_WorkspacesServerLogsExecute_Call{Call: _e.mock.On("WorkspacesServerLogsExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesServerLogsExecute_Call) Run(run func(r ApiWorkspacesServerLogsRequest)) *MockWorkspacesAPI_WorkspacesServerLogsExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesServerLogsRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesServerLogsRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesServerLogsRequest)) }) return _c } @@ -4605,26 +3950,15 @@ type MockWorkspacesAPI_WorkspacesSetEnvVar_Call struct { } // WorkspacesSetEnvVar is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesSetEnvVar(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesSetEnvVar_Call { return &MockWorkspacesAPI_WorkspacesSetEnvVar_Call{Call: _e.mock.On("WorkspacesSetEnvVar", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesSetEnvVar_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesSetEnvVar_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -4673,20 +4007,14 @@ type MockWorkspacesAPI_WorkspacesSetEnvVarExecute_Call struct { } // WorkspacesSetEnvVarExecute is a helper method to define mock.On call -// - r ApiWorkspacesSetEnvVarRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesSetEnvVarExecute(r interface{}) *MockWorkspacesAPI_WorkspacesSetEnvVarExecute_Call { return &MockWorkspacesAPI_WorkspacesSetEnvVarExecute_Call{Call: _e.mock.On("WorkspacesSetEnvVarExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesSetEnvVarExecute_Call) Run(run func(r ApiWorkspacesSetEnvVarRequest)) *MockWorkspacesAPI_WorkspacesSetEnvVarExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesSetEnvVarRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesSetEnvVarRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesSetEnvVarRequest)) }) return _c } @@ -4724,32 +4052,16 @@ type MockWorkspacesAPI_WorkspacesStartPipelineStage_Call struct { } // WorkspacesStartPipelineStage is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - stage string +// - ctx +// - workspaceId +// - stage func (_e *MockWorkspacesAPI_Expecter) WorkspacesStartPipelineStage(ctx interface{}, workspaceId interface{}, stage interface{}) *MockWorkspacesAPI_WorkspacesStartPipelineStage_Call { return &MockWorkspacesAPI_WorkspacesStartPipelineStage_Call{Call: _e.mock.On("WorkspacesStartPipelineStage", ctx, workspaceId, stage)} } func (_c *MockWorkspacesAPI_WorkspacesStartPipelineStage_Call) Run(run func(ctx context.Context, workspaceId float32, stage string)) *MockWorkspacesAPI_WorkspacesStartPipelineStage_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -4787,38 +4099,17 @@ type MockWorkspacesAPI_WorkspacesStartPipelineStage1_Call struct { } // WorkspacesStartPipelineStage1 is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - stage string -// - profile string +// - ctx +// - workspaceId +// - stage +// - profile func (_e *MockWorkspacesAPI_Expecter) WorkspacesStartPipelineStage1(ctx interface{}, workspaceId interface{}, stage interface{}, profile interface{}) *MockWorkspacesAPI_WorkspacesStartPipelineStage1_Call { return &MockWorkspacesAPI_WorkspacesStartPipelineStage1_Call{Call: _e.mock.On("WorkspacesStartPipelineStage1", ctx, workspaceId, stage, profile)} } func (_c *MockWorkspacesAPI_WorkspacesStartPipelineStage1_Call) Run(run func(ctx context.Context, workspaceId float32, stage string, profile string)) *MockWorkspacesAPI_WorkspacesStartPipelineStage1_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - var arg3 string - if args[3] != nil { - arg3 = args[3].(string) - } - run( - arg0, - arg1, - arg2, - arg3, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string), args[3].(string)) }) return _c } @@ -4867,20 +4158,14 @@ type MockWorkspacesAPI_WorkspacesStartPipelineStage1Execute_Call struct { } // WorkspacesStartPipelineStage1Execute is a helper method to define mock.On call -// - r ApiWorkspacesStartPipelineStage1Request +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesStartPipelineStage1Execute(r interface{}) *MockWorkspacesAPI_WorkspacesStartPipelineStage1Execute_Call { return &MockWorkspacesAPI_WorkspacesStartPipelineStage1Execute_Call{Call: _e.mock.On("WorkspacesStartPipelineStage1Execute", r)} } func (_c *MockWorkspacesAPI_WorkspacesStartPipelineStage1Execute_Call) Run(run func(r ApiWorkspacesStartPipelineStage1Request)) *MockWorkspacesAPI_WorkspacesStartPipelineStage1Execute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesStartPipelineStage1Request - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesStartPipelineStage1Request) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesStartPipelineStage1Request)) }) return _c } @@ -4929,20 +4214,14 @@ type MockWorkspacesAPI_WorkspacesStartPipelineStageExecute_Call struct { } // WorkspacesStartPipelineStageExecute is a helper method to define mock.On call -// - r ApiWorkspacesStartPipelineStageRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesStartPipelineStageExecute(r interface{}) *MockWorkspacesAPI_WorkspacesStartPipelineStageExecute_Call { return &MockWorkspacesAPI_WorkspacesStartPipelineStageExecute_Call{Call: _e.mock.On("WorkspacesStartPipelineStageExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesStartPipelineStageExecute_Call) Run(run func(r ApiWorkspacesStartPipelineStageRequest)) *MockWorkspacesAPI_WorkspacesStartPipelineStageExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesStartPipelineStageRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesStartPipelineStageRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesStartPipelineStageRequest)) }) return _c } @@ -4980,32 +4259,16 @@ type MockWorkspacesAPI_WorkspacesStopPipelineStage_Call struct { } // WorkspacesStopPipelineStage is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 -// - stage string +// - ctx +// - workspaceId +// - stage func (_e *MockWorkspacesAPI_Expecter) WorkspacesStopPipelineStage(ctx interface{}, workspaceId interface{}, stage interface{}) *MockWorkspacesAPI_WorkspacesStopPipelineStage_Call { return &MockWorkspacesAPI_WorkspacesStopPipelineStage_Call{Call: _e.mock.On("WorkspacesStopPipelineStage", ctx, workspaceId, stage)} } func (_c *MockWorkspacesAPI_WorkspacesStopPipelineStage_Call) Run(run func(ctx context.Context, workspaceId float32, stage string)) *MockWorkspacesAPI_WorkspacesStopPipelineStage_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - var arg2 string - if args[2] != nil { - arg2 = args[2].(string) - } - run( - arg0, - arg1, - arg2, - ) + run(args[0].(context.Context), args[1].(float32), args[2].(string)) }) return _c } @@ -5054,20 +4317,14 @@ type MockWorkspacesAPI_WorkspacesStopPipelineStageExecute_Call struct { } // WorkspacesStopPipelineStageExecute is a helper method to define mock.On call -// - r ApiWorkspacesStopPipelineStageRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesStopPipelineStageExecute(r interface{}) *MockWorkspacesAPI_WorkspacesStopPipelineStageExecute_Call { return &MockWorkspacesAPI_WorkspacesStopPipelineStageExecute_Call{Call: _e.mock.On("WorkspacesStopPipelineStageExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesStopPipelineStageExecute_Call) Run(run func(r ApiWorkspacesStopPipelineStageRequest)) *MockWorkspacesAPI_WorkspacesStopPipelineStageExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesStopPipelineStageRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesStopPipelineStageRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesStopPipelineStageRequest)) }) return _c } @@ -5105,26 +4362,15 @@ type MockWorkspacesAPI_WorkspacesTeardownLandscape_Call struct { } // WorkspacesTeardownLandscape is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesTeardownLandscape(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesTeardownLandscape_Call { return &MockWorkspacesAPI_WorkspacesTeardownLandscape_Call{Call: _e.mock.On("WorkspacesTeardownLandscape", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesTeardownLandscape_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesTeardownLandscape_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -5173,20 +4419,14 @@ type MockWorkspacesAPI_WorkspacesTeardownLandscapeExecute_Call struct { } // WorkspacesTeardownLandscapeExecute is a helper method to define mock.On call -// - r ApiWorkspacesTeardownLandscapeRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesTeardownLandscapeExecute(r interface{}) *MockWorkspacesAPI_WorkspacesTeardownLandscapeExecute_Call { return &MockWorkspacesAPI_WorkspacesTeardownLandscapeExecute_Call{Call: _e.mock.On("WorkspacesTeardownLandscapeExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesTeardownLandscapeExecute_Call) Run(run func(r ApiWorkspacesTeardownLandscapeRequest)) *MockWorkspacesAPI_WorkspacesTeardownLandscapeExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesTeardownLandscapeRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesTeardownLandscapeRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesTeardownLandscapeRequest)) }) return _c } @@ -5224,26 +4464,15 @@ type MockWorkspacesAPI_WorkspacesUpdateWorkspace_Call struct { } // WorkspacesUpdateWorkspace is a helper method to define mock.On call -// - ctx context.Context -// - workspaceId float32 +// - ctx +// - workspaceId func (_e *MockWorkspacesAPI_Expecter) WorkspacesUpdateWorkspace(ctx interface{}, workspaceId interface{}) *MockWorkspacesAPI_WorkspacesUpdateWorkspace_Call { return &MockWorkspacesAPI_WorkspacesUpdateWorkspace_Call{Call: _e.mock.On("WorkspacesUpdateWorkspace", ctx, workspaceId)} } func (_c *MockWorkspacesAPI_WorkspacesUpdateWorkspace_Call) Run(run func(ctx context.Context, workspaceId float32)) *MockWorkspacesAPI_WorkspacesUpdateWorkspace_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 context.Context - if args[0] != nil { - arg0 = args[0].(context.Context) - } - var arg1 float32 - if args[1] != nil { - arg1 = args[1].(float32) - } - run( - arg0, - arg1, - ) + run(args[0].(context.Context), args[1].(float32)) }) return _c } @@ -5292,20 +4521,14 @@ type MockWorkspacesAPI_WorkspacesUpdateWorkspaceExecute_Call struct { } // WorkspacesUpdateWorkspaceExecute is a helper method to define mock.On call -// - r ApiWorkspacesUpdateWorkspaceRequest +// - r func (_e *MockWorkspacesAPI_Expecter) WorkspacesUpdateWorkspaceExecute(r interface{}) *MockWorkspacesAPI_WorkspacesUpdateWorkspaceExecute_Call { return &MockWorkspacesAPI_WorkspacesUpdateWorkspaceExecute_Call{Call: _e.mock.On("WorkspacesUpdateWorkspaceExecute", r)} } func (_c *MockWorkspacesAPI_WorkspacesUpdateWorkspaceExecute_Call) Run(run func(r ApiWorkspacesUpdateWorkspaceRequest)) *MockWorkspacesAPI_WorkspacesUpdateWorkspaceExecute_Call { _c.Call.Run(func(args mock.Arguments) { - var arg0 ApiWorkspacesUpdateWorkspaceRequest - if args[0] != nil { - arg0 = args[0].(ApiWorkspacesUpdateWorkspaceRequest) - } - run( - arg0, - ) + run(args[0].(ApiWorkspacesUpdateWorkspaceRequest)) }) return _c } diff --git a/api/workspace.go b/api/workspace.go index ee68c38..2ec8ef1 100644 --- a/api/workspace.go +++ b/api/workspace.go @@ -108,6 +108,17 @@ func (c *Client) GetPipelineState(wsId int, stage string) ([]PipelineStatus, err return res, errors.FormatAPIError(err) } +// ScaleWorkspace sets the number of replicas for a workspace. +// For on-demand workspaces, setting replicas to 1 wakes up the workspace. +func (c *Client) ScaleWorkspace(wsId int, replicas int) error { + req := c.api.WorkspacesAPI.WorkspacesUpdateWorkspace(c.ctx, float32(wsId)). + WorkspacesUpdateWorkspaceRequest(openapi_client.WorkspacesUpdateWorkspaceRequest{ + Replicas: &replicas, + }) + _, err := req.Execute() + return errors.FormatAPIError(err) +} + // Waits for a given workspace to be running. // // Returns [TimedOut] error if the workspace does not become running in time. @@ -119,8 +130,11 @@ func (client *Client) WaitForWorkspaceRunning(workspace *Workspace, timeout time status, err := client.WorkspaceStatus(workspace.Id) if err != nil { - // TODO: log error and retry until timeout is reached. - return errors.FormatAPIError(err) + if client.time.Now().After(maxWaitTime) { + return errors.FormatAPIError(err) + } + client.time.Sleep(delay) + continue } if status.IsRunning { return nil diff --git a/cli/cmd/client.go b/cli/cmd/client.go index 88b4b2b..4c33402 100644 --- a/cli/cmd/client.go +++ b/cli/cmd/client.go @@ -8,7 +8,9 @@ package cmd import ( "context" "fmt" + "io" "net/url" + "time" "github.com/codesphere-cloud/cs-go/api" ) @@ -18,6 +20,9 @@ type Client interface { ListWorkspaces(teamId int) ([]api.Workspace, error) ListBaseimages() ([]api.Baseimage, error) GetWorkspace(workspaceId int) (api.Workspace, error) + WorkspaceStatus(workspaceId int) (*api.WorkspaceStatus, error) + WaitForWorkspaceRunning(workspace *api.Workspace, timeout time.Duration) error + ScaleWorkspace(wsId int, replicas int) error SetEnvVarOnWorkspace(workspaceId int, vars map[string]string) error ExecCommand(workspaceId int, command string, workdir string, env map[string]string) (string, string, error) ListWorkspacePlans() ([]api.WorkspacePlan, error) @@ -29,6 +34,11 @@ type Client interface { DeployLandscape(wsId int, profile string) error } +// CommandExecutor abstracts command execution for testing +type CommandExecutor interface { + Execute(ctx context.Context, name string, args []string, stdout, stderr io.Writer) error +} + func NewClient(opts GlobalOptions) (Client, error) { token, err := opts.Env.GetApiToken() if err != nil { diff --git a/cli/cmd/curl.go b/cli/cmd/curl.go new file mode 100644 index 0000000..2376e7e --- /dev/null +++ b/cli/cmd/curl.go @@ -0,0 +1,132 @@ +// Copyright (c) Codesphere Inc. +// SPDX-License-Identifier: Apache-2.0 + +package cmd + +import ( + "context" + "fmt" + "io" + "log" + "os" + "os/exec" + "strings" + "time" + + io_pkg "github.com/codesphere-cloud/cs-go/pkg/io" + "github.com/spf13/cobra" +) + +// DefaultCommandExecutor uses os/exec to run commands +type DefaultCommandExecutor struct{} + +func (e *DefaultCommandExecutor) Execute(ctx context.Context, name string, args []string, stdout, stderr io.Writer) error { + cmd := exec.CommandContext(ctx, name, args...) + cmd.Stdout = stdout + cmd.Stderr = stderr + return cmd.Run() +} + +type CurlCmd struct { + cmd *cobra.Command + Opts GlobalOptions + Port int + Timeout time.Duration + Insecure bool + Executor CommandExecutor // Injectable for testing +} + +func (c *CurlCmd) RunE(_ *cobra.Command, args []string) error { + client, err := NewClient(c.Opts) + if err != nil { + return fmt.Errorf("failed to create Codesphere client: %w", err) + } + + wsId, err := c.Opts.GetWorkspaceId() + if err != nil { + return fmt.Errorf("failed to get workspace ID: %w", err) + } + + token, err := c.Opts.Env.GetApiToken() + if err != nil { + return fmt.Errorf("failed to get API token: %w", err) + } + + path := args[0] + curlArgs := args[1:] + + return c.CurlWorkspace(client, wsId, token, path, curlArgs) +} + +func AddCurlCmd(rootCmd *cobra.Command, opts GlobalOptions) { + curl := CurlCmd{ + cmd: &cobra.Command{ + Use: "curl [path] [-- curl-args...]", + Short: "Send authenticated HTTP requests to workspace dev domain", + Long: `Send authenticated HTTP requests to a workspace's development domain using curl-like syntax.`, + Example: io_pkg.FormatExampleCommands("curl", []io_pkg.Example{ + {Cmd: "/ -w 1234", Desc: "GET request to workspace root"}, + {Cmd: "/api/health -w 1234 -p 3001", Desc: "GET request to port 3001"}, + {Cmd: "/api/data -w 1234 -- -XPOST -d '{\"key\":\"value\"}'", Desc: "POST request with data"}, + {Cmd: "/api/endpoint -w 1234 -- -v", Desc: "verbose output"}, + {Cmd: "/ -- -I", Desc: "HEAD request using workspace from env var"}, + }), + Args: cobra.MinimumNArgs(1), + }, + Opts: opts, + Executor: &DefaultCommandExecutor{}, + } + curl.cmd.Flags().IntVarP(&curl.Port, "port", "p", 3000, "Port to connect to") + curl.cmd.Flags().DurationVar(&curl.Timeout, "timeout", 30*time.Second, "Timeout for the request") + curl.cmd.Flags().BoolVar(&curl.Insecure, "insecure", false, "skip TLS certificate verification (for testing only)") + rootCmd.AddCommand(curl.cmd) + curl.cmd.RunE = curl.RunE +} + +func (c *CurlCmd) CurlWorkspace(client Client, wsId int, token string, path string, curlArgs []string) error { + workspace, err := client.GetWorkspace(wsId) + if err != nil { + return fmt.Errorf("failed to get workspace: %w", err) + } + + // Get the dev domain from the workspace + if workspace.DevDomain == nil || *workspace.DevDomain == "" { + return fmt.Errorf("workspace %d does not have a dev domain configured", wsId) + } + + // Use the workspace's dev domain and replace the port if needed + // DevDomain format is: {workspace_id}-{port}.{domain} + devDomain := *workspace.DevDomain + var url string + if c.Port != 3000 { + // Replace the default port (3000) with the custom port in the dev domain + url = fmt.Sprintf("https://%d-%d.%s%s", wsId, c.Port, devDomain[strings.Index(devDomain, ".")+1:], path) + } else { + url = fmt.Sprintf("https://%s%s", devDomain, path) + } + + log.Printf("Sending request to workspace %d (%s) at %s\n", wsId, workspace.Name, url) + + ctx, cancel := context.WithTimeout(context.Background(), c.Timeout) + defer cancel() + + // Build curl command with authentication header + cmdArgs := []string{"curl", "-H", fmt.Sprintf("x-forward-security: %s", token)} + + // Add insecure flag if specified + if c.Insecure { + cmdArgs = append(cmdArgs, "-k") + } + + cmdArgs = append(cmdArgs, curlArgs...) + cmdArgs = append(cmdArgs, url) + + err = c.Executor.Execute(ctx, cmdArgs[0], cmdArgs[1:], os.Stdout, os.Stderr) + if err != nil && err == context.DeadlineExceeded { + return fmt.Errorf("timeout exceeded while requesting workspace %d", wsId) + } else if err != nil { + return fmt.Errorf("curl command failed: %w", err) + } + + return nil +} diff --git a/cli/cmd/curl_test.go b/cli/cmd/curl_test.go new file mode 100644 index 0000000..69918e6 --- /dev/null +++ b/cli/cmd/curl_test.go @@ -0,0 +1,217 @@ +// Copyright (c) Codesphere Inc. +// SPDX-License-Identifier: Apache-2.0 + +package cmd_test + +import ( + "fmt" + "time" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "github.com/stretchr/testify/mock" + + "github.com/codesphere-cloud/cs-go/api" + "github.com/codesphere-cloud/cs-go/cli/cmd" +) + +var _ = Describe("Curl", func() { + var ( + mockEnv *cmd.MockEnv + mockClient *cmd.MockClient + mockExecutor *cmd.MockCommandExecutor + c *cmd.CurlCmd + wsId int + teamId int + token string + port int + ) + + JustBeforeEach(func() { + mockClient = cmd.NewMockClient(GinkgoT()) + mockEnv = cmd.NewMockEnv(GinkgoT()) + mockExecutor = cmd.NewMockCommandExecutor(GinkgoT()) + wsId = 42 + teamId = 21 + token = "test-api-token" + port = 3000 + c = &cmd.CurlCmd{ + Opts: cmd.GlobalOptions{ + Env: mockEnv, + WorkspaceId: &wsId, + }, + Port: port, + Timeout: 30 * time.Second, + Executor: mockExecutor, + } + }) + + Context("CurlWorkspace", func() { + It("should construct the correct URL with default port", func() { + devDomain := "42-3000.dev.5.codesphere.com" + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + DevDomain: &devDomain, + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockExecutor.EXPECT().Execute( + mock.Anything, + "curl", + mock.MatchedBy(func(args []string) bool { + // Verify the args contain the expected header, flag, and URL + hasHeader := false + hasFlag := false + hasURL := false + for i, arg := range args { + if arg == "-H" && i+1 < len(args) && args[i+1] == fmt.Sprintf("x-forward-security: %s", token) { + hasHeader = true + } + if arg == "-I" { + hasFlag = true + } + if arg == "https://42-3000.dev.5.codesphere.com/api/health" { + hasURL = true + } + } + return hasHeader && hasFlag && hasURL + }), + mock.Anything, + mock.Anything, + ).Return(nil) + + err := c.CurlWorkspace(mockClient, wsId, token, "/api/health", []string{"-I"}) + + Expect(err).ToNot(HaveOccurred()) + }) + + It("should construct the correct URL with custom port", func() { + c.Port = 3001 + devDomain := "42-3000.dev.5.codesphere.com" + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + DevDomain: &devDomain, + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockExecutor.EXPECT().Execute( + mock.Anything, + "curl", + mock.MatchedBy(func(args []string) bool { + // Verify the URL contains the custom port + hasHeader := false + hasURL := false + for i, arg := range args { + if arg == "-H" && i+1 < len(args) && args[i+1] == fmt.Sprintf("x-forward-security: %s", token) { + hasHeader = true + } + if arg == "https://42-3001.dev.5.codesphere.com/custom/path" { + hasURL = true + } + } + return hasHeader && hasURL + }), + mock.Anything, + mock.Anything, + ).Return(nil) + + err := c.CurlWorkspace(mockClient, wsId, token, "/custom/path", []string{}) + + Expect(err).ToNot(HaveOccurred()) + }) + + It("should pass insecure flag when specified", func() { + c.Insecure = true + devDomain := "42-3000.dev.5.codesphere.com" + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + DevDomain: &devDomain, + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockExecutor.EXPECT().Execute( + mock.Anything, + "curl", + mock.MatchedBy(func(args []string) bool { + // Verify the insecure flag is present + hasInsecure := false + hasHeader := false + hasURL := false + for i, arg := range args { + if arg == "-k" { + hasInsecure = true + } + if arg == "-H" && i+1 < len(args) && args[i+1] == fmt.Sprintf("x-forward-security: %s", token) { + hasHeader = true + } + if arg == "https://42-3000.dev.5.codesphere.com/" { + hasURL = true + } + } + return hasInsecure && hasHeader && hasURL + }), + mock.Anything, + mock.Anything, + ).Return(nil) + + err := c.CurlWorkspace(mockClient, wsId, token, "/", []string{}) + + Expect(err).ToNot(HaveOccurred()) + }) + + It("should return error if workspace has no dev domain", func() { + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + DevDomain: nil, + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + + err := c.CurlWorkspace(mockClient, wsId, token, "/", []string{}) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("does not have a dev domain configured")) + }) + + It("should return error if GetWorkspace fails", func() { + mockClient.EXPECT().GetWorkspace(wsId).Return(api.Workspace{}, fmt.Errorf("api error")) + + err := c.CurlWorkspace(mockClient, wsId, token, "/", []string{}) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("failed to get workspace")) + }) + + It("should return error if command execution fails", func() { + devDomain := "42-3000.dev.5.codesphere.com" + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + DevDomain: &devDomain, + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockExecutor.EXPECT().Execute( + mock.Anything, + mock.Anything, + mock.Anything, + mock.Anything, + mock.Anything, + ).Return(fmt.Errorf("command failed")) + + err := c.CurlWorkspace(mockClient, wsId, token, "/", []string{}) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("curl command failed")) + }) + }) +}) diff --git a/cli/cmd/list_workspaces.go b/cli/cmd/list_workspaces.go index 679df0a..dfc73b7 100644 --- a/cli/cmd/list_workspaces.go +++ b/cli/cmd/list_workspaces.go @@ -25,7 +25,7 @@ func addListWorkspacesCmd(p *cobra.Command, opts GlobalOptions) { Short: "List workspaces", Long: `List workspaces available in Codesphere`, Example: io.FormatExampleCommands("list workspaces", []io.Example{ - {Cmd: "--team-id ", Desc: "List all workspaces"}, + {Cmd: "-t ", Desc: "List all workspaces"}, }), }, Opts: opts, diff --git a/cli/cmd/mocks.go b/cli/cmd/mocks.go index f9d274f..5a6f9cf 100644 --- a/cli/cmd/mocks.go +++ b/cli/cmd/mocks.go @@ -5,8 +5,11 @@ package cmd import ( + "context" "github.com/codesphere-cloud/cs-go/api" mock "github.com/stretchr/testify/mock" + "io" + "time" ) // NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. @@ -708,6 +711,63 @@ func (_c *MockClient_ListWorkspaces_Call) RunAndReturn(run func(teamId int) ([]a return _c } +// ScaleWorkspace provides a mock function for the type MockClient +func (_mock *MockClient) ScaleWorkspace(wsId int, replicas int) error { + ret := _mock.Called(wsId, replicas) + + if len(ret) == 0 { + panic("no return value specified for ScaleWorkspace") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(int, int) error); ok { + r0 = returnFunc(wsId, replicas) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockClient_ScaleWorkspace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScaleWorkspace' +type MockClient_ScaleWorkspace_Call struct { + *mock.Call +} + +// ScaleWorkspace is a helper method to define mock.On call +// - wsId int +// - replicas int +func (_e *MockClient_Expecter) ScaleWorkspace(wsId interface{}, replicas interface{}) *MockClient_ScaleWorkspace_Call { + return &MockClient_ScaleWorkspace_Call{Call: _e.mock.On("ScaleWorkspace", wsId, replicas)} +} + +func (_c *MockClient_ScaleWorkspace_Call) Run(run func(wsId int, replicas int)) *MockClient_ScaleWorkspace_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 int + if args[0] != nil { + arg0 = args[0].(int) + } + var arg1 int + if args[1] != nil { + arg1 = args[1].(int) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockClient_ScaleWorkspace_Call) Return(err error) *MockClient_ScaleWorkspace_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockClient_ScaleWorkspace_Call) RunAndReturn(run func(wsId int, replicas int) error) *MockClient_ScaleWorkspace_Call { + _c.Call.Return(run) + return _c +} + // SetEnvVarOnWorkspace provides a mock function for the type MockClient func (_mock *MockClient) SetEnvVarOnWorkspace(workspaceId int, vars map[string]string) error { ret := _mock.Called(workspaceId, vars) @@ -828,6 +888,227 @@ func (_c *MockClient_StartPipelineStage_Call) RunAndReturn(run func(wsId int, pr return _c } +// WaitForWorkspaceRunning provides a mock function for the type MockClient +func (_mock *MockClient) WaitForWorkspaceRunning(workspace *api.Workspace, timeout time.Duration) error { + ret := _mock.Called(workspace, timeout) + + if len(ret) == 0 { + panic("no return value specified for WaitForWorkspaceRunning") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(*api.Workspace, time.Duration) error); ok { + r0 = returnFunc(workspace, timeout) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockClient_WaitForWorkspaceRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitForWorkspaceRunning' +type MockClient_WaitForWorkspaceRunning_Call struct { + *mock.Call +} + +// WaitForWorkspaceRunning is a helper method to define mock.On call +// - workspace *api.Workspace +// - timeout time.Duration +func (_e *MockClient_Expecter) WaitForWorkspaceRunning(workspace interface{}, timeout interface{}) *MockClient_WaitForWorkspaceRunning_Call { + return &MockClient_WaitForWorkspaceRunning_Call{Call: _e.mock.On("WaitForWorkspaceRunning", workspace, timeout)} +} + +func (_c *MockClient_WaitForWorkspaceRunning_Call) Run(run func(workspace *api.Workspace, timeout time.Duration)) *MockClient_WaitForWorkspaceRunning_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *api.Workspace + if args[0] != nil { + arg0 = args[0].(*api.Workspace) + } + var arg1 time.Duration + if args[1] != nil { + arg1 = args[1].(time.Duration) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *MockClient_WaitForWorkspaceRunning_Call) Return(err error) *MockClient_WaitForWorkspaceRunning_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockClient_WaitForWorkspaceRunning_Call) RunAndReturn(run func(workspace *api.Workspace, timeout time.Duration) error) *MockClient_WaitForWorkspaceRunning_Call { + _c.Call.Return(run) + return _c +} + +// WorkspaceStatus provides a mock function for the type MockClient +func (_mock *MockClient) WorkspaceStatus(workspaceId int) (*api.WorkspaceStatus, error) { + ret := _mock.Called(workspaceId) + + if len(ret) == 0 { + panic("no return value specified for WorkspaceStatus") + } + + var r0 *api.WorkspaceStatus + var r1 error + if returnFunc, ok := ret.Get(0).(func(int) (*api.WorkspaceStatus, error)); ok { + return returnFunc(workspaceId) + } + if returnFunc, ok := ret.Get(0).(func(int) *api.WorkspaceStatus); ok { + r0 = returnFunc(workspaceId) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*api.WorkspaceStatus) + } + } + if returnFunc, ok := ret.Get(1).(func(int) error); ok { + r1 = returnFunc(workspaceId) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockClient_WorkspaceStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkspaceStatus' +type MockClient_WorkspaceStatus_Call struct { + *mock.Call +} + +// WorkspaceStatus is a helper method to define mock.On call +// - workspaceId int +func (_e *MockClient_Expecter) WorkspaceStatus(workspaceId interface{}) *MockClient_WorkspaceStatus_Call { + return &MockClient_WorkspaceStatus_Call{Call: _e.mock.On("WorkspaceStatus", workspaceId)} +} + +func (_c *MockClient_WorkspaceStatus_Call) Run(run func(workspaceId int)) *MockClient_WorkspaceStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 int + if args[0] != nil { + arg0 = args[0].(int) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *MockClient_WorkspaceStatus_Call) Return(v *api.WorkspaceStatus, err error) *MockClient_WorkspaceStatus_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *MockClient_WorkspaceStatus_Call) RunAndReturn(run func(workspaceId int) (*api.WorkspaceStatus, error)) *MockClient_WorkspaceStatus_Call { + _c.Call.Return(run) + return _c +} + +// NewMockCommandExecutor creates a new instance of MockCommandExecutor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockCommandExecutor(t interface { + mock.TestingT + Cleanup(func()) +}) *MockCommandExecutor { + mock := &MockCommandExecutor{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockCommandExecutor is an autogenerated mock type for the CommandExecutor type +type MockCommandExecutor struct { + mock.Mock +} + +type MockCommandExecutor_Expecter struct { + mock *mock.Mock +} + +func (_m *MockCommandExecutor) EXPECT() *MockCommandExecutor_Expecter { + return &MockCommandExecutor_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function for the type MockCommandExecutor +func (_mock *MockCommandExecutor) Execute(ctx context.Context, name string, args []string, stdout io.Writer, stderr io.Writer) error { + ret := _mock.Called(ctx, name, args, stdout, stderr) + + if len(ret) == 0 { + panic("no return value specified for Execute") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, io.Writer, io.Writer) error); ok { + r0 = returnFunc(ctx, name, args, stdout, stderr) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockCommandExecutor_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockCommandExecutor_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - ctx context.Context +// - name string +// - args []string +// - stdout io.Writer +// - stderr io.Writer +func (_e *MockCommandExecutor_Expecter) Execute(ctx interface{}, name interface{}, args interface{}, stdout interface{}, stderr interface{}) *MockCommandExecutor_Execute_Call { + return &MockCommandExecutor_Execute_Call{Call: _e.mock.On("Execute", ctx, name, args, stdout, stderr)} +} + +func (_c *MockCommandExecutor_Execute_Call) Run(run func(ctx context.Context, name string, args []string, stdout io.Writer, stderr io.Writer)) *MockCommandExecutor_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + var arg3 io.Writer + if args[3] != nil { + arg3 = args[3].(io.Writer) + } + var arg4 io.Writer + if args[4] != nil { + arg4 = args[4].(io.Writer) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *MockCommandExecutor_Execute_Call) Return(err error) *MockCommandExecutor_Execute_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockCommandExecutor_Execute_Call) RunAndReturn(run func(ctx context.Context, name string, args []string, stdout io.Writer, stderr io.Writer) error) *MockCommandExecutor_Execute_Call { + _c.Call.Return(run) + return _c +} + // NewMockPrompt creates a new instance of MockPrompt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewMockPrompt(t interface { diff --git a/cli/cmd/root.go b/cli/cmd/root.go index 71e6d86..64559f7 100644 --- a/cli/cmd/root.go +++ b/cli/cmd/root.go @@ -92,6 +92,8 @@ func GetRootCmd() *cobra.Command { AddSyncCmd(rootCmd, &opts) AddUpdateCmd(rootCmd) AddGoCmd(rootCmd) + AddWakeUpCmd(rootCmd, opts) + AddCurlCmd(rootCmd, opts) return rootCmd } diff --git a/cli/cmd/wakeup.go b/cli/cmd/wakeup.go new file mode 100644 index 0000000..a43a0b5 --- /dev/null +++ b/cli/cmd/wakeup.go @@ -0,0 +1,92 @@ +// Copyright (c) Codesphere Inc. +// SPDX-License-Identifier: Apache-2.0 + +package cmd + +import ( + "fmt" + "time" + + "github.com/codesphere-cloud/cs-go/pkg/io" + "github.com/spf13/cobra" +) + +type WakeUpCmd struct { + cmd *cobra.Command + Opts GlobalOptions + Timeout time.Duration +} + +func (c *WakeUpCmd) RunE(_ *cobra.Command, args []string) error { + client, err := NewClient(c.Opts) + if err != nil { + return fmt.Errorf("failed to create Codesphere client: %w", err) + } + + wsId, err := c.Opts.GetWorkspaceId() + if err != nil { + return fmt.Errorf("failed to get workspace ID: %w", err) + } + + return c.WakeUpWorkspace(client, wsId) +} + +func AddWakeUpCmd(rootCmd *cobra.Command, opts GlobalOptions) { + wakeup := WakeUpCmd{ + cmd: &cobra.Command{ + Use: "wake-up", + Short: "Wake up an on-demand workspace", + Long: `Wake up an on-demand workspace by scaling it to 1 replica via the API.`, + Example: io.FormatExampleCommands("wake-up", []io.Example{ + {Cmd: "-w 1234", Desc: "wake up workspace 1234"}, + {Cmd: "", Desc: "wake up workspace set by environment variable CS_WORKSPACE_ID"}, + {Cmd: "-w 1234 --timeout 60s", Desc: "wake up workspace with 60 second timeout"}, + }), + }, + Opts: opts, + } + wakeup.cmd.Flags().DurationVar(&wakeup.Timeout, "timeout", 120*time.Second, "Timeout for waking up the workspace") + rootCmd.AddCommand(wakeup.cmd) + wakeup.cmd.RunE = wakeup.RunE +} + +func (c *WakeUpCmd) WakeUpWorkspace(client Client, wsId int) error { + workspace, err := client.GetWorkspace(wsId) + if err != nil { + return fmt.Errorf("failed to get workspace: %w", err) + } + + // Check if workspace is already running + status, err := client.WorkspaceStatus(wsId) + if err != nil { + return fmt.Errorf("failed to get workspace status: %w", err) + } + + if status.IsRunning { + fmt.Printf("Workspace %d (%s) is already running\n", wsId, workspace.Name) + return nil + } + + fmt.Printf("Waking up workspace %d (%s)...\n", wsId, workspace.Name) + + // Scale workspace to at least 1 replica to wake it up + // If workspace already has replicas configured (but not running), preserve that count + targetReplicas := 1 + if workspace.Replicas > 1 { + targetReplicas = workspace.Replicas + } + + err = client.ScaleWorkspace(wsId, targetReplicas) + if err != nil { + return fmt.Errorf("failed to scale workspace: %w", err) + } + + fmt.Printf("Waiting for workspace %d to be running...\n", wsId) + err = client.WaitForWorkspaceRunning(&workspace, c.Timeout) + if err != nil { + return fmt.Errorf("workspace did not become running: %w", err) + } + + fmt.Printf("Workspace %d is now running\n", wsId) + return nil +} diff --git a/cli/cmd/wakeup_test.go b/cli/cmd/wakeup_test.go new file mode 100644 index 0000000..38a8683 --- /dev/null +++ b/cli/cmd/wakeup_test.go @@ -0,0 +1,100 @@ +// Copyright (c) Codesphere Inc. +// SPDX-License-Identifier: Apache-2.0 + +package cmd_test + +import ( + "fmt" + "time" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "github.com/stretchr/testify/mock" + + "github.com/codesphere-cloud/cs-go/api" + "github.com/codesphere-cloud/cs-go/cli/cmd" +) + +var _ = Describe("WakeUp", func() { + var ( + mockEnv *cmd.MockEnv + mockClient *cmd.MockClient + c *cmd.WakeUpCmd + wsId int + teamId int + ) + + JustBeforeEach(func() { + mockClient = cmd.NewMockClient(GinkgoT()) + mockEnv = cmd.NewMockEnv(GinkgoT()) + wsId = 42 + teamId = 21 + c = &cmd.WakeUpCmd{ + Opts: cmd.GlobalOptions{ + Env: mockEnv, + WorkspaceId: &wsId, + }, + } + }) + + Context("WakeUpWorkspace", func() { + It("should wake up the workspace by scaling to 1 replica", func() { + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + } + c.Timeout = 120 * time.Second + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockClient.EXPECT().WorkspaceStatus(wsId).Return(&api.WorkspaceStatus{IsRunning: false}, nil) + mockClient.EXPECT().ScaleWorkspace(wsId, 1).Return(nil) + mockClient.EXPECT().WaitForWorkspaceRunning(mock.Anything, mock.Anything).Return(nil) + + err := c.WakeUpWorkspace(mockClient, wsId) + + Expect(err).ToNot(HaveOccurred()) + }) + + It("should return early if workspace is already running", func() { + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockClient.EXPECT().WorkspaceStatus(wsId).Return(&api.WorkspaceStatus{IsRunning: true}, nil) + + err := c.WakeUpWorkspace(mockClient, wsId) + + Expect(err).ToNot(HaveOccurred()) + }) + + It("should return error if GetWorkspace fails", func() { + mockClient.EXPECT().GetWorkspace(wsId).Return(api.Workspace{}, fmt.Errorf("api error")) + + err := c.WakeUpWorkspace(mockClient, wsId) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("failed to get workspace")) + }) + + It("should return error if ScaleWorkspace fails", func() { + workspace := api.Workspace{ + Id: wsId, + TeamId: teamId, + Name: "test-workspace", + } + + mockClient.EXPECT().GetWorkspace(wsId).Return(workspace, nil) + mockClient.EXPECT().WorkspaceStatus(wsId).Return(&api.WorkspaceStatus{IsRunning: false}, nil) + mockClient.EXPECT().ScaleWorkspace(wsId, 1).Return(fmt.Errorf("scale error")) + + err := c.WakeUpWorkspace(mockClient, wsId) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("failed to scale workspace")) + }) + }) +}) diff --git a/docs/README.md b/docs/README.md index 550ed80..890b480 100644 --- a/docs/README.md +++ b/docs/README.md @@ -19,6 +19,7 @@ Manage and debug resources deployed in Codesphere via command line. ### SEE ALSO * [cs create](cs_create.md) - Create codesphere resource +* [cs curl](cs_curl.md) - Send authenticated HTTP requests to workspace dev domain * [cs delete](cs_delete.md) - Delete Codesphere resources * [cs exec](cs_exec.md) - Run a command in Codesphere workspace * [cs generate](cs_generate.md) - Generate codesphere artifacts @@ -33,4 +34,5 @@ Manage and debug resources deployed in Codesphere via command line. * [cs sync](cs_sync.md) - Sync Codesphere resources * [cs update](cs_update.md) - Update Codesphere CLI * [cs version](cs_version.md) - Print version +* [cs wake-up](cs_wake-up.md) - Wake up an on-demand workspace diff --git a/docs/cs.md b/docs/cs.md index 550ed80..890b480 100644 --- a/docs/cs.md +++ b/docs/cs.md @@ -19,6 +19,7 @@ Manage and debug resources deployed in Codesphere via command line. ### SEE ALSO * [cs create](cs_create.md) - Create codesphere resource +* [cs curl](cs_curl.md) - Send authenticated HTTP requests to workspace dev domain * [cs delete](cs_delete.md) - Delete Codesphere resources * [cs exec](cs_exec.md) - Run a command in Codesphere workspace * [cs generate](cs_generate.md) - Generate codesphere artifacts @@ -33,4 +34,5 @@ Manage and debug resources deployed in Codesphere via command line. * [cs sync](cs_sync.md) - Sync Codesphere resources * [cs update](cs_update.md) - Update Codesphere CLI * [cs version](cs_version.md) - Print version +* [cs wake-up](cs_wake-up.md) - Wake up an on-demand workspace diff --git a/docs/cs_curl.md b/docs/cs_curl.md new file mode 100644 index 0000000..4ace46e --- /dev/null +++ b/docs/cs_curl.md @@ -0,0 +1,53 @@ +## cs curl + +Send authenticated HTTP requests to workspace dev domain + +### Synopsis + +Send authenticated HTTP requests to a workspace's development domain using curl-like syntax. + +``` +cs curl [path] [-- curl-args...] [flags] +``` + +### Examples + +``` +# GET request to workspace root +$ cs curl / -w 1234 + +# GET request to port 3001 +$ cs curl /api/health -w 1234 -p 3001 + +# POST request with data +$ cs curl /api/data -w 1234 -- -XPOST -d '{"key":"value"}' + +# verbose output +$ cs curl /api/endpoint -w 1234 -- -v + +# HEAD request using workspace from env var +$ cs curl / -- -I +``` + +### Options + +``` + -h, --help help for curl + --insecure skip TLS certificate verification (for testing only) + -p, --port int Port to connect to (default 3000) + --timeout duration Timeout for the request (default 30s) +``` + +### Options inherited from parent commands + +``` + -a, --api string URL of Codesphere API (can also be CS_API) + -t, --team int Team ID (relevant for some commands, can also be CS_TEAM_ID) (default -1) + -v, --verbose Verbose output + -w, --workspace int Workspace ID (relevant for some commands, can also be CS_WORKSPACE_ID) (default -1) +``` + +### SEE ALSO + +* [cs](cs.md) - The Codesphere CLI + diff --git a/docs/cs_list_workspaces.md b/docs/cs_list_workspaces.md index b0c8201..3327f01 100644 --- a/docs/cs_list_workspaces.md +++ b/docs/cs_list_workspaces.md @@ -14,7 +14,7 @@ cs list workspaces [flags] ``` # List all workspaces -$ cs list workspaces --team-id +$ cs list workspaces -t ``` ### Options diff --git a/docs/cs_wake-up.md b/docs/cs_wake-up.md new file mode 100644 index 0000000..fa746d5 --- /dev/null +++ b/docs/cs_wake-up.md @@ -0,0 +1,45 @@ +## cs wake-up + +Wake up an on-demand workspace + +### Synopsis + +Wake up an on-demand workspace by scaling it to 1 replica via the API. + +``` +cs wake-up [flags] +``` + +### Examples + +``` +# wake up workspace 1234 +$ cs wake-up -w 1234 + +# wake up workspace set by environment variable CS_WORKSPACE_ID +$ cs wake-up + +# wake up workspace with 60 second timeout +$ cs wake-up -w 1234 --timeout 60s +``` + +### Options + +``` + -h, --help help for wake-up + --timeout duration Timeout for waking up the workspace (default 2m0s) +``` + +### Options inherited from parent commands + +``` + -a, --api string URL of Codesphere API (can also be CS_API) + -t, --team int Team ID (relevant for some commands, can also be CS_TEAM_ID) (default -1) + -v, --verbose Verbose output + -w, --workspace int Workspace ID (relevant for some commands, can also be CS_WORKSPACE_ID) (default -1) +``` + +### SEE ALSO + +* [cs](cs.md) - The Codesphere CLI + diff --git a/int/integration_test.go b/int/integration_test.go index 43ae670..9e62703 100644 --- a/int/integration_test.go +++ b/int/integration_test.go @@ -401,8 +401,13 @@ var _ = Describe("Open Workspace Integration Tests", func() { It("should fail when workspace ID is missing", func() { By("Attempting to open workspace without ID") originalWsId := os.Getenv("CS_WORKSPACE_ID") + originalWsIdFallback := os.Getenv("WORKSPACE_ID") _ = os.Unsetenv("CS_WORKSPACE_ID") - defer func() { _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) }() + _ = os.Unsetenv("WORKSPACE_ID") + defer func() { + _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) + _ = os.Setenv("WORKSPACE_ID", originalWsIdFallback) + }() output, exitCode := intutil.RunCommandWithExitCode( "open", "workspace", @@ -822,6 +827,8 @@ var _ = Describe("Command Error Handling Tests", func() { {"start pipeline", []string{"start", "pipeline", "-w", "99999999"}}, {"git pull", []string{"git", "pull", "-w", "99999999"}}, {"set-env", []string{"set-env", "-w", "99999999", "TEST_VAR=test"}}, + {"wake-up", []string{"wake-up", "-w", "99999999"}}, + {"curl", []string{"curl", "/", "-w", "99999999"}}, } for _, tc := range testCases { @@ -975,6 +982,348 @@ var _ = Describe("Git Pull Integration Tests", func() { }) }) +var _ = Describe("Wake Up Workspace Integration Tests", func() { + var ( + teamId string + workspaceName string + workspaceId string + ) + + BeforeEach(func() { + teamId, _ = intutil.SkipIfMissingEnvVars() + workspaceName = fmt.Sprintf("cli-wakeup-test-%d", time.Now().Unix()) + }) + + AfterEach(func() { + if workspaceId != "" { + By(fmt.Sprintf("Cleaning up: deleting workspace %s (ID: %s)", workspaceName, workspaceId)) + intutil.CleanupWorkspace(workspaceId) + workspaceId = "" + } + }) + + Context("Wake Up Command", func() { + BeforeEach(func() { + By("Creating a workspace for wake-up testing") + output := intutil.RunCommand( + "create", "workspace", workspaceName, + "-t", teamId, + "-p", "8", + "--timeout", "15m", + ) + fmt.Printf("Create workspace output: %s\n", output) + + Expect(output).To(ContainSubstring("Workspace created")) + workspaceId = intutil.ExtractWorkspaceId(output) + Expect(workspaceId).NotTo(BeEmpty()) + + By("Waiting for workspace to be fully provisioned") + time.Sleep(5 * time.Second) + }) + + It("should wake up workspace successfully", func() { + By("Waking up the workspace") + output := intutil.RunCommand( + "wake-up", + "-w", workspaceId, + ) + fmt.Printf("Wake up workspace output: %s\n", output) + + Expect(output).To(Or( + ContainSubstring("Waking up workspace"), + // The workspace might already be running + ContainSubstring("is already running"), + )) + Expect(output).To(ContainSubstring(workspaceId)) + }) + + It("should respect custom timeout", func() { + By("Waking up workspace with custom timeout") + output, exitCode := intutil.RunCommandWithExitCode( + "wake-up", + "-w", workspaceId, + "--timeout", "5s", + ) + fmt.Printf("Wake up with timeout output: %s (exit code: %d)\n", output, exitCode) + + Expect(output).To(Or( + ContainSubstring("Waking up workspace"), + // The workspace might already be running + ContainSubstring("is already running"), + )) + Expect(exitCode).To(Equal(0)) + }) + + It("should work with workspace ID from environment variable", func() { + By("Setting CS_WORKSPACE_ID environment variable") + originalWsId := os.Getenv("CS_WORKSPACE_ID") + _ = os.Setenv("CS_WORKSPACE_ID", workspaceId) + defer func() { _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) }() + + By("Waking up workspace using environment variable") + output := intutil.RunCommand("wake-up") + fmt.Printf("Wake up with env var output: %s\n", output) + + Expect(output).To(Or( + ContainSubstring("Waking up workspace"), + // The workspace might already be running + ContainSubstring("is already running"), + )) + Expect(output).To(ContainSubstring(workspaceId)) + }) + }) + + Context("Wake Up Error Handling", func() { + It("should fail when workspace ID is missing", func() { + By("Attempting to wake up workspace without ID") + originalWsId := os.Getenv("CS_WORKSPACE_ID") + originalWsIdFallback := os.Getenv("WORKSPACE_ID") + _ = os.Unsetenv("CS_WORKSPACE_ID") + _ = os.Unsetenv("WORKSPACE_ID") + defer func() { + _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) + _ = os.Setenv("WORKSPACE_ID", originalWsIdFallback) + }() + + output, exitCode := intutil.RunCommandWithExitCode("wake-up") + fmt.Printf("Wake up without workspace ID output: %s (exit code: %d)\n", output, exitCode) + + Expect(exitCode).NotTo(Equal(0)) + Expect(output).To(Or( + ContainSubstring("workspace"), + ContainSubstring("required"), + ContainSubstring("not set"), + )) + }) + + It("should fail gracefully with non-existent workspace", func() { + By("Attempting to wake up non-existent workspace") + output, exitCode := intutil.RunCommandWithExitCode( + "wake-up", + "-w", "99999999", + ) + fmt.Printf("Wake up non-existent workspace output: %s (exit code: %d)\n", output, exitCode) + + Expect(exitCode).NotTo(Equal(0)) + Expect(output).To(Or( + ContainSubstring("failed to get workspace"), + ContainSubstring("not found"), + ContainSubstring("404"), + )) + }) + + It("should handle workspace without dev domain gracefully", func() { + By("Creating a workspace (which might not have dev domain configured)") + output := intutil.RunCommand( + "create", "workspace", workspaceName, + "-t", teamId, + "-p", "8", + "--timeout", "15m", + ) + fmt.Printf("Create workspace output: %s\n", output) + + Expect(output).To(ContainSubstring("Workspace created")) + workspaceId = intutil.ExtractWorkspaceId(output) + Expect(workspaceId).NotTo(BeEmpty()) + + By("Attempting to wake up the workspace") + wakeupOutput, wakeupExitCode := intutil.RunCommandWithExitCode( + "wake-up", + "-w", workspaceId, + ) + fmt.Printf("Wake up workspace output: %s (exit code: %d)\n", wakeupOutput, wakeupExitCode) + + if wakeupExitCode != 0 { + Expect(wakeupOutput).To(Or( + ContainSubstring("development domain"), + ContainSubstring("dev domain"), + ContainSubstring("failed to wake up"), + )) + } + }) + }) + + Context("Wake Up Command Help", func() { + It("should display help information", func() { + By("Running wake-up --help") + output := intutil.RunCommand("wake-up", "--help") + fmt.Printf("Wake up help output: %s\n", output) + + Expect(output).To(ContainSubstring("Wake up an on-demand workspace")) + Expect(output).To(ContainSubstring("--timeout")) + Expect(output).To(ContainSubstring("-w, --workspace")) + }) + }) +}) + +var _ = Describe("Curl Workspace Integration Tests", func() { + var ( + teamId string + workspaceName string + workspaceId string + ) + + BeforeEach(func() { + teamId, _ = intutil.SkipIfMissingEnvVars() + workspaceName = fmt.Sprintf("cli-curl-test-%d", time.Now().Unix()) + }) + + AfterEach(func() { + if workspaceId != "" { + By(fmt.Sprintf("Cleaning up: deleting workspace %s (ID: %s)", workspaceName, workspaceId)) + intutil.CleanupWorkspace(workspaceId) + workspaceId = "" + } + }) + + Context("Curl Command", func() { + BeforeEach(func() { + By("Creating a workspace for curl testing") + output := intutil.RunCommand( + "create", "workspace", workspaceName, + "-t", teamId, + "-p", "8", + "--timeout", "15m", + ) + fmt.Printf("Create workspace output: %s\n", output) + + Expect(output).To(ContainSubstring("Workspace created")) + workspaceId = intutil.ExtractWorkspaceId(output) + Expect(workspaceId).NotTo(BeEmpty()) + + By("Waiting for workspace to be fully provisioned") + time.Sleep(5 * time.Second) + }) + + It("should send authenticated request to workspace", func() { + By("Sending curl request to workspace root") + output := intutil.RunCommand( + "curl", "/", + "-w", workspaceId, + "--insecure", + "--", "-s", "-o", "/dev/null", "-w", "%{http_code}", + ) + fmt.Printf("Curl workspace output: %s\n", output) + + Expect(output).To(ContainSubstring("Sending request to workspace")) + Expect(output).To(ContainSubstring(workspaceId)) + }) + + It("should support custom port", func() { + By("Sending curl request to custom port") + output, exitCode := intutil.RunCommandWithExitCode( + "curl", "/", + "-w", workspaceId, + "-p", "3001", + "--insecure", + "--", "-s", "-o", "/dev/null", "-w", "%{http_code}", + ) + fmt.Printf("Curl with custom port output: %s (exit code: %d)\n", output, exitCode) + + Expect(output).To(ContainSubstring("Sending request to workspace")) + }) + + It("should pass through curl arguments", func() { + By("Sending HEAD request using curl -I flag") + output := intutil.RunCommand( + "curl", "/", + "-w", workspaceId, + "--insecure", + "--", "-I", + ) + fmt.Printf("Curl with -I flag output: %s\n", output) + + Expect(output).To(ContainSubstring("Sending request to workspace")) + }) + + It("should work with workspace ID from environment variable", func() { + By("Setting CS_WORKSPACE_ID environment variable") + originalWsId := os.Getenv("CS_WORKSPACE_ID") + _ = os.Setenv("CS_WORKSPACE_ID", workspaceId) + defer func() { _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) }() + + By("Sending curl request using environment variable") + output := intutil.RunCommand( + "curl", "/", + "--insecure", + "--", "-s", "-o", "/dev/null", "-w", "%{http_code}", + ) + fmt.Printf("Curl with env var output: %s\n", output) + + Expect(output).To(ContainSubstring("Sending request to workspace")) + Expect(output).To(ContainSubstring(workspaceId)) + }) + }) + + Context("Curl Error Handling", func() { + It("should fail when workspace ID is missing", func() { + By("Attempting to curl without workspace ID") + originalWsId := os.Getenv("CS_WORKSPACE_ID") + originalWsIdFallback := os.Getenv("WORKSPACE_ID") + _ = os.Unsetenv("CS_WORKSPACE_ID") + _ = os.Unsetenv("WORKSPACE_ID") + defer func() { + _ = os.Setenv("CS_WORKSPACE_ID", originalWsId) + _ = os.Setenv("WORKSPACE_ID", originalWsIdFallback) + }() + + output, exitCode := intutil.RunCommandWithExitCode("curl", "/") + fmt.Printf("Curl without workspace ID output: %s (exit code: %d)\n", output, exitCode) + + Expect(exitCode).NotTo(Equal(0)) + Expect(output).To(Or( + ContainSubstring("workspace"), + ContainSubstring("required"), + ContainSubstring("not set"), + )) + }) + + It("should fail gracefully with non-existent workspace", func() { + By("Attempting to curl non-existent workspace") + output, exitCode := intutil.RunCommandWithExitCode( + "curl", "/", + "-w", "99999999", + ) + fmt.Printf("Curl non-existent workspace output: %s (exit code: %d)\n", output, exitCode) + + Expect(exitCode).NotTo(Equal(0)) + Expect(output).To(Or( + ContainSubstring("failed to get workspace"), + ContainSubstring("not found"), + ContainSubstring("404"), + )) + }) + + It("should require path argument", func() { + By("Attempting to curl without path") + output, exitCode := intutil.RunCommandWithExitCode( + "curl", + "-w", "1234", + ) + fmt.Printf("Curl without path output: %s (exit code: %d)\n", output, exitCode) + + Expect(exitCode).NotTo(Equal(0)) + Expect(output).To(Or( + ContainSubstring("path"), + ContainSubstring("required"), + ContainSubstring("argument"), + )) + }) + }) + + Context("Curl Command Help", func() { + It("should display help information", func() { + By("Running curl --help") + output := intutil.RunCommand("curl", "--help") + fmt.Printf("Curl help output: %s\n", output) + + Expect(output).To(ContainSubstring("Send authenticated HTTP requests")) + Expect(output).To(ContainSubstring("--port")) + Expect(output).To(ContainSubstring("-w, --workspace")) + }) + }) +}) + var _ = Describe("Command Error Handling Tests", func() { It("should fail gracefully with non-existent workspace for all commands", func() { testCases := []struct { diff --git a/int/util/workspace.go b/int/util/workspace.go index 2877271..ca27880 100644 --- a/int/util/workspace.go +++ b/int/util/workspace.go @@ -92,6 +92,10 @@ func WaitForWorkspaceRunning(client *api.Client, workspaceId int, timeout time.D return client.WaitForWorkspaceRunning(&api.Workspace{Id: workspaceId}, timeout) } +func ScaleWorkspace(client *api.Client, workspaceId int, replicas int) error { + return client.ScaleWorkspace(workspaceId, replicas) +} + func VerifyWorkspaceExists(workspaceId, teamId string) bool { output := RunCommand("list", "workspaces", "-t", teamId) return strings.Contains(output, workspaceId)