diff --git a/pkg/accounts/account_service.go b/pkg/accounts/account_service.go index 32390b91..d71db115 100644 --- a/pkg/accounts/account_service.go +++ b/pkg/accounts/account_service.go @@ -105,6 +105,8 @@ func (s *AccountService) GetByID(id string) (IAccount, error) { } // GetUsages lists the projects and deployments which are using an account. +// +// Deprecated: Use accounts.GetUsages func (s *AccountService) GetUsages(account IAccount) (*AccountUsage, error) { path := account.GetLinks()[constants.LinkUsages] resp, err := api.ApiGet(s.GetClient(), new(AccountUsage), path) @@ -197,6 +199,17 @@ func DeleteByID(client newclient.Client, spaceID string, id string) error { return newclient.DeleteByID(client, template, spaceID, id) } +// GetUsages lists the projects and deployments which are using an account. +func GetUsages(client newclient.Client, account IAccount) (*AccountUsage, error) { + path := account.GetLinks()[constants.LinkUsages] + res, err := newclient.Get[AccountUsage](client.HttpSession(), path) + if err != nil { + return nil, err + } + + return res, nil +} + // GetAll returns all accounts. If an error occurs, it returns nil. func GetAll(client newclient.Client, spaceID string) ([]IAccount, error) { items, err := newclient.GetAll[AccountResource](client, template, spaceID) diff --git a/pkg/actiontemplates/action_template_service.go b/pkg/actiontemplates/action_template_service.go index eddad856..cea90a92 100644 --- a/pkg/actiontemplates/action_template_service.go +++ b/pkg/actiontemplates/action_template_service.go @@ -1,6 +1,7 @@ package actiontemplates import ( + "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/newclient" "strings" "github.com/OctopusDeploy/go-octopusdeploy/v2/internal" @@ -39,6 +40,8 @@ func NewActionTemplateService(sling *sling.Sling, uriTemplate string, categories } // Add creates a new action template. +// +// Deprecated: Use actiontemplates.Add func (s *ActionTemplateService) Add(actionTemplate *ActionTemplate) (*ActionTemplate, error) { if IsNil(actionTemplate) { return nil, internal.CreateInvalidParameterError(constants.OperationAdd, constants.ParameterActionTemplate) @@ -64,6 +67,8 @@ func (s *ActionTemplateService) Add(actionTemplate *ActionTemplate) (*ActionTemp // Get returns a collection of action templates based on the criteria defined // by its input query parameter. If an error occurs, an empty collection is // returned along with the associated error. +// +// Deprecated: Use actiontemplates.Get func (s *ActionTemplateService) Get(actionTemplatesQuery Query) (*resources.Resources[*ActionTemplate], error) { v, _ := query.Values(actionTemplatesQuery) path := s.BasePath @@ -82,6 +87,8 @@ func (s *ActionTemplateService) Get(actionTemplatesQuery Query) (*resources.Reso // GetAll returns all action templates. If none can be found or an error // occurs, it returns an empty collection. +// +// Deprecated: Use actiontemplates.GetAll func (s *ActionTemplateService) GetAll() ([]*ActionTemplate, error) { items := []*ActionTemplate{} path, err := services.GetAllPath(s) @@ -94,6 +101,8 @@ func (s *ActionTemplateService) GetAll() ([]*ActionTemplate, error) { } // GetCategories returns all action template categories. +// +// Deprecated: Use actiontemplates.GetCategories func (s *ActionTemplateService) GetCategories() ([]ActionTemplateCategory, error) { items := new([]ActionTemplateCategory) if err := services.ValidateInternalState(s); err != nil { @@ -109,6 +118,8 @@ func (s *ActionTemplateService) GetCategories() ([]ActionTemplateCategory, error // GetByID returns the action template that matches the input ID. If one cannot // be found, it returns nil and an error. +// +// Deprecated: Use actiontemplates.GetByID func (s *ActionTemplateService) GetByID(id string) (*ActionTemplate, error) { if internal.IsEmpty(id) { return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) @@ -129,6 +140,8 @@ func (s *ActionTemplateService) GetByID(id string) (*ActionTemplate, error) { // Search lists all available action templates including built-in, custom, and // community-contributed step templates. +// +// Deprecated: Use actiontemplates.Search func (s *ActionTemplateService) Search(searchQuery string) ([]ActionTemplateSearch, error) { searchResults := []ActionTemplateSearch{} if err := services.ValidateInternalState(s); err != nil { @@ -155,6 +168,8 @@ func (s *ActionTemplateService) Search(searchQuery string) ([]ActionTemplateSear } // Update modifies an ActionTemplate based on the one provided as input. +// +// Deprecated: Use actiontemplates.Update func (s *ActionTemplateService) Update(actionTemplate *ActionTemplate) (*ActionTemplate, error) { if actionTemplate == nil { return nil, internal.CreateInvalidParameterError(constants.OperationUpdate, "actionTemplate") @@ -172,3 +187,82 @@ func (s *ActionTemplateService) Update(actionTemplate *ActionTemplate) (*ActionT return resp.(*ActionTemplate), nil } + +// ----- new ----- +const ( + template = "/api/{spaceId}/actiontemplates{/id}" + categoriesTemplate = "/api/{spaceId}/actiontemplates/categories" + searchTemplate = "/api/{spaceId}/actiontemplates/search" +) + +// Add creates a new action template. +func Add(client newclient.Client, actionTemplate *ActionTemplate) (*ActionTemplate, error) { + if IsNil(actionTemplate) { + return nil, internal.CreateInvalidParameterError(constants.OperationAdd, constants.ParameterActionTemplate) + } + + if err := actionTemplate.Validate(); err != nil { + return nil, internal.CreateValidationFailureError(constants.OperationAdd, err) + } + + return newclient.Add[ActionTemplate](client, template, actionTemplate.SpaceID, actionTemplate) +} + +// Get returns a collection of action templates based on the criteria defined +// by its input query parameter. If an error occurs, an empty collection is +// returned along with the associated error. +func Get(client newclient.Client, spaceID string, actionTemplatesQuery Query) (*resources.Resources[*ActionTemplate], error) { + return newclient.GetByQuery[ActionTemplate](client, template, spaceID, actionTemplatesQuery) +} + +// GetAll returns all action templates. If none can be found or an error +// occurs, it returns an empty collection. +func GetAll(client newclient.Client, spaceID string) ([]*ActionTemplate, error) { + return newclient.GetAll[ActionTemplate](client, template, spaceID) +} + +// GetCategories returns all action template categories. +func GetCategories(client newclient.Client, spaceID string) ([]*ActionTemplateCategory, error) { + return newclient.GetAll[ActionTemplateCategory](client, categoriesTemplate, spaceID) +} + +// GetByID returns the action template that matches the input ID. If one cannot +// be found, it returns nil and an error. +func GetByID(client newclient.Client, spaceID string, id string) (*ActionTemplate, error) { + if internal.IsEmpty(id) { + return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) + } + + return newclient.GetByID[ActionTemplate](client, template, spaceID, id) +} + +// Search lists all available action templates including built-in, custom, and +// community-contributed step templates. +func Search(client newclient.Client, spaceID string, searchQuery string) (*[]ActionTemplateSearch, error) { + path, err := client.URITemplateCache().Expand(searchTemplate, map[string]any{ + "spaceId": spaceID, + "type": searchQuery, + }) + if err != nil { + return nil, err + } + + if len(searchQuery) <= 0 { + path = strings.Split(path, "?")[0] + } + + return newclient.Get[[]ActionTemplateSearch](client.HttpSession(), path) +} + +// Update modifies an ActionTemplate based on the one provided as input. +func Update(client newclient.Client, actionTemplate *ActionTemplate) (*ActionTemplate, error) { + if actionTemplate == nil { + return nil, internal.CreateInvalidParameterError(constants.OperationUpdate, "actionTemplate") + } + + return newclient.Update[ActionTemplate](client, template, actionTemplate.SpaceID, actionTemplate.ID, actionTemplate) +} + +func DeleteByID(client newclient.Client, spaceID string, id string) error { + return newclient.DeleteByID(client, template, spaceID, id) +} diff --git a/pkg/artifacts/artifact_service.go b/pkg/artifacts/artifact_service.go index 9163c324..d0bd3f1a 100644 --- a/pkg/artifacts/artifact_service.go +++ b/pkg/artifacts/artifact_service.go @@ -3,6 +3,7 @@ package artifacts import ( "github.com/OctopusDeploy/go-octopusdeploy/v2/internal" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/constants" + "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/newclient" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/resources" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/services" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/services/api" @@ -26,6 +27,8 @@ func NewArtifactService(sling *sling.Sling, uriTemplate string) *ArtifactService } // Add creates a new artifact. +// +// Deprecated: Use artifacts.Add func (s *ArtifactService) Add(artifact *Artifact) (*Artifact, error) { if IsNil(artifact) { return nil, internal.CreateInvalidParameterError(constants.OperationAdd, constants.ParameterArtifact) @@ -47,6 +50,8 @@ func (s *ArtifactService) Add(artifact *Artifact) (*Artifact, error) { // Get returns a collection of artifacts based on the criteria defined by its // input query parameter. If an error occurs, an empty collection is returned // along with the associated error. +// +// Deprecated: Use artifacts.Get func (s *ArtifactService) Get(artifactsQuery Query) (*resources.Resources[*Artifact], error) { v, _ := query.Values(artifactsQuery) path := s.BasePath @@ -65,6 +70,8 @@ func (s *ArtifactService) Get(artifactsQuery Query) (*resources.Resources[*Artif // GetAll returns all artifacts. If none can be found or an error occurs, it // returns an empty collection. +// +// Deprecated: Use artifacts.GetAll func (s *ArtifactService) GetAll() ([]*Artifact, error) { path, err := services.GetPath(s) if err != nil { @@ -76,6 +83,8 @@ func (s *ArtifactService) GetAll() ([]*Artifact, error) { // GetByID returns the artifact that matches the input ID. If one cannot be // found, it returns nil and an error. +// +// Deprecated: Use artifacts.GetByID func (s *ArtifactService) GetByID(id string) (*Artifact, error) { if internal.IsEmpty(id) { return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) @@ -95,6 +104,8 @@ func (s *ArtifactService) GetByID(id string) (*Artifact, error) { } // Update modifies an Artifact based on the one provided as input. +// +// Deprecated: Use artifacts.Update func (s *ArtifactService) Update(artifact Artifact) (*Artifact, error) { path, err := services.GetUpdatePath(s, &artifact) if err != nil { @@ -108,3 +119,49 @@ func (s *ArtifactService) Update(artifact Artifact) (*Artifact, error) { return resp.(*Artifact), nil } + +// ----- new ----- + +const template = "/api/{spaceId}/artifacts{/id}" + +// Add creates a new artifact. +func Add(client newclient.Client, artifact *Artifact) (*Artifact, error) { + if IsNil(artifact) { + return nil, internal.CreateInvalidParameterError(constants.OperationAdd, constants.ParameterArtifact) + } + + resp, err := newclient.Add[Artifact](client, template, artifact.SpaceID, artifact) + if err != nil { + return nil, err + } + + return resp, nil +} + +// Get returns a collection of artifacts based on the criteria defined by its +// input query parameter. If an error occurs, an empty collection is returned +// along with the associated error. +func Get(client newclient.Client, spaceID string, artifactsQuery Query) (*resources.Resources[*Artifact], error) { + return newclient.GetByQuery[Artifact](client, template, spaceID, artifactsQuery) +} + +// GetAll returns all artifacts. If none can be found or an error occurs, it +// returns an empty collection. +func GetAll(client newclient.Client, spaceID string) ([]*Artifact, error) { + return newclient.GetAll[Artifact](client, template, spaceID) +} + +// GetByID returns the artifact that matches the input ID. If one cannot be +// found, it returns nil and an error. +func GetByID(client newclient.Client, spaceID string, id string) (*Artifact, error) { + if internal.IsEmpty(id) { + return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) + } + + return newclient.GetByID[Artifact](client, template, spaceID, id) +} + +// Update modifies an Artifact based on the one provided as input. +func Update(client newclient.Client, artifact Artifact) (*Artifact, error) { + return newclient.Update[Artifact](client, template, artifact.SpaceID, artifact.ID, artifact) +} diff --git a/pkg/authentication/authentication_service.go b/pkg/authentication/authentication_service.go index d857ae15..1e63b76d 100644 --- a/pkg/authentication/authentication_service.go +++ b/pkg/authentication/authentication_service.go @@ -2,6 +2,7 @@ package authentication import ( "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/constants" + "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/newclient" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/services" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/services/api" "github.com/dghubble/sling" @@ -22,6 +23,7 @@ func NewAuthenticationService(sling *sling.Sling, uriTemplate string, loginIniti } } +// Deprecated: Use authentication.Get func (s *AuthenticationService) Get() (*Authentication, error) { path, err := services.GetPath(s) if err != nil { @@ -35,3 +37,10 @@ func (s *AuthenticationService) Get() (*Authentication, error) { return resp.(*Authentication), nil } + +// ----- new ----- +const template = "/api/authentication" + +func Get(client newclient.Client) (*Authentication, error) { + return newclient.Get[Authentication](client.HttpSession(), template) +} diff --git a/pkg/certificates/certificate_service.go b/pkg/certificates/certificate_service.go index 20c4a565..e3d6b29d 100644 --- a/pkg/certificates/certificate_service.go +++ b/pkg/certificates/certificate_service.go @@ -2,7 +2,6 @@ package certificates import ( "fmt" - "github.com/OctopusDeploy/go-octopusdeploy/v2/internal" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/constants" "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/newclient" @@ -52,6 +51,8 @@ func (s *CertificateService) Add(certificate *CertificateResource) (*Certificate } // Archive sets the status of a certificate to an archived state. +// +// Deprecated: use certificates.Archive func (s *CertificateService) Archive(resource *CertificateResource) (*CertificateResource, error) { path := resource.Links["Archive"] @@ -136,6 +137,7 @@ func (s *CertificateService) Update(resource CertificateResource) (*CertificateR return resp.(*CertificateResource), nil } +// Deprecated: use certificates.Replace func (s *CertificateService) Replace(certificateID string, replacementCertificate *ReplacementCertificate) (*CertificateResource, error) { if internal.IsEmpty(certificateID) { return nil, internal.CreateInvalidParameterError("Replace", "certificateID") @@ -162,6 +164,8 @@ func (s *CertificateService) Replace(certificateID string, replacementCertificat } // Unarchive resets the status of an archived certificate. +// +// Deprecated: use certificates.Unarchive func (s *CertificateService) Unarchive(resource *CertificateResource) (*CertificateResource, error) { path := resource.Links["Unarchive"] @@ -175,7 +179,10 @@ func (s *CertificateService) Unarchive(resource *CertificateResource) (*Certific // --- new --- -const template = "/api/{spaceId}/certificates{/id}{?skip,take,search,archived,tenant,firstResult,orderBy,ids,partialName}" +const ( + template = "/api/{spaceId}/certificates{/id}{?skip,take,search,archived,tenant,firstResult,orderBy,ids,partialName}" + certificateReplaceTemplate = "/api/{spaceID}/certificates/{id}/replace" +) // Get returns a collection of certificates based on the criteria defined by its input // query parameter. If an error occurs, a nil is returned along @@ -209,3 +216,51 @@ func Update(client newclient.Client, resource *CertificateResource) (*Certificat func GetAll(client newclient.Client, spaceID string) ([]*CertificateResource, error) { return newclient.GetAll[CertificateResource](client, template, spaceID) } + +// Archive sets the status of a certificate to an archived state. +func Archive(client newclient.Client, spaceID string, resource *CertificateResource) (*CertificateResource, error) { + path := resource.Links["Archive"] + + _, err := newclient.Post[CertificateResource](client.HttpSession(), path, resource) + if err != nil { + return resource, err + } + + return newclient.GetByID[CertificateResource](client, template, spaceID, resource.GetID()) +} + +func Replace(client newclient.Client, spaceID string, certificateID string, replacementCertificate *ReplacementCertificate) (*CertificateResource, error) { + if internal.IsEmpty(certificateID) { + return nil, internal.CreateInvalidParameterError("Replace", "certificateID") + } + + if replacementCertificate == nil { + return nil, internal.CreateInvalidParameterError("Replace", "replacementCertificate") + } + + templateParams := map[string]any{"spaceId": spaceID, "id": certificateID} + expandedUri, err := client.URITemplateCache().Expand(certificateReplaceTemplate, templateParams) + if err != nil { + return nil, err + } + + if _, err := newclient.Post[CertificateResource](client.HttpSession(), expandedUri, replacementCertificate); err != nil { + return nil, err + } + + // The API endpoint /certificates/id/replace returns the old cert, we need + // to re-query to get the updated one + return newclient.GetByID[CertificateResource](client, template, spaceID, certificateID) +} + +// Unarchive resets the status of an archived certificate. +func Unarchive(client newclient.Client, spaceID string, resource *CertificateResource) (*CertificateResource, error) { + path := resource.Links["Unarchive"] + + _, err := newclient.Post[CertificateResource](client.HttpSession(), path, resource) + if err != nil { + return resource, err + } + + return newclient.GetByID[CertificateResource](client, template, spaceID, resource.GetID()) +} diff --git a/pkg/deployments/deployment_service.go b/pkg/deployments/deployment_service.go index 3080ac1c..c4ef0635 100644 --- a/pkg/deployments/deployment_service.go +++ b/pkg/deployments/deployment_service.go @@ -13,7 +13,8 @@ import ( "github.com/dghubble/sling" ) -// DeploymentService handles communication for any operations in the Octopus +// handles communication for any operations in the Octopus +// // API that pertain to deployments. type DeploymentService struct { services.CanDeleteService @@ -30,6 +31,8 @@ func NewDeploymentService(sling *sling.Sling, uriTemplate string) *DeploymentSer } // Add creates a new deployment. +// +// Deprecated: Use deployments.Add func (s *DeploymentService) Add(deployment *Deployment) (*Deployment, error) { if IsNil(deployment) { return nil, internal.CreateInvalidParameterError(constants.OperationAdd, "deployment") @@ -50,6 +53,8 @@ func (s *DeploymentService) Add(deployment *Deployment) (*Deployment, error) { // GetByID gets a deployment that matches the input ID. If one cannot be found, // it returns nil and an error. +// +// Deprecated: Use deployments.GetByID func (s *DeploymentService) GetByID(id string) (*Deployment, error) { if internal.IsEmpty(id) { return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) @@ -69,6 +74,8 @@ func (s *DeploymentService) GetByID(id string) (*Deployment, error) { } // GetByIDs gets a list of deployments that match the input IDs. +// +// Deprecated: Use deployments.GetByIDs func (s *DeploymentService) GetByIDs(ids []string) ([]*Deployment, error) { if len(ids) == 0 { return []*Deployment{}, nil @@ -83,6 +90,8 @@ func (s *DeploymentService) GetByIDs(ids []string) ([]*Deployment, error) { } // GetByName performs a lookup and returns instances of a Deployment with a matching partial name. +// +// Deprecated: Use deployments.GetByName func (s *DeploymentService) GetByName(name string) ([]*Deployment, error) { if internal.IsEmpty(name) { return []*Deployment{}, internal.CreateInvalidParameterError(constants.OperationGetByName, constants.ParameterName) @@ -97,6 +106,8 @@ func (s *DeploymentService) GetByName(name string) ([]*Deployment, error) { } // Update modifies a Deployment based on the one provided as input. +// +// Deprecated: Use deployments.Update func (s *DeploymentService) Update(resource Deployment) (*Deployment, error) { path, err := services.GetUpdatePath(s, &resource) if err != nil { @@ -111,6 +122,7 @@ func (s *DeploymentService) Update(resource Deployment) (*Deployment, error) { return resp.(*Deployment), nil } +// Deprecated: Use deployments.GetDeployments func (s *DeploymentService) GetDeployments(release *releases.Release, deploymentQuery ...*DeploymentQuery) (*resources.Resources[*Deployment], error) { if release == nil { return nil, internal.CreateInvalidParameterError("GetDeployments", "release") @@ -142,6 +154,7 @@ func (s *DeploymentService) GetDeployments(release *releases.Release, deployment return resp.(*resources.Resources[*Deployment]), nil } +// Deprecated: Use deployments.GetProgression func (s *DeploymentService) GetProgression(release *releases.Release) (*releases.LifecycleProgression, error) { if release == nil { return nil, internal.CreateInvalidParameterError(constants.OperationGetDeployments, constants.ParameterRelease) @@ -158,6 +171,8 @@ func (s *DeploymentService) GetProgression(release *releases.Release) (*releases // GetDeploymentSettings loads the deployment settings for a project. // If the project is version controlled you'll need to specify a gitRef such as 'main' +// +// Deprecated: Use deployments.GetDeploymentSettings func (s *DeploymentService) GetDeploymentSettings(project *projects.Project, gitRef string) (*DeploymentSettings, error) { if project == nil { return nil, internal.CreateInvalidParameterError("GetDeploymentSettings", constants.ParameterProject) @@ -189,6 +204,156 @@ func (s *DeploymentService) GetDeploymentSettings(project *projects.Project, git return resp.(*DeploymentSettings), nil } +// ----- new ----- + +const deploymentsTemplate = "/api/{spaceId}/deployments{/id}{?skip,take,ids,projects,environments,tenants,channels,taskState,partialName}" + +// Add creates a new deployment. +func Add(client newclient.Client, deployment *Deployment) (*Deployment, error) { + if IsNil(deployment) { + return nil, internal.CreateInvalidParameterError(constants.OperationAdd, "deployment") + } + + resp, err := newclient.Add[Deployment](client, deploymentsTemplate, deployment.SpaceID, deployment) + if err != nil { + return nil, err + } + + return resp, nil +} + +// GetByID gets a deployment that matches the input ID. If one cannot be found, +// it returns nil and an error. +func GetByID(client newclient.Client, spaceID string, id string) (*Deployment, error) { + if internal.IsEmpty(id) { + return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) + } + + resp, err := newclient.GetByID[Deployment](client, deploymentsTemplate, spaceID, id) + if err != nil { + return nil, err + } + + return resp, nil +} + +// GetByIDs gets a list of deployments that match the input IDs. +func GetByIDs(client newclient.Client, spaceID string, ids []string) ([]*Deployment, error) { + if len(ids) == 0 { + return []*Deployment{}, nil + } + + templateParams := map[string]any{"spaceId": spaceID, "ids": ids} + expandedUri, err := client.URITemplateCache().Expand(deploymentsTemplate, templateParams) + if err != nil { + return nil, err + } + + searchResults, err := newclient.Get[resources.Resources[*Deployment]](client.HttpSession(), expandedUri) + return searchResults.Items, nil +} + +// GetByName performs a lookup and returns instances of a Deployment with a matching partial name. +func GetByName(client newclient.Client, spaceID string, name string) ([]*Deployment, error) { + if internal.IsEmpty(name) { + return []*Deployment{}, internal.CreateInvalidParameterError(constants.OperationGetByName, constants.ParameterName) + } + + templateParams := map[string]any{"spaceId": spaceID, "partialName": name} + expandedUri, err := client.URITemplateCache().Expand(deploymentsTemplate, templateParams) + if err != nil { + return nil, err + } + + searchResults, err := newclient.Get[resources.Resources[*Deployment]](client.HttpSession(), expandedUri) + return searchResults.Items, nil +} + +// Update modifies a Deployment based on the one provided as input. +func Update(client newclient.Client, resource Deployment) (*Deployment, error) { + resp, err := newclient.Update[Deployment](client, deploymentsTemplate, resource.SpaceID, resource.ID, resource) + if err != nil { + return nil, err + } + + return resp, nil +} + +func GetDeployments(client newclient.Client, release *releases.Release, deploymentQuery ...*DeploymentQuery) (*resources.Resources[*Deployment], error) { + if release == nil { + return nil, internal.CreateInvalidParameterError("GetDeployments", "release") + } + + uriTemplate, err := uritemplates.Parse(release.GetLinks()[constants.LinkDeployments]) + if err != nil { + return &resources.Resources[*Deployment]{}, err + } + + values := make(map[string]interface{}) + path, err := uriTemplate.Expand(values) + if err != nil { + return &resources.Resources[*Deployment]{}, err + } + + if deploymentQuery != nil { + path, err = uriTemplate.Expand(deploymentQuery[0]) + if err != nil { + return &resources.Resources[*Deployment]{}, err + } + } + + resp, err := newclient.Get[resources.Resources[*Deployment]](client.HttpSession(), path) + if err != nil { + return &resources.Resources[*Deployment]{}, err + } + + return resp, nil +} + +func GetProgression(client newclient.Client, release *releases.Release) (*releases.LifecycleProgression, error) { + if release == nil { + return nil, internal.CreateInvalidParameterError(constants.OperationGetDeployments, constants.ParameterRelease) + } + + path := release.GetLinks()[constants.LinkProgression] + resp, err := newclient.Get[releases.LifecycleProgression](client.HttpSession(), path) + if err != nil { + return nil, err + } + + return resp, nil +} + +// GetDeploymentSettings loads the deployment settings for a project. +// If the project is version controlled you'll need to specify a gitRef such as 'main' +func GetDeploymentSettings(client newclient.Client, project *projects.Project, gitRef string) (*DeploymentSettings, error) { + if project == nil { + return nil, internal.CreateInvalidParameterError("GetDeploymentSettings", constants.ParameterProject) + } + + template, err := uritemplates.Parse(project.Links[constants.LinkDeploymentSettings]) + if err != nil { + return nil, err + } + + var templateParameters map[string]interface{} + if gitRef != "" { + templateParameters = map[string]interface{}{"gitRef": gitRef} + } else { // non-CaC project links don't have templates so this is a no-op, but it would safely remove any {?extra}{junk} that might be on the query string + templateParameters = map[string]interface{}{} + } + + path, err := template.Expand(templateParameters) + if err != nil { + return nil, err + } + resp, err := newclient.Get[DeploymentSettings](client.HttpSession(), path) + if err != nil { + return nil, err + } + return resp, nil +} + // GetReleaseDeploymentPreview gets a preview of a release for a given environment. // This is used by the portal to show which machines would be deployed to, and other information about the deployment, // before proceeding with it. The CLI uses it to build the selector for picking specific machines to deploy to diff --git a/pkg/releases/release_service.go b/pkg/releases/release_service.go index b315550a..ac2455c9 100644 --- a/pkg/releases/release_service.go +++ b/pkg/releases/release_service.go @@ -26,6 +26,8 @@ func NewReleaseService(sling *sling.Sling, uriTemplate string) *ReleaseService { } // Add creates a new release. +// +// Deprecated: Use releases.Add func (s *ReleaseService) Add(release *Release) (*Release, error) { if IsNil(release) { return nil, internal.CreateInvalidParameterError(constants.OperationAdd, constants.ParameterRelease) @@ -47,6 +49,8 @@ func (s *ReleaseService) Add(release *Release) (*Release, error) { // Get returns a collection of releases based on the criteria defined by its // input query parameter. If an error occurs, an empty collection is returned // along with the associated error. +// +// Deprecated: Use releases.Get func (s *ReleaseService) Get(releasesQuery ...ReleasesQuery) (*resources.Resources[*Release], error) { v, _ := query.Values(releasesQuery[0]) path := s.BasePath @@ -65,6 +69,8 @@ func (s *ReleaseService) Get(releasesQuery ...ReleasesQuery) (*resources.Resourc // GetByID returns the release that matches the input ID. If one cannot be // found, it returns nil and an error. +// +// Deprecated: Use releases.GetByID func (s *ReleaseService) GetByID(id string) (*Release, error) { if internal.IsEmpty(id) { return nil, internal.CreateInvalidParameterError(constants.OperationGetByID, constants.ParameterID) @@ -83,6 +89,7 @@ func (s *ReleaseService) GetByID(id string) (*Release, error) { return resp.(*Release), nil } +// Deprecated func (s *ReleaseService) GetReleases(channel *channels.Channel, releaseQuery ...*ReleaseQuery) (*resources.Resources[*Release], error) { if channel == nil { return nil, internal.CreateInvalidParameterError("GetReleases", "channel") @@ -116,6 +123,25 @@ func (s *ReleaseService) GetReleases(channel *channels.Channel, releaseQuery ... // ----- Experimental --------------------------------------------------------- +const template = "/api/{spaceId}/releases{/id}{?skip,ignoreChannelRules,take,ids}" + +// Add creates a new release. +func Add(client newclient.Client, release *Release) (*Release, error) { + return newclient.Add[Release](client, template, release.SpaceID, release) +} + +// Get returns a collection of releases based on the criteria defined by its +// input query parameter. +func Get(client newclient.Client, spaceID string, releasesQuery ReleasesQuery) (*resources.Resources[*Release], error) { + return newclient.GetByQuery[Release](client, template, spaceID, releasesQuery) +} + +// GetByID returns the release that matches the input ID. If one cannot be +// found, it returns nil and an error. +func GetByID(client newclient.Client, spaceID string, ID string) (*Release, error) { + return newclient.GetByID[Release](client, template, spaceID, ID) +} + // GetReleasesInProjectChannel is EXPERIMENTAL func GetReleasesInProjectChannel(client newclient.Client, spaceID string, projectID string, channelID string) ([]*Release, error) { if client == nil { diff --git a/test/e2e/account_service_test.go b/test/e2e/account_service_test.go index 10127156..ea1fdfc6 100644 --- a/test/e2e/account_service_test.go +++ b/test/e2e/account_service_test.go @@ -570,11 +570,11 @@ func TestAccountServiceUpdate(t *testing.T) { // === NEW === -func TestAccountServiceGetByIDs_NewClient(t *testing.T) { +func TestAccountServiceGetByIDs_New(t *testing.T) { client := getOctopusClient() require.NotNil(t, client) - accountsToTest, err := client.Accounts.GetAll() + accountsToTest, err := accounts.GetAll(client, client.GetSpaceID()) require.NoError(t, err) require.NotNil(t, accountsToTest) @@ -589,3 +589,366 @@ func TestAccountServiceGetByIDs_NewClient(t *testing.T) { require.NoError(t, err) require.GreaterOrEqual(t, len(accountsToTest), len(accountsByIDs.Items)) } + +func CreateTestAmazonWebServicesAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + accessKey := internal.GetRandomName() + name := internal.GetRandomName() + secretKey := core.NewSensitiveValue(internal.GetRandomName()) + + account, err := accounts.NewAmazonWebServicesAccount(name, accessKey, secretKey) + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + createdAccount, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, createdAccount) + require.NotEmpty(t, createdAccount.GetID()) + require.Equal(t, accounts.AccountTypeAmazonWebServicesAccount, createdAccount.GetAccountType()) + require.Equal(t, name, createdAccount.GetName()) + + return createdAccount +} + +func CreateTestAzureServicePrincipalAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + applicationID := uuid.New() + applicationPassword := core.NewSensitiveValue(internal.GetRandomName()) + azureEnvironment := getRandomAzureEnvironment() + name := internal.GetRandomName() + subscriptionID := uuid.New() + tenantID := uuid.New() + + account, err := accounts.NewAzureServicePrincipalAccount(name, subscriptionID, tenantID, applicationID, applicationPassword) + + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + // set Azure environment fields + if !internal.IsEmpty(azureEnvironment.Name) { + account.AzureEnvironment = azureEnvironment.Name + account.AuthenticationEndpoint = azureEnvironment.AuthenticationEndpoint + account.ResourceManagerEndpoint = azureEnvironment.ResourceManagerEndpoint + } + + require.NoError(t, account.Validate()) + + createdAccount, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, createdAccount) + require.NotEmpty(t, createdAccount.GetID()) + require.Equal(t, accounts.AccountTypeAzureServicePrincipal, createdAccount.GetAccountType()) + require.Equal(t, name, createdAccount.GetName()) + + return createdAccount +} + +func CreateTestAzureOIDCAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + applicationID := uuid.New() + azureEnvironment := getRandomAzureEnvironment() + name := internal.GetRandomName() + subscriptionID := uuid.New() + tenantID := uuid.New() + + account, err := accounts.NewAzureOIDCAccount(name, subscriptionID, tenantID, applicationID) + + require.NoError(t, err) + require.NotNil(t, account) + require.NoError(t, account.Validate()) + + // set Azure environment fields + if !internal.IsEmpty(azureEnvironment.Name) { + account.AzureEnvironment = azureEnvironment.Name + account.AuthenticationEndpoint = azureEnvironment.AuthenticationEndpoint + account.ResourceManagerEndpoint = azureEnvironment.ResourceManagerEndpoint + } + + require.NoError(t, account.Validate()) + + createdAccount, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, createdAccount) + require.NotEmpty(t, createdAccount.GetID()) + require.Equal(t, accounts.AccountTypeAzureOIDC, createdAccount.GetAccountType()) + require.Equal(t, name, createdAccount.GetName()) + + return createdAccount +} + +func CreateTestAzureSubscriptionAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + azureEnvironment := getRandomAzureEnvironment() + name := internal.GetRandomName() + subscriptionID := uuid.New() + + account, err := accounts.NewAzureSubscriptionAccount(name, subscriptionID) + + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + // set Azure environment fields + if !internal.IsEmpty(azureEnvironment.Name) { + account.AzureEnvironment = azureEnvironment.Name + account.ManagementEndpoint = azureEnvironment.ManagementEndpoint + account.StorageEndpointSuffix = azureEnvironment.StorageEndpointSuffix + } + + require.NoError(t, account.Validate()) + + resource, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, resource) + + return resource +} + +func CreateTestSSHKeyAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + name := internal.GetRandomName() + username := internal.GetRandomName() + privateKeyFile := core.NewSensitiveValue(internal.GetRandomName()) + + account, err := accounts.NewSSHKeyAccount(name, username, privateKeyFile) + + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + resource, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, resource) + + return resource +} + +func CreateTestTokenAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + name := internal.GetRandomName() + token := core.NewSensitiveValue(internal.GetRandomName()) + + account, err := accounts.NewTokenAccount(name, token) + + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + resource, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, resource) + + return resource +} + +func CreateTestUsernamePasswordAccount_New(t *testing.T, client *client.Client) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + name := internal.GetRandomName() + + account, err := accounts.NewUsernamePasswordAccount(name) + require.NotNil(t, account) + require.NoError(t, err) + require.NoError(t, account.Validate()) + + resource, err := accounts.Add(client, account) + require.NoError(t, err) + require.NotNil(t, resource) + + return resource +} + +func DeleteTestAccount_New(t *testing.T, client *client.Client, account accounts.IAccount) { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + err := client.Accounts.DeleteByID(account.GetID()) + assert.NoError(t, err) + + // verify the delete operation was successful + deletedAccount, err := accounts.GetByID(client, client.GetSpaceID(), account.GetID()) + assert.Error(t, err) + assert.Nil(t, deletedAccount) +} + +func UpdateAccount_New(t *testing.T, client *client.Client, account accounts.IAccount) accounts.IAccount { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + updatedAccount, err := accounts.Update(client, account) + require.NoError(t, err) + require.NotNil(t, updatedAccount) + + return updatedAccount +} + +func TestAccountServiceAddGetDelete_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + amazonWebServicesAccount := CreateTestAmazonWebServicesAccount_New(t, client) + ValidateAccount(t, amazonWebServicesAccount) + defer DeleteTestAccount_New(t, client, amazonWebServicesAccount) + + azureServicePrincipalAccount := CreateTestAzureServicePrincipalAccount_New(t, client) + ValidateAccount(t, azureServicePrincipalAccount) + defer DeleteTestAccount_New(t, client, azureServicePrincipalAccount) + + azureOIDCAccount := CreateTestAzureOIDCAccount_New(t, client) + ValidateAccount(t, azureOIDCAccount) + defer DeleteTestAccount_New(t, client, azureOIDCAccount) + + azureSubscriptionAccount := CreateTestAzureSubscriptionAccount_New(t, client) + ValidateAccount(t, azureSubscriptionAccount) + defer DeleteTestAccount_New(t, client, azureSubscriptionAccount) + + sshKeyAccount := CreateTestSSHKeyAccount_New(t, client) + ValidateAccount(t, sshKeyAccount) + defer DeleteTestAccount_New(t, client, sshKeyAccount) + + tokenAccount := CreateTestTokenAccount_New(t, client) + ValidateAccount(t, tokenAccount) + defer DeleteTestAccount_New(t, client, tokenAccount) + + usernamePasswordAccount := CreateTestUsernamePasswordAccount_New(t, client) + ValidateAccount(t, usernamePasswordAccount) + defer DeleteTestAccount_New(t, client, usernamePasswordAccount) + + allAccounts, err := accounts.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, allAccounts) + + for _, account := range allAccounts { + name := account.GetName() + query := accounts.AccountsQuery{ + PartialName: name, + Take: 1, + } + + namedAccounts, err := accounts.Get(client, client.GetSpaceID(), &query) + require.NoError(t, err) + require.NotNil(t, namedAccounts) + + for _, namedAccount := range namedAccounts.Items { + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), namedAccount.GetID()) + require.NoError(t, err) + require.NotNil(t, accountToCompare) + CompareAccounts(t, namedAccount, accountToCompare) + } + + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), account.GetID()) + require.NoError(t, err) + require.NotNil(t, accountToCompare) + + for _, namedAccount := range namedAccounts.Items { + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), namedAccount.GetID()) + require.NoError(t, err) + require.NotNil(t, accountToCompare) + CompareAccounts(t, namedAccount, accountToCompare) + } + + accountUsages, err := accounts.GetUsages(client, account) + require.NoError(t, err) + require.NotNil(t, accountUsages) + } + + accountTypes := []accounts.AccountType{ + accounts.AccountTypeNone, + accounts.AccountTypeUsernamePassword, + accounts.AccountTypeSSHKeyPair, + accounts.AccountTypeAzureSubscription, + accounts.AccountTypeAzureServicePrincipal, + accounts.AccountTypeAzureOIDC, + accounts.AccountTypeAmazonWebServicesAccount, + accounts.AccountTypeToken, + } + + for _, accountType := range accountTypes { + query := accounts.AccountsQuery{AccountType: accountType} + accountResource, err := accounts.Get(client, client.GetSpaceID(), &query) + require.NoError(t, err) + + for _, account := range accountResource.Items { + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), account.GetID()) + require.NoError(t, err) + CompareAccounts(t, account, accountToCompare) + } + } +} + +func TestAccountServiceGetByID_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + id := internal.GetRandomName() + resource, err := accounts.GetByID(client, client.GetSpaceID(), id) + require.Error(t, err) + require.Nil(t, resource) + + apiError := err.(*core.APIError) + assert.Equal(t, 404, apiError.StatusCode) + + accountResource, err := accounts.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, accountResource) + + for _, account := range accountResource { + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), account.GetID()) + require.NoError(t, err) + CompareAccounts(t, account, accountToCompare) + } +} + +func TestAccountServiceTokenAccounts_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + for i := 0; i < 10; i++ { + tokenAccount := CreateTestTokenAccount(t, client) + ValidateAccount(t, tokenAccount) + defer DeleteTestAccount(t, client, tokenAccount) + } + + accountResource, err := accounts.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, accountResource) + + for _, account := range accountResource { + accountToCompare, err := accounts.GetByID(client, client.GetSpaceID(), account.GetID()) + require.NoError(t, err) + CompareAccounts(t, account, accountToCompare) + } +} diff --git a/test/e2e/action_template_service_test.go b/test/e2e/action_template_service_test.go index 4a76f8ad..550263a5 100644 --- a/test/e2e/action_template_service_test.go +++ b/test/e2e/action_template_service_test.go @@ -110,3 +110,69 @@ func TestActionTemplateServiceSearch(t *testing.T) { assert.NoError(t, err) assert.NotEmpty(t, resource) } + +// ----- new ----- + +func TestActionTemplateServiceAdd_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + invalidResource := &actiontemplates.ActionTemplate{} + resource, err := client.ActionTemplates.Add(invalidResource) + assert.NotNil(t, err) + assert.Nil(t, resource) + + resource = createActionTemplate(t) + require.NotNil(t, resource) + + resource, err = actiontemplates.Add(client, resource) + require.NoError(t, err) + require.NotNil(t, resource) + defer actiontemplates.DeleteByID(client, client.GetSpaceID(), resource.GetID()) +} + +func TestActionTemplateServiceGetCategories_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + resource, err := client.ActionTemplates.GetCategories() + assert.NoError(t, err) + assert.NotEmpty(t, resource) +} + +func TestActionTemplateServiceGetByID_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + id := internal.GetRandomName() + resource, err := actiontemplates.GetByID(client, client.GetSpaceID(), id) + assert.NotNil(t, err) + assert.Nil(t, resource) + + resources, err := actiontemplates.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, resources) + + for _, resource := range resources { + resourceToCompare, err := client.ActionTemplates.GetByID(resource.GetID()) + require.NoError(t, err) + IsEqualActionTemplates(t, resource, resourceToCompare) + } +} + +func TestActionTemplateServiceSearch_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + search := "" + + resource, err := actiontemplates.Search(client, client.GetSpaceID(), search) + assert.NoError(t, err) + assert.NotEmpty(t, resource) + + search = "Octopus.Script" + + resource, err = actiontemplates.Search(client, client.GetSpaceID(), search) + assert.NoError(t, err) + assert.NotEmpty(t, resource) +} diff --git a/test/e2e/artifact_service_test.go b/test/e2e/artifact_service_test.go index ab4e76a6..8a3cf7b2 100644 --- a/test/e2e/artifact_service_test.go +++ b/test/e2e/artifact_service_test.go @@ -113,3 +113,109 @@ func TestArtifactServiceGetByID(t *testing.T) { AssertEqualArtifacts(t, resources[0], resourceToCompare) } } + +// ----- new ----- + +func CreateTestArtifact_New(t *testing.T, client *client.Client) *artifacts.Artifact { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + filename := "output.log" + + artifact := artifacts.NewArtifact(filename) + require.NotNil(t, artifact) + + createdArtifact, err := artifacts.Add(client, artifact) + require.NoError(t, err) + require.NotNil(t, createdArtifact) + require.NotEmpty(t, createdArtifact.GetID()) + + return createdArtifact +} + +func DeleteTestArtifact_New(t *testing.T, client *client.Client, artifact *artifacts.Artifact) { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + err := client.Artifacts.DeleteByID(artifact.GetID()) + assert.NoError(t, err) + + // verify the delete operation was successful + deletedArtifact, err := artifacts.GetByID(client, client.GetSpaceID(), artifact.GetID()) + assert.Error(t, err) + assert.Nil(t, deletedArtifact) + +} + +func AssertEqualArtifacts_New(t *testing.T, expected *artifacts.Artifact, actual *artifacts.Artifact) { + // equality cannot be determined through a direct comparison (below) + // because APIs like GetByPartialName do not include the fields, + // LastModifiedBy and LastModifiedOn + // + // assert.EqualValues(expected, actual) + // + // this statement (above) is expected to succeed, but it fails due to these + // missing fields + + // IResource + assert.Equal(t, expected.GetID(), actual.GetID()) + assert.True(t, internal.IsLinksEqual(expected.GetLinks(), actual.GetLinks())) + + // Artifact + assert.Equal(t, expected.Created, actual.Created) + assert.Equal(t, expected.Filename, actual.Filename) + assert.Equal(t, expected.LogCorrelationID, actual.LogCorrelationID) + assert.Equal(t, expected.ServerTaskID, actual.ServerTaskID) + assert.Equal(t, expected.Source, actual.Source) + assert.Equal(t, expected.SpaceID, actual.SpaceID) +} + +func TestArtifactServiceDeleteAll_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + accounts, err := artifacts.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, accounts) + + for _, account := range accounts { + defer DeleteTestArtifact(t, client, account) + } +} + +// TODO: fix test +// func TestArtifactServiceGetAll_New(t *testing.T) { +// client := getOctopusClient() +// require.NotNil(t, client) + +// // create 30 test artifacts (to be deleted) +// for i := 0; i < 30; i++ { +// artifact := CreateTestArtifact(t, client) +// require.NotNil(t, artifact) +// defer DeleteTestArtifact(t, client, artifact) +// } + +// allArtifacts, err := client.Artifacts.GetAll() +// require.NoError(t, err) +// require.NotNil(t, allArtifacts) +// require.True(t, len(allArtifacts) >= 30) +// } + +func TestArtifactServiceGetByID_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + resources, err := artifacts.GetAll(client, client.GetSpaceID()) + require.NoError(t, err) + require.NotNil(t, resources) + + if len(resources) > 0 { + resourceToCompare, err := artifacts.GetByID(client, client.GetSpaceID(), resources[0].GetID()) + require.NoError(t, err) + AssertEqualArtifacts(t, resources[0], resourceToCompare) + } +} diff --git a/test/e2e/authentication_service_test.go b/test/e2e/authentication_service_test.go new file mode 100644 index 00000000..a918c352 --- /dev/null +++ b/test/e2e/authentication_service_test.go @@ -0,0 +1,23 @@ +package e2e + +import ( + "github.com/OctopusDeploy/go-octopusdeploy/v2/pkg/authentication" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "testing" +) + +func TestAuthenticationServiceGet(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + resources, err := authentication.Get(client) + require.NoError(t, err) + require.NotNil(t, resources) + require.NotNil(t, resources.AuthenticationProviders) + + for _, provider := range resources.AuthenticationProviders { + assert.NoError(t, err) + assert.NotEmpty(t, provider) + } +} diff --git a/test/e2e/certificate_service_test.go b/test/e2e/certificate_service_test.go index 9563ad80..3eb59e90 100644 --- a/test/e2e/certificate_service_test.go +++ b/test/e2e/certificate_service_test.go @@ -279,3 +279,24 @@ func DeleteTestCertificateResource_NewClient(t *testing.T, client *client.Client require.Error(t, err) require.Nil(t, deletedCertificate) } + +func TestCertificateServiceArchiveUnarchive_NewClient(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + certificate := CreateTestCertificateResource(t, client) + require.NotNil(t, certificate) + + archivedCertificate, err := certificates.Archive(client, client.GetSpaceID(), certificate) + require.NoError(t, err) + require.NotNil(t, archivedCertificate) + + unarchivedCertificate, err := certificates.Unarchive(client, client.GetSpaceID(), certificate) + require.NoError(t, err) + require.NotNil(t, archivedCertificate) + + archivedCertificate, err = certificates.Archive(client, client.GetSpaceID(), unarchivedCertificate) + require.NoError(t, err) + require.NotNil(t, archivedCertificate) + defer DeleteTestCertificateResource(t, client, archivedCertificate) +} diff --git a/test/e2e/release_service_test.go b/test/e2e/release_service_test.go index 620a4846..4a09cd35 100644 --- a/test/e2e/release_service_test.go +++ b/test/e2e/release_service_test.go @@ -192,3 +192,123 @@ func TestReleaseServiceGetByID(t *testing.T) { AssertEqualReleases(t, release, releaseToCompare) } } + +// --- new --- + +func CreateTestRelease_New(t *testing.T, client *client.Client, channel *channels.Channel, project *projects.Project) *releases.Release { + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + version := "0.0.1" + + release := releases.NewRelease(channel.GetID(), project.GetID(), version) + + require.NotNil(t, release) + require.NoError(t, release.Validate()) + + createdRelease, err := releases.Add(client, release) + require.NoError(t, err) + require.NotNil(t, createdRelease) + require.NotEmpty(t, createdRelease.GetID()) + + // verify the add operation was successful + releaseToCompare, err := releases.GetByID(client, client.GetSpaceID(), createdRelease.GetID()) + require.NoError(t, err) + require.NotNil(t, releaseToCompare) + AssertEqualReleases(t, createdRelease, releaseToCompare) + + return createdRelease +} + +func DeleteTestRelease_New(t *testing.T, client *client.Client, release *releases.Release) { + require.NotNil(t, release) + + if client == nil { + client = getOctopusClient() + } + require.NotNil(t, client) + + err := client.Releases.DeleteByID(release.GetID()) + assert.NoError(t, err) + + // verify the delete operation was successful + deletedRelease, err := releases.GetByID(client, client.GetSpaceID(), release.GetID()) + assert.Error(t, err) + assert.Nil(t, deletedRelease) +} + +func TestReleaseServiceAddGetDelete_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + space := GetDefaultSpace(t, client) + require.NotNil(t, space) + + lifecycle := CreateTestLifecycle(t, client) + require.NotNil(t, lifecycle) + defer DeleteTestLifecycle(t, client, lifecycle) + + projectGroup := CreateTestProjectGroup(t, client) + require.NotNil(t, projectGroup) + defer DeleteTestProjectGroup(t, client, projectGroup) + + project := CreateTestProject(t, client, space, lifecycle, projectGroup) + require.NotNil(t, project) + defer DeleteTestProject(t, client, project) + + channel := CreateTestChannel(t, client, project) + require.NotNil(t, channel) + defer DeleteTestChannel(t, client, channel) + + release := CreateTestRelease(t, client, channel, project) + require.NotNil(t, release) + defer DeleteTestRelease_New(t, client, release) + + releaseToCompare, err := releases.GetByID(client, client.GetSpaceID(), release.GetID()) + require.NoError(t, err) + require.NotNil(t, releaseToCompare) + AssertEqualReleases(t, release, releaseToCompare) +} + +func TestReleaseServiceDeleteAll_new(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + query := releases.ReleasesQuery{ + Take: 50, + } + + releases, err := releases.Get(client, client.GetSpaceID(), query) + require.NoError(t, err) + require.NotNil(t, releases) + + for _, release := range releases.Items { + defer DeleteTestRelease_New(t, client, release) + } +} + +func TestReleaseServiceGetByID_New(t *testing.T) { + client := getOctopusClient() + require.NotNil(t, client) + + id := internal.GetRandomName() + release, err := releases.GetByID(client, client.GetSpaceID(), id) + require.Error(t, err) + assert.Nil(t, release) + + query := releases.ReleasesQuery{ + Take: 50, + } + + releaseResource, err := releases.Get(client, client.GetSpaceID(), query) + assert.NoError(t, err) + assert.NotNil(t, releaseResource) + + for _, release := range releaseResource.Items { + releaseToCompare, err := releases.GetByID(client, client.GetSpaceID(), release.GetID()) + assert.NoError(t, err) + AssertEqualReleases(t, release, releaseToCompare) + } +}