github.com/bradfeehan/terraform@v0.7.0-rc3.0.20170529055808-34b45c5ad841/builtin/providers/digitalocean/resource_digitalocean_loadbalancer_test.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/digitalocean/godo"
    10  	"github.com/hashicorp/terraform/helper/acctest"
    11  	"github.com/hashicorp/terraform/helper/resource"
    12  	"github.com/hashicorp/terraform/terraform"
    13  )
    14  
    15  func TestAccDigitalOceanLoadbalancer_Basic(t *testing.T) {
    16  	var loadbalancer godo.LoadBalancer
    17  	rInt := acctest.RandInt()
    18  
    19  	resource.Test(t, resource.TestCase{
    20  		PreCheck:     func() { testAccPreCheck(t) },
    21  		Providers:    testAccProviders,
    22  		CheckDestroy: testAccCheckDigitalOceanLoadbalancerDestroy,
    23  		Steps: []resource.TestStep{
    24  			{
    25  				Config: testAccCheckDigitalOceanLoadbalancerConfig_basic(rInt),
    26  				Check: resource.ComposeAggregateTestCheckFunc(
    27  					testAccCheckDigitalOceanLoadbalancerExists("digitalocean_loadbalancer.foobar", &loadbalancer),
    28  					resource.TestCheckResourceAttr(
    29  						"digitalocean_loadbalancer.foobar", "name", fmt.Sprintf("loadbalancer-%d", rInt)),
    30  					resource.TestCheckResourceAttr(
    31  						"digitalocean_loadbalancer.foobar", "region", "nyc3"),
    32  					resource.TestCheckResourceAttr(
    33  						"digitalocean_loadbalancer.foobar", "forwarding_rule.#", "1"),
    34  					resource.TestCheckResourceAttr(
    35  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_port", "80"),
    36  					resource.TestCheckResourceAttr(
    37  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_protocol", "http"),
    38  					resource.TestCheckResourceAttr(
    39  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_port", "80"),
    40  					resource.TestCheckResourceAttr(
    41  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_protocol", "http"),
    42  					resource.TestCheckResourceAttr(
    43  						"digitalocean_loadbalancer.foobar", "healthcheck.#", "1"),
    44  					resource.TestCheckResourceAttr(
    45  						"digitalocean_loadbalancer.foobar", "healthcheck.0.port", "22"),
    46  					resource.TestCheckResourceAttr(
    47  						"digitalocean_loadbalancer.foobar", "healthcheck.0.protocol", "tcp"),
    48  					resource.TestCheckResourceAttr(
    49  						"digitalocean_loadbalancer.foobar", "droplet_ids.#", "1"),
    50  				),
    51  			},
    52  		},
    53  	})
    54  }
    55  
    56  func TestAccDigitalOceanLoadbalancer_Updated(t *testing.T) {
    57  	var loadbalancer godo.LoadBalancer
    58  	rInt := acctest.RandInt()
    59  
    60  	resource.Test(t, resource.TestCase{
    61  		PreCheck:     func() { testAccPreCheck(t) },
    62  		Providers:    testAccProviders,
    63  		CheckDestroy: testAccCheckDigitalOceanLoadbalancerDestroy,
    64  		Steps: []resource.TestStep{
    65  			{
    66  				Config: testAccCheckDigitalOceanLoadbalancerConfig_basic(rInt),
    67  				Check: resource.ComposeAggregateTestCheckFunc(
    68  					testAccCheckDigitalOceanLoadbalancerExists("digitalocean_loadbalancer.foobar", &loadbalancer),
    69  					resource.TestCheckResourceAttr(
    70  						"digitalocean_loadbalancer.foobar", "name", fmt.Sprintf("loadbalancer-%d", rInt)),
    71  					resource.TestCheckResourceAttr(
    72  						"digitalocean_loadbalancer.foobar", "region", "nyc3"),
    73  					resource.TestCheckResourceAttr(
    74  						"digitalocean_loadbalancer.foobar", "forwarding_rule.#", "1"),
    75  					resource.TestCheckResourceAttr(
    76  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_port", "80"),
    77  					resource.TestCheckResourceAttr(
    78  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_protocol", "http"),
    79  					resource.TestCheckResourceAttr(
    80  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_port", "80"),
    81  					resource.TestCheckResourceAttr(
    82  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_protocol", "http"),
    83  					resource.TestCheckResourceAttr(
    84  						"digitalocean_loadbalancer.foobar", "healthcheck.#", "1"),
    85  					resource.TestCheckResourceAttr(
    86  						"digitalocean_loadbalancer.foobar", "healthcheck.0.port", "22"),
    87  					resource.TestCheckResourceAttr(
    88  						"digitalocean_loadbalancer.foobar", "healthcheck.0.protocol", "tcp"),
    89  					resource.TestCheckResourceAttr(
    90  						"digitalocean_loadbalancer.foobar", "droplet_ids.#", "1"),
    91  				),
    92  			},
    93  			{
    94  				Config: testAccCheckDigitalOceanLoadbalancerConfig_updated(rInt),
    95  				Check: resource.ComposeAggregateTestCheckFunc(
    96  					testAccCheckDigitalOceanLoadbalancerExists("digitalocean_loadbalancer.foobar", &loadbalancer),
    97  					resource.TestCheckResourceAttr(
    98  						"digitalocean_loadbalancer.foobar", "name", fmt.Sprintf("loadbalancer-%d", rInt)),
    99  					resource.TestCheckResourceAttr(
   100  						"digitalocean_loadbalancer.foobar", "region", "nyc3"),
   101  					resource.TestCheckResourceAttr(
   102  						"digitalocean_loadbalancer.foobar", "forwarding_rule.#", "1"),
   103  					resource.TestCheckResourceAttr(
   104  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_port", "81"),
   105  					resource.TestCheckResourceAttr(
   106  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_protocol", "http"),
   107  					resource.TestCheckResourceAttr(
   108  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_port", "81"),
   109  					resource.TestCheckResourceAttr(
   110  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_protocol", "http"),
   111  					resource.TestCheckResourceAttr(
   112  						"digitalocean_loadbalancer.foobar", "healthcheck.#", "1"),
   113  					resource.TestCheckResourceAttr(
   114  						"digitalocean_loadbalancer.foobar", "healthcheck.0.port", "22"),
   115  					resource.TestCheckResourceAttr(
   116  						"digitalocean_loadbalancer.foobar", "healthcheck.0.protocol", "tcp"),
   117  					resource.TestCheckResourceAttr(
   118  						"digitalocean_loadbalancer.foobar", "droplet_ids.#", "2"),
   119  				),
   120  			},
   121  		},
   122  	})
   123  }
   124  
   125  func TestAccDigitalOceanLoadbalancer_dropletTag(t *testing.T) {
   126  	var loadbalancer godo.LoadBalancer
   127  	rInt := acctest.RandInt()
   128  
   129  	resource.Test(t, resource.TestCase{
   130  		PreCheck:     func() { testAccPreCheck(t) },
   131  		Providers:    testAccProviders,
   132  		CheckDestroy: testAccCheckDigitalOceanLoadbalancerDestroy,
   133  		Steps: []resource.TestStep{
   134  			{
   135  				Config: testAccCheckDigitalOceanLoadbalancerConfig_dropletTag(rInt),
   136  				Check: resource.ComposeAggregateTestCheckFunc(
   137  					testAccCheckDigitalOceanLoadbalancerExists("digitalocean_loadbalancer.foobar", &loadbalancer),
   138  					resource.TestCheckResourceAttr(
   139  						"digitalocean_loadbalancer.foobar", "name", fmt.Sprintf("loadbalancer-%d", rInt)),
   140  					resource.TestCheckResourceAttr(
   141  						"digitalocean_loadbalancer.foobar", "region", "nyc3"),
   142  					resource.TestCheckResourceAttr(
   143  						"digitalocean_loadbalancer.foobar", "forwarding_rule.#", "1"),
   144  					resource.TestCheckResourceAttr(
   145  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_port", "80"),
   146  					resource.TestCheckResourceAttr(
   147  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.entry_protocol", "http"),
   148  					resource.TestCheckResourceAttr(
   149  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_port", "80"),
   150  					resource.TestCheckResourceAttr(
   151  						"digitalocean_loadbalancer.foobar", "forwarding_rule.0.target_protocol", "http"),
   152  					resource.TestCheckResourceAttr(
   153  						"digitalocean_loadbalancer.foobar", "healthcheck.#", "1"),
   154  					resource.TestCheckResourceAttr(
   155  						"digitalocean_loadbalancer.foobar", "healthcheck.0.port", "22"),
   156  					resource.TestCheckResourceAttr(
   157  						"digitalocean_loadbalancer.foobar", "healthcheck.0.protocol", "tcp"),
   158  					resource.TestCheckResourceAttr(
   159  						"digitalocean_loadbalancer.foobar", "droplet_tag", "sample"),
   160  				),
   161  			},
   162  		},
   163  	})
   164  }
   165  
   166  func testAccCheckDigitalOceanLoadbalancerDestroy(s *terraform.State) error {
   167  	client := testAccProvider.Meta().(*godo.Client)
   168  
   169  	for _, rs := range s.RootModule().Resources {
   170  		if rs.Type != "digitalocean_loadbalancer" {
   171  			continue
   172  		}
   173  
   174  		_, _, err := client.LoadBalancers.Get(context.Background(), rs.Primary.ID)
   175  
   176  		if err != nil && !strings.Contains(err.Error(), "404") {
   177  			return fmt.Errorf(
   178  				"Error waiting for loadbalancer (%s) to be destroyed: %s",
   179  				rs.Primary.ID, err)
   180  		}
   181  	}
   182  
   183  	return nil
   184  }
   185  
   186  func testAccCheckDigitalOceanLoadbalancerExists(n string, loadbalancer *godo.LoadBalancer) resource.TestCheckFunc {
   187  	return func(s *terraform.State) error {
   188  		rs, ok := s.RootModule().Resources[n]
   189  		if !ok {
   190  			return fmt.Errorf("Not found: %s", n)
   191  		}
   192  
   193  		if rs.Primary.ID == "" {
   194  			return fmt.Errorf("No Loadbalancer ID is set")
   195  		}
   196  
   197  		client := testAccProvider.Meta().(*godo.Client)
   198  
   199  		lb, _, err := client.LoadBalancers.Get(context.Background(), rs.Primary.ID)
   200  
   201  		if err != nil {
   202  			return err
   203  		}
   204  
   205  		if lb.ID != rs.Primary.ID {
   206  			return fmt.Errorf("Loabalancer not found")
   207  		}
   208  
   209  		*loadbalancer = *lb
   210  
   211  		return nil
   212  	}
   213  }
   214  
   215  func testAccCheckDigitalOceanLoadbalancerConfig_basic(rInt int) string {
   216  	return fmt.Sprintf(`
   217  resource "digitalocean_droplet" "foobar" {
   218    name      = "foo-%d"
   219    size      = "512mb"
   220    image     = "centos-7-x64"
   221    region    = "nyc3"
   222  }
   223  
   224  resource "digitalocean_loadbalancer" "foobar" {
   225    name = "loadbalancer-%d"
   226    region = "nyc3"
   227  
   228    forwarding_rule {
   229      entry_port = 80
   230      entry_protocol = "http"
   231  
   232      target_port = 80
   233      target_protocol = "http"
   234    }
   235  
   236    healthcheck {
   237      port = 22
   238      protocol = "tcp"
   239    }
   240  
   241    droplet_ids = ["${digitalocean_droplet.foobar.id}"]
   242  }`, rInt, rInt)
   243  }
   244  
   245  func testAccCheckDigitalOceanLoadbalancerConfig_updated(rInt int) string {
   246  	return fmt.Sprintf(`
   247  resource "digitalocean_droplet" "foobar" {
   248    name      = "foo-%d"
   249    size      = "512mb"
   250    image     = "centos-7-x64"
   251    region    = "nyc3"
   252  }
   253  
   254  resource "digitalocean_droplet" "foo" {
   255    name      = "foo-%d"
   256    size      = "512mb"
   257    image     = "centos-7-x64"
   258    region    = "nyc3"
   259  }
   260  
   261  resource "digitalocean_loadbalancer" "foobar" {
   262    name = "loadbalancer-%d"
   263    region = "nyc3"
   264  
   265    forwarding_rule {
   266      entry_port = 81
   267      entry_protocol = "http"
   268  
   269      target_port = 81
   270      target_protocol = "http"
   271    }
   272  
   273    healthcheck {
   274      port = 22
   275      protocol = "tcp"
   276    }
   277  
   278    droplet_ids = ["${digitalocean_droplet.foobar.id}","${digitalocean_droplet.foo.id}"]
   279  }`, rInt, rInt, rInt)
   280  }
   281  
   282  func testAccCheckDigitalOceanLoadbalancerConfig_dropletTag(rInt int) string {
   283  	return fmt.Sprintf(`
   284  resource "digitalocean_tag" "barbaz" {
   285    name = "sample"
   286  }
   287  
   288  resource "digitalocean_droplet" "foobar" {
   289    name      = "foo-%d"
   290    size      = "512mb"
   291    image     = "centos-7-x64"
   292    region    = "nyc3"
   293    tags = ["${digitalocean_tag.barbaz.id}"]
   294  }
   295  
   296  resource "digitalocean_loadbalancer" "foobar" {
   297    name = "loadbalancer-%d"
   298    region = "nyc3"
   299  
   300    forwarding_rule {
   301      entry_port = 80
   302      entry_protocol = "http"
   303  
   304      target_port = 80
   305      target_protocol = "http"
   306    }
   307  
   308    healthcheck {
   309      port = 22
   310      protocol = "tcp"
   311    }
   312  
   313    droplet_tag = "${digitalocean_tag.barbaz.name}"
   314  
   315    depends_on = ["digitalocean_droplet.foobar"]
   316  }`, rInt, rInt)
   317  }