mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 01:41:48 -06:00
53a73a8ab6
In order to handle optional attributes, the Variable type needs to keep track of the type constraint for decoding and conversion, as well as the concrete type for creating values and type comparison. Since the Type field is referenced throughout the codebase, and for future refactoring if the handling of optional attributes changes significantly, the constraint is now loaded into an entirely new field called ConstraintType. This prevents types containing ObjectWithOptionalAttrs from escaping the decode/conversion codepaths into the rest of the codebase.
319 lines
8.4 KiB
Go
319 lines
8.4 KiB
Go
package configs
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/hcl/v2"
|
|
"github.com/hashicorp/hcl/v2/gohcl"
|
|
"github.com/hashicorp/terraform/internal/addrs"
|
|
"github.com/zclconf/go-cty/cty"
|
|
)
|
|
|
|
func TestModuleOverrideVariable(t *testing.T) {
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-variable")
|
|
assertNoDiagnostics(t, diags)
|
|
if mod == nil {
|
|
t.Fatalf("module is nil")
|
|
}
|
|
|
|
got := mod.Variables
|
|
want := map[string]*Variable{
|
|
"fully_overridden": {
|
|
Name: "fully_overridden",
|
|
Description: "b_override description",
|
|
DescriptionSet: true,
|
|
Default: cty.StringVal("b_override"),
|
|
Type: cty.String,
|
|
ConstraintType: cty.String,
|
|
ParsingMode: VariableParseLiteral,
|
|
DeclRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-variable/primary.tf",
|
|
Start: hcl.Pos{
|
|
Line: 1,
|
|
Column: 1,
|
|
Byte: 0,
|
|
},
|
|
End: hcl.Pos{
|
|
Line: 1,
|
|
Column: 28,
|
|
Byte: 27,
|
|
},
|
|
},
|
|
},
|
|
"partially_overridden": {
|
|
Name: "partially_overridden",
|
|
Description: "base description",
|
|
DescriptionSet: true,
|
|
Default: cty.StringVal("b_override partial"),
|
|
Type: cty.String,
|
|
ConstraintType: cty.String,
|
|
ParsingMode: VariableParseLiteral,
|
|
DeclRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-variable/primary.tf",
|
|
Start: hcl.Pos{
|
|
Line: 7,
|
|
Column: 1,
|
|
Byte: 103,
|
|
},
|
|
End: hcl.Pos{
|
|
Line: 7,
|
|
Column: 32,
|
|
Byte: 134,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
assertResultDeepEqual(t, got, want)
|
|
}
|
|
|
|
func TestModuleOverrideModule(t *testing.T) {
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-module")
|
|
assertNoDiagnostics(t, diags)
|
|
if mod == nil {
|
|
t.Fatalf("module is nil")
|
|
}
|
|
|
|
if _, exists := mod.ModuleCalls["example"]; !exists {
|
|
t.Fatalf("no module 'example'")
|
|
}
|
|
if len(mod.ModuleCalls) != 1 {
|
|
t.Fatalf("wrong number of module calls in result %d; want 1", len(mod.ModuleCalls))
|
|
}
|
|
|
|
got := mod.ModuleCalls["example"]
|
|
want := &ModuleCall{
|
|
Name: "example",
|
|
SourceAddr: addrs.ModuleSourceLocal("./example2-a_override"),
|
|
SourceAddrRaw: "./example2-a_override",
|
|
SourceAddrRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-module/a_override.tf",
|
|
Start: hcl.Pos{
|
|
Line: 3,
|
|
Column: 12,
|
|
Byte: 31,
|
|
},
|
|
End: hcl.Pos{
|
|
Line: 3,
|
|
Column: 35,
|
|
Byte: 54,
|
|
},
|
|
},
|
|
SourceSet: true,
|
|
DeclRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-module/primary.tf",
|
|
Start: hcl.Pos{
|
|
Line: 2,
|
|
Column: 1,
|
|
Byte: 1,
|
|
},
|
|
End: hcl.Pos{
|
|
Line: 2,
|
|
Column: 17,
|
|
Byte: 17,
|
|
},
|
|
},
|
|
Providers: []PassedProviderConfig{
|
|
{
|
|
InChild: &ProviderConfigRef{
|
|
Name: "test",
|
|
NameRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-module/b_override.tf",
|
|
Start: hcl.Pos{Line: 7, Column: 5, Byte: 97},
|
|
End: hcl.Pos{Line: 7, Column: 9, Byte: 101},
|
|
},
|
|
},
|
|
InParent: &ProviderConfigRef{
|
|
Name: "test",
|
|
NameRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-module/b_override.tf",
|
|
Start: hcl.Pos{Line: 7, Column: 12, Byte: 104},
|
|
End: hcl.Pos{Line: 7, Column: 16, Byte: 108},
|
|
},
|
|
Alias: "b_override",
|
|
AliasRange: &hcl.Range{
|
|
Filename: "testdata/valid-modules/override-module/b_override.tf",
|
|
Start: hcl.Pos{Line: 7, Column: 16, Byte: 108},
|
|
End: hcl.Pos{Line: 7, Column: 27, Byte: 119},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// We're going to extract and nil out our hcl.Body here because DeepEqual
|
|
// is not a useful way to assert on that.
|
|
gotConfig := got.Config
|
|
got.Config = nil
|
|
|
|
assertResultDeepEqual(t, got, want)
|
|
|
|
type content struct {
|
|
Kept *string `hcl:"kept"`
|
|
Foo *string `hcl:"foo"`
|
|
New *string `hcl:"new"`
|
|
Newer *string `hcl:"newer"`
|
|
}
|
|
var gotArgs content
|
|
diags = gohcl.DecodeBody(gotConfig, nil, &gotArgs)
|
|
assertNoDiagnostics(t, diags)
|
|
|
|
wantArgs := content{
|
|
Kept: stringPtr("primary kept"),
|
|
Foo: stringPtr("a_override foo"),
|
|
New: stringPtr("b_override new"),
|
|
Newer: stringPtr("b_override newer"),
|
|
}
|
|
|
|
assertResultDeepEqual(t, gotArgs, wantArgs)
|
|
}
|
|
|
|
func TestModuleOverrideDynamic(t *testing.T) {
|
|
schema := &hcl.BodySchema{
|
|
Blocks: []hcl.BlockHeaderSchema{
|
|
{Type: "foo"},
|
|
{Type: "dynamic", LabelNames: []string{"type"}},
|
|
},
|
|
}
|
|
|
|
t.Run("base is dynamic", func(t *testing.T) {
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-dynamic-block-base")
|
|
assertNoDiagnostics(t, diags)
|
|
if mod == nil {
|
|
t.Fatalf("module is nil")
|
|
}
|
|
|
|
if _, exists := mod.ManagedResources["test.foo"]; !exists {
|
|
t.Fatalf("no module 'example'")
|
|
}
|
|
if len(mod.ManagedResources) != 1 {
|
|
t.Fatalf("wrong number of managed resources in result %d; want 1", len(mod.ManagedResources))
|
|
}
|
|
|
|
body := mod.ManagedResources["test.foo"].Config
|
|
content, diags := body.Content(schema)
|
|
assertNoDiagnostics(t, diags)
|
|
|
|
if len(content.Blocks) != 1 {
|
|
t.Fatalf("wrong number of blocks in result %d; want 1", len(content.Blocks))
|
|
}
|
|
if got, want := content.Blocks[0].Type, "foo"; got != want {
|
|
t.Fatalf("wrong block type %q; want %q", got, want)
|
|
}
|
|
})
|
|
t.Run("override is dynamic", func(t *testing.T) {
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-dynamic-block-override")
|
|
assertNoDiagnostics(t, diags)
|
|
if mod == nil {
|
|
t.Fatalf("module is nil")
|
|
}
|
|
|
|
if _, exists := mod.ManagedResources["test.foo"]; !exists {
|
|
t.Fatalf("no module 'example'")
|
|
}
|
|
if len(mod.ManagedResources) != 1 {
|
|
t.Fatalf("wrong number of managed resources in result %d; want 1", len(mod.ManagedResources))
|
|
}
|
|
|
|
body := mod.ManagedResources["test.foo"].Config
|
|
content, diags := body.Content(schema)
|
|
assertNoDiagnostics(t, diags)
|
|
|
|
if len(content.Blocks) != 1 {
|
|
t.Fatalf("wrong number of blocks in result %d; want 1", len(content.Blocks))
|
|
}
|
|
if got, want := content.Blocks[0].Type, "dynamic"; got != want {
|
|
t.Fatalf("wrong block type %q; want %q", got, want)
|
|
}
|
|
if got, want := content.Blocks[0].Labels[0], "foo"; got != want {
|
|
t.Fatalf("wrong dynamic block label %q; want %q", got, want)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestModuleOverrideSensitiveVariable(t *testing.T) {
|
|
type testCase struct {
|
|
sensitive bool
|
|
sensitiveSet bool
|
|
}
|
|
cases := map[string]testCase{
|
|
"false_true": {
|
|
sensitive: true,
|
|
sensitiveSet: true,
|
|
},
|
|
"true_false": {
|
|
sensitive: false,
|
|
sensitiveSet: true,
|
|
},
|
|
"false_false_true": {
|
|
sensitive: true,
|
|
sensitiveSet: true,
|
|
},
|
|
"true_true_false": {
|
|
sensitive: false,
|
|
sensitiveSet: true,
|
|
},
|
|
"false_true_false": {
|
|
sensitive: false,
|
|
sensitiveSet: true,
|
|
},
|
|
"true_false_true": {
|
|
sensitive: true,
|
|
sensitiveSet: true,
|
|
},
|
|
}
|
|
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-variable-sensitive")
|
|
|
|
assertNoDiagnostics(t, diags)
|
|
|
|
if mod == nil {
|
|
t.Fatalf("module is nil")
|
|
}
|
|
|
|
got := mod.Variables
|
|
|
|
for v, want := range cases {
|
|
t.Run(fmt.Sprintf("variable %s", v), func(t *testing.T) {
|
|
if got[v].Sensitive != want.sensitive {
|
|
t.Errorf("wrong result for sensitive\ngot: %t want: %t", got[v].Sensitive, want.sensitive)
|
|
}
|
|
|
|
if got[v].SensitiveSet != want.sensitiveSet {
|
|
t.Errorf("wrong result for sensitive set\ngot: %t want: %t", got[v].Sensitive, want.sensitive)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestModuleOverrideResourceFQNs(t *testing.T) {
|
|
mod, diags := testModuleFromDir("testdata/valid-modules/override-resource-provider")
|
|
assertNoDiagnostics(t, diags)
|
|
|
|
got := mod.ManagedResources["test_instance.explicit"]
|
|
wantProvider := addrs.NewProvider(addrs.DefaultProviderRegistryHost, "bar", "test")
|
|
wantProviderCfg := &ProviderConfigRef{
|
|
Name: "bar-test",
|
|
NameRange: hcl.Range{
|
|
Filename: "testdata/valid-modules/override-resource-provider/a_override.tf",
|
|
Start: hcl.Pos{Line: 2, Column: 14, Byte: 51},
|
|
End: hcl.Pos{Line: 2, Column: 22, Byte: 59},
|
|
},
|
|
}
|
|
|
|
if !got.Provider.Equals(wantProvider) {
|
|
t.Fatalf("wrong provider %s, want %s", got.Provider, wantProvider)
|
|
}
|
|
assertResultDeepEqual(t, got.ProviderConfigRef, wantProviderCfg)
|
|
|
|
// now verify that a resource with no provider config falls back to default
|
|
got = mod.ManagedResources["test_instance.default"]
|
|
wantProvider = addrs.NewDefaultProvider("test")
|
|
if !got.Provider.Equals(wantProvider) {
|
|
t.Fatalf("wrong provider %s, want %s", got.Provider, wantProvider)
|
|
}
|
|
if got.ProviderConfigRef != nil {
|
|
t.Fatalf("wrong result: found provider config ref %s, expected nil", got.ProviderConfigRef)
|
|
}
|
|
}
|