github.com/IBM-Cloud/terraform@v0.6.4-0.20170726051544-8872b87621df/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  `