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