github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/aws/resource_aws_cloudwatch_log_group_test.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"regexp"
     6  	"testing"
     7  
     8  	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
     9  	"github.com/hashicorp/terraform/helper/acctest"
    10  	"github.com/hashicorp/terraform/helper/resource"
    11  	"github.com/hashicorp/terraform/terraform"
    12  )
    13  
    14  func TestAccAWSCloudWatchLogGroup_basic(t *testing.T) {
    15  	var lg cloudwatchlogs.LogGroup
    16  	rInt := acctest.RandInt()
    17  
    18  	resource.Test(t, resource.TestCase{
    19  		PreCheck:     func() { testAccPreCheck(t) },
    20  		Providers:    testAccProviders,
    21  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    22  		Steps: []resource.TestStep{
    23  			{
    24  				Config: testAccAWSCloudWatchLogGroupConfig(rInt),
    25  				Check: resource.ComposeTestCheckFunc(
    26  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    27  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "0"),
    28  				),
    29  			},
    30  		},
    31  	})
    32  }
    33  
    34  func TestAccAWSCloudWatchLogGroup_namePrefix(t *testing.T) {
    35  	var lg cloudwatchlogs.LogGroup
    36  
    37  	resource.Test(t, resource.TestCase{
    38  		PreCheck:     func() { testAccPreCheck(t) },
    39  		Providers:    testAccProviders,
    40  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    41  		Steps: []resource.TestStep{
    42  			{
    43  				Config: testAccAWSCloudWatchLogGroup_namePrefix,
    44  				Check: resource.ComposeTestCheckFunc(
    45  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.test", &lg),
    46  					resource.TestMatchResourceAttr("aws_cloudwatch_log_group.test", "name", regexp.MustCompile("^tf-test-")),
    47  				),
    48  			},
    49  		},
    50  	})
    51  }
    52  
    53  func TestAccAWSCloudWatchLogGroup_generatedName(t *testing.T) {
    54  	var lg cloudwatchlogs.LogGroup
    55  
    56  	resource.Test(t, resource.TestCase{
    57  		PreCheck:     func() { testAccPreCheck(t) },
    58  		Providers:    testAccProviders,
    59  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    60  		Steps: []resource.TestStep{
    61  			{
    62  				Config: testAccAWSCloudWatchLogGroup_generatedName,
    63  				Check: resource.ComposeTestCheckFunc(
    64  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.test", &lg),
    65  				),
    66  			},
    67  		},
    68  	})
    69  }
    70  
    71  func TestAccAWSCloudWatchLogGroup_retentionPolicy(t *testing.T) {
    72  	var lg cloudwatchlogs.LogGroup
    73  	rInt := acctest.RandInt()
    74  
    75  	resource.Test(t, resource.TestCase{
    76  		PreCheck:     func() { testAccPreCheck(t) },
    77  		Providers:    testAccProviders,
    78  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    79  		Steps: []resource.TestStep{
    80  			{
    81  				Config: testAccAWSCloudWatchLogGroupConfig_withRetention(rInt),
    82  				Check: resource.ComposeTestCheckFunc(
    83  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    84  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "365"),
    85  				),
    86  			},
    87  			{
    88  				Config: testAccAWSCloudWatchLogGroupConfigModified_withRetention(rInt),
    89  				Check: resource.ComposeTestCheckFunc(
    90  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    91  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "0"),
    92  				),
    93  			},
    94  		},
    95  	})
    96  }
    97  
    98  func TestAccAWSCloudWatchLogGroup_multiple(t *testing.T) {
    99  	var lg cloudwatchlogs.LogGroup
   100  	rInt := acctest.RandInt()
   101  
   102  	resource.Test(t, resource.TestCase{
   103  		PreCheck:     func() { testAccPreCheck(t) },
   104  		Providers:    testAccProviders,
   105  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
   106  		Steps: []resource.TestStep{
   107  			{
   108  				Config: testAccAWSCloudWatchLogGroupConfig_multiple(rInt),
   109  				Check: resource.ComposeTestCheckFunc(
   110  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.alpha", &lg),
   111  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.alpha", "retention_in_days", "14"),
   112  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.beta", &lg),
   113  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.beta", "retention_in_days", "0"),
   114  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.charlie", &lg),
   115  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.charlie", "retention_in_days", "3653"),
   116  				),
   117  			},
   118  		},
   119  	})
   120  }
   121  
   122  func TestAccAWSCloudWatchLogGroup_disappears(t *testing.T) {
   123  	var lg cloudwatchlogs.LogGroup
   124  	rInt := acctest.RandInt()
   125  
   126  	resource.Test(t, resource.TestCase{
   127  		PreCheck:     func() { testAccPreCheck(t) },
   128  		Providers:    testAccProviders,
   129  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
   130  		Steps: []resource.TestStep{
   131  			{
   132  				Config: testAccAWSCloudWatchLogGroupConfig(rInt),
   133  				Check: resource.ComposeTestCheckFunc(
   134  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
   135  					testAccCheckCloudWatchLogGroupDisappears(&lg),
   136  				),
   137  				ExpectNonEmptyPlan: true,
   138  			},
   139  		},
   140  	})
   141  }
   142  
   143  func TestAccAWSCloudWatchLogGroup_tagging(t *testing.T) {
   144  	var lg cloudwatchlogs.LogGroup
   145  	rInt := acctest.RandInt()
   146  
   147  	resource.Test(t, resource.TestCase{
   148  		PreCheck:     func() { testAccPreCheck(t) },
   149  		Providers:    testAccProviders,
   150  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
   151  		Steps: []resource.TestStep{
   152  			{
   153  				Config: testAccAWSCloudWatchLogGroupConfigWithTags(rInt),
   154  				Check: resource.ComposeTestCheckFunc(
   155  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
   156  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.%", "3"),
   157  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Environment", "Production"),
   158  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Foo", "Bar"),
   159  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Empty", ""),
   160  				),
   161  			},
   162  			{
   163  				Config: testAccAWSCloudWatchLogGroupConfigWithTagsAdded(rInt),
   164  				Check: resource.ComposeTestCheckFunc(
   165  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
   166  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.%", "4"),
   167  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Environment", "Development"),
   168  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Foo", "Bar"),
   169  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Empty", ""),
   170  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Bar", "baz"),
   171  				),
   172  			},
   173  			{
   174  				Config: testAccAWSCloudWatchLogGroupConfigWithTagsUpdated(rInt),
   175  				Check: resource.ComposeTestCheckFunc(
   176  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
   177  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.%", "4"),
   178  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Environment", "Development"),
   179  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Empty", "NotEmpty"),
   180  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Foo", "UpdatedBar"),
   181  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Bar", "baz"),
   182  				),
   183  			},
   184  			{
   185  				Config: testAccAWSCloudWatchLogGroupConfigWithTags(rInt),
   186  				Check: resource.ComposeTestCheckFunc(
   187  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
   188  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.%", "3"),
   189  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Environment", "Production"),
   190  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Foo", "Bar"),
   191  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "tags.Empty", ""),
   192  				),
   193  			},
   194  		},
   195  	})
   196  }
   197  
   198  func testAccCheckCloudWatchLogGroupDisappears(lg *cloudwatchlogs.LogGroup) resource.TestCheckFunc {
   199  	return func(s *terraform.State) error {
   200  		conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   201  		opts := &cloudwatchlogs.DeleteLogGroupInput{
   202  			LogGroupName: lg.LogGroupName,
   203  		}
   204  		if _, err := conn.DeleteLogGroup(opts); err != nil {
   205  			return err
   206  		}
   207  		return nil
   208  	}
   209  }
   210  
   211  func testAccCheckCloudWatchLogGroupExists(n string, lg *cloudwatchlogs.LogGroup) resource.TestCheckFunc {
   212  	return func(s *terraform.State) error {
   213  		rs, ok := s.RootModule().Resources[n]
   214  		if !ok {
   215  			return fmt.Errorf("Not found: %s", n)
   216  		}
   217  
   218  		conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   219  		logGroup, exists, err := lookupCloudWatchLogGroup(conn, rs.Primary.ID, nil)
   220  		if err != nil {
   221  			return err
   222  		}
   223  		if !exists {
   224  			return fmt.Errorf("Bad: LogGroup %q does not exist", rs.Primary.ID)
   225  		}
   226  
   227  		*lg = *logGroup
   228  
   229  		return nil
   230  	}
   231  }
   232  
   233  func testAccCheckAWSCloudWatchLogGroupDestroy(s *terraform.State) error {
   234  	conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   235  
   236  	for _, rs := range s.RootModule().Resources {
   237  		if rs.Type != "aws_cloudwatch_log_group" {
   238  			continue
   239  		}
   240  		_, exists, err := lookupCloudWatchLogGroup(conn, rs.Primary.ID, nil)
   241  		if err != nil {
   242  			return nil
   243  		}
   244  
   245  		if exists {
   246  			return fmt.Errorf("Bad: LogGroup still exists: %q", rs.Primary.ID)
   247  		}
   248  
   249  	}
   250  
   251  	return nil
   252  }
   253  
   254  func testAccAWSCloudWatchLogGroupConfig(rInt int) string {
   255  	return fmt.Sprintf(`
   256  resource "aws_cloudwatch_log_group" "foobar" {
   257      name = "foo-bar-%d"
   258  }
   259  `, rInt)
   260  }
   261  
   262  func testAccAWSCloudWatchLogGroupConfigWithTags(rInt int) string {
   263  	return fmt.Sprintf(`
   264  resource "aws_cloudwatch_log_group" "foobar" {
   265      name = "foo-bar-%d"
   266  
   267      tags {
   268      	Environment = "Production"
   269      	Foo = "Bar"
   270      	Empty = ""
   271      }
   272  }
   273  `, rInt)
   274  }
   275  
   276  func testAccAWSCloudWatchLogGroupConfigWithTagsAdded(rInt int) string {
   277  	return fmt.Sprintf(`
   278  resource "aws_cloudwatch_log_group" "foobar" {
   279      name = "foo-bar-%d"
   280  
   281      tags {
   282      	Environment = "Development"
   283      	Foo = "Bar"
   284      	Empty = ""
   285      	Bar = "baz"
   286      }
   287  }
   288  `, rInt)
   289  }
   290  
   291  func testAccAWSCloudWatchLogGroupConfigWithTagsUpdated(rInt int) string {
   292  	return fmt.Sprintf(`
   293  resource "aws_cloudwatch_log_group" "foobar" {
   294      name = "foo-bar-%d"
   295  
   296      tags {
   297      	Environment = "Development"
   298      	Foo = "UpdatedBar"
   299      	Empty = "NotEmpty"
   300      	Bar = "baz"
   301      }
   302  }
   303  `, rInt)
   304  }
   305  
   306  func testAccAWSCloudWatchLogGroupConfigWithTagsRemoval(rInt int) string {
   307  	return fmt.Sprintf(`
   308  resource "aws_cloudwatch_log_group" "foobar" {
   309      name = "foo-bar-%d"
   310  
   311      tags {
   312      	Environment = "Production"
   313      	Foo = "Bar"
   314      	Empty = ""
   315      }
   316  }
   317  `, rInt)
   318  }
   319  
   320  func testAccAWSCloudWatchLogGroupConfig_withRetention(rInt int) string {
   321  	return fmt.Sprintf(`
   322  resource "aws_cloudwatch_log_group" "foobar" {
   323      name = "foo-bar-%d"
   324      retention_in_days = 365
   325  }
   326  `, rInt)
   327  }
   328  
   329  func testAccAWSCloudWatchLogGroupConfigModified_withRetention(rInt int) string {
   330  	return fmt.Sprintf(`
   331  resource "aws_cloudwatch_log_group" "foobar" {
   332      name = "foo-bar-%d"
   333  }
   334  `, rInt)
   335  }
   336  
   337  func testAccAWSCloudWatchLogGroupConfig_multiple(rInt int) string {
   338  	return fmt.Sprintf(`
   339  resource "aws_cloudwatch_log_group" "alpha" {
   340      name = "foo-bar-%d"
   341      retention_in_days = 14
   342  }
   343  resource "aws_cloudwatch_log_group" "beta" {
   344      name = "foo-bar-%d"
   345  }
   346  resource "aws_cloudwatch_log_group" "charlie" {
   347      name = "foo-bar-%d"
   348      retention_in_days = 3653
   349  }
   350  `, rInt, rInt+1, rInt+2)
   351  }
   352  
   353  const testAccAWSCloudWatchLogGroup_namePrefix = `
   354  resource "aws_cloudwatch_log_group" "test" {
   355      name_prefix = "tf-test-"
   356  }
   357  `
   358  
   359  const testAccAWSCloudWatchLogGroup_generatedName = `
   360  resource "aws_cloudwatch_log_group" "test" {}
   361  `