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  `