github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/triton/resource_machine_test.go (about) 1 package triton 2 3 import ( 4 "context" 5 "fmt" 6 "log" 7 "regexp" 8 "testing" 9 "time" 10 11 "github.com/davecgh/go-spew/spew" 12 "github.com/hashicorp/terraform/helper/acctest" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/terraform" 15 "github.com/joyent/triton-go" 16 ) 17 18 func TestAccTritonMachine_basic(t *testing.T) { 19 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 20 config := fmt.Sprintf(testAccTritonMachine_basic, machineName) 21 22 resource.Test(t, resource.TestCase{ 23 PreCheck: func() { testAccPreCheck(t) }, 24 Providers: testAccProviders, 25 CheckDestroy: testCheckTritonMachineDestroy, 26 Steps: []resource.TestStep{ 27 { 28 Config: config, 29 Check: resource.ComposeTestCheckFunc( 30 testCheckTritonMachineExists("triton_machine.test"), 31 func(*terraform.State) error { 32 time.Sleep(10 * time.Second) 33 return nil 34 }, 35 ), 36 }, 37 }, 38 }) 39 } 40 41 func TestAccTritonMachine_dns(t *testing.T) { 42 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 43 dns_output := fmt.Sprintf(testAccTritonMachine_dns, machineName) 44 45 resource.Test(t, resource.TestCase{ 46 PreCheck: func() { testAccPreCheck(t) }, 47 Providers: testAccProviders, 48 CheckDestroy: testCheckTritonMachineDestroy, 49 Steps: []resource.TestStep{ 50 { 51 Config: dns_output, 52 Check: resource.ComposeTestCheckFunc( 53 testCheckTritonMachineExists("triton_machine.test"), 54 func(state *terraform.State) error { 55 time.Sleep(10 * time.Second) 56 log.Printf("[DEBUG] %s", spew.Sdump(state)) 57 return nil 58 }, 59 resource.TestMatchOutput("domain_names", regexp.MustCompile(".*acctest-.*")), 60 ), 61 }, 62 }, 63 }) 64 } 65 66 func TestAccTritonMachine_nic(t *testing.T) { 67 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 68 config := testAccTritonMachine_singleNIC(machineName, acctest.RandIntRange(1024, 2048), acctest.RandIntRange(0, 256)) 69 70 resource.Test(t, resource.TestCase{ 71 PreCheck: func() { testAccPreCheck(t) }, 72 Providers: testAccProviders, 73 CheckDestroy: testCheckTritonMachineDestroy, 74 Steps: []resource.TestStep{ 75 { 76 Config: config, 77 Check: resource.ComposeTestCheckFunc( 78 testCheckTritonMachineExists("triton_machine.test"), 79 func(*terraform.State) error { 80 time.Sleep(10 * time.Second) 81 return nil 82 }, 83 testCheckTritonMachineHasFabric("triton_machine.test", "triton_fabric.test"), 84 ), 85 }, 86 }, 87 }) 88 } 89 90 func TestAccTritonMachine_addNIC(t *testing.T) { 91 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 92 vlanNumber := acctest.RandIntRange(1024, 2048) 93 subnetNumber := acctest.RandIntRange(0, 256) 94 95 singleNICConfig := testAccTritonMachine_singleNIC(machineName, vlanNumber, subnetNumber) 96 dualNICConfig := testAccTritonMachine_dualNIC(machineName, vlanNumber, subnetNumber) 97 98 resource.Test(t, resource.TestCase{ 99 PreCheck: func() { testAccPreCheck(t) }, 100 Providers: testAccProviders, 101 CheckDestroy: testCheckTritonMachineDestroy, 102 Steps: []resource.TestStep{ 103 { 104 Config: singleNICConfig, 105 Check: resource.ComposeTestCheckFunc( 106 testCheckTritonMachineExists("triton_machine.test"), 107 func(*terraform.State) error { 108 time.Sleep(10 * time.Second) 109 return nil 110 }, 111 ), 112 }, 113 { 114 Config: dualNICConfig, 115 Check: resource.ComposeTestCheckFunc( 116 testCheckTritonMachineExists("triton_machine.test"), 117 testCheckTritonMachineHasFabric("triton_machine.test", "triton_fabric.test_add"), 118 ), 119 }, 120 }, 121 }) 122 } 123 124 func testCheckTritonMachineExists(name string) resource.TestCheckFunc { 125 return func(s *terraform.State) error { 126 // Ensure we have enough information in state to look up in API 127 rs, ok := s.RootModule().Resources[name] 128 if !ok { 129 return fmt.Errorf("Not found: %s", name) 130 } 131 conn := testAccProvider.Meta().(*triton.Client) 132 133 machine, err := conn.Machines().GetMachine(context.Background(), &triton.GetMachineInput{ 134 ID: rs.Primary.ID, 135 }) 136 if err != nil { 137 return fmt.Errorf("Bad: Check Machine Exists: %s", err) 138 } 139 140 if machine == nil { 141 return fmt.Errorf("Bad: Machine %q does not exist", rs.Primary.ID) 142 } 143 144 return nil 145 } 146 } 147 148 func testCheckTritonMachineHasFabric(name, fabricName string) resource.TestCheckFunc { 149 return func(s *terraform.State) error { 150 // Ensure we have enough information in state to look up in API 151 machine, ok := s.RootModule().Resources[name] 152 if !ok { 153 return fmt.Errorf("Not found: %s", name) 154 } 155 156 network, ok := s.RootModule().Resources[fabricName] 157 if !ok { 158 return fmt.Errorf("Not found: %s", fabricName) 159 } 160 conn := testAccProvider.Meta().(*triton.Client) 161 162 nics, err := conn.Machines().ListNICs(context.Background(), &triton.ListNICsInput{ 163 MachineID: machine.Primary.ID, 164 }) 165 if err != nil { 166 return fmt.Errorf("Bad: Check NICs Exist: %s", err) 167 } 168 169 for _, nic := range nics { 170 if nic.Network == network.Primary.ID { 171 return nil 172 } 173 } 174 175 return fmt.Errorf("Bad: Machine %q does not have Fabric %q", machine.Primary.ID, network.Primary.ID) 176 } 177 } 178 179 func testCheckTritonMachineDestroy(s *terraform.State) error { 180 conn := testAccProvider.Meta().(*triton.Client) 181 182 for _, rs := range s.RootModule().Resources { 183 if rs.Type != "triton_machine" { 184 continue 185 } 186 187 resp, err := conn.Machines().GetMachine(context.Background(), &triton.GetMachineInput{ 188 ID: rs.Primary.ID, 189 }) 190 if err != nil { 191 if triton.IsResourceNotFound(err) { 192 return nil 193 } 194 return err 195 } 196 197 if resp != nil && resp.State != machineStateDeleted { 198 return fmt.Errorf("Bad: Machine %q still exists", rs.Primary.ID) 199 } 200 } 201 202 return nil 203 } 204 205 func TestAccTritonMachine_firewall(t *testing.T) { 206 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 207 disabled_config := fmt.Sprintf(testAccTritonMachine_firewall_0, machineName) 208 enabled_config := fmt.Sprintf(testAccTritonMachine_firewall_1, machineName) 209 210 resource.Test(t, resource.TestCase{ 211 PreCheck: func() { testAccPreCheck(t) }, 212 Providers: testAccProviders, 213 CheckDestroy: testCheckTritonMachineDestroy, 214 Steps: []resource.TestStep{ 215 { 216 Config: enabled_config, 217 Check: resource.ComposeTestCheckFunc( 218 testCheckTritonMachineExists("triton_machine.test"), 219 resource.TestCheckResourceAttr( 220 "triton_machine.test", "firewall_enabled", "true"), 221 ), 222 }, 223 { 224 Config: disabled_config, 225 Check: resource.ComposeTestCheckFunc( 226 testCheckTritonMachineExists("triton_machine.test"), 227 resource.TestCheckResourceAttr( 228 "triton_machine.test", "firewall_enabled", "false"), 229 ), 230 }, 231 { 232 Config: enabled_config, 233 Check: resource.ComposeTestCheckFunc( 234 testCheckTritonMachineExists("triton_machine.test"), 235 resource.TestCheckResourceAttr( 236 "triton_machine.test", "firewall_enabled", "true"), 237 ), 238 }, 239 }, 240 }) 241 } 242 243 func TestAccTritonMachine_metadata(t *testing.T) { 244 machineName := fmt.Sprintf("acctest-%d", acctest.RandInt()) 245 basic := fmt.Sprintf(testAccTritonMachine_metadata_1, machineName) 246 add_metadata := fmt.Sprintf(testAccTritonMachine_metadata_1, machineName) 247 add_metadata_2 := fmt.Sprintf(testAccTritonMachine_metadata_2, machineName) 248 add_metadata_3 := fmt.Sprintf(testAccTritonMachine_metadata_3, machineName) 249 250 resource.Test(t, resource.TestCase{ 251 PreCheck: func() { testAccPreCheck(t) }, 252 Providers: testAccProviders, 253 CheckDestroy: testCheckTritonMachineDestroy, 254 Steps: []resource.TestStep{ 255 { 256 Config: basic, 257 Check: resource.ComposeTestCheckFunc( 258 testCheckTritonMachineExists("triton_machine.test"), 259 ), 260 }, 261 { 262 Config: add_metadata, 263 Check: resource.ComposeTestCheckFunc( 264 testCheckTritonMachineExists("triton_machine.test"), 265 resource.TestCheckResourceAttr( 266 "triton_machine.test", "user_data", "hello"), 267 ), 268 }, 269 { 270 Config: add_metadata_2, 271 Check: resource.ComposeTestCheckFunc( 272 testCheckTritonMachineExists("triton_machine.test"), 273 resource.TestCheckResourceAttr( 274 "triton_machine.test", 275 "tags.triton.cns.services", "test-cns-service"), 276 ), 277 }, 278 { 279 Config: add_metadata_3, 280 Check: resource.ComposeTestCheckFunc( 281 testCheckTritonMachineExists("triton_machine.test"), 282 resource.TestCheckResourceAttr( 283 "triton_machine.test", 284 "tags.triton.cns.services", "test-cns-service"), 285 ), 286 }, 287 }, 288 }) 289 } 290 291 var testAccTritonMachine_basic = ` 292 resource "triton_machine" "test" { 293 name = "%s" 294 package = "g4-general-4G" 295 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 296 297 tags = { 298 test = "hello!" 299 } 300 } 301 ` 302 303 var testAccTritonMachine_firewall_0 = ` 304 resource "triton_machine" "test" { 305 name = "%s" 306 package = "g4-general-4G" 307 image = "c20b4b7c-e1a6-11e5-9a4d-ef590901732e" 308 309 firewall_enabled = 0 310 } 311 ` 312 var testAccTritonMachine_firewall_1 = ` 313 resource "triton_machine" "test" { 314 name = "%s" 315 package = "g4-general-4G" 316 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 317 318 firewall_enabled = 1 319 } 320 ` 321 322 var testAccTritonMachine_metadata_1 = ` 323 resource "triton_machine" "test" { 324 name = "%s" 325 package = "g4-general-4G" 326 image = "c20b4b7c-e1a6-11e5-9a4d-ef590901732e" 327 328 user_data = "hello" 329 330 tags = { 331 test = "hello!" 332 } 333 } 334 ` 335 var testAccTritonMachine_metadata_2 = ` 336 variable "tags" { 337 default = { 338 test = "hello!" 339 triton.cns.services = "test-cns-service" 340 } 341 } 342 resource "triton_machine" "test" { 343 name = "%s" 344 package = "g4-highcpu-128M" 345 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 346 347 user_data = "hello" 348 349 tags = "${var.tags}" 350 } 351 ` 352 var testAccTritonMachine_metadata_3 = ` 353 resource "triton_machine" "test" { 354 name = "%s" 355 package = "g4-highcpu-128M" 356 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 357 358 user_data = "hello" 359 360 tags = { 361 test = "hello!" 362 triton.cns.services = "test-cns-service" 363 } 364 } 365 ` 366 var testAccTritonMachine_singleNIC = func(name string, vlanNumber int, subnetNumber int) string { 367 return fmt.Sprintf(`resource "triton_vlan" "test" { 368 vlan_id = %d 369 name = "%s-vlan" 370 description = "test vlan" 371 } 372 373 resource "triton_fabric" "test" { 374 name = "%s-network" 375 description = "test network" 376 vlan_id = "${triton_vlan.test.vlan_id}" 377 378 subnet = "10.%d.0.0/24" 379 gateway = "10.%d.0.1" 380 provision_start_ip = "10.%d.0.10" 381 provision_end_ip = "10.%d.0.250" 382 383 resolvers = ["8.8.8.8", "8.8.4.4"] 384 } 385 386 resource "triton_machine" "test" { 387 name = "%s-instance" 388 package = "g4-highcpu-128M" 389 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 390 391 tags = { 392 test = "Test" 393 } 394 395 nic { 396 network = "${triton_fabric.test.id}" 397 } 398 }`, vlanNumber, name, name, subnetNumber, subnetNumber, subnetNumber, subnetNumber, name) 399 } 400 401 var testAccTritonMachine_dualNIC = func(name string, vlanNumber, subnetNumber int) string { 402 return fmt.Sprintf(`resource "triton_vlan" "test" { 403 vlan_id = %d 404 name = "%s-vlan" 405 description = "test vlan" 406 } 407 408 resource "triton_fabric" "test" { 409 name = "%s-network" 410 description = "test network" 411 vlan_id = "${triton_vlan.test.vlan_id}" 412 413 subnet = "10.%d.0.0/24" 414 gateway = "10.%d.0.1" 415 provision_start_ip = "10.%d.0.10" 416 provision_end_ip = "10.%d.0.250" 417 418 resolvers = ["8.8.8.8", "8.8.4.4"] 419 } 420 421 resource "triton_fabric" "test_add" { 422 name = "%s-network-2" 423 description = "test network 2" 424 vlan_id = "${triton_vlan.test.vlan_id}" 425 426 subnet = "172.23.%d.0/24" 427 gateway = "172.23.%d.1" 428 provision_start_ip = "172.23.%d.10" 429 provision_end_ip = "172.23.%d.250" 430 431 resolvers = ["8.8.8.8", "8.8.4.4"] 432 } 433 434 resource "triton_machine" "test" { 435 name = "%s-instance" 436 package = "g4-highcpu-128M" 437 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 438 439 tags = { 440 test = "Test" 441 } 442 443 nic { 444 network = "${triton_fabric.test.id}" 445 } 446 nic { 447 network = "${triton_fabric.test_add.id}" 448 } 449 }`, vlanNumber, name, name, subnetNumber, subnetNumber, subnetNumber, subnetNumber, name, subnetNumber, subnetNumber, subnetNumber, subnetNumber, name) 450 } 451 452 var testAccTritonMachine_dns = ` 453 provider "triton" { 454 } 455 456 resource "triton_machine" "test" { 457 name = "%s" 458 package = "g4-highcpu-128M" 459 image = "fb5fe970-e6e4-11e6-9820-4b51be190db9" 460 } 461 462 output "domain_names" { 463 value = "${join(", ", triton_machine.test.domain_names)}" 464 } 465 `