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