IntenseWebs/opentofu
3
0
Fork 0
mirror of https://github.com/opentofu/opentofu.git synced 2024-12-27 09:21:14 -06:00
Code Issues Packages Projects Releases Wiki Activity
d42d83572b
opentofu/internal/addrs/parse_ref_test.go

756 lines
18 KiB
Go
Raw Normal View History

addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
package addrs
import (
"testing"
"github.com/go-test/deep"
vendor: switch to HCL 2.0 in the HCL repository Previously we were using the experimental HCL 2 repository, but now we'll shift over to the v2 import path within the main HCL repository as part of actually releasing HCL 2.0 as stable. This is a mechanical search/replace to the new import paths. It also switches to the v2.0.0 release of HCL, which includes some new code that Terraform didn't previously have but should not change any behavior that matters for Terraform's purposes. For the moment the experimental HCL2 repository is still an indirect dependency via terraform-config-inspect, so it remains in our go.sum and vendor directories for the moment. Because terraform-config-inspect uses a much smaller subset of the HCL2 functionality, this does still manage to prune the vendor directory a little. A subsequent release of terraform-config-inspect should allow us to completely remove that old repository in a future commit.
2019-09-09 17:58:44 -05:00
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
Move tfdiags/ to internal/tfdiags/ This is part of a general effort to move all of Terraform's non-library package surface under internal in order to reinforce that these are for internal use within Terraform only. If you were previously importing packages under this prefix into an external codebase, you could pin to an earlier release tag as an interim solution until you've make a plan to achieve the same functionality some other way.
2021-05-17 12:11:06 -05:00
"github.com/hashicorp/terraform/internal/tfdiags"
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
"github.com/zclconf/go-cty/cty"
)
func TestParseRef(t *testing.T) {
tests := []struct {
Input string
Want *Reference
WantErr string
}{
// count
{
`count.index`,
&Reference{
Subject: CountAttr{
Name: "index",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 12, Byte: 11},
},
},
``,
},
{
`count.index.blah`,
&Reference{
Subject: CountAttr{
Name: "index",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 12, Byte: 11},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 12, Byte: 11},
End: hcl.Pos{Line: 1, Column: 17, Byte: 16},
},
},
},
},
``, // valid at this layer, but will fail during eval because "index" is a number
},
{
`count`,
nil,
`The "count" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`count["hello"]`,
nil,
`The "count" object does not support this operation.`,
},
Resource for_each
2019-06-12 10:07:32 -05:00
// each
{
`each.key`,
&Reference{
Subject: ForEachAttr{
Name: "key",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 9, Byte: 8},
},
},
``,
},
{
`each.value.blah`,
&Reference{
Subject: ForEachAttr{
Name: "value",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 11, Byte: 10},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 11, Byte: 10},
End: hcl.Pos{Line: 1, Column: 16, Byte: 15},
},
},
},
},
``,
},
{
`each`,
nil,
`The "each" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`each["hello"]`,
nil,
`The "each" object does not support this operation.`,
},
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
// data
{
`data.external.foo`,
&Reference{
parse resource refs correctly Now that we only evaluate whole resources, we can parse resource refs correct as the resource, rather than an unknown instance.
2019-09-19 08:53:23 -05:00
Subject: Resource{
Mode: DataResourceMode,
Type: "external",
Name: "foo",
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 18, Byte: 17},
},
},
``,
},
{
`data.external.foo.bar`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: DataResourceMode,
Type: "external",
Name: "foo",
},
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 18, Byte: 17},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "bar",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 18, Byte: 17},
End: hcl.Pos{Line: 1, Column: 22, Byte: 21},
},
},
},
},
``,
},
{
`data.external.foo["baz"].bar`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: DataResourceMode,
Type: "external",
Name: "foo",
},
Key: StringKey("baz"),
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 25, Byte: 24},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "bar",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 25, Byte: 24},
End: hcl.Pos{Line: 1, Column: 29, Byte: 28},
},
},
},
},
``,
},
{
`data.external.foo["baz"]`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: DataResourceMode,
Type: "external",
Name: "foo",
},
Key: StringKey("baz"),
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 25, Byte: 24},
},
},
``,
},
{
`data`,
nil,
`The "data" object must be followed by two attribute names: the data source type and the resource name.`,
},
{
`data.external`,
nil,
`The "data" object must be followed by two attribute names: the data source type and the resource name.`,
},
// local
{
`local.foo`,
&Reference{
Subject: LocalValue{
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 10, Byte: 9},
},
},
``,
},
{
`local.foo.blah`,
&Reference{
Subject: LocalValue{
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 10, Byte: 9},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 10, Byte: 9},
End: hcl.Pos{Line: 1, Column: 15, Byte: 14},
},
},
},
},
``,
},
{
`local.foo["blah"]`,
&Reference{
Subject: LocalValue{
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 10, Byte: 9},
},
Remaining: hcl.Traversal{
hcl.TraverseIndex{
Key: cty.StringVal("blah"),
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 10, Byte: 9},
End: hcl.Pos{Line: 1, Column: 18, Byte: 17},
},
},
},
},
``,
},
{
`local`,
nil,
`The "local" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`local["foo"]`,
nil,
`The "local" object does not support this operation.`,
},
// module
{
`module.foo`,
&Reference{
parse module references as whole modules Module references, like resource references, need to always return the and object containing all instances in order to handle modules as single values, and to postpone index evaluation to when the expression as whole is evaluated.
2020-04-12 10:26:44 -05:00
Subject: ModuleCall{
Name: "foo",
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 11, Byte: 10},
},
},
``,
},
{
`module.foo.bar`,
&Reference{
addrs: Rename AbsModuleCallOutput to ModuleCallInstanceOutput The previous name didn't fit with the naming scheme for addrs types: The "Abs" prefix typically means that it's an addrs.ModuleInstance combined with whatever type name appears after "Abs", but this is instead a ModuleCallOutput combined with an InstanceKey, albeit structured the other way around for convenience, and so the expected name for this would be the suffix "Instance". We don't have an "Abs" type corresponding with this one because it would represent no additional information than AbsOutputValue.
2021-06-29 17:06:00 -05:00
Subject: ModuleCallInstanceOutput{
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
Call: ModuleCallInstance{
Call: ModuleCall{
Name: "foo",
},
},
Name: "bar",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 15, Byte: 14},
},
},
``,
},
{
`module.foo.bar.baz`,
&Reference{
addrs: Rename AbsModuleCallOutput to ModuleCallInstanceOutput The previous name didn't fit with the naming scheme for addrs types: The "Abs" prefix typically means that it's an addrs.ModuleInstance combined with whatever type name appears after "Abs", but this is instead a ModuleCallOutput combined with an InstanceKey, albeit structured the other way around for convenience, and so the expected name for this would be the suffix "Instance". We don't have an "Abs" type corresponding with this one because it would represent no additional information than AbsOutputValue.
2021-06-29 17:06:00 -05:00
Subject: ModuleCallInstanceOutput{
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
Call: ModuleCallInstance{
Call: ModuleCall{
Name: "foo",
},
},
Name: "bar",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 15, Byte: 14},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "baz",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 15, Byte: 14},
End: hcl.Pos{Line: 1, Column: 19, Byte: 18},
},
},
},
},
``,
},
{
`module.foo["baz"]`,
&Reference{
Subject: ModuleCallInstance{
Call: ModuleCall{
Name: "foo",
},
Key: StringKey("baz"),
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 18, Byte: 17},
},
},
``,
},
{
`module.foo["baz"].bar`,
&Reference{
addrs: Rename AbsModuleCallOutput to ModuleCallInstanceOutput The previous name didn't fit with the naming scheme for addrs types: The "Abs" prefix typically means that it's an addrs.ModuleInstance combined with whatever type name appears after "Abs", but this is instead a ModuleCallOutput combined with an InstanceKey, albeit structured the other way around for convenience, and so the expected name for this would be the suffix "Instance". We don't have an "Abs" type corresponding with this one because it would represent no additional information than AbsOutputValue.
2021-06-29 17:06:00 -05:00
Subject: ModuleCallInstanceOutput{
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
Call: ModuleCallInstance{
Call: ModuleCall{
Name: "foo",
},
Key: StringKey("baz"),
},
Name: "bar",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 22, Byte: 21},
},
},
``,
},
{
`module.foo["baz"].bar.boop`,
&Reference{
addrs: Rename AbsModuleCallOutput to ModuleCallInstanceOutput The previous name didn't fit with the naming scheme for addrs types: The "Abs" prefix typically means that it's an addrs.ModuleInstance combined with whatever type name appears after "Abs", but this is instead a ModuleCallOutput combined with an InstanceKey, albeit structured the other way around for convenience, and so the expected name for this would be the suffix "Instance". We don't have an "Abs" type corresponding with this one because it would represent no additional information than AbsOutputValue.
2021-06-29 17:06:00 -05:00
Subject: ModuleCallInstanceOutput{
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
Call: ModuleCallInstance{
Call: ModuleCall{
Name: "foo",
},
Key: StringKey("baz"),
},
Name: "bar",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 22, Byte: 21},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "boop",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 22, Byte: 21},
End: hcl.Pos{Line: 1, Column: 27, Byte: 26},
},
},
},
},
``,
},
{
`module`,
nil,
`The "module" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`module["foo"]`,
nil,
`The "module" object does not support this operation.`,
},
// path
{
`path.module`,
&Reference{
Subject: PathAttr{
Name: "module",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 12, Byte: 11},
},
},
``,
},
{
`path.module.blah`,
&Reference{
Subject: PathAttr{
Name: "module",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 12, Byte: 11},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 12, Byte: 11},
End: hcl.Pos{Line: 1, Column: 17, Byte: 16},
},
},
},
},
``, // valid at this layer, but will fail during eval because "module" is a string
},
{
`path`,
nil,
`The "path" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`path["module"]`,
nil,
`The "path" object does not support this operation.`,
},
// self
{
`self`,
&Reference{
Subject: Self,
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 5, Byte: 4},
},
},
``,
},
{
`self.blah`,
&Reference{
Subject: Self,
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 5, Byte: 4},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 5, Byte: 4},
End: hcl.Pos{Line: 1, Column: 10, Byte: 9},
},
},
},
},
``,
},
// terraform
{
`terraform.workspace`,
&Reference{
Subject: TerraformAttr{
Name: "workspace",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 20, Byte: 19},
},
},
``,
},
{
`terraform.workspace.blah`,
&Reference{
Subject: TerraformAttr{
Name: "workspace",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 20, Byte: 19},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 20, Byte: 19},
End: hcl.Pos{Line: 1, Column: 25, Byte: 24},
},
},
},
},
``, // valid at this layer, but will fail during eval because "workspace" is a string
},
{
`terraform`,
nil,
`The "terraform" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`terraform["workspace"]`,
nil,
`The "terraform" object does not support this operation.`,
},
// var
{
`var.foo`,
&Reference{
Subject: InputVariable{
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 8, Byte: 7},
},
},
``,
},
{
`var.foo.blah`,
&Reference{
Subject: InputVariable{
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 8, Byte: 7},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "blah",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 8, Byte: 7},
End: hcl.Pos{Line: 1, Column: 13, Byte: 12},
},
},
},
},
``, // valid at this layer, but will fail during eval because "module" is a string
},
{
`var`,
nil,
`The "var" object cannot be accessed directly. Instead, access one of its attributes.`,
},
{
`var["foo"]`,
nil,
`The "var" object does not support this operation.`,
},
lang: Allow "resource." prefix as another way to refer to resources The current way to refer to a managed resource is to use its resource type name as a top-level symbol in the reference. This is convenient and makes sense given that managed resources are the primary kind of object in Terraform. However, it does mean that an externally-extensible namespace (the set of all possible resource type names) overlaps with a reserved word namespace (the special prefixes like "path", "var", etc), and thus introducing any new reserved prefix in future risks masking an existing resource type so it can't be used anymore. We only intend to introduce new reserved symbols as part of future language editions that each module can opt into separately, and when doing so we will always research to try to choose a name that doesn't overlap with commonly-used providers, but not all providers are visible to us and so there is always a small chance that the name we choose will already be in use by a third-party provider. In preparation for that event, this introduces an alternative way to refer to managed resources that mimics the reference style used for data resources: resource.type.name . When using this form, the second portion is _always_ a resource type name and never a reserved word. There is currently no need to use this because all of the already-reserved symbol names are effectively blocked from use by existing Terraform versions that lack this escape hatch. Therefore there's no explicit documentation about it yet. The intended use for this is that a module upgrade tool for a future language edition would detect references to resource types that have now become reserved words and add the "resource." prefix to keep that functionality working. Existing modules that aren't opted in to the new language edition would keep working without that prefix, thus keeping to compatibility promises.
2021-05-14 18:42:30 -05:00
// the "resource" prefix forces interpreting the next name as a
// resource type name. This is an alias for just using a resource
// type name at the top level, to be used only if a later edition
// of the Terraform language introduces a new reserved word that
// overlaps with a resource type name.
{
`resource.boop_instance.foo`,
&Reference{
Subject: Resource{
Mode: ManagedResourceMode,
Type: "boop_instance",
Name: "foo",
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 27, Byte: 26},
},
},
``,
},
addrs: Reserve "template" and similar prefixes for future expansion At the time of this commit we have a proposal #28700 which would, if accepted, need to reserve a new reference prefix to represent template arguments. It seems unlikely that the proposal would be accepted and implemented before Terraform v1.0 creates additional compatibility constraints, and so this pre-emptively reserves a few candidate symbol names to allow something like that proposal to potentially move forward later without requiring a new opt-in language edition. If we do move forward with the proposal then we'll select one of these three reserved names depending on which form of the proposal we decide to move forward with, and then un-reserve the other two. If we decide to not pursue this proposal at all then we'll un-reserve all three once that decision is finalized. It's unlikely that there is any existing provider which has a resource type named either "template", "lazy", or "arg", but in that unlikely event users of that provider can keep using it by adding the "resource." escaping prefix, such as changing "lazy.foo.bar" into "resource.lazy.foo.bar".
2021-05-14 18:58:02 -05:00
// We have some names reserved which might be used by a
// still-under-discussion proposal for template values or lazy
// expressions.
{
`template.foo`,
nil,
`The symbol name "template" is reserved for use in a future Terraform version. If you are using a provider that already uses this as a resource type name, add the prefix "resource." to force interpretation as a resource type name.`,
},
{
`lazy.foo`,
nil,
`The symbol name "lazy" is reserved for use in a future Terraform version. If you are using a provider that already uses this as a resource type name, add the prefix "resource." to force interpretation as a resource type name.`,
},
{
`arg.foo`,
nil,
`The symbol name "arg" is reserved for use in a future Terraform version. If you are using a provider that already uses this as a resource type name, add the prefix "resource." to force interpretation as a resource type name.`,
},
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
// anything else, interpreted as a managed resource reference
{
`boop_instance.foo`,
&Reference{
parse resource refs correctly Now that we only evaluate whole resources, we can parse resource refs correct as the resource, rather than an unknown instance.
2019-09-19 08:53:23 -05:00
Subject: Resource{
Mode: ManagedResourceMode,
Type: "boop_instance",
Name: "foo",
addrs: ParseRef function, for parsing references in expressions This function corresponds to terraform.NewInterpolatedVariable, but built with HCL2 primitives. It accepts a hcl.Traversal, which is what is returned from the HCL2 API functions to find which variables are referenced in a given expression.
2018-03-30 22:18:59 -05:00
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 18, Byte: 17},
},
},
``,
},
{
`boop_instance.foo.bar`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: ManagedResourceMode,
Type: "boop_instance",
Name: "foo",
},
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 18, Byte: 17},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "bar",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 18, Byte: 17},
End: hcl.Pos{Line: 1, Column: 22, Byte: 21},
},
},
},
},
``,
},
{
`boop_instance.foo["baz"].bar`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: ManagedResourceMode,
Type: "boop_instance",
Name: "foo",
},
Key: StringKey("baz"),
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 25, Byte: 24},
},
Remaining: hcl.Traversal{
hcl.TraverseAttr{
Name: "bar",
SrcRange: hcl.Range{
Start: hcl.Pos{Line: 1, Column: 25, Byte: 24},
End: hcl.Pos{Line: 1, Column: 29, Byte: 28},
},
},
},
},
``,
},
{
`boop_instance.foo["baz"]`,
&Reference{
Subject: ResourceInstance{
Resource: Resource{
Mode: ManagedResourceMode,
Type: "boop_instance",
Name: "foo",
},
Key: StringKey("baz"),
},
SourceRange: tfdiags.SourceRange{
Start: tfdiags.SourcePos{Line: 1, Column: 1, Byte: 0},
End: tfdiags.SourcePos{Line: 1, Column: 25, Byte: 24},
},
},
``,
},
{
`boop_instance`,
nil,
`A reference to a resource type must be followed by at least one attribute access, specifying the resource name.`,
},
}
for _, test := range tests {
t.Run(test.Input, func(t *testing.T) {
traversal, travDiags := hclsyntax.ParseTraversalAbs([]byte(test.Input), "", hcl.Pos{Line: 1, Column: 1})
if travDiags.HasErrors() {
t.Fatal(travDiags.Error())
}
got, diags := ParseRef(traversal)
switch len(diags) {
case 0:
if test.WantErr != "" {
t.Fatalf("succeeded; want error: %s", test.WantErr)
}
case 1:
if test.WantErr == "" {
t.Fatalf("unexpected diagnostics: %s", diags.Err())
}
if got, want := diags[0].Description().Detail, test.WantErr; got != want {
t.Fatalf("wrong error\ngot: %s\nwant: %s", got, want)
}
default:
t.Fatalf("too many diagnostics: %s", diags.Err())
}
if diags.HasErrors() {
return
}
for _, problem := range deep.Equal(got, test.Want) {
t.Errorf(problem)
}
})
}
}
Reference in New Issue Copy Permalink