From 1b3369e351c7e741d43236d989d6662db45c385b Mon Sep 17 00:00:00 2001 From: Karl Kirch Date: Fri, 18 Feb 2022 12:25:03 -0600 Subject: [PATCH] Add provider version create/list/delete/read implementation and tests --- helper_test.go | 2 +- registry_provider_version.go | 52 ++++- registry_provider_version_integration_test.go | 186 ++++++++++++++++++ 3 files changed, 233 insertions(+), 7 deletions(-) diff --git a/helper_test.go b/helper_test.go index 591f7f761..b90bf9bdd 100644 --- a/helper_test.go +++ b/helper_test.go @@ -857,7 +857,7 @@ func createRegistryProviderVersion(t *testing.T, client *Client, provider *Regis RegistryProviderID: providerId, } if err := client.RegistryProviderVersions.Delete(ctx, id); err != nil { - t.Errorf("Error destroying registry provider! WARNING: Dangling resources\n"+ + t.Errorf("Error destroying registry provider version! WARNING: Dangling resources\n"+ "may exist! The full error is shown below.\n\n"+ "Registry Provider Version: %s/%s/%s\nError: %s", prvv.RegistryProvider.Namespace, prvv.RegistryProvider.Name, prvv.Version, err) } diff --git a/registry_provider_version.go b/registry_provider_version.go index 4251593f7..524b7a400 100644 --- a/registry_provider_version.go +++ b/registry_provider_version.go @@ -21,7 +21,7 @@ type RegistryProviderVersions interface { Create(ctx context.Context, providerId RegistryProviderID, options RegistryProviderVersionCreateOptions) (*RegistryProviderVersion, error) // Read a registry provider - Read(ctx context.Context, versionId RegistryProviderVersionID, options *RegistryProviderVersionReadOptions) (*RegistryProvider, error) + Read(ctx context.Context, versionId RegistryProviderVersionID, options *RegistryProviderVersionReadOptions) (*RegistryProviderVersion, error) // Delete a registry provider Delete(ctx context.Context, versionId RegistryProviderVersionID) error @@ -43,7 +43,7 @@ type RegistryProviderVersion struct { // Relations RegistryProvider *RegistryProvider `jsonapi:"relation,registry-provider"` - RegistryProviderPlatforms []*RegistryProviderPlatform `jsonapi:"relation,registry-provider-platform"` + RegistryProviderPlatforms []*RegistryProviderPlatform `jsonapi:"relation,registry-provider-platforms"` // Links Links map[string]interface{} `jsonapi:"links,omitempty"` @@ -70,7 +70,7 @@ func (id RegistryProviderVersionID) valid() error { type RegistryProviderVersionList struct { *Pagination - Items []*RegistryProvider + Items []*RegistryProviderVersion } type RegistryProviderVersionListOptions struct { @@ -162,11 +162,51 @@ func (r *registryProviderVersions) Create(ctx context.Context, providerId Regist type RegistryProviderVersionReadOptions struct{} // Read a registry provider -func (r *registryProviderVersions) Read(ctx context.Context, versionId RegistryProviderVersionID, options *RegistryProviderVersionReadOptions) (*RegistryProvider, error) { - return nil, nil +func (r *registryProviderVersions) Read(ctx context.Context, versionId RegistryProviderVersionID, options *RegistryProviderVersionReadOptions) (*RegistryProviderVersion, error) { + if err := versionId.valid(); err != nil { + return nil, err + } + + u := fmt.Sprintf( + "organizations/%s/registry-providers/%s/%s/%s/versions/%s", + url.QueryEscape(versionId.OrganizationName), + url.QueryEscape(string(versionId.RegistryName)), + url.QueryEscape(versionId.Namespace), + url.QueryEscape(versionId.Name), + url.QueryEscape(versionId.Version), + ) + req, err := r.client.newRequest("GET", u, options) + if err != nil { + return nil, err + } + + prvv := &RegistryProviderVersion{} + err = r.client.do(ctx, req, prvv) + if err != nil { + return nil, err + } + + return prvv, nil } // Delete a registry provider func (r *registryProviderVersions) Delete(ctx context.Context, versionId RegistryProviderVersionID) error { - return nil + if err := versionId.valid(); err != nil { + return err + } + + u := fmt.Sprintf( + "organizations/%s/registry-providers/%s/%s/%s/versions/%s", + url.QueryEscape(versionId.OrganizationName), + url.QueryEscape(string(versionId.RegistryName)), + url.QueryEscape(versionId.Namespace), + url.QueryEscape(versionId.Name), + url.QueryEscape(versionId.Version), + ) + req, err := r.client.newRequest("DELETE", u, nil) + if err != nil { + return err + } + + return r.client.do(ctx, req, nil) } diff --git a/registry_provider_version_integration_test.go b/registry_provider_version_integration_test.go index 75a60a805..8e6d26af6 100644 --- a/registry_provider_version_integration_test.go +++ b/registry_provider_version_integration_test.go @@ -5,6 +5,7 @@ package tfe import ( "context" + "fmt" "testing" "github.com/stretchr/testify/assert" @@ -184,3 +185,188 @@ func TestRegistryProviderVersionsCreate(t *testing.T) { }) }) } + +func TestRegistryProviderVersionsList(t *testing.T) { + client := testClient(t) + ctx := context.Background() + + t.Run("with versions", func(t *testing.T) { + provider, providerCleanup := createPrivateRegistryProvider(t, client, nil) + defer providerCleanup() + + createN := 10 + versions := make([]*RegistryProviderVersion, 0) + // these providers will be destroyed when the org is cleaned up + for i := 0; i < createN; i++ { + version, _ := createRegistryProviderVersion(t, client, provider) + versions = append(versions, version) + } + versionN := len(versions) + + id := RegistryProviderID{ + OrganizationName: provider.Organization.Name, + Namespace: provider.Namespace, + Name: provider.Name, + RegistryName: provider.RegistryName, + } + + t.Run("returns all versions", func(t *testing.T) { + returnedVersions, err := client.RegistryProviderVersions.List(ctx, id, &RegistryProviderVersionListOptions{ + ListOptions: ListOptions{ + PageNumber: 0, + PageSize: versionN, + }, + }) + require.NoError(t, err) + assert.NotEmpty(t, returnedVersions.Items) + assert.Equal(t, versionN, returnedVersions.TotalCount) + assert.Equal(t, 1, returnedVersions.TotalPages) + for _, rv := range returnedVersions.Items { + foundVersion := false + for _, v := range versions { + if rv.ID == v.ID { + foundVersion = true + break + } + } + assert.True(t, foundVersion, "Expected to find version %s but did not:\nexpected:\n%v\nreturned\n%v", rv.ID, versions, returnedVersions) + } + }) + + t.Run("returns pages", func(t *testing.T) { + pageN := 2 + pageSize := versionN / pageN + + for page := 0; page < pageN; page++ { + testName := fmt.Sprintf("returns page %d of versions", page) + t.Run(testName, func(t *testing.T) { + returnedVersions, err := client.RegistryProviderVersions.List(ctx, id, &RegistryProviderVersionListOptions{ + ListOptions: ListOptions{ + PageNumber: page, + PageSize: pageSize, + }, + }) + require.NoError(t, err) + assert.NotEmpty(t, returnedVersions.Items) + assert.Equal(t, versionN, returnedVersions.TotalCount) + assert.Equal(t, pageN, returnedVersions.TotalPages) + assert.Equal(t, pageSize, len(returnedVersions.Items)) + for _, rv := range returnedVersions.Items { + foundVersion := false + for _, v := range versions { + if rv.ID == v.ID { + foundVersion = true + break + } + } + assert.True(t, foundVersion, "Expected to find version %s but did not:\nexpected:\n%v\nreturned\n%v", rv.ID, versions, returnedVersions) + } + }) + } + }) + }) + + t.Run("without versions", func(t *testing.T) { + provider, providerCleanup := createPrivateRegistryProvider(t, client, nil) + defer providerCleanup() + + id := RegistryProviderID{ + OrganizationName: provider.Organization.Name, + Namespace: provider.Namespace, + Name: provider.Name, + RegistryName: provider.RegistryName, + } + + versions, err := client.RegistryProviderVersions.List(ctx, id, nil) + require.NoError(t, err) + assert.Empty(t, versions.Items) + assert.Equal(t, 0, versions.TotalCount) + assert.Equal(t, 0, versions.TotalPages) + }) + + t.Run("with include provider platforms", func(t *testing.T) { + }) +} + +func TestRegistryProviderVersionsDelete(t *testing.T) { + client := testClient(t) + ctx := context.Background() + + provider, providerCleanup := createPrivateRegistryProvider(t, client, nil) + defer providerCleanup() + + t.Run("with valid version", func(t *testing.T) { + version, _ := createRegistryProviderVersion(t, client, provider) + + versionId := RegistryProviderVersionID{ + RegistryProviderID: RegistryProviderID{ + OrganizationName: version.RegistryProvider.Organization.Name, + RegistryName: version.RegistryProvider.RegistryName, + Namespace: version.RegistryProvider.Namespace, + Name: version.RegistryProvider.Name, + }, + Version: version.Version, + } + + err := client.RegistryProviderVersions.Delete(ctx, versionId) + assert.NoError(t, err) + }) + + t.Run("with non existing version", func(t *testing.T) { + versionId := RegistryProviderVersionID{ + RegistryProviderID: RegistryProviderID{ + OrganizationName: provider.Organization.Name, + RegistryName: provider.RegistryName, + Namespace: provider.Namespace, + Name: provider.Name, + }, + Version: "1.0.0", + } + + err := client.RegistryProviderVersions.Delete(ctx, versionId) + assert.Error(t, err) + }) +} + +func TestRegistryProviderVersionsRead(t *testing.T) { + client := testClient(t) + ctx := context.Background() + + t.Run("with valid version", func(t *testing.T) { + version, versionCleanup := createRegistryProviderVersion(t, client, nil) + defer versionCleanup() + + versionId := RegistryProviderVersionID{ + RegistryProviderID: RegistryProviderID{ + OrganizationName: version.RegistryProvider.Organization.Name, + RegistryName: version.RegistryProvider.RegistryName, + Namespace: version.RegistryProvider.Namespace, + Name: version.RegistryProvider.Name, + }, + Version: version.Version, + } + + readVersion, err := client.RegistryProviderVersions.Read(ctx, versionId, nil) + assert.NoError(t, err) + assert.Equal(t, version.ID, readVersion.ID) + }) + + t.Run("with non existing version", func(t *testing.T) { + provider, providerCleanup := createPrivateRegistryProvider(t, client, nil) + defer providerCleanup() + + versionId := RegistryProviderVersionID{ + RegistryProviderID: RegistryProviderID{ + OrganizationName: provider.Organization.Name, + RegistryName: provider.RegistryName, + Namespace: provider.Namespace, + Name: provider.Name, + }, + Version: "1.0.0", + } + + _, err := client.RegistryProviderVersions.Read(ctx, versionId, nil) + assert.Error(t, err) + }) + +}