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  `