github.com/pulumi/terraform@v1.4.0/pkg/terraform/transform_targets_test.go (about) 1 package terraform 2 3 import ( 4 "strings" 5 "testing" 6 7 "github.com/pulumi/terraform/pkg/addrs" 8 ) 9 10 func TestTargetsTransformer(t *testing.T) { 11 mod := testModule(t, "transform-targets-basic") 12 13 g := Graph{Path: addrs.RootModuleInstance} 14 { 15 tf := &ConfigTransformer{Config: mod} 16 if err := tf.Transform(&g); err != nil { 17 t.Fatalf("err: %s", err) 18 } 19 } 20 21 { 22 transform := &AttachResourceConfigTransformer{Config: mod} 23 if err := transform.Transform(&g); err != nil { 24 t.Fatalf("err: %s", err) 25 } 26 } 27 28 { 29 transform := &ReferenceTransformer{} 30 if err := transform.Transform(&g); err != nil { 31 t.Fatalf("err: %s", err) 32 } 33 } 34 35 { 36 transform := &TargetsTransformer{ 37 Targets: []addrs.Targetable{ 38 addrs.RootModuleInstance.Resource( 39 addrs.ManagedResourceMode, "aws_instance", "me", 40 ), 41 }, 42 } 43 if err := transform.Transform(&g); err != nil { 44 t.Fatalf("err: %s", err) 45 } 46 } 47 48 actual := strings.TrimSpace(g.String()) 49 expected := strings.TrimSpace(` 50 aws_instance.me 51 aws_subnet.me 52 aws_subnet.me 53 aws_vpc.me 54 aws_vpc.me 55 `) 56 if actual != expected { 57 t.Fatalf("bad:\n\nexpected:\n%s\n\ngot:\n%s\n", expected, actual) 58 } 59 } 60 61 func TestTargetsTransformer_downstream(t *testing.T) { 62 mod := testModule(t, "transform-targets-downstream") 63 64 g := Graph{Path: addrs.RootModuleInstance} 65 { 66 transform := &ConfigTransformer{Config: mod} 67 if err := transform.Transform(&g); err != nil { 68 t.Fatalf("%T failed: %s", transform, err) 69 } 70 } 71 72 { 73 transform := &AttachResourceConfigTransformer{Config: mod} 74 if err := transform.Transform(&g); err != nil { 75 t.Fatalf("%T failed: %s", transform, err) 76 } 77 } 78 79 { 80 transform := &AttachResourceConfigTransformer{Config: mod} 81 if err := transform.Transform(&g); err != nil { 82 t.Fatalf("%T failed: %s", transform, err) 83 } 84 } 85 86 { 87 transform := &OutputTransformer{Config: mod} 88 if err := transform.Transform(&g); err != nil { 89 t.Fatalf("%T failed: %s", transform, err) 90 } 91 } 92 93 { 94 transform := &ReferenceTransformer{} 95 if err := transform.Transform(&g); err != nil { 96 t.Fatalf("err: %s", err) 97 } 98 } 99 100 { 101 transform := &TargetsTransformer{ 102 Targets: []addrs.Targetable{ 103 addrs.RootModuleInstance. 104 Child("child", addrs.NoKey). 105 Child("grandchild", addrs.NoKey). 106 Resource( 107 addrs.ManagedResourceMode, "aws_instance", "foo", 108 ), 109 }, 110 } 111 if err := transform.Transform(&g); err != nil { 112 t.Fatalf("%T failed: %s", transform, err) 113 } 114 } 115 116 actual := strings.TrimSpace(g.String()) 117 // Even though we only asked to target the grandchild resource, all of the 118 // outputs that descend from it are also targeted. 119 expected := strings.TrimSpace(` 120 module.child.module.grandchild.aws_instance.foo 121 module.child.module.grandchild.output.id (expand) 122 module.child.module.grandchild.aws_instance.foo 123 module.child.output.grandchild_id (expand) 124 module.child.module.grandchild.output.id (expand) 125 output.grandchild_id (expand) 126 module.child.output.grandchild_id (expand) 127 `) 128 if actual != expected { 129 t.Fatalf("bad:\n\nexpected:\n%s\n\ngot:\n%s\n", expected, actual) 130 } 131 } 132 133 // This tests the TargetsTransformer targeting a whole module, 134 // rather than a resource within a module instance. 135 func TestTargetsTransformer_wholeModule(t *testing.T) { 136 mod := testModule(t, "transform-targets-downstream") 137 138 g := Graph{Path: addrs.RootModuleInstance} 139 { 140 transform := &ConfigTransformer{Config: mod} 141 if err := transform.Transform(&g); err != nil { 142 t.Fatalf("%T failed: %s", transform, err) 143 } 144 } 145 146 { 147 transform := &AttachResourceConfigTransformer{Config: mod} 148 if err := transform.Transform(&g); err != nil { 149 t.Fatalf("%T failed: %s", transform, err) 150 } 151 } 152 153 { 154 transform := &AttachResourceConfigTransformer{Config: mod} 155 if err := transform.Transform(&g); err != nil { 156 t.Fatalf("%T failed: %s", transform, err) 157 } 158 } 159 160 { 161 transform := &OutputTransformer{Config: mod} 162 if err := transform.Transform(&g); err != nil { 163 t.Fatalf("%T failed: %s", transform, err) 164 } 165 } 166 167 { 168 transform := &ReferenceTransformer{} 169 if err := transform.Transform(&g); err != nil { 170 t.Fatalf("err: %s", err) 171 } 172 } 173 174 { 175 transform := &TargetsTransformer{ 176 Targets: []addrs.Targetable{ 177 addrs.RootModule. 178 Child("child"). 179 Child("grandchild"), 180 }, 181 } 182 if err := transform.Transform(&g); err != nil { 183 t.Fatalf("%T failed: %s", transform, err) 184 } 185 } 186 187 actual := strings.TrimSpace(g.String()) 188 // Even though we only asked to target the grandchild module, all of the 189 // outputs that descend from it are also targeted. 190 expected := strings.TrimSpace(` 191 module.child.module.grandchild.aws_instance.foo 192 module.child.module.grandchild.output.id (expand) 193 module.child.module.grandchild.aws_instance.foo 194 module.child.output.grandchild_id (expand) 195 module.child.module.grandchild.output.id (expand) 196 output.grandchild_id (expand) 197 module.child.output.grandchild_id (expand) 198 `) 199 if actual != expected { 200 t.Fatalf("bad:\n\nexpected:\n%s\n\ngot:\n%s\n", expected, actual) 201 } 202 }