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 }