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

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/aws/aws-sdk-go/aws"
     8  	"github.com/aws/aws-sdk-go/aws/awserr"
     9  	"github.com/aws/aws-sdk-go/service/rds"
    10  	"github.com/hashicorp/terraform/helper/acctest"
    11  	"github.com/hashicorp/terraform/helper/resource"
    12  	"github.com/hashicorp/terraform/terraform"
    13  )
    14  
    15  func TestAccAWSDBOptionGroup_basic(t *testing.T) {
    16  	var v rds.OptionGroup
    17  	rName := fmt.Sprintf("option-group-test-terraform-%s", acctest.RandString(5))
    18  
    19  	resource.Test(t, resource.TestCase{
    20  		PreCheck:     func() { testAccPreCheck(t) },
    21  		Providers:    testAccProviders,
    22  		CheckDestroy: testAccCheckAWSDBOptionGroupDestroy,
    23  		Steps: []resource.TestStep{
    24  			resource.TestStep{
    25  				Config: testAccAWSDBOptionGroupBasicConfig(rName),
    26  				Check: resource.ComposeTestCheckFunc(
    27  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
    28  					testAccCheckAWSDBOptionGroupAttributes(&v),
    29  					resource.TestCheckResourceAttr(
    30  						"aws_db_option_group.bar", "name", rName),
    31  				),
    32  			},
    33  		},
    34  	})
    35  }
    36  
    37  func TestAccAWSDBOptionGroup_OptionSettings(t *testing.T) {
    38  	var v rds.OptionGroup
    39  	rName := fmt.Sprintf("option-group-test-terraform-%s", acctest.RandString(5))
    40  
    41  	resource.Test(t, resource.TestCase{
    42  		PreCheck:     func() { testAccPreCheck(t) },
    43  		Providers:    testAccProviders,
    44  		CheckDestroy: testAccCheckAWSDBOptionGroupDestroy,
    45  		Steps: []resource.TestStep{
    46  			resource.TestStep{
    47  				Config: testAccAWSDBOptionGroupOptionSettings(rName),
    48  				Check: resource.ComposeTestCheckFunc(
    49  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
    50  					resource.TestCheckResourceAttr(
    51  						"aws_db_option_group.bar", "name", rName),
    52  					resource.TestCheckResourceAttr(
    53  						"aws_db_option_group.bar", "option.#", "1"),
    54  					resource.TestCheckResourceAttr(
    55  						"aws_db_option_group.bar", "option.961211605.option_settings.129825347.value", "UTC"),
    56  				),
    57  			},
    58  			resource.TestStep{
    59  				Config: testAccAWSDBOptionGroupOptionSettings_update(rName),
    60  				Check: resource.ComposeTestCheckFunc(
    61  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
    62  					resource.TestCheckResourceAttr(
    63  						"aws_db_option_group.bar", "name", rName),
    64  					resource.TestCheckResourceAttr(
    65  						"aws_db_option_group.bar", "option.#", "1"),
    66  					resource.TestCheckResourceAttr(
    67  						"aws_db_option_group.bar", "option.2422743510.option_settings.1350509764.value", "US/Pacific"),
    68  				),
    69  			},
    70  		},
    71  	})
    72  }
    73  
    74  func TestAccAWSDBOptionGroup_sqlServerOptionsUpdate(t *testing.T) {
    75  	var v rds.OptionGroup
    76  	rName := fmt.Sprintf("option-group-test-terraform-%s", acctest.RandString(5))
    77  
    78  	resource.Test(t, resource.TestCase{
    79  		PreCheck:     func() { testAccPreCheck(t) },
    80  		Providers:    testAccProviders,
    81  		CheckDestroy: testAccCheckAWSDBOptionGroupDestroy,
    82  		Steps: []resource.TestStep{
    83  			resource.TestStep{
    84  				Config: testAccAWSDBOptionGroupSqlServerEEOptions(rName),
    85  				Check: resource.ComposeTestCheckFunc(
    86  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
    87  					resource.TestCheckResourceAttr(
    88  						"aws_db_option_group.bar", "name", rName),
    89  				),
    90  			},
    91  
    92  			resource.TestStep{
    93  				Config: testAccAWSDBOptionGroupSqlServerEEOptions_update(rName),
    94  				Check: resource.ComposeTestCheckFunc(
    95  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
    96  					resource.TestCheckResourceAttr(
    97  						"aws_db_option_group.bar", "name", rName),
    98  					resource.TestCheckResourceAttr(
    99  						"aws_db_option_group.bar", "option.#", "1"),
   100  				),
   101  			},
   102  		},
   103  	})
   104  }
   105  
   106  func TestAccAWSDBOptionGroup_multipleOptions(t *testing.T) {
   107  	var v rds.OptionGroup
   108  	rName := fmt.Sprintf("option-group-test-terraform-%s", acctest.RandString(5))
   109  
   110  	resource.Test(t, resource.TestCase{
   111  		PreCheck:     func() { testAccPreCheck(t) },
   112  		Providers:    testAccProviders,
   113  		CheckDestroy: testAccCheckAWSDBOptionGroupDestroy,
   114  		Steps: []resource.TestStep{
   115  			resource.TestStep{
   116  				Config: testAccAWSDBOptionGroupMultipleOptions(rName),
   117  				Check: resource.ComposeTestCheckFunc(
   118  					testAccCheckAWSDBOptionGroupExists("aws_db_option_group.bar", &v),
   119  					resource.TestCheckResourceAttr(
   120  						"aws_db_option_group.bar", "name", rName),
   121  					resource.TestCheckResourceAttr(
   122  						"aws_db_option_group.bar", "option.#", "2"),
   123  				),
   124  			},
   125  		},
   126  	})
   127  }
   128  
   129  func testAccCheckAWSDBOptionGroupAttributes(v *rds.OptionGroup) resource.TestCheckFunc {
   130  	return func(s *terraform.State) error {
   131  
   132  		if *v.EngineName != "mysql" {
   133  			return fmt.Errorf("bad engine_name: %#v", *v.EngineName)
   134  		}
   135  
   136  		if *v.MajorEngineVersion != "5.6" {
   137  			return fmt.Errorf("bad major_engine_version: %#v", *v.MajorEngineVersion)
   138  		}
   139  
   140  		if *v.OptionGroupDescription != "Test option group for terraform" {
   141  			return fmt.Errorf("bad option_group_description: %#v", *v.OptionGroupDescription)
   142  		}
   143  
   144  		return nil
   145  	}
   146  }
   147  
   148  func TestResourceAWSDBOptionGroupName_validation(t *testing.T) {
   149  	cases := []struct {
   150  		Value    string
   151  		ErrCount int
   152  	}{
   153  		{
   154  			Value:    "testing123!",
   155  			ErrCount: 1,
   156  		},
   157  		{
   158  			Value:    "1testing123",
   159  			ErrCount: 1,
   160  		},
   161  		{
   162  			Value:    "testing--123",
   163  			ErrCount: 1,
   164  		},
   165  		{
   166  			Value:    "testing123-",
   167  			ErrCount: 1,
   168  		},
   169  		{
   170  			Value:    randomString(256),
   171  			ErrCount: 1,
   172  		},
   173  	}
   174  
   175  	for _, tc := range cases {
   176  		_, errors := validateDbOptionGroupName(tc.Value, "aws_db_option_group_name")
   177  
   178  		if len(errors) != tc.ErrCount {
   179  			t.Fatalf("Expected the DB Option Group Name to trigger a validation error")
   180  		}
   181  	}
   182  }
   183  
   184  func testAccCheckAWSDBOptionGroupExists(n string, v *rds.OptionGroup) resource.TestCheckFunc {
   185  	return func(s *terraform.State) error {
   186  		rs, ok := s.RootModule().Resources[n]
   187  		if !ok {
   188  			return fmt.Errorf("Not found: %s", n)
   189  		}
   190  
   191  		if rs.Primary.ID == "" {
   192  			return fmt.Errorf("No DB Option Group Name is set")
   193  		}
   194  
   195  		conn := testAccProvider.Meta().(*AWSClient).rdsconn
   196  
   197  		opts := rds.DescribeOptionGroupsInput{
   198  			OptionGroupName: aws.String(rs.Primary.ID),
   199  		}
   200  
   201  		resp, err := conn.DescribeOptionGroups(&opts)
   202  
   203  		if err != nil {
   204  			return err
   205  		}
   206  
   207  		if len(resp.OptionGroupsList) != 1 ||
   208  			*resp.OptionGroupsList[0].OptionGroupName != rs.Primary.ID {
   209  			return fmt.Errorf("DB Option Group not found")
   210  		}
   211  
   212  		*v = *resp.OptionGroupsList[0]
   213  
   214  		return nil
   215  	}
   216  }
   217  
   218  func testAccCheckAWSDBOptionGroupDestroy(s *terraform.State) error {
   219  	conn := testAccProvider.Meta().(*AWSClient).rdsconn
   220  
   221  	for _, rs := range s.RootModule().Resources {
   222  		if rs.Type != "aws_db_option_group" {
   223  			continue
   224  		}
   225  
   226  		resp, err := conn.DescribeOptionGroups(
   227  			&rds.DescribeOptionGroupsInput{
   228  				OptionGroupName: aws.String(rs.Primary.ID),
   229  			})
   230  
   231  		if err == nil {
   232  			if len(resp.OptionGroupsList) != 0 &&
   233  				*resp.OptionGroupsList[0].OptionGroupName == rs.Primary.ID {
   234  				return fmt.Errorf("DB Option Group still exists")
   235  			}
   236  		}
   237  
   238  		// Verify the error
   239  		newerr, ok := err.(awserr.Error)
   240  		if !ok {
   241  			return err
   242  		}
   243  		if newerr.Code() != "OptionGroupNotFoundFault" {
   244  			return err
   245  		}
   246  	}
   247  
   248  	return nil
   249  }
   250  
   251  func testAccAWSDBOptionGroupBasicConfig(r string) string {
   252  	return fmt.Sprintf(`
   253  resource "aws_db_option_group" "bar" {
   254    name                     = "%s"
   255    option_group_description = "Test option group for terraform"
   256    engine_name              = "mysql"
   257    major_engine_version     = "5.6"
   258  }
   259  `, r)
   260  }
   261  
   262  func testAccAWSDBOptionGroupOptionSettings(r string) string {
   263  	return fmt.Sprintf(`
   264  resource "aws_db_option_group" "bar" {
   265    name                     = "%s"
   266    option_group_description = "Test option group for terraform"
   267    engine_name              = "oracle-ee"
   268    major_engine_version     = "11.2"
   269  
   270    option {
   271      option_name = "Timezone"
   272      option_settings {
   273        name = "TIME_ZONE"
   274        value = "UTC"
   275      }
   276    }
   277  }
   278  `, r)
   279  }
   280  
   281  func testAccAWSDBOptionGroupOptionSettings_update(r string) string {
   282  	return fmt.Sprintf(`
   283  resource "aws_db_option_group" "bar" {
   284    name                     = "%s"
   285    option_group_description = "Test option group for terraform"
   286    engine_name              = "oracle-ee"
   287    major_engine_version     = "11.2"
   288  
   289    option {
   290      option_name = "Timezone"
   291      option_settings {
   292        name = "TIME_ZONE"
   293        value = "US/Pacific"
   294      }
   295    }
   296  }
   297  `, r)
   298  }
   299  
   300  func testAccAWSDBOptionGroupSqlServerEEOptions(r string) string {
   301  	return fmt.Sprintf(`
   302  resource "aws_db_option_group" "bar" {
   303    name                     = "%s"
   304    option_group_description = "Test option group for terraform"
   305    engine_name              = "sqlserver-ee"
   306    major_engine_version     = "11.00"
   307  }
   308  `, r)
   309  }
   310  
   311  func testAccAWSDBOptionGroupSqlServerEEOptions_update(r string) string {
   312  	return fmt.Sprintf(`
   313  resource "aws_db_option_group" "bar" {
   314    name                     = "%s"
   315    option_group_description = "Test option group for terraform"
   316    engine_name              = "sqlserver-ee"
   317    major_engine_version     = "11.00"
   318  
   319    option {
   320      option_name = "Mirroring"
   321    }
   322  }
   323  `, r)
   324  }
   325  
   326  func testAccAWSDBOptionGroupMultipleOptions(r string) string {
   327  	return fmt.Sprintf(`
   328  resource "aws_db_option_group" "bar" {
   329    name                     = "%s"
   330    option_group_description = "Test option group for terraform"
   331    engine_name              = "oracle-se"
   332    major_engine_version     = "11.2"
   333  
   334    option {
   335      option_name = "STATSPACK"
   336    }
   337  
   338    option {
   339      option_name = "XMLDB"
   340    }
   341  }
   342  `, r)
   343  }