github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/google/resource_compute_instance_group_test.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"google.golang.org/api/compute/v1"
     8  
     9  	"github.com/hashicorp/terraform/helper/acctest"
    10  	"github.com/hashicorp/terraform/helper/resource"
    11  	"github.com/hashicorp/terraform/terraform"
    12  )
    13  
    14  func TestAccComputeInstanceGroup_basic(t *testing.T) {
    15  	var instanceGroup compute.InstanceGroup
    16  	var instanceName = fmt.Sprintf("instancegroup-test-%s", acctest.RandString(10))
    17  
    18  	resource.Test(t, resource.TestCase{
    19  		PreCheck:     func() { testAccPreCheck(t) },
    20  		Providers:    testAccProviders,
    21  		CheckDestroy: testAccComputeInstanceGroup_destroy,
    22  		Steps: []resource.TestStep{
    23  			{
    24  				Config: testAccComputeInstanceGroup_basic(instanceName),
    25  				Check: resource.ComposeTestCheckFunc(
    26  					testAccComputeInstanceGroup_exists(
    27  						"google_compute_instance_group.basic", &instanceGroup),
    28  					testAccComputeInstanceGroup_exists(
    29  						"google_compute_instance_group.empty", &instanceGroup),
    30  				),
    31  			},
    32  		},
    33  	})
    34  }
    35  
    36  func TestAccComputeInstanceGroup_update(t *testing.T) {
    37  	var instanceGroup compute.InstanceGroup
    38  	var instanceName = fmt.Sprintf("instancegroup-test-%s", acctest.RandString(10))
    39  
    40  	resource.Test(t, resource.TestCase{
    41  		PreCheck:     func() { testAccPreCheck(t) },
    42  		Providers:    testAccProviders,
    43  		CheckDestroy: testAccComputeInstanceGroup_destroy,
    44  		Steps: []resource.TestStep{
    45  			{
    46  				Config: testAccComputeInstanceGroup_update(instanceName),
    47  				Check: resource.ComposeTestCheckFunc(
    48  					testAccComputeInstanceGroup_exists(
    49  						"google_compute_instance_group.update", &instanceGroup),
    50  					testAccComputeInstanceGroup_named_ports(
    51  						"google_compute_instance_group.update",
    52  						map[string]int64{"http": 8080, "https": 8443},
    53  						&instanceGroup),
    54  				),
    55  			},
    56  			{
    57  				Config: testAccComputeInstanceGroup_update2(instanceName),
    58  				Check: resource.ComposeTestCheckFunc(
    59  					testAccComputeInstanceGroup_exists(
    60  						"google_compute_instance_group.update", &instanceGroup),
    61  					testAccComputeInstanceGroup_updated(
    62  						"google_compute_instance_group.update", 3, &instanceGroup),
    63  					testAccComputeInstanceGroup_named_ports(
    64  						"google_compute_instance_group.update",
    65  						map[string]int64{"http": 8081, "test": 8444},
    66  						&instanceGroup),
    67  				),
    68  			},
    69  		},
    70  	})
    71  }
    72  
    73  func TestAccComputeInstanceGroup_outOfOrderInstances(t *testing.T) {
    74  	var instanceGroup compute.InstanceGroup
    75  	var instanceName = fmt.Sprintf("instancegroup-test-%s", acctest.RandString(10))
    76  
    77  	resource.Test(t, resource.TestCase{
    78  		PreCheck:     func() { testAccPreCheck(t) },
    79  		Providers:    testAccProviders,
    80  		CheckDestroy: testAccComputeInstanceGroup_destroy,
    81  		Steps: []resource.TestStep{
    82  			{
    83  				Config: testAccComputeInstanceGroup_outOfOrderInstances(instanceName),
    84  				Check: resource.ComposeTestCheckFunc(
    85  					testAccComputeInstanceGroup_exists(
    86  						"google_compute_instance_group.group", &instanceGroup),
    87  				),
    88  			},
    89  		},
    90  	})
    91  }
    92  
    93  func TestAccComputeInstanceGroup_network(t *testing.T) {
    94  	var instanceGroup compute.InstanceGroup
    95  	var instanceName = fmt.Sprintf("instancegroup-test-%s", acctest.RandString(10))
    96  
    97  	resource.Test(t, resource.TestCase{
    98  		PreCheck:     func() { testAccPreCheck(t) },
    99  		Providers:    testAccProviders,
   100  		CheckDestroy: testAccComputeInstanceGroup_destroy,
   101  		Steps: []resource.TestStep{
   102  			resource.TestStep{
   103  				Config: testAccComputeInstanceGroup_network(instanceName),
   104  				Check: resource.ComposeTestCheckFunc(
   105  					testAccComputeInstanceGroup_exists(
   106  						"google_compute_instance_group.with_instance", &instanceGroup),
   107  					testAccComputeInstanceGroup_hasCorrectNetwork(
   108  						"google_compute_instance_group.with_instance", "google_compute_network.ig_network", &instanceGroup),
   109  					testAccComputeInstanceGroup_exists(
   110  						"google_compute_instance_group.without_instance", &instanceGroup),
   111  					testAccComputeInstanceGroup_hasCorrectNetwork(
   112  						"google_compute_instance_group.without_instance", "google_compute_network.ig_network", &instanceGroup),
   113  				),
   114  			},
   115  		},
   116  	})
   117  }
   118  
   119  func testAccComputeInstanceGroup_destroy(s *terraform.State) error {
   120  	config := testAccProvider.Meta().(*Config)
   121  
   122  	for _, rs := range s.RootModule().Resources {
   123  		if rs.Type != "google_compute_instance_group" {
   124  			continue
   125  		}
   126  		_, err := config.clientCompute.InstanceGroups.Get(
   127  			config.Project, rs.Primary.Attributes["zone"], rs.Primary.ID).Do()
   128  		if err == nil {
   129  			return fmt.Errorf("InstanceGroup still exists")
   130  		}
   131  	}
   132  
   133  	return nil
   134  }
   135  
   136  func testAccComputeInstanceGroup_exists(n string, instanceGroup *compute.InstanceGroup) resource.TestCheckFunc {
   137  	return func(s *terraform.State) error {
   138  		rs, ok := s.RootModule().Resources[n]
   139  		if !ok {
   140  			return fmt.Errorf("Not found: %s", n)
   141  		}
   142  
   143  		if rs.Primary.ID == "" {
   144  			return fmt.Errorf("No ID is set")
   145  		}
   146  
   147  		config := testAccProvider.Meta().(*Config)
   148  
   149  		found, err := config.clientCompute.InstanceGroups.Get(
   150  			config.Project, rs.Primary.Attributes["zone"], rs.Primary.ID).Do()
   151  		if err != nil {
   152  			return err
   153  		}
   154  
   155  		if found.Name != rs.Primary.ID {
   156  			return fmt.Errorf("InstanceGroup not found")
   157  		}
   158  
   159  		*instanceGroup = *found
   160  
   161  		return nil
   162  	}
   163  }
   164  
   165  func testAccComputeInstanceGroup_updated(n string, size int64, instanceGroup *compute.InstanceGroup) resource.TestCheckFunc {
   166  	return func(s *terraform.State) error {
   167  		rs, ok := s.RootModule().Resources[n]
   168  		if !ok {
   169  			return fmt.Errorf("Not found: %s", n)
   170  		}
   171  
   172  		if rs.Primary.ID == "" {
   173  			return fmt.Errorf("No ID is set")
   174  		}
   175  
   176  		config := testAccProvider.Meta().(*Config)
   177  
   178  		instanceGroup, err := config.clientCompute.InstanceGroups.Get(
   179  			config.Project, rs.Primary.Attributes["zone"], rs.Primary.ID).Do()
   180  		if err != nil {
   181  			return err
   182  		}
   183  
   184  		// Cannot check the target pool as the instance creation is asynchronous.  However, can
   185  		// check the target_size.
   186  		if instanceGroup.Size != size {
   187  			return fmt.Errorf("instance count incorrect")
   188  		}
   189  
   190  		return nil
   191  	}
   192  }
   193  
   194  func testAccComputeInstanceGroup_named_ports(n string, np map[string]int64, instanceGroup *compute.InstanceGroup) resource.TestCheckFunc {
   195  	return func(s *terraform.State) error {
   196  		rs, ok := s.RootModule().Resources[n]
   197  		if !ok {
   198  			return fmt.Errorf("Not found: %s", n)
   199  		}
   200  
   201  		if rs.Primary.ID == "" {
   202  			return fmt.Errorf("No ID is set")
   203  		}
   204  
   205  		config := testAccProvider.Meta().(*Config)
   206  
   207  		instanceGroup, err := config.clientCompute.InstanceGroups.Get(
   208  			config.Project, rs.Primary.Attributes["zone"], rs.Primary.ID).Do()
   209  		if err != nil {
   210  			return err
   211  		}
   212  
   213  		var found bool
   214  		for _, namedPort := range instanceGroup.NamedPorts {
   215  			found = false
   216  			for name, port := range np {
   217  				if namedPort.Name == name && namedPort.Port == port {
   218  					found = true
   219  				}
   220  			}
   221  			if !found {
   222  				return fmt.Errorf("named port incorrect")
   223  			}
   224  		}
   225  
   226  		return nil
   227  	}
   228  }
   229  
   230  func testAccComputeInstanceGroup_hasCorrectNetwork(nInstanceGroup string, nNetwork string, instanceGroup *compute.InstanceGroup) resource.TestCheckFunc {
   231  	return func(s *terraform.State) error {
   232  		config := testAccProvider.Meta().(*Config)
   233  
   234  		rsInstanceGroup, ok := s.RootModule().Resources[nInstanceGroup]
   235  		if !ok {
   236  			return fmt.Errorf("Not found: %s", nInstanceGroup)
   237  		}
   238  		if rsInstanceGroup.Primary.ID == "" {
   239  			return fmt.Errorf("No ID is set")
   240  		}
   241  		instanceGroup, err := config.clientCompute.InstanceGroups.Get(
   242  			config.Project, rsInstanceGroup.Primary.Attributes["zone"], rsInstanceGroup.Primary.ID).Do()
   243  		if err != nil {
   244  			return err
   245  		}
   246  
   247  		rsNetwork, ok := s.RootModule().Resources[nNetwork]
   248  		if !ok {
   249  			return fmt.Errorf("Not found: %s", nNetwork)
   250  		}
   251  		if rsNetwork.Primary.ID == "" {
   252  			return fmt.Errorf("No ID is set")
   253  		}
   254  		network, err := config.clientCompute.Networks.Get(
   255  			config.Project, rsNetwork.Primary.ID).Do()
   256  		if err != nil {
   257  			return err
   258  		}
   259  
   260  		if instanceGroup.Network != network.SelfLink {
   261  			return fmt.Errorf("network incorrect: actual=%s vs expected=%s", instanceGroup.Network, network.SelfLink)
   262  		}
   263  
   264  		return nil
   265  	}
   266  }
   267  
   268  func testAccComputeInstanceGroup_basic(instance string) string {
   269  	return fmt.Sprintf(`
   270  	resource "google_compute_instance" "ig_instance" {
   271  		name = "%s"
   272  		machine_type = "n1-standard-1"
   273  		can_ip_forward = false
   274  		zone = "us-central1-c"
   275  
   276  		disk {
   277  			image = "debian-8-jessie-v20160803"
   278  		}
   279  
   280  		network_interface {
   281  			network = "default"
   282  		}
   283  	}
   284  
   285  	resource "google_compute_instance_group" "basic" {
   286  		description = "Terraform test instance group"
   287  		name = "%s"
   288  		zone = "us-central1-c"
   289  		instances = [ "${google_compute_instance.ig_instance.self_link}" ]
   290  		named_port {
   291  			name = "http"
   292  			port = "8080"
   293  		}
   294  		named_port {
   295  			name = "https"
   296  			port = "8443"
   297  		}
   298  	}
   299  
   300  	resource "google_compute_instance_group" "empty" {
   301  		description = "Terraform test instance group empty"
   302  		name = "%s-empty"
   303  		zone = "us-central1-c"
   304  		named_port {
   305  			name = "http"
   306  			port = "8080"
   307  		}
   308  		named_port {
   309  			name = "https"
   310  			port = "8443"
   311  		}
   312  	}`, instance, instance, instance)
   313  }
   314  
   315  func testAccComputeInstanceGroup_update(instance string) string {
   316  	return fmt.Sprintf(`
   317  	resource "google_compute_instance" "ig_instance" {
   318  		name = "%s-${count.index}"
   319  		machine_type = "n1-standard-1"
   320  		can_ip_forward = false
   321  		zone = "us-central1-c"
   322  		count = 1
   323  
   324  		disk {
   325  			image = "debian-8-jessie-v20160803"
   326  		}
   327  
   328  		network_interface {
   329  			network = "default"
   330  		}
   331  	}
   332  
   333  	resource "google_compute_instance_group" "update" {
   334  		description = "Terraform test instance group"
   335  		name = "%s"
   336  		zone = "us-central1-c"
   337  		instances = [ "${google_compute_instance.ig_instance.self_link}" ]
   338  		named_port {
   339  			name = "http"
   340  			port = "8080"
   341  		}
   342  		named_port {
   343  			name = "https"
   344  			port = "8443"
   345  		}
   346  	}`, instance, instance)
   347  }
   348  
   349  // Change IGM's instance template and target size
   350  func testAccComputeInstanceGroup_update2(instance string) string {
   351  	return fmt.Sprintf(`
   352  	resource "google_compute_instance" "ig_instance" {
   353  		name = "%s-${count.index}"
   354  		machine_type = "n1-standard-1"
   355  		can_ip_forward = false
   356  		zone = "us-central1-c"
   357  		count = 3
   358  
   359  		disk {
   360  			image = "debian-8-jessie-v20160803"
   361  		}
   362  
   363  		network_interface {
   364  			network = "default"
   365  		}
   366  	}
   367  
   368  	resource "google_compute_instance_group" "update" {
   369  		description = "Terraform test instance group"
   370  		name = "%s"
   371  		zone = "us-central1-c"
   372  		instances = [ "${google_compute_instance.ig_instance.*.self_link}" ]
   373  
   374  		named_port {
   375  			name = "http"
   376  			port = "8081"
   377  		}
   378  		named_port {
   379  			name = "test"
   380  			port = "8444"
   381  		}
   382  	}`, instance, instance)
   383  }
   384  
   385  func testAccComputeInstanceGroup_outOfOrderInstances(instance string) string {
   386  	return fmt.Sprintf(`
   387  	resource "google_compute_instance" "ig_instance" {
   388  		name = "%s-1"
   389  		machine_type = "n1-standard-1"
   390  		can_ip_forward = false
   391  		zone = "us-central1-c"
   392  
   393  		disk {
   394  			image = "debian-8-jessie-v20160803"
   395  		}
   396  
   397  		network_interface {
   398  			network = "default"
   399  		}
   400  	}
   401  
   402  	resource "google_compute_instance" "ig_instance_2" {
   403  		name = "%s-2"
   404  		machine_type = "n1-standard-1"
   405  		can_ip_forward = false
   406  		zone = "us-central1-c"
   407  
   408  		disk {
   409  			image = "debian-8-jessie-v20160803"
   410  		}
   411  
   412  		network_interface {
   413  			network = "default"
   414  		}
   415  	}
   416  
   417  	resource "google_compute_instance_group" "group" {
   418  		description = "Terraform test instance group"
   419  		name = "%s"
   420  		zone = "us-central1-c"
   421  		instances = [ "${google_compute_instance.ig_instance_2.self_link}", "${google_compute_instance.ig_instance.self_link}" ]
   422  		named_port {
   423  			name = "http"
   424  			port = "8080"
   425  		}
   426  		named_port {
   427  			name = "https"
   428  			port = "8443"
   429  		}
   430  	}`, instance, instance, instance)
   431  }
   432  
   433  func testAccComputeInstanceGroup_network(instance string) string {
   434  	return fmt.Sprintf(`
   435  	resource "google_compute_network" "ig_network" {
   436  		name = "%[1]s"
   437  		auto_create_subnetworks = true
   438  	}
   439  
   440  	resource "google_compute_instance" "ig_instance" {
   441  		name = "%[1]s"
   442  		machine_type = "n1-standard-1"
   443  		can_ip_forward = false
   444  		zone = "us-central1-c"
   445  
   446  		disk {
   447  			image = "debian-8-jessie-v20160803"
   448  		}
   449  
   450  		network_interface {
   451  			network = "${google_compute_network.ig_network.name}"
   452  		}
   453  	}
   454  
   455  	resource "google_compute_instance_group" "with_instance" {
   456  		description = "Terraform test instance group"
   457  		name = "%[1]s-with-instance"
   458  		zone = "us-central1-c"
   459  		instances = [ "${google_compute_instance.ig_instance.self_link}" ]
   460  	}
   461  
   462  	resource "google_compute_instance_group" "without_instance" {
   463  		description = "Terraform test instance group"
   464  		name = "%[1]s-without-instance"
   465  		zone = "us-central1-c"
   466  		network = "${google_compute_network.ig_network.self_link}"
   467  	}`, instance)
   468  }