Merge pull request #24 from negz/useful

Add machinery for tracking ProviderConfig usage
2020-10-01 15:45:52 -07:00 · 2020-10-01 15:45:52 -07:00 · fb258cc0eb
parent 33157c0fda 4ca8c576ff
commit fb258cc0eb
5 changed files with 357 additions and 106 deletions
--- a/cmd/angryjet/main.go
+++ b/cmd/angryjet/main.go
@ -60,7 +60,9 @@ func main() {
 		headerFile          = methodsets.Flag("header-file", "The contents of this file will be added to the top of all generated files.").ExistingFile()
 		filenameManaged     = methodsets.Flag("filename-managed", "The filename of generated managed resource files.").Default("zz_generated.managed.go").String()
 		filenameManagedList = methodsets.Flag("filename-managed-list", "The filename of generated managed list resource files.").Default("zz_generated.managedlist.go").String()
-		filenameProvider    = methodsets.Flag("filename-provider", "The filename of generated provider files.").Default("zz_generated.provider.go").String()
+		filenamePC          = methodsets.Flag("filename-pc", "The filename of generated provider config files.").Default("zz_generated.pc.go").String()
+		filenamePCU         = methodsets.Flag("filename-pcu", "The filename of generated provider config usage files.").Default("zz_generated.pcu.go").String()
+		filenamePCUList     = methodsets.Flag("filename-pcu-list", "The filename of generated provider config usage files.").Default("zz_generated.pculist.go").String()
 		pattern             = methodsets.Arg("packages", "Package(s) for which to generate methods, for example github.com/crossplane/crossplane/apis/...").String()
 	)
 	kingpin.MustParse(app.Parse(os.Args[1:]))
@ -81,7 +83,9 @@ func main() {
 		}
 		kingpin.FatalIfError(GenerateManaged(*filenameManaged, header, p), "cannot write managed resource method set for package %s", p.PkgPath)
 		kingpin.FatalIfError(GenerateManagedList(*filenameManagedList, header, p), "cannot write managed resource list method set for package %s", p.PkgPath)
-		kingpin.FatalIfError(GenerateProvider(*filenameProvider, header, p), "cannot write provider method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateProviderConfig(*filenamePC, header, p), "cannot write provider config method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateProviderConfigUsage(*filenamePCU, header, p), "cannot write provider config usage method set for package %s", p.PkgPath)
+		kingpin.FatalIfError(GenerateProviderConfigUsageList(*filenamePCUList, header, p), "cannot write provider config usage list method set for package %s", p.PkgPath)
 	}
 }

@ -139,23 +143,71 @@ func GenerateManagedList(filename, header string, p *packages.Package) error {
 	return errors.Wrap(err, "cannot write managed resource list methods")
 }

-// GenerateProvider generates the resource.Provider method set.
-func GenerateProvider(filename, header string, p *packages.Package) error {
+// GenerateProviderConfig generates the resource.ProviderConfig method set.
+func GenerateProviderConfig(filename, header string, p *packages.Package) error {
 	receiver := "p"

 	methods := method.Set{
 		"SetCredentialsSecretReference": method.NewSetCredentialsSecretReference(receiver, RuntimeImport),
 		"GetCredentialsSecretReference": method.NewGetCredentialsSecretReference(receiver, RuntimeImport),
+		"SetUsers":                      method.NewSetUsers(receiver),
+		"GetUsers":                      method.NewGetUsers(receiver),
+		"SetConditions":                 method.NewSetConditions(receiver, RuntimeImport),
+		"GetCondition":                  method.NewGetCondition(receiver, RuntimeImport),
 	}

 	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
 		generate.WithHeaders(header),
 		generate.WithImportAliases(map[string]string{RuntimeImport: RuntimeAlias}),
 		generate.WithMatcher(match.AllOf(
-			match.Provider(),
+			match.ProviderConfig(),
 			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
 		),
 	)

-	return errors.Wrap(err, "cannot write provider methods")
+	return errors.Wrap(err, "cannot write provider config methods")
+}
+
+// GenerateProviderConfigUsage generates the resource.ProviderConfigUsage method set.
+func GenerateProviderConfigUsage(filename, header string, p *packages.Package) error {
+	receiver := "p"
+
+	methods := method.Set{
+		"SetProviderConfigReference": method.NewSetRootProviderConfigReference(receiver, RuntimeImport),
+		"GetProviderConfigReference": method.NewGetRootProviderConfigReference(receiver, RuntimeImport),
+		"SetResourceReference":       method.NewSetRootResourceReference(receiver, RuntimeImport),
+		"GetResourceReference":       method.NewGetRootResourceReference(receiver, RuntimeImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{RuntimeImport: RuntimeAlias}),
+		generate.WithMatcher(match.AllOf(
+			match.ProviderConfigUsage(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write provider config usage methods")
+}
+
+// GenerateProviderConfigUsageList generates the
+// resource.ProviderConfigUsageList method set.
+func GenerateProviderConfigUsageList(filename, header string, p *packages.Package) error {
+	receiver := "p"
+
+	methods := method.Set{
+		"GetItems": method.NewProviderConfigUsageGetItems(receiver, ResourceImport),
+	}
+
+	err := generate.WriteMethods(p, methods, filepath.Join(filepath.Dir(p.GoFiles[0]), filename),
+		generate.WithHeaders(header),
+		generate.WithImportAliases(map[string]string{RuntimeImport: RuntimeAlias}),
+		generate.WithMatcher(match.AllOf(
+			match.ProviderConfigUsageList(),
+			match.DoesNotHaveMarker(comments.In(p), DisableMarker, "false")),
+		),
+	)
+
+	return errors.Wrap(err, "cannot write provider config usage list methods")
 }
--- a/internal/fields/fields.go
+++ b/internal/fields/fields.go
@ -24,34 +24,33 @@ import (

 // Field names.
 const (
-	NameTypeMeta          = "TypeMeta"
-	NameObjectMeta        = "ObjectMeta"
-	NameListMeta          = "ListMeta"
-	NameSpec              = "Spec"
-	NameSpecTemplate      = "SpecTemplate"
-	NameStatus            = "Status"
-	NameResourceSpec      = "ResourceSpec"
-	NameResourceStatus    = "ResourceStatus"
-	NameResourceClaimSpec = "ResourceClaimSpec"
-	NameClassSpecTemplate = "ClassSpecTemplate"
-	NameProviderSpec      = "ProviderSpec"
-	NameItems             = "Items"
+	NameTypeMeta             = "TypeMeta"
+	NameObjectMeta           = "ObjectMeta"
+	NameListMeta             = "ListMeta"
+	NameSpec                 = "Spec"
+	NameSpecTemplate         = "SpecTemplate"
+	NameStatus               = "Status"
+	NameResourceSpec         = "ResourceSpec"
+	NameResourceStatus       = "ResourceStatus"
+	NameProviderConfigSpec   = "ProviderConfigSpec"
+	NameProviderConfigStatus = "ProviderConfigStatus"
+	NameProviderConfigUsage  = "ProviderConfigUsage"
+	NameItems                = "Items"
 )

 // Field type suffixes.
 const (
-	TypeSuffixTypeMeta            = "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"
-	TypeSuffixObjectMeta          = "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"
-	TypeSuffixListMeta            = "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"
-	TypeSuffixSpec                = NameSpec
-	TypeSuffixSpecTemplate        = NameSpecTemplate
-	TypeSuffixStatus              = NameStatus
-	TypeSuffixResourceSpec        = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceSpec"
-	TypeSuffixResourceStatus      = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceStatus"
-	TypeSuffixResourceClaimSpec   = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceClaimSpec"
-	TypeSuffixResourceClaimStatus = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceClaimStatus"
-	TypeSuffixClassSpecTemplate   = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ClassSpecTemplate"
-	TypeSuffixProviderSpec        = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ProviderSpec"
+	TypeSuffixTypeMeta             = "k8s.io/apimachinery/pkg/apis/meta/v1.TypeMeta"
+	TypeSuffixObjectMeta           = "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"
+	TypeSuffixListMeta             = "k8s.io/apimachinery/pkg/apis/meta/v1.ListMeta"
+	TypeSuffixSpec                 = NameSpec
+	TypeSuffixSpecTemplate         = NameSpecTemplate
+	TypeSuffixStatus               = NameStatus
+	TypeSuffixResourceSpec         = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceSpec"
+	TypeSuffixResourceStatus       = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ResourceStatus"
+	TypeSuffixProviderConfigSpec   = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ProviderConfigSpec"
+	TypeSuffixProviderConfigStatus = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ProviderConfigStatus"
+	TypeSuffixProviderConfigUsage  = "github.com/crossplane/crossplane-runtime/apis/core/v1alpha1.ProviderConfigUsage"
 )

 func matches(s *types.Struct, m Matcher) bool {
@ -187,28 +186,22 @@ func IsResourceSpec() Matcher { return IsTypeNamed(TypeSuffixResourceSpec, NameR
 // appears to be a Crossplane managed resource status.
 func IsResourceStatus() Matcher { return IsTypeNamed(TypeSuffixResourceStatus, NameResourceStatus) }

-// IsResourceClaimSpec returns a Matcher that returns true if the supplied field
-// appears to be a Crossplane resource claim spec.
-func IsResourceClaimSpec() Matcher {
-	return IsTypeNamed(TypeSuffixResourceClaimSpec, NameResourceClaimSpec)
+// IsProviderConfigSpec returns a Matcher that returns true if the supplied
+// field appears to be a Crossplane provider config spec.
+func IsProviderConfigSpec() Matcher {
+	return IsTypeNamed(TypeSuffixProviderConfigSpec, NameProviderConfigSpec)
 }

-// IsResourceClaimStatus returns a Matcher that returns true if the supplied
-// field appears to be a Crossplane resource claim status.
-func IsResourceClaimStatus() Matcher {
-	return IsTypeNamed(TypeSuffixResourceClaimStatus, NameStatus)
+// IsProviderConfigStatus returns a Matcher that returns true if the supplied
+// field appears to be a Crossplane provider config status.
+func IsProviderConfigStatus() Matcher {
+	return IsTypeNamed(TypeSuffixProviderConfigStatus, NameProviderConfigStatus)
 }

-// IsClassSpecTemplate returns a Matcher that returns true if the supplied field
-// appears to be a Crossplane resource class spec template.
-func IsClassSpecTemplate() Matcher {
-	return IsTypeNamed(TypeSuffixClassSpecTemplate, NameClassSpecTemplate)
-}
-
-// IsProviderSpec returns a Matcher that returns true if the supplied field
-// appears to be a Crossplane provider spec.
-func IsProviderSpec() Matcher {
-	return IsTypeNamed(TypeSuffixProviderSpec, NameProviderSpec)
+// IsProviderConfigUsage returns a Matcher that returns true if the supplied
+// field appears to be a Crossplane provider config usage.
+func IsProviderConfigUsage() Matcher {
+	return IsTypeNamed(TypeSuffixProviderConfigUsage, NameProviderConfigUsage)
 }

 // IsItems returns a Matcher that returns true if the supplied field appears to
--- a/internal/match/match.go
+++ b/internal/match/match.go
@ -65,79 +65,45 @@ func ManagedList() Object {
 	}
 }

-// Class returns an Object matcher that returns true if the supplied Object is a
-// Crossplane resource class.
-func Class() Object {
+// ProviderConfig returns an Object matcher that returns true if the supplied
+// Object is a Crossplane ProviderConfig.
+func ProviderConfig() Object {
 	return func(o types.Object) bool {
 		return fields.Has(o,
 			fields.IsTypeMeta().And(fields.IsEmbedded()),
 			fields.IsObjectMeta().And(fields.IsEmbedded()),
-			fields.IsSpecTemplate().And(fields.HasFieldThat(
-				fields.IsClassSpecTemplate().And(fields.IsEmbedded()),
+			fields.IsSpec().And(fields.HasFieldThat(
+				fields.IsProviderConfigSpec().And(fields.IsEmbedded()),
+			)),
+			fields.IsStatus().And(fields.HasFieldThat(
+				fields.IsProviderConfigStatus().And(fields.IsEmbedded()),
 			)),
 		)
 	}
 }

-// ClassList returns an Object matcher that returns true if the supplied
-// Object is a list of Crossplane resource classes.
-func ClassList() Object {
+// ProviderConfigUsage returns an Object matcher that returns true if the supplied
+// Object is a Crossplane ProviderConfigUsage.
+func ProviderConfigUsage() Object {
+	return func(o types.Object) bool {
+		return fields.Has(o,
+			fields.IsTypeMeta().And(fields.IsEmbedded()),
+			fields.IsObjectMeta().And(fields.IsEmbedded()),
+			fields.IsProviderConfigUsage().And(fields.IsEmbedded()),
+		)
+	}
+}
+
+// ProviderConfigUsageList returns an Object matcher that returns true if the
+// supplied Object is a list of Crossplane provider config usages.
+func ProviderConfigUsageList() Object {
 	return func(o types.Object) bool {
 		return fields.Has(o,
 			fields.IsTypeMeta().And(fields.IsEmbedded()),
 			fields.IsItems().And(fields.IsSlice()).And(fields.HasFieldThat(
 				fields.IsTypeMeta().And(fields.IsEmbedded()),
 				fields.IsObjectMeta().And(fields.IsEmbedded()),
-				fields.IsSpecTemplate().And(fields.HasFieldThat(
-					fields.IsClassSpecTemplate().And(fields.IsEmbedded()),
-				)),
-			)),
-		)
-	}
-}
-
-// Claim returns an Object matcher that returns true if the supplied Object is a
-// Crossplane resource claim.
-func Claim() Object {
-	return func(o types.Object) bool {
-		return fields.Has(o,
-			fields.IsTypeMeta().And(fields.IsEmbedded()),
-			fields.IsObjectMeta().And(fields.IsEmbedded()),
-			fields.IsSpec().And(fields.HasFieldThat(
-				fields.IsResourceClaimSpec().And(fields.IsEmbedded()),
-			)),
-			fields.IsResourceClaimStatus(),
-		)
-	}
-}
-
-// ClaimList returns an Object matcher that returns true if the supplied
-// Object is a list of Crossplane resource claims.
-func ClaimList() Object {
-	return func(o types.Object) bool {
-		return fields.Has(o,
-			fields.IsTypeMeta().And(fields.IsEmbedded()),
-			fields.IsItems().And(fields.IsSlice()).And(fields.HasFieldThat(
-				fields.IsTypeMeta().And(fields.IsEmbedded()),
-				fields.IsObjectMeta().And(fields.IsEmbedded()),
-				fields.IsSpec().And(fields.HasFieldThat(
-					fields.IsResourceClaimSpec().And(fields.IsEmbedded()),
-				)),
-				fields.IsResourceClaimStatus(),
-			)),
-		)
-	}
-}
-
-// Provider returns an Object matcher that returns true if the supplied Object is a
-// Crossplane Provider.
-func Provider() Object {
-	return func(o types.Object) bool {
-		return fields.Has(o,
-			fields.IsTypeMeta().And(fields.IsEmbedded()),
-			fields.IsObjectMeta().And(fields.IsEmbedded()),
-			fields.IsSpec().And(fields.HasFieldThat(
-				fields.IsProviderSpec().And(fields.IsEmbedded()),
+				fields.IsProviderConfigUsage().And(fields.IsEmbedded()),
 			)),
 		)
 	}
--- a/internal/method/method.go
+++ b/internal/method/method.go
@ -258,6 +258,28 @@ func NewSetCredentialsSecretReference(receiver, runtime string) New {
 	}
 }

+// NewSetUsers returns a NewMethod that writes a SetUsers method for the
+// supplied Object to the supplied file.
+func NewSetUsers(receiver string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("SetUsers of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("SetUsers").Params(jen.Id("i").Int64()).Block(
+			jen.Id(receiver).Dot(fields.NameStatus).Dot("Users").Op("=").Id("i"),
+		)
+	}
+}
+
+// NewGetUsers returns a NewMethod that writes a GetUsers method for the
+// supplied Object to the supplied file.
+func NewGetUsers(receiver string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetUsers of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetUsers").Params().Int64().Block(
+			jen.Return(jen.Id(receiver).Dot(fields.NameStatus).Dot("Users")),
+		)
+	}
+}
+
 // NewManagedGetItems returns a New that writes a GetItems method for the
 // supplied object to the supplied file.
 func NewManagedGetItems(receiver, resource string) New {
@ -272,3 +294,68 @@ func NewManagedGetItems(receiver, resource string) New {
 		)
 	}
 }
+
+// NewSetRootProviderConfigReference returns a NewMethod that writes a
+// SetProviderConfigReference method for the supplied Object to the supplied
+// file. Note that unlike NewSetProviderConfigReference the generated method
+// expects the ProviderConfigReference to be at the root of the struct, not
+// under its Spec field.
+func NewSetRootProviderConfigReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("SetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("SetProviderConfigReference").Params(jen.Id("r").Qual(runtime, "Reference")).Block(
+			jen.Id(receiver).Dot("ProviderConfigReference").Op("=").Id("r"),
+		)
+	}
+}
+
+// NewGetRootProviderConfigReference returns a NewMethod that writes a
+// GetProviderConfigReference method for the supplied Object to the supplied
+// file. file. Note that unlike NewGetProviderConfigReference the generated
+// method expects the ProviderConfigReference to be at the root of the struct,
+// not under its Spec field.
+func NewGetRootProviderConfigReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetProviderConfigReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetProviderConfigReference").Params().Qual(runtime, "Reference").Block(
+			jen.Return(jen.Id(receiver).Dot("ProviderConfigReference")),
+		)
+	}
+}
+
+// NewSetRootResourceReference returns a NewMethod that writes a
+// SetRootResourceReference method for the supplied Object to the supplied file.
+func NewSetRootResourceReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("SetResourceReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("SetResourceReference").Params(jen.Id("r").Qual(runtime, "TypedReference")).Block(
+			jen.Id(receiver).Dot("ResourceReference").Op("=").Id("r"),
+		)
+	}
+}
+
+// NewGetRootResourceReference returns a NewMethod that writes a
+// GetRootResourceReference method for the supplied Object to the supplied file.
+func NewGetRootResourceReference(receiver, runtime string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetResourceReference of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetResourceReference").Params().Qual(runtime, "TypedReference").Block(
+			jen.Return(jen.Id(receiver).Dot("ResourceReference")),
+		)
+	}
+}
+
+// NewProviderConfigUsageGetItems returns a New that writes a GetItems method for the
+// supplied object to the supplied file.
+func NewProviderConfigUsageGetItems(receiver, resource string) New {
+	return func(f *jen.File, o types.Object) {
+		f.Commentf("GetItems of this %s.", o.Name())
+		f.Func().Params(jen.Id(receiver).Op("*").Id(o.Name())).Id("GetItems").Params().Index().Qual(resource, "ProviderConfigUsage").Block(
+			jen.Id("items").Op(":=").Make(jen.Index().Qual(resource, "ProviderConfigUsage"), jen.Len(jen.Id(receiver).Dot("Items"))),
+			jen.For(jen.Id("i").Op(":=").Range().Id(receiver).Dot("Items")).Block(
+				jen.Id("items").Index(jen.Id("i")).Op("=").Op("&").Id(receiver).Dot("Items").Index(jen.Id("i")),
+			),
+			jen.Return(jen.Id("items")),
+		)
+	}
+}
--- a/internal/method/method_test.go
+++ b/internal/method/method_test.go
@ -279,6 +279,70 @@ func (t *Type) GetDeletionPolicy() runtime.DeletionPolicy {
 	}
 }

+func TestNewSetCredentialsSecretReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// SetCredentialsSecretReference of this Type.
+func (t *Type) SetCredentialsSecretReference(r *runtime.SecretKeySelector) {
+	t.Spec.CredentialsSecretRef = r
+}
+`
+	f := jen.NewFile("pkg")
+	NewSetCredentialsSecretReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewSetCredentialsSecretReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewGetCredentialsSecretReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// GetCredentialsSecretReference of this Type.
+func (t *Type) GetCredentialsSecretReference() *runtime.SecretKeySelector {
+	return t.Spec.CredentialsSecretRef
+}
+`
+	f := jen.NewFile("pkg")
+	NewGetCredentialsSecretReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewGetCredentialsSecretLocalReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewSetUsers(t *testing.T) {
+	want := `package pkg
+
+// SetUsers of this Type.
+func (t *Type) SetUsers(i int64) {
+	t.Status.Users = i
+}
+`
+	f := jen.NewFile("pkg")
+	NewSetUsers("t")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewSetUsers(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewGetUsers(t *testing.T) {
+	want := `package pkg
+
+// GetUsers of this Type.
+func (t *Type) GetUsers() int64 {
+	return t.Status.Users
+}
+`
+	f := jen.NewFile("pkg")
+	NewGetUsers("t")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewGetUsers(): -want, +got\n%s", diff)
+	}
+}
+
 func TestNewManagedGetItems(t *testing.T) {
 	want := `package pkg

@ -299,3 +363,92 @@ func (t *Type) GetItems() []resource.Managed {
 		t.Errorf("NewManagedGetItems(): -want, +got\n%s", diff)
 	}
 }
+
+func TestNewSetRootProviderConfigReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// SetProviderConfigReference of this Type.
+func (t *Type) SetProviderConfigReference(r runtime.Reference) {
+	t.ProviderConfigReference = r
+}
+`
+	f := jen.NewFile("pkg")
+	NewSetRootProviderConfigReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewSetRootProviderConfigReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewGetRootProviderConfigReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// GetProviderConfigReference of this Type.
+func (t *Type) GetProviderConfigReference() runtime.Reference {
+	return t.ProviderConfigReference
+}
+`
+	f := jen.NewFile("pkg")
+	NewGetRootProviderConfigReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewGetRootProviderReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewSetRootResourceReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// SetResourceReference of this Type.
+func (t *Type) SetResourceReference(r runtime.TypedReference) {
+	t.ResourceReference = r
+}
+`
+	f := jen.NewFile("pkg")
+	NewSetRootResourceReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewSetRootResourceReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewGetRootResourceReference(t *testing.T) {
+	want := `package pkg
+
+import runtime "example.org/runtime"
+
+// GetResourceReference of this Type.
+func (t *Type) GetResourceReference() runtime.TypedReference {
+	return t.ResourceReference
+}
+`
+	f := jen.NewFile("pkg")
+	NewGetRootResourceReference("t", "example.org/runtime")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewGetRootProviderReference(): -want, +got\n%s", diff)
+	}
+}
+
+func TestNewProviderConfigUsageGetItems(t *testing.T) {
+	want := `package pkg
+
+import resource "example.org/resource"
+
+// GetItems of this Type.
+func (t *Type) GetItems() []resource.ProviderConfigUsage {
+	items := make([]resource.ProviderConfigUsage, len(t.Items))
+	for i := range t.Items {
+		items[i] = &t.Items[i]
+	}
+	return items
+}
+`
+	f := jen.NewFile("pkg")
+	NewProviderConfigUsageGetItems("t", "example.org/resource")(f, MockObject{Named: "Type"})
+	if diff := cmp.Diff(want, fmt.Sprintf("%#v", f)); diff != "" {
+		t.Errorf("NewProviderConfigUsageGetItems(): -want, +got\n%s", diff)
+	}
+}