github.com/daveadams/terraform@v0.6.4-0.20160830094355-13ce74975936/builtin/providers/aws/resource_aws_vpc_peering_connection_test.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "log" 6 "os" 7 "reflect" 8 "testing" 9 10 "github.com/aws/aws-sdk-go/aws" 11 "github.com/aws/aws-sdk-go/service/ec2" 12 "github.com/hashicorp/terraform/helper/resource" 13 "github.com/hashicorp/terraform/terraform" 14 ) 15 16 func TestAccAWSVPCPeeringConnection_basic(t *testing.T) { 17 var connection ec2.VpcPeeringConnection 18 19 resource.Test(t, resource.TestCase{ 20 PreCheck: func() { 21 testAccPreCheck(t) 22 if os.Getenv("AWS_ACCOUNT_ID") == "" { 23 t.Fatal("AWS_ACCOUNT_ID must be set.") 24 } 25 }, 26 27 IDRefreshName: "aws_vpc_peering_connection.foo", 28 IDRefreshIgnore: []string{"auto_accept"}, 29 30 Providers: testAccProviders, 31 CheckDestroy: testAccCheckAWSVpcPeeringConnectionDestroy, 32 Steps: []resource.TestStep{ 33 resource.TestStep{ 34 Config: testAccVpcPeeringConfig, 35 Check: resource.ComposeTestCheckFunc( 36 testAccCheckAWSVpcPeeringConnectionExists( 37 "aws_vpc_peering_connection.foo", 38 &connection), 39 ), 40 }, 41 }, 42 }) 43 } 44 45 func TestAccAWSVPCPeeringConnection_plan(t *testing.T) { 46 var connection ec2.VpcPeeringConnection 47 48 // reach out and DELETE the VPC Peering connection outside of Terraform 49 testDestroy := func(*terraform.State) error { 50 conn := testAccProvider.Meta().(*AWSClient).ec2conn 51 log.Printf("[DEBUG] Test deleting the VPC Peering Connection.") 52 _, err := conn.DeleteVpcPeeringConnection( 53 &ec2.DeleteVpcPeeringConnectionInput{ 54 VpcPeeringConnectionId: connection.VpcPeeringConnectionId, 55 }) 56 if err != nil { 57 return err 58 } 59 return nil 60 } 61 62 resource.Test(t, resource.TestCase{ 63 PreCheck: func() { 64 testAccPreCheck(t) 65 if os.Getenv("AWS_ACCOUNT_ID") == "" { 66 t.Fatal("AWS_ACCOUNT_ID must be set.") 67 } 68 }, 69 70 IDRefreshIgnore: []string{"auto_accept"}, 71 72 Providers: testAccProviders, 73 CheckDestroy: testAccCheckAWSVpcPeeringConnectionDestroy, 74 Steps: []resource.TestStep{ 75 resource.TestStep{ 76 Config: testAccVpcPeeringConfig, 77 Check: resource.ComposeTestCheckFunc( 78 testAccCheckAWSVpcPeeringConnectionExists( 79 "aws_vpc_peering_connection.foo", 80 &connection), 81 testDestroy, 82 ), 83 ExpectNonEmptyPlan: true, 84 }, 85 }, 86 }) 87 } 88 89 func TestAccAWSVPCPeeringConnection_tags(t *testing.T) { 90 var connection ec2.VpcPeeringConnection 91 92 resource.Test(t, resource.TestCase{ 93 PreCheck: func() { 94 testAccPreCheck(t) 95 if os.Getenv("AWS_ACCOUNT_ID") == "" { 96 t.Fatal("AWS_ACCOUNT_ID must be set.") 97 } 98 }, 99 100 IDRefreshName: "aws_vpc_peering_connection.foo", 101 IDRefreshIgnore: []string{"auto_accept"}, 102 103 Providers: testAccProviders, 104 CheckDestroy: testAccCheckVpcDestroy, 105 Steps: []resource.TestStep{ 106 resource.TestStep{ 107 Config: testAccVpcPeeringConfigTags, 108 Check: resource.ComposeTestCheckFunc( 109 testAccCheckAWSVpcPeeringConnectionExists( 110 "aws_vpc_peering_connection.foo", 111 &connection), 112 testAccCheckTags(&connection.Tags, "foo", "bar"), 113 ), 114 }, 115 }, 116 }) 117 } 118 119 func TestAccAWSVPCPeeringConnection_options(t *testing.T) { 120 var connection ec2.VpcPeeringConnection 121 122 testAccepterChange := func(*terraform.State) error { 123 conn := testAccProvider.Meta().(*AWSClient).ec2conn 124 log.Printf("[DEBUG] Test change to the VPC Peering Connection Options.") 125 126 _, err := conn.ModifyVpcPeeringConnectionOptions( 127 &ec2.ModifyVpcPeeringConnectionOptionsInput{ 128 VpcPeeringConnectionId: connection.VpcPeeringConnectionId, 129 AccepterPeeringConnectionOptions: &ec2.PeeringConnectionOptionsRequest{ 130 AllowDnsResolutionFromRemoteVpc: aws.Bool(false), 131 }, 132 }) 133 if err != nil { 134 return err 135 } 136 return nil 137 } 138 139 resource.Test(t, resource.TestCase{ 140 PreCheck: func() { 141 testAccPreCheck(t) 142 if os.Getenv("AWS_ACCOUNT_ID") == "" { 143 t.Fatal("AWS_ACCOUNT_ID must be set") 144 } 145 }, 146 147 IDRefreshName: "aws_vpc_peering_connection.foo", 148 IDRefreshIgnore: []string{"auto_accept"}, 149 150 Providers: testAccProviders, 151 CheckDestroy: testAccCheckAWSVpcPeeringConnectionDestroy, 152 Steps: []resource.TestStep{ 153 resource.TestStep{ 154 Config: testAccVpcPeeringConfigOptions, 155 Check: resource.ComposeTestCheckFunc( 156 testAccCheckAWSVpcPeeringConnectionExists( 157 "aws_vpc_peering_connection.foo", 158 &connection), 159 resource.TestCheckResourceAttr( 160 "aws_vpc_peering_connection.foo", 161 "accepter.#", "1"), 162 resource.TestCheckResourceAttr( 163 "aws_vpc_peering_connection.foo", 164 "accepter.1102046665.allow_remote_vpc_dns_resolution", "true"), 165 testAccCheckAWSVpcPeeringConnectionOptions( 166 "aws_vpc_peering_connection.foo", "accepter", 167 &ec2.VpcPeeringConnectionOptionsDescription{ 168 AllowDnsResolutionFromRemoteVpc: aws.Bool(true), 169 AllowEgressFromLocalClassicLinkToRemoteVpc: aws.Bool(false), 170 AllowEgressFromLocalVpcToRemoteClassicLink: aws.Bool(false), 171 }), 172 resource.TestCheckResourceAttr( 173 "aws_vpc_peering_connection.foo", 174 "requester.#", "1"), 175 resource.TestCheckResourceAttr( 176 "aws_vpc_peering_connection.foo", 177 "requester.41753983.allow_classic_link_to_remote_vpc", "true"), 178 resource.TestCheckResourceAttr( 179 "aws_vpc_peering_connection.foo", 180 "requester.41753983.allow_vpc_to_remote_classic_link", "true"), 181 testAccCheckAWSVpcPeeringConnectionOptions( 182 "aws_vpc_peering_connection.foo", "requester", 183 &ec2.VpcPeeringConnectionOptionsDescription{ 184 AllowDnsResolutionFromRemoteVpc: aws.Bool(false), 185 AllowEgressFromLocalClassicLinkToRemoteVpc: aws.Bool(true), 186 AllowEgressFromLocalVpcToRemoteClassicLink: aws.Bool(true), 187 }, 188 ), 189 testAccepterChange, 190 ), 191 ExpectNonEmptyPlan: true, 192 }, 193 resource.TestStep{ 194 Config: testAccVpcPeeringConfigOptions, 195 Check: resource.ComposeTestCheckFunc( 196 testAccCheckAWSVpcPeeringConnectionExists( 197 "aws_vpc_peering_connection.foo", 198 &connection), 199 resource.TestCheckResourceAttr( 200 "aws_vpc_peering_connection.foo", 201 "accepter.#", "1"), 202 resource.TestCheckResourceAttr( 203 "aws_vpc_peering_connection.foo", 204 "accepter.1102046665.allow_remote_vpc_dns_resolution", "true"), 205 testAccCheckAWSVpcPeeringConnectionOptions( 206 "aws_vpc_peering_connection.foo", "accepter", 207 &ec2.VpcPeeringConnectionOptionsDescription{ 208 AllowDnsResolutionFromRemoteVpc: aws.Bool(true), 209 AllowEgressFromLocalClassicLinkToRemoteVpc: aws.Bool(false), 210 AllowEgressFromLocalVpcToRemoteClassicLink: aws.Bool(false), 211 }, 212 ), 213 ), 214 }, 215 }, 216 }) 217 } 218 219 func testAccCheckAWSVpcPeeringConnectionDestroy(s *terraform.State) error { 220 conn := testAccProvider.Meta().(*AWSClient).ec2conn 221 222 for _, rs := range s.RootModule().Resources { 223 if rs.Type != "aws_vpc_peering_connection" { 224 continue 225 } 226 227 describe, err := conn.DescribeVpcPeeringConnections( 228 &ec2.DescribeVpcPeeringConnectionsInput{ 229 VpcPeeringConnectionIds: []*string{aws.String(rs.Primary.ID)}, 230 }) 231 232 if err != nil { 233 return err 234 } 235 236 var pc *ec2.VpcPeeringConnection 237 for _, c := range describe.VpcPeeringConnections { 238 if rs.Primary.ID == *c.VpcPeeringConnectionId { 239 pc = c 240 } 241 } 242 243 if pc == nil { 244 // not found 245 return nil 246 } 247 248 if pc.Status != nil { 249 if *pc.Status.Code == "deleted" { 250 return nil 251 } 252 return fmt.Errorf("Found the VPC Peering Connection in an unexpected state: %s", pc) 253 } 254 255 // return error here; we've found the vpc_peering object we want, however 256 // it's not in an expected state 257 return fmt.Errorf("Fall through error for testAccCheckAWSVpcPeeringConnectionDestroy.") 258 } 259 260 return nil 261 } 262 263 func testAccCheckAWSVpcPeeringConnectionExists(n string, connection *ec2.VpcPeeringConnection) resource.TestCheckFunc { 264 return func(s *terraform.State) error { 265 rs, ok := s.RootModule().Resources[n] 266 if !ok { 267 return fmt.Errorf("Not found: %s", n) 268 } 269 270 if rs.Primary.ID == "" { 271 return fmt.Errorf("No VPC Peering Connection ID is set.") 272 } 273 274 conn := testAccProvider.Meta().(*AWSClient).ec2conn 275 resp, err := conn.DescribeVpcPeeringConnections( 276 &ec2.DescribeVpcPeeringConnectionsInput{ 277 VpcPeeringConnectionIds: []*string{aws.String(rs.Primary.ID)}, 278 }) 279 if err != nil { 280 return err 281 } 282 if len(resp.VpcPeeringConnections) == 0 { 283 return fmt.Errorf("VPC Peering Connection could not be found.") 284 } 285 286 *connection = *resp.VpcPeeringConnections[0] 287 288 return nil 289 } 290 } 291 292 func testAccCheckAWSVpcPeeringConnectionOptions(n, block string, options *ec2.VpcPeeringConnectionOptionsDescription) resource.TestCheckFunc { 293 return func(s *terraform.State) error { 294 rs, ok := s.RootModule().Resources[n] 295 if !ok { 296 return fmt.Errorf("Not found: %s", n) 297 } 298 299 if rs.Primary.ID == "" { 300 return fmt.Errorf("No VPC Peering Connection ID is set.") 301 } 302 303 conn := testAccProvider.Meta().(*AWSClient).ec2conn 304 resp, err := conn.DescribeVpcPeeringConnections( 305 &ec2.DescribeVpcPeeringConnectionsInput{ 306 VpcPeeringConnectionIds: []*string{aws.String(rs.Primary.ID)}, 307 }) 308 if err != nil { 309 return err 310 } 311 312 pc := resp.VpcPeeringConnections[0] 313 314 o := pc.AccepterVpcInfo 315 if block == "requester" { 316 o = pc.RequesterVpcInfo 317 } 318 319 if !reflect.DeepEqual(o.PeeringOptions, options) { 320 return fmt.Errorf("Expected the VPC Peering Connection Options to be %#v, got %#v", 321 options, o.PeeringOptions) 322 } 323 324 return nil 325 } 326 } 327 328 const testAccVpcPeeringConfig = ` 329 resource "aws_vpc" "foo" { 330 cidr_block = "10.0.0.0/16" 331 tags { 332 Name = "TestAccAWSVPCPeeringConnection_basic" 333 } 334 } 335 336 resource "aws_vpc" "bar" { 337 cidr_block = "10.1.0.0/16" 338 } 339 340 resource "aws_vpc_peering_connection" "foo" { 341 vpc_id = "${aws_vpc.foo.id}" 342 peer_vpc_id = "${aws_vpc.bar.id}" 343 auto_accept = true 344 } 345 ` 346 347 const testAccVpcPeeringConfigTags = ` 348 resource "aws_vpc" "foo" { 349 cidr_block = "10.0.0.0/16" 350 tags { 351 Name = "TestAccAWSVPCPeeringConnection_tags" 352 } 353 } 354 355 resource "aws_vpc" "bar" { 356 cidr_block = "10.1.0.0/16" 357 } 358 359 resource "aws_vpc_peering_connection" "foo" { 360 vpc_id = "${aws_vpc.foo.id}" 361 peer_vpc_id = "${aws_vpc.bar.id}" 362 auto_accept = true 363 tags { 364 foo = "bar" 365 } 366 } 367 ` 368 369 const testAccVpcPeeringConfigOptions = ` 370 resource "aws_vpc" "foo" { 371 cidr_block = "10.0.0.0/16" 372 tags { 373 Name = "TestAccAWSVPCPeeringConnection_options" 374 } 375 } 376 377 resource "aws_vpc" "bar" { 378 cidr_block = "10.1.0.0/16" 379 enable_dns_hostnames = true 380 } 381 382 resource "aws_vpc_peering_connection" "foo" { 383 vpc_id = "${aws_vpc.foo.id}" 384 peer_vpc_id = "${aws_vpc.bar.id}" 385 auto_accept = true 386 387 accepter { 388 allow_remote_vpc_dns_resolution = true 389 } 390 391 requester { 392 allow_vpc_to_remote_classic_link = true 393 allow_classic_link_to_remote_vpc = true 394 } 395 } 396 `