crossplane
/
crossplane-runtime
mirror of https://github.com/crossplane/crossplane-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #780 from cychiang/chore-deprecate-pointer-helper-function 

chore: deprecate the reference pointer helper functions
This commit is contained in:
Nic Cope 2024-11-04 12:04:27 -08:00 committed by GitHub
parent 33515178ea 5cb43a5a26
commit e66c7ab42f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 1 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
pkg/reconciler/managed/reconciler_typed.go
View File

@ -52,6 +52,7 @@ func (c *typedExternalClientWrapper[managed]) Create(ctx context.Context, mg res
}
return c.c.Create(ctx, cr)
}
func (c *typedExternalClientWrapper[managed]) Update(ctx context.Context, mg resource.Managed) (ExternalUpdate, error) {
cr, ok := mg.(managed)
if !ok {

123
pkg/reference/reference.go
View File

@ -20,7 +20,6 @@ package reference
import (
"context"
"strconv"
kerrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/types"
@ -40,128 +39,6 @@ const (
errNoValue = "referenced field was empty (referenced resource may not yet be ready)"
)
// NOTE(negz): There are many equivalents of FromPtrValue and ToPtrValue
// throughout the Crossplane codebase. We duplicate them here to reduce the
// number of packages our API types have to import to support references.
// FromPtrValue adapts a string pointer field for use as a CurrentValue.
func FromPtrValue(v *string) string {
if v == nil {
return ""
}
return *v
}
// FromFloatPtrValue adapts a float pointer field for use as a CurrentValue.
func FromFloatPtrValue(v *float64) string {
if v == nil {
return ""
}
return strconv.FormatFloat(*v, 'f', 0, 64)
}
// FromIntPtrValue adapts an int pointer field for use as a CurrentValue.
func FromIntPtrValue(v *int64) string {
if v == nil {
return ""
}
return strconv.FormatInt(*v, 10)
}
// ToPtrValue adapts a ResolvedValue for use as a string pointer field.
func ToPtrValue(v string) *string {
if v == "" {
return nil
}
return &v
}
// ToFloatPtrValue adapts a ResolvedValue for use as a float64 pointer field.
func ToFloatPtrValue(v string) *float64 {
if v == "" {
return nil
}
vParsed, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil
}
return &vParsed
}
// ToIntPtrValue adapts a ResolvedValue for use as an int pointer field.
func ToIntPtrValue(v string) *int64 {
if v == "" {
return nil
}
vParsed, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return nil
}
return &vParsed
}
// FromPtrValues adapts a slice of string pointer fields for use as CurrentValues.
// NOTE: Do not use this utility function unless you have to.
// Using pointer slices does not adhere to our current API practices.
// The current use case is where generated code creates reference-able fields in a provider which are
// string pointers and need to be resolved as part of `ResolveMultiple`.
func FromPtrValues(v []*string) []string {
res := make([]string, len(v))
for i := range len(v) {
res[i] = FromPtrValue(v[i])
}
return res
}
// FromFloatPtrValues adapts a slice of float64 pointer fields for use as CurrentValues.
func FromFloatPtrValues(v []*float64) []string {
res := make([]string, len(v))
for i := range len(v) {
res[i] = FromFloatPtrValue(v[i])
}
return res
}
// FromIntPtrValues adapts a slice of int64 pointer fields for use as CurrentValues.
func FromIntPtrValues(v []*int64) []string {
res := make([]string, len(v))
for i := range len(v) {
res[i] = FromIntPtrValue(v[i])
}
return res
}
// ToPtrValues adapts ResolvedValues for use as a slice of string pointer fields.
// NOTE: Do not use this utility function unless you have to.
// Using pointer slices does not adhere to our current API practices.
// The current use case is where generated code creates reference-able fields in a provider which are
// string pointers and need to be resolved as part of `ResolveMultiple`.
func ToPtrValues(v []string) []*string {
res := make([]*string, len(v))
for i := range len(v) {
res[i] = ToPtrValue(v[i])
}
return res
}
// ToFloatPtrValues adapts ResolvedValues for use as a slice of float64 pointer fields.
func ToFloatPtrValues(v []string) []*float64 {
res := make([]*float64, len(v))
for i := range len(v) {
res[i] = ToFloatPtrValue(v[i])
}
return res
}
// ToIntPtrValues adapts ResolvedValues for use as a slice of int64 pointer fields.
func ToIntPtrValues(v []string) []*int64 {
res := make([]*int64, len(v))
for i := range len(v) {
res[i] = ToIntPtrValue(v[i])
}
return res
}
// To indicates the kind of managed resource a reference is to.
type To struct {
Managed resource.Managed

91
pkg/reference/reference_test.go
View File

@ -47,97 +47,6 @@ func (fml *FakeManagedList) GetItems() []resource.Managed {
return fml.Items
}
func TestToAndFromPtr(t *testing.T) {
cases := map[string]struct {
want string
}{
"Zero": {want: ""},
"NonZero": {want: "pointy"},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
got := FromPtrValue(ToPtrValue(tc.want))
if diff := cmp.Diff(tc.want, got); diff != "" {
t.Errorf("FromPtrValue(ToPtrValue(%s): -want, +got: %s", tc.want, diff)
}
})
}
}
func TestToAndFromFloatPtr(t *testing.T) {
cases := map[string]struct {
want string
}{
"Zero": {want: ""},
"NonZero": {want: "1123581321"},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
got := FromFloatPtrValue(ToFloatPtrValue(tc.want))
if diff := cmp.Diff(tc.want, got); diff != "" {
t.Errorf("FromPtrValue(ToPtrValue(%s): -want, +got: %s", tc.want, diff)
}
})
}
}
func TestToAndFromPtrValues(t *testing.T) {
cases := map[string]struct {
want []string
}{
"Nil": {want: []string{}},
"Zero": {want: []string{""}},
"NonZero": {want: []string{"pointy"}},
"Multiple": {want: []string{"pointy", "pointers"}},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
got := FromPtrValues(ToPtrValues(tc.want))
if diff := cmp.Diff(tc.want, got); diff != "" {
t.Errorf("FromPtrValues(ToPtrValues(%s): -want, +got: %s", tc.want, diff)
}
})
}
}
func TestToAndFromFloatPtrValues(t *testing.T) {
cases := map[string]struct {
want []string
}{
"Nil": {want: []string{}},
"Zero": {want: []string{""}},
"NonZero": {want: []string{"1123581321"}},
"Multiple": {want: []string{"1123581321", "1234567890"}},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
got := FromFloatPtrValues(ToFloatPtrValues(tc.want))
if diff := cmp.Diff(tc.want, got); diff != "" {
t.Errorf("FromPtrValues(ToPtrValues(%s): -want, +got: %s", tc.want, diff)
}
})
}
}
func TestToAndFromIntPtrValues(t *testing.T) {
cases := map[string]struct {
want []string
}{
"Nil": {want: []string{}},
"Zero": {want: []string{""}},
"NonZero": {want: []string{"1123581321"}},
"Multiple": {want: []string{"1123581321", "1234567890"}},
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
got := FromIntPtrValues(ToIntPtrValues(tc.want))
if diff := cmp.Diff(tc.want, got); diff != "" {
t.Errorf("FromIntPtrValues(ToIntPtrValues(%s): -want, +got: %s", tc.want, diff)
}
})
}
}
func TestResolve(t *testing.T) {
errBoom := errors.New("boom")
now := metav1.Now()