IntenseWebs/opentofu
3
0
Fork 0
mirror of https://github.com/opentofu/opentofu.git synced 2024-12-28 18:01:01 -06:00
Code Issues Packages Projects Releases Wiki Activity
84d4e78481
opentofu/terraform/transform_destroy_edge_test.go

247 lines
6.5 KiB
Go
Raw Normal View History

terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
package terraform
import (
"strings"
"testing"
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
"github.com/hashicorp/terraform/addrs"
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
)
terraform: references can have backups terraform: more specific resource references terraform: outputs need to know about the new reference format terraform: resources w/o a config still have a referencable name
2016-11-08 11:35:57 -06:00
func TestDestroyEdgeTransformer_basic(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.A"})
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.B"})
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-basic"),
Schemas: simpleTestSchemas(),
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(testTransformDestroyEdgeBasicStr)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
}
}
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
func TestDestroyEdgeTransformer_create(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.A"})
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.B"})
g.Add(&graphNodeCreatorTest{AddrString: "test_object.A"})
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-basic"),
Schemas: simpleTestSchemas(),
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(testTransformDestroyEdgeCreatorStr)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
}
}
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
func TestDestroyEdgeTransformer_multi(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.A"})
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.B"})
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.C"})
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-multi"),
Schemas: simpleTestSchemas(),
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(testTransformDestroyEdgeMultiStr)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
}
}
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
func TestDestroyEdgeTransformer_selfRef(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.A"})
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-self-ref"),
Schemas: simpleTestSchemas(),
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(testTransformDestroyEdgeSelfRefStr)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
}
}
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
func TestDestroyEdgeTransformer_module(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "module.child.test_object.b"})
g.Add(&graphNodeDestroyerTest{AddrString: "test_object.a"})
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-module"),
Schemas: simpleTestSchemas(),
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(testTransformDestroyEdgeModuleStr)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
}
}
terraform: passing test for destroy edge for module only Just adding passing tests as a sanity check for a bug.
2017-02-07 21:12:03 -06:00
func TestDestroyEdgeTransformer_moduleOnly(t *testing.T) {
core: Get tests compiling again After the refactoring to integrate HCL2 many of the tests were no longer using correct types, attribute names, etc. This is a bulk update of all of the tests to make them compile again, with minimal changes otherwise. Although the tests now compile, many of them do not yet pass. The tests will be gradually repaired in subsequent commits, as we continue to complete the refactoring and retrofit work.
2018-05-04 21:24:06 -05:00
g := Graph{Path: addrs.RootModuleInstance}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
g.Add(&graphNodeDestroyerTest{AddrString: "module.child.test_object.a"})
g.Add(&graphNodeDestroyerTest{AddrString: "module.child.test_object.b"})
g.Add(&graphNodeDestroyerTest{AddrString: "module.child.test_object.c"})
terraform: passing test for destroy edge for module only Just adding passing tests as a sanity check for a bug.
2017-02-07 21:12:03 -06:00
tf := &DestroyEdgeTransformer{
core: Fetch schemas during context construction Previously we fetched schemas during the AttachSchemaTransformer, potentially multiple times as that was re-run for each graph built. Now we fetch the schemas just once during context construction, passing that result into each of the graph builders. This only addresses the schema accesses during graph construction. We're still separately loading schemas during the main walk for evaluation purposes. This will be addressed in a later commit.
2018-05-31 14:39:45 -05:00
Config: testModule(t, "transform-destroy-edge-module-only"),
Schemas: simpleTestSchemas(),
terraform: passing test for destroy edge for module only Just adding passing tests as a sanity check for a bug.
2017-02-07 21:12:03 -06:00
}
if err := tf.Transform(&g); err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(g.String())
expected := strings.TrimSpace(`
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
module.child.test_object.a (destroy)
module.child.test_object.b (destroy)
module.child.test_object.c (destroy)
module.child.test_object.b (destroy)
module.child.test_object.c (destroy)
module.child.test_object.c (destroy)
terraform: passing test for destroy edge for module only Just adding passing tests as a sanity check for a bug.
2017-02-07 21:12:03 -06:00
`)
if actual != expected {
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
t.Fatalf("wrong result\n\ngot:\n%s\n\nwant:\n%s", actual, expected)
terraform: passing test for destroy edge for module only Just adding passing tests as a sanity check for a bug.
2017-02-07 21:12:03 -06:00
}
}
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
type graphNodeCreatorTest struct {
AddrString string
terraform: apply resource must depend on destroy deps Fixes #10440 This updates the behavior of "apply" resources to depend on the destroy versions of their dependencies. We make an exception to this behavior when the "apply" resource is CBD. This is odd and not 100% correct, but it mimics the behavior of the legacy graphs and avoids us having to do major core work to support the 100% correct solution. I'll explain this in examples... Given the following configuration: resource "null_resource" "a" { count = "${var.count}" } resource "null_resource" "b" { triggers { key = "${join(",", null_resource.a.*.id)}" } } Assume we've successfully created this configuration with count = 2. When going from count = 2 to count = 1, `null_resource.b` should wait for `null_resource.a.1` to destroy. If it doesn't, then it is a race: depending when we interpolate the `triggers.key` attribute of `null_resource.b`, we may get 1 value or 2. If `null_resource.a.1` is destroyed, we'll get 1. Otherwise, we'll get 2. This was the root cause of #10440 In the legacy graphs, `null_resource.b` would depend on the destruction of any `null_resource.a` (orphans, tainted, anything!). This would ensure proper ordering. We mimic that behavior here. The difference is CBD. If `null_resource.b` has CBD enabled, then the ordering **in the legacy graph** becomes: 1. null_resource.b (create) 2. null_resource.b (destroy) 3. null_resource.a (destroy) In this case, the update would always have 2 values for `triggers.key`, even though we were destroying a resource later! This scenario required two `terraform apply` operations. This is what the CBD check is for in this PR. We do this to mimic the behavior of the legacy graph. The correct solution to do one day is to allow splat references (`null_resource.a.*.id`) to happen in parallel and only read up to to the `count` amount in the state. This requires some fairly significant work close to the 0.8 release date, so we can defer this to later and adopt the 0.7.x behavior for now.
2016-12-04 01:44:09 -06:00
Refs []string
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
var (
_ GraphNodeCreator = (*graphNodeCreatorTest)(nil)
_ GraphNodeReferencer = (*graphNodeCreatorTest)(nil)
)
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
func (n *graphNodeCreatorTest) Name() string {
return n.CreateAddr().String()
}
func (n *graphNodeCreatorTest) mustAddr() addrs.AbsResourceInstance {
addr, diags := addrs.ParseAbsResourceInstanceStr(n.AddrString)
if diags.HasErrors() {
panic(diags.Err())
}
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
return addr
}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
func (n *graphNodeCreatorTest) Path() addrs.ModuleInstance {
return n.mustAddr().Module
}
func (n *graphNodeCreatorTest) CreateAddr() *addrs.AbsResourceInstance {
addr := n.mustAddr()
return &addr
}
func (n *graphNodeCreatorTest) References() []*addrs.Reference {
ret := make([]*addrs.Reference, len(n.Refs))
for i, str := range n.Refs {
ref, diags := addrs.ParseRefStr(str)
if diags.HasErrors() {
panic(diags.Err())
}
ret[i] = ref
}
return ret
}
terraform: apply resource must depend on destroy deps Fixes #10440 This updates the behavior of "apply" resources to depend on the destroy versions of their dependencies. We make an exception to this behavior when the "apply" resource is CBD. This is odd and not 100% correct, but it mimics the behavior of the legacy graphs and avoids us having to do major core work to support the 100% correct solution. I'll explain this in examples... Given the following configuration: resource "null_resource" "a" { count = "${var.count}" } resource "null_resource" "b" { triggers { key = "${join(",", null_resource.a.*.id)}" } } Assume we've successfully created this configuration with count = 2. When going from count = 2 to count = 1, `null_resource.b` should wait for `null_resource.a.1` to destroy. If it doesn't, then it is a race: depending when we interpolate the `triggers.key` attribute of `null_resource.b`, we may get 1 value or 2. If `null_resource.a.1` is destroyed, we'll get 1. Otherwise, we'll get 2. This was the root cause of #10440 In the legacy graphs, `null_resource.b` would depend on the destruction of any `null_resource.a` (orphans, tainted, anything!). This would ensure proper ordering. We mimic that behavior here. The difference is CBD. If `null_resource.b` has CBD enabled, then the ordering **in the legacy graph** becomes: 1. null_resource.b (create) 2. null_resource.b (destroy) 3. null_resource.a (destroy) In this case, the update would always have 2 values for `triggers.key`, even though we were destroying a resource later! This scenario required two `terraform apply` operations. This is what the CBD check is for in this PR. We do this to mimic the behavior of the legacy graph. The correct solution to do one day is to allow splat references (`null_resource.a.*.id`) to happen in parallel and only read up to to the `count` amount in the state. This requires some fairly significant work close to the 0.8 release date, so we can defer this to later and adopt the 0.7.x behavior for now.
2016-12-04 01:44:09 -06:00
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
type graphNodeDestroyerTest struct {
AddrString string
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
CBD bool
terraform: when promoting non-CBD to CBD, mark the config as such This brings the change for the new graph. See #10455
2016-12-02 08:46:42 -06:00
Modified bool
}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
var _ GraphNodeDestroyer = (*graphNodeDestroyerTest)(nil)
terraform: when promoting non-CBD to CBD, mark the config as such This brings the change for the new graph. See #10455
2016-12-02 08:46:42 -06:00
func (n *graphNodeDestroyerTest) Name() string {
result := n.DestroyAddr().String() + " (destroy)"
if n.Modified {
result += " (modified)"
}
return result
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
func (n *graphNodeDestroyerTest) mustAddr() addrs.AbsResourceInstance {
addr, diags := addrs.ParseAbsResourceInstanceStr(n.AddrString)
if diags.HasErrors() {
panic(diags.Err())
}
return addr
}
func (n *graphNodeDestroyerTest) CreateBeforeDestroy() bool {
return n.CBD
}
terraform: when promoting non-CBD to CBD, mark the config as such This brings the change for the new graph. See #10455
2016-12-02 08:46:42 -06:00
func (n *graphNodeDestroyerTest) ModifyCreateBeforeDestroy(v bool) error {
n.Modified = true
return nil
}
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
func (n *graphNodeDestroyerTest) DestroyAddr() *addrs.AbsResourceInstance {
addr := n.mustAddr()
return &addr
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
}
const testTransformDestroyEdgeBasicStr = `
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
test_object.A (destroy)
test_object.B (destroy)
test_object.B (destroy)
terraform: test the destroy edge transform
2016-09-20 12:16:49 -05:00
`
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
const testTransformDestroyEdgeCreatorStr = `
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
test_object.A
test_object.A (destroy)
test_object.A (destroy)
test_object.B (destroy)
test_object.B (destroy)
terraform: starting CBD, destroy edge for the destroy relationship
2016-09-21 12:55:07 -05:00
`
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
const testTransformDestroyEdgeMultiStr = `
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
test_object.A (destroy)
test_object.B (destroy)
test_object.C (destroy)
test_object.B (destroy)
test_object.C (destroy)
test_object.C (destroy)
terraform: more destroy edge tests
2016-09-20 12:18:31 -05:00
`
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
const testTransformDestroyEdgeSelfRefStr = `
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
test_object.A (destroy)
terraform: destroy edges should never point to self Fixes #9920 This was an issue caught with the shadow graph. Self references in provisioners were causing a self-edge on destroy apply graphs. We need to explicitly check that we're not creating an edge to ourself. This is also how the reference transformer works.
2016-11-08 14:27:33 -06:00
`
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
const testTransformDestroyEdgeModuleStr = `
core: Pass components through to the destroy transformers These transformers both construct temporary graphs using many of the same transformers used in the apply graph, and properly doing this now requires access to the providers and provisioners in order to obtain their schemas. Along with this, we also update the tests here to use the simpleMockComponentFactory helper to get a mock provider with a schema already configured, which means we also need to update the test fixtures and assertions to use the resource type and attributes defined in that mock factory.
2018-05-09 19:05:18 -05:00
module.child.test_object.b (destroy)
test_object.a (destroy)
test_object.a (destroy)
terraform: destroy edge must include resources through outputs This fixes: `TestContext2Apply_moduleDestroyOrder` The new destroy graph wasn't properly creating edges that happened _through_ an output, it was only created the edges for _direct_ dependents. To fix this, the DestroyEdgeTransformer now creates the full transitive list of destroy edges by walking all ancestors. This will create more edges than are necessary but also will no longer miss resources through an output.
2016-11-11 16:29:19 -06:00
`
Reference in New Issue Copy Permalink