Add json include for provider versions on registry provider

helper_test.go

@@ -763,6 +763,8 @@ func createPrivateRegistryProvider(t *testing.T, client *Client, org *Organizati
 		t.Fatal(err)
 	}
 
+	prv.Organization = org
+
 	return prv, func() {
 		id := RegistryProviderID{
 			OrganizationName: org.Name,
@@ -801,6 +803,8 @@ func createPublicRegistryProvider(t *testing.T, client *Client, org *Organizatio
 		t.Fatal(err)
 	}
 
+	prv.Organization = org
+
 	return prv, func() {
 		id := RegistryProviderID{
 			OrganizationName: org.Name,
@@ -838,12 +842,15 @@ func createRegistryProviderVersion(t *testing.T, client *Client, provider *Regis
 
 	options := RegistryProviderVersionCreateOptions{
 		Version: randomSemver(t),
+		KeyID:   randomString(t),
 	}
 	prvv, err := client.RegistryProviderVersions.Create(ctx, providerId, options)
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	prvv.RegistryProvider = provider
+
 	return prvv, func() {
 		id := RegistryProviderVersionID{
 			Version:            options.Version,

registry_provider.go

@@ -49,6 +49,14 @@ func (rn RegistryName) valid() error {
 	return ErrInvalidRegistryName
 }
 
+// RegistryProviderIncludeOps represents which jsonapi include can be used with registry providers
+type RegistryProviderIncludeOps string
+
+// List of available includes
+const (
+	RegistryProviderVersionsInclude RegistryProviderIncludeOps = "registry-provider-versions"
+)
+
 // RegistryProvider represents a registry provider
 type RegistryProvider struct {
 	ID           string                       `jsonapi:"primary,registry-providers"`
@@ -61,7 +69,7 @@ type RegistryProvider struct {
 
 	// Relations
 	Organization             *Organization              `jsonapi:"relation,organization"`
-	RegistryProviderVersions []*RegistryProviderVersion `jsonapi:"relation,registry-provider-version"`
+	RegistryProviderVersions []*RegistryProviderVersion `jsonapi:"relation,registry-provider-versions"`
 }
 
 type RegistryProviderPermissions struct {
@@ -76,6 +84,9 @@ type RegistryProviderListOptions struct {
 	OrganizationName string `url:"filter[organization_name],omitempty"`
 	// A query string to do a fuzzy search
 	Search string `url:"q,omitempty"`
+
+	// Include related jsonapi relationships
+	Include *[]RegistryProviderIncludeOps `url:"include,omitempty"`
 }
 
 type RegistryProviderList struct {
@@ -194,6 +205,8 @@ func (id RegistryProviderID) valid() error {
 }
 
 type RegistryProviderReadOptions struct {
+	// Include related jsonapi relationships
+	Include *[]RegistryProviderIncludeOps `url:"include,omitempty"`
 }
 
 func (r *registryProviders) Read(ctx context.Context, providerId RegistryProviderID, options *RegistryProviderReadOptions) (*RegistryProvider, error) {

registry_provider_integration_test.go

@@ -143,6 +143,41 @@ func TestRegistryProvidersList(t *testing.T) {
 		assert.Equal(t, 0, providers.TotalCount)
 		assert.Equal(t, 0, providers.TotalPages)
 	})
+
+	t.Run("with include provider versions", func(t *testing.T) {
+		version1, version1Cleanup := createRegistryProviderVersion(t, client, nil)
+		defer version1Cleanup()
+
+		provider := version1.RegistryProvider
+
+		version2, version2Cleanup := createRegistryProviderVersion(t, client, provider)
+		defer version2Cleanup()
+
+		versions := []*RegistryProviderVersion{version1, version2}
+
+		options := RegistryProviderListOptions{
+			Include: &[]RegistryProviderIncludeOps{
+				RegistryProviderVersionsInclude,
+			},
+		}
+
+		providersRead, err := client.RegistryProviders.List(ctx, provider.Organization.Name, &options)
+		assert.NoError(t, err)
+		providerRead := providersRead.Items[0]
+		assert.Equal(t, providerRead.ID, provider.ID)
+		assert.Equal(t, len(versions), len(providerRead.RegistryProviderVersions))
+		foundVersion := &RegistryProviderVersion{}
+		for _, v := range providerRead.RegistryProviderVersions {
+			for i := 0; i < len(versions); i++ {
+				if v.ID == versions[i].ID {
+					foundVersion = versions[i]
+					break
+				}
+			}
+			assert.True(t, foundVersion.ID != "", "Expected to find versions: %v but did not", versions)
+			assert.Equal(t, v.Version, foundVersion.Version)
+		}
+	})
 }
 
 func TestRegistryProvidersCreate(t *testing.T) {
@@ -354,6 +389,47 @@ func TestRegistryProvidersRead(t *testing.T) {
 			})
 		})
 	}
+
+	t.Run("populates version relationships", func(t *testing.T) {
+		version1, version1Cleanup := createRegistryProviderVersion(t, client, nil)
+		defer version1Cleanup()
+
+		provider := version1.RegistryProvider
+
+		version2, version2Cleanup := createRegistryProviderVersion(t, client, provider)
+		defer version2Cleanup()
+
+		versions := []*RegistryProviderVersion{version1, version2}
+
+		id := RegistryProviderID{
+			OrganizationName: provider.Organization.Name,
+			RegistryName:     provider.RegistryName,
+			Namespace:        provider.Namespace,
+			Name:             provider.Name,
+		}
+
+		options := RegistryProviderReadOptions{
+			Include: &[]RegistryProviderIncludeOps{
+				RegistryProviderVersionsInclude,
+			},
+		}
+
+		providerRead, err := client.RegistryProviders.Read(ctx, id, &options)
+		assert.NoError(t, err)
+		assert.Equal(t, providerRead.ID, provider.ID)
+		assert.Equal(t, len(versions), len(providerRead.RegistryProviderVersions))
+		foundVersion := &RegistryProviderVersion{}
+		for _, v := range providerRead.RegistryProviderVersions {
+			for i := 0; i < len(versions); i++ {
+				if v.ID == versions[i].ID {
+					foundVersion = versions[i]
+					break
+				}
+			}
+			assert.True(t, foundVersion.ID != "", "Expected to find versions: %v but did not", versions)
+			assert.Equal(t, v.Version, foundVersion.Version)
+		}
+	})
 }
 
 func TestRegistryProvidersDelete(t *testing.T) {