internal/legacy/helper/plugin
This is used internally for testing
This commit is contained in:
James Bardin
parent
e4edce22ca
commit
5bbac72a85
|
|
@ -0,0 +1,6 @@
|
|||
// Package plugin contains types and functions to help Terraform plugins
|
||||
// implement the plugin rpc interface.
|
||||
// The primary Provider type will be responsible for converting from the grpc
|
||||
// wire protocol to the types and methods known to the provider
|
||||
// implementations.
|
||||
package plugin
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,201 @@
|
|||
package plugin
|
||||
|
||||
import (
|
||||
"log"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/hashicorp/terraform/internal/legacy/helper/schema"
|
||||
"github.com/hashicorp/terraform/internal/legacy/terraform"
|
||||
proto "github.com/hashicorp/terraform/internal/tfplugin5"
|
||||
"github.com/hashicorp/terraform/plugin/convert"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
ctyconvert "github.com/zclconf/go-cty/cty/convert"
|
||||
"github.com/zclconf/go-cty/cty/msgpack"
|
||||
context "golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// NewGRPCProvisionerServerShim wraps a terraform.ResourceProvisioner in a
|
||||
// proto.ProvisionerServer implementation. If the provided provisioner is not a
|
||||
// *schema.Provisioner, this will return nil,
|
||||
func NewGRPCProvisionerServerShim(p terraform.ResourceProvisioner) *GRPCProvisionerServer {
|
||||
sp, ok := p.(*schema.Provisioner)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return &GRPCProvisionerServer{
|
||||
provisioner: sp,
|
||||
}
|
||||
}
|
||||
|
||||
type GRPCProvisionerServer struct {
|
||||
provisioner *schema.Provisioner
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) GetSchema(_ context.Context, req *proto.GetProvisionerSchema_Request) (*proto.GetProvisionerSchema_Response, error) {
|
||||
resp := &proto.GetProvisionerSchema_Response{}
|
||||
|
||||
resp.Provisioner = &proto.Schema{
|
||||
Block: convert.ConfigSchemaToProto(schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()),
|
||||
}
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) ValidateProvisionerConfig(_ context.Context, req *proto.ValidateProvisionerConfig_Request) (*proto.ValidateProvisionerConfig_Response, error) {
|
||||
resp := &proto.ValidateProvisionerConfig_Response{}
|
||||
|
||||
cfgSchema := schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()
|
||||
|
||||
configVal, err := msgpack.Unmarshal(req.Config.Msgpack, cfgSchema.ImpliedType())
|
||||
if err != nil {
|
||||
resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
config := terraform.NewResourceConfigShimmed(configVal, cfgSchema)
|
||||
|
||||
warns, errs := s.provisioner.Validate(config)
|
||||
resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, convert.WarnsAndErrsToProto(warns, errs))
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// stringMapFromValue converts a cty.Value to a map[stirng]string.
|
||||
// This will panic if the val is not a cty.Map(cty.String).
|
||||
func stringMapFromValue(val cty.Value) map[string]string {
|
||||
m := map[string]string{}
|
||||
if val.IsNull() || !val.IsKnown() {
|
||||
return m
|
||||
}
|
||||
|
||||
for it := val.ElementIterator(); it.Next(); {
|
||||
ak, av := it.Element()
|
||||
name := ak.AsString()
|
||||
|
||||
if !av.IsKnown() || av.IsNull() {
|
||||
continue
|
||||
}
|
||||
|
||||
av, _ = ctyconvert.Convert(av, cty.String)
|
||||
m[name] = av.AsString()
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// uiOutput implements the terraform.UIOutput interface to adapt the grpc
|
||||
// stream to the legacy Provisioner.Apply method.
|
||||
type uiOutput struct {
|
||||
srv proto.Provisioner_ProvisionResourceServer
|
||||
}
|
||||
|
||||
func (o uiOutput) Output(s string) {
|
||||
err := o.srv.Send(&proto.ProvisionResource_Response{
|
||||
Output: toValidUTF8(s, string(utf8.RuneError)),
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("[ERROR] %s", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) ProvisionResource(req *proto.ProvisionResource_Request, srv proto.Provisioner_ProvisionResourceServer) error {
|
||||
// We send back a diagnostics over the stream if there was a
|
||||
// provisioner-side problem.
|
||||
srvResp := &proto.ProvisionResource_Response{}
|
||||
|
||||
cfgSchema := schema.InternalMap(s.provisioner.Schema).CoreConfigSchema()
|
||||
cfgVal, err := msgpack.Unmarshal(req.Config.Msgpack, cfgSchema.ImpliedType())
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
return nil
|
||||
}
|
||||
resourceConfig := terraform.NewResourceConfigShimmed(cfgVal, cfgSchema)
|
||||
|
||||
connVal, err := msgpack.Unmarshal(req.Connection.Msgpack, cty.Map(cty.String))
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
return nil
|
||||
}
|
||||
|
||||
conn := stringMapFromValue(connVal)
|
||||
|
||||
instanceState := &terraform.InstanceState{
|
||||
Ephemeral: terraform.EphemeralState{
|
||||
ConnInfo: conn,
|
||||
},
|
||||
Meta: make(map[string]interface{}),
|
||||
}
|
||||
|
||||
err = s.provisioner.Apply(uiOutput{srv}, instanceState, resourceConfig)
|
||||
if err != nil {
|
||||
srvResp.Diagnostics = convert.AppendProtoDiag(srvResp.Diagnostics, err)
|
||||
srv.Send(srvResp)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *GRPCProvisionerServer) Stop(_ context.Context, req *proto.Stop_Request) (*proto.Stop_Response, error) {
|
||||
resp := &proto.Stop_Response{}
|
||||
|
||||
err := s.provisioner.Stop()
|
||||
if err != nil {
|
||||
resp.Error = err.Error()
|
||||
}
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// FIXME: backported from go1.13 strings package, remove once terraform is
|
||||
// using go >= 1.13
|
||||
// ToValidUTF8 returns a copy of the string s with each run of invalid UTF-8 byte sequences
|
||||
// replaced by the replacement string, which may be empty.
|
||||
func toValidUTF8(s, replacement string) string {
|
||||
var b strings.Builder
|
||||
|
||||
for i, c := range s {
|
||||
if c != utf8.RuneError {
|
||||
continue
|
||||
}
|
||||
|
||||
_, wid := utf8.DecodeRuneInString(s[i:])
|
||||
if wid == 1 {
|
||||
b.Grow(len(s) + len(replacement))
|
||||
b.WriteString(s[:i])
|
||||
s = s[i:]
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// Fast path for unchanged input
|
||||
if b.Cap() == 0 { // didn't call b.Grow above
|
||||
return s
|
||||
}
|
||||
|
||||
invalid := false // previous byte was from an invalid UTF-8 sequence
|
||||
for i := 0; i < len(s); {
|
||||
c := s[i]
|
||||
if c < utf8.RuneSelf {
|
||||
i++
|
||||
invalid = false
|
||||
b.WriteByte(c)
|
||||
continue
|
||||
}
|
||||
_, wid := utf8.DecodeRuneInString(s[i:])
|
||||
if wid == 1 {
|
||||
i++
|
||||
if !invalid {
|
||||
invalid = true
|
||||
b.WriteString(replacement)
|
||||
}
|
||||
continue
|
||||
}
|
||||
invalid = false
|
||||
b.WriteString(s[i : i+wid])
|
||||
i += wid
|
||||
}
|
||||
|
||||
return b.String()
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
package plugin
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/golang/mock/gomock"
|
||||
"github.com/hashicorp/terraform/internal/legacy/helper/schema"
|
||||
"github.com/hashicorp/terraform/internal/legacy/terraform"
|
||||
proto "github.com/hashicorp/terraform/internal/tfplugin5"
|
||||
mockproto "github.com/hashicorp/terraform/plugin/mock_proto"
|
||||
context "golang.org/x/net/context"
|
||||
)
|
||||
|
||||
var _ proto.ProvisionerServer = (*GRPCProvisionerServer)(nil)
|
||||
|
||||
type validUTF8Matcher string
|
||||
|
||||
func (m validUTF8Matcher) Matches(x interface{}) bool {
|
||||
resp := x.(*proto.ProvisionResource_Response)
|
||||
return utf8.Valid([]byte(resp.Output))
|
||||
}
|
||||
|
||||
func (m validUTF8Matcher) String() string {
|
||||
return string(m)
|
||||
}
|
||||
|
||||
func mockProvisionerServer(t *testing.T, c *gomock.Controller) *mockproto.MockProvisioner_ProvisionResourceServer {
|
||||
server := mockproto.NewMockProvisioner_ProvisionResourceServer(c)
|
||||
|
||||
server.EXPECT().Send(
|
||||
validUTF8Matcher("check for valid utf8"),
|
||||
).Return(nil)
|
||||
|
||||
return server
|
||||
}
|
||||
|
||||
// ensure that a provsioner cannot return invalid utf8 which isn't allowed in
|
||||
// the grpc protocol.
|
||||
func TestProvisionerInvalidUTF8(t *testing.T) {
|
||||
p := &schema.Provisioner{
|
||||
ConnSchema: map[string]*schema.Schema{
|
||||
"foo": {
|
||||
Type: schema.TypeString,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
|
||||
Schema: map[string]*schema.Schema{
|
||||
"foo": {
|
||||
Type: schema.TypeInt,
|
||||
Optional: true,
|
||||
},
|
||||
},
|
||||
|
||||
ApplyFunc: func(ctx context.Context) error {
|
||||
out := ctx.Value(schema.ProvOutputKey).(terraform.UIOutput)
|
||||
out.Output("invalid \xc3\x28\n")
|
||||
return nil
|
||||
},
|
||||
}
|
||||
|
||||
ctrl := gomock.NewController(t)
|
||||
defer ctrl.Finish()
|
||||
|
||||
srv := mockProvisionerServer(t, ctrl)
|
||||
cfg := &proto.DynamicValue{
|
||||
Msgpack: []byte("\x81\xa3foo\x01"),
|
||||
}
|
||||
conn := &proto.DynamicValue{
|
||||
Msgpack: []byte("\x81\xa3foo\xa4host"),
|
||||
}
|
||||
provisionerServer := NewGRPCProvisionerServerShim(p)
|
||||
req := &proto.ProvisionResource_Request{
|
||||
Config: cfg,
|
||||
Connection: conn,
|
||||
}
|
||||
|
||||
if err := provisionerServer.ProvisionResource(req, srv); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
package plugin
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
// SetUnknowns takes a cty.Value, and compares it to the schema setting any null
|
||||
// values which are computed to unknown.
|
||||
func SetUnknowns(val cty.Value, schema *configschema.Block) cty.Value {
|
||||
if !val.IsKnown() {
|
||||
return val
|
||||
}
|
||||
|
||||
// If the object was null, we still need to handle the top level attributes
|
||||
// which might be computed, but we don't need to expand the blocks.
|
||||
if val.IsNull() {
|
||||
objMap := map[string]cty.Value{}
|
||||
allNull := true
|
||||
for name, attr := range schema.Attributes {
|
||||
switch {
|
||||
case attr.Computed:
|
||||
objMap[name] = cty.UnknownVal(attr.Type)
|
||||
allNull = false
|
||||
default:
|
||||
objMap[name] = cty.NullVal(attr.Type)
|
||||
}
|
||||
}
|
||||
|
||||
// If this object has no unknown attributes, then we can leave it null.
|
||||
if allNull {
|
||||
return val
|
||||
}
|
||||
|
||||
return cty.ObjectVal(objMap)
|
||||
}
|
||||
|
||||
valMap := val.AsValueMap()
|
||||
newVals := make(map[string]cty.Value)
|
||||
|
||||
for name, attr := range schema.Attributes {
|
||||
v := valMap[name]
|
||||
|
||||
if attr.Computed && v.IsNull() {
|
||||
newVals[name] = cty.UnknownVal(attr.Type)
|
||||
continue
|
||||
}
|
||||
|
||||
newVals[name] = v
|
||||
}
|
||||
|
||||
for name, blockS := range schema.BlockTypes {
|
||||
blockVal := valMap[name]
|
||||
if blockVal.IsNull() || !blockVal.IsKnown() {
|
||||
newVals[name] = blockVal
|
||||
continue
|
||||
}
|
||||
|
||||
blockValType := blockVal.Type()
|
||||
blockElementType := blockS.Block.ImpliedType()
|
||||
|
||||
// This switches on the value type here, so we can correctly switch
|
||||
// between Tuples/Lists and Maps/Objects.
|
||||
switch {
|
||||
case blockS.Nesting == configschema.NestingSingle || blockS.Nesting == configschema.NestingGroup:
|
||||
// NestingSingle is the only exception here, where we treat the
|
||||
// block directly as an object
|
||||
newVals[name] = SetUnknowns(blockVal, &blockS.Block)
|
||||
|
||||
case blockValType.IsSetType(), blockValType.IsListType(), blockValType.IsTupleType():
|
||||
listVals := blockVal.AsValueSlice()
|
||||
newListVals := make([]cty.Value, 0, len(listVals))
|
||||
|
||||
for _, v := range listVals {
|
||||
newListVals = append(newListVals, SetUnknowns(v, &blockS.Block))
|
||||
}
|
||||
|
||||
switch {
|
||||
case blockValType.IsSetType():
|
||||
switch len(newListVals) {
|
||||
case 0:
|
||||
newVals[name] = cty.SetValEmpty(blockElementType)
|
||||
default:
|
||||
newVals[name] = cty.SetVal(newListVals)
|
||||
}
|
||||
case blockValType.IsListType():
|
||||
switch len(newListVals) {
|
||||
case 0:
|
||||
newVals[name] = cty.ListValEmpty(blockElementType)
|
||||
default:
|
||||
newVals[name] = cty.ListVal(newListVals)
|
||||
}
|
||||
case blockValType.IsTupleType():
|
||||
newVals[name] = cty.TupleVal(newListVals)
|
||||
}
|
||||
|
||||
case blockValType.IsMapType(), blockValType.IsObjectType():
|
||||
mapVals := blockVal.AsValueMap()
|
||||
newMapVals := make(map[string]cty.Value)
|
||||
|
||||
for k, v := range mapVals {
|
||||
newMapVals[k] = SetUnknowns(v, &blockS.Block)
|
||||
}
|
||||
|
||||
switch {
|
||||
case blockValType.IsMapType():
|
||||
switch len(newMapVals) {
|
||||
case 0:
|
||||
newVals[name] = cty.MapValEmpty(blockElementType)
|
||||
default:
|
||||
newVals[name] = cty.MapVal(newMapVals)
|
||||
}
|
||||
case blockValType.IsObjectType():
|
||||
if len(newMapVals) == 0 {
|
||||
// We need to populate empty values to make a valid object.
|
||||
for attr, ty := range blockElementType.AttributeTypes() {
|
||||
newMapVals[attr] = cty.NullVal(ty)
|
||||
}
|
||||
}
|
||||
newVals[name] = cty.ObjectVal(newMapVals)
|
||||
}
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("failed to set unknown values for nested block %q:%#v", name, blockValType))
|
||||
}
|
||||
}
|
||||
|
||||
return cty.ObjectVal(newVals)
|
||||
}
|
||||
|
|
@ -0,0 +1,483 @@
|
|||
package plugin
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/hashicorp/terraform/configs/configschema"
|
||||
"github.com/zclconf/go-cty/cty"
|
||||
)
|
||||
|
||||
func TestSetUnknowns(t *testing.T) {
|
||||
for n, tc := range map[string]struct {
|
||||
Schema *configschema.Block
|
||||
Val cty.Value
|
||||
Expected cty.Value
|
||||
}{
|
||||
"empty": {
|
||||
&configschema.Block{},
|
||||
cty.EmptyObjectVal,
|
||||
cty.EmptyObjectVal,
|
||||
},
|
||||
"no prior": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"foo": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"baz": {
|
||||
Nesting: configschema.NestingSingle,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"boz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"biz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"foo": cty.String,
|
||||
"bar": cty.String,
|
||||
"baz": cty.Object(map[string]cty.Type{
|
||||
"boz": cty.String,
|
||||
"biz": cty.String,
|
||||
}),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.NullVal(cty.String),
|
||||
"bar": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
},
|
||||
"null stays null": {
|
||||
// if the object has no computed attributes, it should stay null
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"foo": &configschema.Attribute{
|
||||
Type: cty.String,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"baz": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"boz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"foo": cty.String,
|
||||
"baz": cty.Set(cty.Object(map[string]cty.Type{
|
||||
"boz": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"foo": cty.String,
|
||||
"baz": cty.Set(cty.Object(map[string]cty.Type{
|
||||
"boz": cty.String,
|
||||
})),
|
||||
})),
|
||||
},
|
||||
"no prior with set": {
|
||||
// the set value should remain null
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"foo": &configschema.Attribute{
|
||||
Type: cty.String,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"baz": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"boz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.NullVal(cty.Object(map[string]cty.Type{
|
||||
"foo": cty.String,
|
||||
"baz": cty.Set(cty.Object(map[string]cty.Type{
|
||||
"boz": cty.String,
|
||||
})),
|
||||
})),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
},
|
||||
"prior attributes": {
|
||||
&configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"foo": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"boz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.StringVal("bonjour"),
|
||||
"bar": cty.StringVal("petit dejeuner"),
|
||||
"baz": cty.StringVal("grande dejeuner"),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.StringVal("bonjour"),
|
||||
"bar": cty.StringVal("petit dejeuner"),
|
||||
"baz": cty.StringVal("grande dejeuner"),
|
||||
"boz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
},
|
||||
"prior nested single": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingSingle,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("beep"),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("beep"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"prior nested list": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("bap"),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ListVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("bap"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"prior nested map": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingMap,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.MapVal(map[string]cty.Value{
|
||||
"a": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.NullVal(cty.String),
|
||||
"baz": cty.StringVal("boop"),
|
||||
}),
|
||||
"b": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
"baz": cty.NullVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.MapVal(map[string]cty.Value{
|
||||
"a": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.UnknownVal(cty.String),
|
||||
"baz": cty.StringVal("boop"),
|
||||
}),
|
||||
"b": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"prior nested set": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
"baz": cty.NullVal(cty.String),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.NullVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("blep"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"sets differing only by unknown": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingSet,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.NullVal(cty.String),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.SetVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.UnknownVal(cty.String),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"prior nested list with dynamic": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingList,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.DynamicPseudoType,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.TupleVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.NullVal(cty.String),
|
||||
"baz": cty.NumberIntVal(8),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.TupleVal([]cty.Value{
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.UnknownVal(cty.String),
|
||||
"baz": cty.NumberIntVal(8),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
"prior nested map with dynamic": {
|
||||
&configschema.Block{
|
||||
BlockTypes: map[string]*configschema.NestedBlock{
|
||||
"foo": {
|
||||
Nesting: configschema.NestingMap,
|
||||
Block: configschema.Block{
|
||||
Attributes: map[string]*configschema.Attribute{
|
||||
"bar": {
|
||||
Type: cty.String,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
"baz": {
|
||||
Type: cty.DynamicPseudoType,
|
||||
Optional: true,
|
||||
Computed: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("beep"),
|
||||
"baz": cty.NullVal(cty.DynamicPseudoType),
|
||||
}),
|
||||
"b": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.NumberIntVal(8),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
cty.ObjectVal(map[string]cty.Value{
|
||||
"foo": cty.ObjectVal(map[string]cty.Value{
|
||||
"a": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("beep"),
|
||||
"baz": cty.UnknownVal(cty.DynamicPseudoType),
|
||||
}),
|
||||
"b": cty.ObjectVal(map[string]cty.Value{
|
||||
"bar": cty.StringVal("boop"),
|
||||
"baz": cty.NumberIntVal(8),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
},
|
||||
} {
|
||||
t.Run(n, func(t *testing.T) {
|
||||
got := SetUnknowns(tc.Val, tc.Schema)
|
||||
if !got.RawEquals(tc.Expected) {
|
||||
t.Fatalf("\nexpected: %#v\ngot: %#v\n", tc.Expected, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue