sam_oneal/pulumi-docker-build
1
0
Fork 0
Code Actions Packages Releases Wiki Activity

Upgrade go-provider (#53)

Browse Source 
This upgrades pulumi-go-provider to latest. Code was automatically
migrated using a slightly modified patch described
[here](https://github.com/pulumi/pulumi-go-provider/pull/227#issuecomment-2073962385).

---------

Co-authored-by: Ian Wahbe <ian@wahbe.com>
This commit is contained in:
Bryce Lampe
2024-05-13 12:23:24 -07:00
committed by GitHub
parent 9b789f3742
commit ff71c251e1
20 changed files with 208 additions and 704 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
provider/internal/deprecated/configencoding.go
View File

@@ -17,9 +17,6 @@ package deprecated
import (
"encoding/json"
"fmt"
"sort"
"google.golang.org/protobuf/types/known/structpb"
"github.com/pulumi/pulumi/pkg/v3/codegen/schema"
"github.com/pulumi/pulumi/sdk/v3/go/common/resource"
@@ -113,6 +110,7 @@ func (enc *ConfigEncoding) unmarshalOpts() plugin.MarshalOptions {
return plugin.MarshalOptions{
Label: "config",
KeepUnknowns: true,
KeepSecrets: true,
SkipNulls: true,
RejectAssets: true,
}
@@ -120,15 +118,10 @@ func (enc *ConfigEncoding) unmarshalOpts() plugin.MarshalOptions {
// Like plugin.UnmarshalPropertyValue but overrides string parsing with convertStringToPropertyValue.
func (enc *ConfigEncoding) unmarshalPropertyValue(key resource.PropertyKey,
v *structpb.Value,
) (*resource.PropertyValue, error) {
pv resource.PropertyValue,
) (resource.PropertyValue, error) {
opts := enc.unmarshalOpts()
pv, err := plugin.UnmarshalPropertyValue(key, v, enc.unmarshalOpts())
if err != nil {
return nil, fmt.Errorf("error unmarshalling property %q: %w", key, err)
}
prop, ok := enc.schema.Variables[string(key)]
// Only apply JSON-encoded recognition for known fields.
@@ -136,8 +129,10 @@ func (enc *ConfigEncoding) unmarshalPropertyValue(key resource.PropertyKey,
return pv, nil
}
var jsonString string
var jsonStringDetected, jsonStringSecret bool
var (
jsonString string
jsonStringDetected, jsonStringSecret bool
)
if pv.IsString() {
jsonString = pv.StringValue()
@@ -153,22 +148,21 @@ func (enc *ConfigEncoding) unmarshalPropertyValue(key resource.PropertyKey,
if jsonStringDetected {
v, err := enc.convertStringToPropertyValue(jsonString, prop)
if err != nil {
return nil, fmt.Errorf("error unmarshalling property %q: %w", key, err)
return resource.PropertyValue{}, fmt.Errorf("error unmarshalling property %q: %w", key, err)
}
if jsonStringSecret {
s := resource.MakeSecret(v)
return &s, nil
return resource.MakeSecret(v), nil
}
return &v, nil
return v, nil
}
// Computed sentinels are coming in as always having an empty string, but the encoding coerses them to a zero
// Computed sentinels are coming in as always having an empty string, but the encoding coerces them to a zero
// value of the appropriate type.
if pv.IsComputed() {
el := pv.V.(resource.Computed).Element
if el.IsString() && el.StringValue() == "" {
res := resource.MakeComputed(enc.zeroValue(prop.Type))
return &res, nil
return res, nil
}
}
@@ -177,36 +171,20 @@ func (enc *ConfigEncoding) unmarshalPropertyValue(key resource.PropertyKey,
// UnmarshalProperties is copied from plugin.UnmarshalProperties substituting plugin.UnmarshalPropertyValue.
func (enc *ConfigEncoding) UnmarshalProperties(
props *structpb.Struct,
props resource.PropertyMap,
) (resource.PropertyMap, error) {
opts := enc.unmarshalOpts()
result := make(resource.PropertyMap)
// First sort the keys so we enumerate them in order (in case errors happen, we want determinism).
var keys []string
if props != nil {
for k := range props.Fields {
keys = append(keys, k)
}
sort.Strings(keys)
}
keys := props.StableKeys()
// And now unmarshal every field it into the map.
for _, key := range keys {
pk := resource.PropertyKey(key)
v, err := enc.unmarshalPropertyValue(pk, props.Fields[key])
v, err := enc.unmarshalPropertyValue(key, props[key])
if err != nil {
return nil, err
} else if v != nil {
if opts.SkipNulls && v.IsNull() {
continue
}
if opts.SkipInternalKeys && resource.IsInternalPropertyKey(pk) {
continue
}
result[pk] = *v
return resource.PropertyMap{}, err
}
result[key] = v
}
return result, nil

111
provider/internal/deprecated/configencoding_test.go
View File

@@ -16,23 +16,23 @@ package deprecated
import (
"fmt"
"strconv"
"testing"
"github.com/stretchr/testify/assert"
structpb "google.golang.org/protobuf/types/known/structpb"
"github.com/stretchr/testify/require"
"github.com/pulumi/pulumi/pkg/v3/codegen/schema"
"github.com/pulumi/pulumi/sdk/v3/go/common/resource"
"github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin"
)
func TestConfigEncoding(t *testing.T) {
t.Parallel()
type testCase struct {
ty schema.TypeSpec
v *structpb.Value
pv resource.PropertyValue
ty schema.TypeSpec
given resource.PropertyValue
want resource.PropertyValue
}
knownKey := "mykey"
@@ -49,69 +49,64 @@ func TestConfigEncoding(t *testing.T) {
)
}
makeValue := func(x any) *structpb.Value {
vv, err := structpb.NewValue(x)
assert.NoErrorf(t, err, "structpb.NewValue failed")
return vv
}
checkUnmarshal := func(t *testing.T, tc testCase) {
enc := makeEnc(tc.ty)
pv, err := enc.unmarshalPropertyValue(resource.PropertyKey(knownKey), tc.v)
assert.NoError(t, err)
assert.NotNil(t, pv)
assert.Equal(t, tc.pv, *pv)
key := resource.PropertyKey(knownKey)
actual, err := enc.unmarshalPropertyValue(key, tc.given)
require.NoError(t, err)
assert.Equal(t, tc.want, actual)
}
turnaroundTestCases := []testCase{
{
schema.TypeSpec{Type: "boolean"},
makeValue(`true`),
resource.NewPropertyValue(`true`),
resource.NewBoolProperty(true),
},
{
schema.TypeSpec{Type: "boolean"},
makeValue(`false`),
resource.NewPropertyValue(`false`),
resource.NewBoolProperty(false),
},
{
schema.TypeSpec{Type: "integer"},
makeValue(`0`),
resource.NewPropertyValue(`0`),
resource.NewNumberProperty(0),
},
{
schema.TypeSpec{Type: "integer"},
makeValue(`42`),
resource.NewPropertyValue(`42`),
resource.NewNumberProperty(42),
},
{
schema.TypeSpec{Type: "number"},
makeValue(`0`),
resource.NewPropertyValue(`0`),
resource.NewNumberProperty(0.0),
},
{
schema.TypeSpec{Type: "number"},
makeValue(`42.5`),
resource.NewPropertyValue(`42.5`),
resource.NewNumberProperty(42.5),
},
{
schema.TypeSpec{Type: "string"},
structpb.NewStringValue(""),
resource.NewStringProperty(""),
resource.NewStringProperty(""),
},
{
schema.TypeSpec{Type: "string"},
structpb.NewStringValue("hello"),
resource.NewStringProperty("hello"),
resource.NewStringProperty("hello"),
},
{
schema.TypeSpec{Type: "array"},
makeValue(`[]`),
resource.NewPropertyValue(`[]`),
resource.NewArrayProperty([]resource.PropertyValue{}),
},
{
schema.TypeSpec{Type: "array"},
makeValue(`["hello","there"]`),
resource.NewPropertyValue(`["hello","there"]`),
resource.NewArrayProperty([]resource.PropertyValue{
resource.NewStringProperty("hello"),
resource.NewStringProperty("there"),
@@ -119,12 +114,12 @@ func TestConfigEncoding(t *testing.T) {
},
{
schema.TypeSpec{Type: "object"},
makeValue(`{}`),
resource.NewPropertyValue(`{}`),
resource.NewObjectProperty(resource.PropertyMap{}),
},
{
schema.TypeSpec{Type: "object"},
makeValue(`{"key":"value"}`),
resource.NewPropertyValue(`{"key":"value"}`),
resource.NewObjectProperty(resource.PropertyMap{
"key": resource.NewStringProperty("value"),
}),
@@ -135,7 +130,7 @@ func TestConfigEncoding(t *testing.T) {
for i, tc := range turnaroundTestCases {
tc := tc
t.Run(fmt.Sprintf("UnmarshalPropertyValue/%d", i), func(t *testing.T) {
t.Run(strconv.Itoa(i), func(t *testing.T) {
t.Parallel()
checkUnmarshal(t, tc)
})
@@ -147,32 +142,32 @@ func TestConfigEncoding(t *testing.T) {
cases := []testCase{
{
schema.TypeSpec{Type: "boolean"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewBoolProperty(false),
},
{
schema.TypeSpec{Type: "number"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewNumberProperty(0.),
},
{
schema.TypeSpec{Type: "integer"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewNumberProperty(0),
},
{
schema.TypeSpec{Type: "string"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewStringProperty(""),
},
{
schema.TypeSpec{Type: "object"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewObjectProperty(make(resource.PropertyMap)),
},
{
schema.TypeSpec{Type: "array"},
makeValue(""),
resource.NewPropertyValue(""),
resource.NewArrayProperty([]resource.PropertyValue{}),
},
}
@@ -187,18 +182,18 @@ func TestConfigEncoding(t *testing.T) {
})
t.Run("computed", func(t *testing.T) {
unk := makeValue(plugin.UnknownStringValue)
unk := resource.MakeComputed(resource.NewStringProperty(""))
for i, tc := range turnaroundTestCases {
tc := tc
t.Run(fmt.Sprintf("UnmarshalPropertyValue/%d", i), func(t *testing.T) {
t.Run(strconv.Itoa(i), func(t *testing.T) {
t.Parallel()
// Unknown sentinel unmarshals to a Computed with a type-appropriate zero value.
checkUnmarshal(t, testCase{
tc.ty,
unk,
resource.MakeComputed(makeEnc(tc.ty).zeroValue(tc.ty.Type)),
ty: tc.ty,
given: unk,
want: resource.MakeComputed(makeEnc(tc.ty).zeroValue(tc.ty.Type)),
})
})
}
@@ -215,46 +210,30 @@ func TestConfigEncoding(t *testing.T) {
var secretCases []testCase
pbSecret := func(v *structpb.Value) *structpb.Value {
return structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{
"4dabf18193072939515e22adb298388d": makeValue("1b47061264138c4ac30d75fd1eb44270"),
"value": v,
}})
}
for _, tc := range turnaroundTestCases {
secretCases = append(secretCases, testCase{
tc.ty,
pbSecret(tc.v),
resource.MakeSecret(tc.pv),
ty: tc.ty,
given: resource.MakeSecret(tc.given),
want: resource.MakeSecret(tc.want),
})
}
for i, tc := range secretCases {
tc := tc
t.Run(fmt.Sprintf("secret/UnmarshalPropertyValue/%d", i), func(t *testing.T) {
t.Run(strconv.Itoa(i), func(t *testing.T) {
t.Parallel()
// Unmarshallin will remove secrts, so the expected value needs to be modified.
tc.pv = tc.pv.SecretValue().Element
checkUnmarshal(t, tc)
})
}
t.Run("tolerate secrets in Configure", func(t *testing.T) {
// This is a bit of a histirocal quirk: the engine may send secrets to Configure before
// receiving the response from Configure indicating that the provider does not want to receive
// secrets. These are simply ignored. The engine does not currently send secrets to CheckConfig.
// The engine does take care of making sure the secrets are stored as such in the statefile.
//
// Check here that unmarshalilng such values removes the secrets.
t.Run("nested secrets", func(t *testing.T) {
checkUnmarshal(t, testCase{
schema.TypeSpec{Type: "object"},
pbSecret(makeValue(`{"key":"val"}`)),
resource.NewObjectProperty(resource.PropertyMap{
resource.MakeSecret(resource.NewPropertyValue(`{"key":"val"}`)),
resource.MakeSecret(resource.NewObjectProperty(resource.PropertyMap{
"key": resource.NewStringProperty("val"),
}),
})),
})
})
})
@@ -262,7 +241,7 @@ func TestConfigEncoding(t *testing.T) {
regressUnmarshalTestCases := []testCase{
{
schema.TypeSpec{Type: "array"},
makeValue(`
resource.NewPropertyValue(`
[
{
"address": "somewhere.org",
@@ -276,7 +255,7 @@ func TestConfigEncoding(t *testing.T) {
resource.NewArrayProperty([]resource.PropertyValue{
resource.NewObjectProperty(resource.PropertyMap{
"address": resource.NewStringProperty("somewhere.org"),
"password": resource.NewStringProperty("some-password"),
"password": resource.MakeSecret(resource.NewStringProperty("some-password")),
"username": resource.NewStringProperty("some-user"),
}),
}),
@@ -286,7 +265,7 @@ func TestConfigEncoding(t *testing.T) {
t.Run("regress-unmarshal", func(t *testing.T) {
for i, tc := range regressUnmarshalTestCases {
tc := tc
t.Run(fmt.Sprintf("UnmarshalPropertyValue/%d", i), func(t *testing.T) {
t.Run(strconv.Itoa(i), func(t *testing.T) {
t.Parallel()
checkUnmarshal(t, tc)
})