github.com/nevins-b/terraform@v0.3.8-0.20170215184714-bbae22007d5a/builtin/providers/google/resource_compute_vpn_tunnel_test.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/hashicorp/terraform/helper/acctest"
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/terraform"
    10  
    11  	"google.golang.org/api/compute/v1"
    12  )
    13  
    14  func TestAccComputeVpnTunnel_basic(t *testing.T) {
    15  	resource.Test(t, resource.TestCase{
    16  		PreCheck:     func() { testAccPreCheck(t) },
    17  		Providers:    testAccProviders,
    18  		CheckDestroy: testAccCheckComputeVpnTunnelDestroy,
    19  		Steps: []resource.TestStep{
    20  			resource.TestStep{
    21  				Config: testAccComputeVpnTunnel_basic,
    22  				Check: resource.ComposeTestCheckFunc(
    23  					testAccCheckComputeVpnTunnelExists(
    24  						"google_compute_vpn_tunnel.foobar"),
    25  					resource.TestCheckResourceAttr(
    26  						"google_compute_vpn_tunnel.foobar", "local_traffic_selector.#", "1"),
    27  					resource.TestCheckResourceAttr(
    28  						"google_compute_vpn_tunnel.foobar", "remote_traffic_selector.#", "2"),
    29  				),
    30  			},
    31  		},
    32  	})
    33  }
    34  
    35  func testAccCheckComputeVpnTunnelDestroy(s *terraform.State) error {
    36  	config := testAccProvider.Meta().(*Config)
    37  	project := config.Project
    38  
    39  	vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
    40  
    41  	for _, rs := range s.RootModule().Resources {
    42  		if rs.Type != "google_compute_network" {
    43  			continue
    44  		}
    45  
    46  		region := rs.Primary.Attributes["region"]
    47  		name := rs.Primary.Attributes["name"]
    48  
    49  		_, err := vpnTunnelsService.Get(project, region, name).Do()
    50  
    51  		if err == nil {
    52  			return fmt.Errorf("Error, VPN Tunnel %s in region %s still exists",
    53  				name, region)
    54  		}
    55  	}
    56  
    57  	return nil
    58  }
    59  
    60  func testAccCheckComputeVpnTunnelExists(n string) resource.TestCheckFunc {
    61  	return func(s *terraform.State) error {
    62  		rs, ok := s.RootModule().Resources[n]
    63  		if !ok {
    64  			return fmt.Errorf("Not found: %s", n)
    65  		}
    66  
    67  		if rs.Primary.ID == "" {
    68  			return fmt.Errorf("No ID is set")
    69  		}
    70  
    71  		config := testAccProvider.Meta().(*Config)
    72  		name := rs.Primary.Attributes["name"]
    73  		region := rs.Primary.Attributes["region"]
    74  		project := config.Project
    75  
    76  		vpnTunnelsService := compute.NewVpnTunnelsService(config.clientCompute)
    77  		_, err := vpnTunnelsService.Get(project, region, name).Do()
    78  
    79  		if err != nil {
    80  			return fmt.Errorf("Error Reading VPN Tunnel %s: %s", name, err)
    81  		}
    82  
    83  		return nil
    84  	}
    85  }
    86  
    87  var testAccComputeVpnTunnel_basic = fmt.Sprintf(`
    88  resource "google_compute_network" "foobar" {
    89  	name = "tunnel-test-%s"
    90  }
    91  resource "google_compute_subnetwork" "foobar" {
    92  	name = "tunnel-test-%s"
    93  	network = "${google_compute_network.foobar.self_link}"
    94  	ip_cidr_range = "10.0.0.0/16"
    95  	region = "us-central1"
    96  }
    97  resource "google_compute_address" "foobar" {
    98  	name = "tunnel-test-%s"
    99  	region = "${google_compute_subnetwork.foobar.region}"
   100  }
   101  resource "google_compute_vpn_gateway" "foobar" {
   102  	name = "tunnel-test-%s"
   103  	network = "${google_compute_network.foobar.self_link}"
   104  	region = "${google_compute_subnetwork.foobar.region}"
   105  }
   106  resource "google_compute_forwarding_rule" "foobar_esp" {
   107  	name = "tunnel-test-%s"
   108  	region = "${google_compute_vpn_gateway.foobar.region}"
   109  	ip_protocol = "ESP"
   110  	ip_address = "${google_compute_address.foobar.address}"
   111  	target = "${google_compute_vpn_gateway.foobar.self_link}"
   112  }
   113  resource "google_compute_forwarding_rule" "foobar_udp500" {
   114  	name = "tunnel-test-%s"
   115  	region = "${google_compute_forwarding_rule.foobar_esp.region}"
   116  	ip_protocol = "UDP"
   117  	port_range = "500-500"
   118  	ip_address = "${google_compute_address.foobar.address}"
   119  	target = "${google_compute_vpn_gateway.foobar.self_link}"
   120  }
   121  resource "google_compute_forwarding_rule" "foobar_udp4500" {
   122  	name = "tunnel-test-%s"
   123  	region = "${google_compute_forwarding_rule.foobar_udp500.region}"
   124  	ip_protocol = "UDP"
   125  	port_range = "4500-4500"
   126  	ip_address = "${google_compute_address.foobar.address}"
   127  	target = "${google_compute_vpn_gateway.foobar.self_link}"
   128  }
   129  resource "google_compute_vpn_tunnel" "foobar" {
   130  	name = "tunnel-test-%s"
   131  	region = "${google_compute_forwarding_rule.foobar_udp4500.region}"
   132  	target_vpn_gateway = "${google_compute_vpn_gateway.foobar.self_link}"
   133  	shared_secret = "unguessable"
   134  	peer_ip = "8.8.8.8"
   135  	local_traffic_selector = ["${google_compute_subnetwork.foobar.ip_cidr_range}"]
   136  	remote_traffic_selector = ["192.168.0.0/24", "192.168.1.0/24"]
   137  }`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
   138  	acctest.RandString(10), acctest.RandString(10), acctest.RandString(10),
   139  	acctest.RandString(10), acctest.RandString(10))