github.com/subuk/terraform@v0.6.14-0.20160317140351-de1567c2e732/builtin/providers/aws/resource_aws_rds_cluster_test.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"math/rand"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/hashicorp/terraform/helper/resource"
    10  	"github.com/hashicorp/terraform/terraform"
    11  
    12  	"github.com/aws/aws-sdk-go/aws"
    13  	"github.com/aws/aws-sdk-go/aws/awserr"
    14  	"github.com/aws/aws-sdk-go/service/rds"
    15  )
    16  
    17  func TestAccAWSRDSCluster_basic(t *testing.T) {
    18  	var v rds.DBCluster
    19  
    20  	ri := rand.New(rand.NewSource(time.Now().UnixNano())).Int()
    21  	config := fmt.Sprintf(testAccAWSClusterConfig, ri)
    22  
    23  	resource.Test(t, resource.TestCase{
    24  		PreCheck:     func() { testAccPreCheck(t) },
    25  		Providers:    testAccProviders,
    26  		CheckDestroy: testAccCheckAWSClusterDestroy,
    27  		Steps: []resource.TestStep{
    28  			resource.TestStep{
    29  				Config: config,
    30  				Check: resource.ComposeTestCheckFunc(
    31  					testAccCheckAWSClusterExists("aws_rds_cluster.default", &v),
    32  					resource.TestCheckResourceAttr(
    33  						"aws_rds_cluster.default", "storage_encrypted", "false"),
    34  				),
    35  			},
    36  		},
    37  	})
    38  }
    39  
    40  func TestAccAWSRDSCluster_encrypted(t *testing.T) {
    41  	var v rds.DBCluster
    42  
    43  	ri := rand.New(rand.NewSource(time.Now().UnixNano())).Int()
    44  	encConfig := fmt.Sprintf(testAccAWSClusterConfig_encrypted, ri)
    45  
    46  	resource.Test(t, resource.TestCase{
    47  		PreCheck:     func() { testAccPreCheck(t) },
    48  		Providers:    testAccProviders,
    49  		CheckDestroy: testAccCheckAWSClusterDestroy,
    50  		Steps: []resource.TestStep{
    51  			resource.TestStep{
    52  				Config: encConfig,
    53  				Check: resource.ComposeTestCheckFunc(
    54  					testAccCheckAWSClusterExists("aws_rds_cluster.default", &v),
    55  					resource.TestCheckResourceAttr(
    56  						"aws_rds_cluster.default", "storage_encrypted", "true"),
    57  				),
    58  			},
    59  		},
    60  	})
    61  }
    62  
    63  func TestAccAWSRDSCluster_backupsUpdate(t *testing.T) {
    64  	var v rds.DBCluster
    65  
    66  	ri := rand.New(rand.NewSource(time.Now().UnixNano())).Int()
    67  	preConfig := fmt.Sprintf(testAccAWSClusterConfig_backups, ri)
    68  	postConfig := fmt.Sprintf(testAccAWSClusterConfig_backupsUpdate, ri)
    69  
    70  	resource.Test(t, resource.TestCase{
    71  		PreCheck:     func() { testAccPreCheck(t) },
    72  		Providers:    testAccProviders,
    73  		CheckDestroy: testAccCheckAWSClusterDestroy,
    74  		Steps: []resource.TestStep{
    75  			resource.TestStep{
    76  				Config: preConfig,
    77  				Check: resource.ComposeTestCheckFunc(
    78  					testAccCheckAWSClusterExists("aws_rds_cluster.default", &v),
    79  					resource.TestCheckResourceAttr(
    80  						"aws_rds_cluster.default", "preferred_backup_window", "07:00-09:00"),
    81  					resource.TestCheckResourceAttr(
    82  						"aws_rds_cluster.default", "backup_retention_period", "5"),
    83  					resource.TestCheckResourceAttr(
    84  						"aws_rds_cluster.default", "preferred_maintenance_window", "tue:04:00-tue:04:30"),
    85  				),
    86  			},
    87  
    88  			resource.TestStep{
    89  				Config: postConfig,
    90  				Check: resource.ComposeTestCheckFunc(
    91  					testAccCheckAWSClusterExists("aws_rds_cluster.default", &v),
    92  					resource.TestCheckResourceAttr(
    93  						"aws_rds_cluster.default", "preferred_backup_window", "03:00-09:00"),
    94  					resource.TestCheckResourceAttr(
    95  						"aws_rds_cluster.default", "backup_retention_period", "10"),
    96  					resource.TestCheckResourceAttr(
    97  						"aws_rds_cluster.default", "preferred_maintenance_window", "wed:01:00-wed:01:30"),
    98  				),
    99  			},
   100  		},
   101  	})
   102  }
   103  
   104  func testAccCheckAWSClusterDestroy(s *terraform.State) error {
   105  	for _, rs := range s.RootModule().Resources {
   106  		if rs.Type != "aws_rds_cluster" {
   107  			continue
   108  		}
   109  
   110  		// Try to find the Group
   111  		conn := testAccProvider.Meta().(*AWSClient).rdsconn
   112  		var err error
   113  		resp, err := conn.DescribeDBClusters(
   114  			&rds.DescribeDBClustersInput{
   115  				DBClusterIdentifier: aws.String(rs.Primary.ID),
   116  			})
   117  
   118  		if err == nil {
   119  			if len(resp.DBClusters) != 0 &&
   120  				*resp.DBClusters[0].DBClusterIdentifier == rs.Primary.ID {
   121  				return fmt.Errorf("DB Cluster %s still exists", rs.Primary.ID)
   122  			}
   123  		}
   124  
   125  		// Return nil if the cluster is already destroyed
   126  		if awsErr, ok := err.(awserr.Error); ok {
   127  			if awsErr.Code() == "DBClusterNotFoundFault" {
   128  				return nil
   129  			}
   130  		}
   131  
   132  		return err
   133  	}
   134  
   135  	return nil
   136  }
   137  
   138  func testAccCheckAWSClusterExists(n string, v *rds.DBCluster) resource.TestCheckFunc {
   139  	return func(s *terraform.State) error {
   140  		rs, ok := s.RootModule().Resources[n]
   141  		if !ok {
   142  			return fmt.Errorf("Not found: %s", n)
   143  		}
   144  
   145  		if rs.Primary.ID == "" {
   146  			return fmt.Errorf("No DB Instance ID is set")
   147  		}
   148  
   149  		conn := testAccProvider.Meta().(*AWSClient).rdsconn
   150  		resp, err := conn.DescribeDBClusters(&rds.DescribeDBClustersInput{
   151  			DBClusterIdentifier: aws.String(rs.Primary.ID),
   152  		})
   153  
   154  		if err != nil {
   155  			return err
   156  		}
   157  
   158  		for _, c := range resp.DBClusters {
   159  			if *c.DBClusterIdentifier == rs.Primary.ID {
   160  				*v = *c
   161  				return nil
   162  			}
   163  		}
   164  
   165  		return fmt.Errorf("DB Cluster (%s) not found", rs.Primary.ID)
   166  	}
   167  }
   168  
   169  var testAccAWSClusterConfig = `
   170  resource "aws_rds_cluster" "default" {
   171    cluster_identifier = "tf-aurora-cluster-%d"
   172    availability_zones = ["us-west-2a","us-west-2b","us-west-2c"]
   173    database_name = "mydb"
   174    master_username = "foo"
   175    master_password = "mustbeeightcharaters"
   176  }`
   177  
   178  var testAccAWSClusterConfig_encrypted = `
   179  resource "aws_rds_cluster" "default" {
   180    cluster_identifier = "tf-aurora-cluster-%d"
   181    availability_zones = ["us-west-2a","us-west-2b","us-west-2c"]
   182    database_name = "mydb"
   183    master_username = "foo"
   184    master_password = "mustbeeightcharaters"
   185    storage_encrypted = true
   186  }`
   187  
   188  var testAccAWSClusterConfig_backups = `
   189  resource "aws_rds_cluster" "default" {
   190    cluster_identifier = "tf-aurora-cluster-%d"
   191    availability_zones = ["us-west-2a","us-west-2b","us-west-2c"]
   192    database_name = "mydb"
   193    master_username = "foo"
   194    master_password = "mustbeeightcharaters"
   195    backup_retention_period = 5
   196    preferred_backup_window = "07:00-09:00"
   197    preferred_maintenance_window = "tue:04:00-tue:04:30"
   198  }`
   199  
   200  var testAccAWSClusterConfig_backupsUpdate = `
   201  resource "aws_rds_cluster" "default" {
   202    cluster_identifier = "tf-aurora-cluster-%d"
   203    availability_zones = ["us-west-2a","us-west-2b","us-west-2c"]
   204    database_name = "mydb"
   205    master_username = "foo"
   206    master_password = "mustbeeightcharaters"
   207    backup_retention_period = 10
   208    preferred_backup_window = "03:00-09:00"
   209    preferred_maintenance_window = "wed:01:00-wed:01:30"
   210    apply_immediately = true
   211  }`