github.com/adrian-bl/terraform@v0.7.0-rc2.0.20160705220747-de0a34fc3517/builtin/providers/aws/resource_aws_rds_cluster_test.go (about)

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