github.com/ojiry/terraform@v0.8.2-0.20161218223921-e50cec712c4a/builtin/providers/aws/resource_aws_cloudwatch_log_group_test.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
     8  	"github.com/hashicorp/terraform/helper/acctest"
     9  	"github.com/hashicorp/terraform/helper/resource"
    10  	"github.com/hashicorp/terraform/terraform"
    11  )
    12  
    13  func TestAccAWSCloudWatchLogGroup_basic(t *testing.T) {
    14  	var lg cloudwatchlogs.LogGroup
    15  	rInt := acctest.RandInt()
    16  
    17  	resource.Test(t, resource.TestCase{
    18  		PreCheck:     func() { testAccPreCheck(t) },
    19  		Providers:    testAccProviders,
    20  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    21  		Steps: []resource.TestStep{
    22  			resource.TestStep{
    23  				Config: testAccAWSCloudWatchLogGroupConfig(rInt),
    24  				Check: resource.ComposeTestCheckFunc(
    25  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    26  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "0"),
    27  				),
    28  			},
    29  		},
    30  	})
    31  }
    32  
    33  func TestAccAWSCloudWatchLogGroup_retentionPolicy(t *testing.T) {
    34  	var lg cloudwatchlogs.LogGroup
    35  	rInt := acctest.RandInt()
    36  
    37  	resource.Test(t, resource.TestCase{
    38  		PreCheck:     func() { testAccPreCheck(t) },
    39  		Providers:    testAccProviders,
    40  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    41  		Steps: []resource.TestStep{
    42  			resource.TestStep{
    43  				Config: testAccAWSCloudWatchLogGroupConfig_withRetention(rInt),
    44  				Check: resource.ComposeTestCheckFunc(
    45  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    46  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "365"),
    47  				),
    48  			},
    49  			resource.TestStep{
    50  				Config: testAccAWSCloudWatchLogGroupConfigModified_withRetention(rInt),
    51  				Check: resource.ComposeTestCheckFunc(
    52  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    53  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.foobar", "retention_in_days", "0"),
    54  				),
    55  			},
    56  		},
    57  	})
    58  }
    59  
    60  func TestAccAWSCloudWatchLogGroup_multiple(t *testing.T) {
    61  	var lg cloudwatchlogs.LogGroup
    62  	rInt := acctest.RandInt()
    63  
    64  	resource.Test(t, resource.TestCase{
    65  		PreCheck:     func() { testAccPreCheck(t) },
    66  		Providers:    testAccProviders,
    67  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    68  		Steps: []resource.TestStep{
    69  			resource.TestStep{
    70  				Config: testAccAWSCloudWatchLogGroupConfig_multiple(rInt),
    71  				Check: resource.ComposeTestCheckFunc(
    72  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.alpha", &lg),
    73  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.alpha", "retention_in_days", "14"),
    74  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.beta", &lg),
    75  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.beta", "retention_in_days", "0"),
    76  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.charlie", &lg),
    77  					resource.TestCheckResourceAttr("aws_cloudwatch_log_group.charlie", "retention_in_days", "3653"),
    78  				),
    79  			},
    80  		},
    81  	})
    82  }
    83  
    84  func TestAccAWSCloudWatchLogGroup_disappears(t *testing.T) {
    85  	var lg cloudwatchlogs.LogGroup
    86  	rInt := acctest.RandInt()
    87  
    88  	resource.Test(t, resource.TestCase{
    89  		PreCheck:     func() { testAccPreCheck(t) },
    90  		Providers:    testAccProviders,
    91  		CheckDestroy: testAccCheckAWSCloudWatchLogGroupDestroy,
    92  		Steps: []resource.TestStep{
    93  			resource.TestStep{
    94  				Config: testAccAWSCloudWatchLogGroupConfig(rInt),
    95  				Check: resource.ComposeTestCheckFunc(
    96  					testAccCheckCloudWatchLogGroupExists("aws_cloudwatch_log_group.foobar", &lg),
    97  					testAccCheckCloudWatchLogGroupDisappears(&lg),
    98  				),
    99  				ExpectNonEmptyPlan: true,
   100  			},
   101  		},
   102  	})
   103  }
   104  
   105  func testAccCheckCloudWatchLogGroupDisappears(lg *cloudwatchlogs.LogGroup) resource.TestCheckFunc {
   106  	return func(s *terraform.State) error {
   107  		conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   108  		opts := &cloudwatchlogs.DeleteLogGroupInput{
   109  			LogGroupName: lg.LogGroupName,
   110  		}
   111  		if _, err := conn.DeleteLogGroup(opts); err != nil {
   112  			return err
   113  		}
   114  		return nil
   115  	}
   116  }
   117  
   118  func testAccCheckCloudWatchLogGroupExists(n string, lg *cloudwatchlogs.LogGroup) resource.TestCheckFunc {
   119  	return func(s *terraform.State) error {
   120  		rs, ok := s.RootModule().Resources[n]
   121  		if !ok {
   122  			return fmt.Errorf("Not found: %s", n)
   123  		}
   124  
   125  		conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   126  		logGroup, exists, err := lookupCloudWatchLogGroup(conn, rs.Primary.ID, nil)
   127  		if err != nil {
   128  			return err
   129  		}
   130  		if !exists {
   131  			return fmt.Errorf("Bad: LogGroup %q does not exist", rs.Primary.ID)
   132  		}
   133  
   134  		*lg = *logGroup
   135  
   136  		return nil
   137  	}
   138  }
   139  
   140  func testAccCheckAWSCloudWatchLogGroupDestroy(s *terraform.State) error {
   141  	conn := testAccProvider.Meta().(*AWSClient).cloudwatchlogsconn
   142  
   143  	for _, rs := range s.RootModule().Resources {
   144  		if rs.Type != "aws_cloudwatch_log_group" {
   145  			continue
   146  		}
   147  		_, exists, err := lookupCloudWatchLogGroup(conn, rs.Primary.ID, nil)
   148  		if err != nil {
   149  			return nil
   150  		}
   151  
   152  		if exists {
   153  			return fmt.Errorf("Bad: LogGroup still exists: %q", rs.Primary.ID)
   154  		}
   155  
   156  	}
   157  
   158  	return nil
   159  }
   160  
   161  func testAccAWSCloudWatchLogGroupConfig(rInt int) string {
   162  	return fmt.Sprintf(`
   163  resource "aws_cloudwatch_log_group" "foobar" {
   164      name = "foo-bar-%d"
   165  }
   166  `, rInt)
   167  }
   168  
   169  func testAccAWSCloudWatchLogGroupConfig_withRetention(rInt int) string {
   170  	return fmt.Sprintf(`
   171  resource "aws_cloudwatch_log_group" "foobar" {
   172      name = "foo-bar-%d"
   173      retention_in_days = 365
   174  }
   175  `, rInt)
   176  }
   177  
   178  func testAccAWSCloudWatchLogGroupConfigModified_withRetention(rInt int) string {
   179  	return fmt.Sprintf(`
   180  resource "aws_cloudwatch_log_group" "foobar" {
   181      name = "foo-bar-%d"
   182  }
   183  `, rInt)
   184  }
   185  
   186  func testAccAWSCloudWatchLogGroupConfig_multiple(rInt int) string {
   187  	return fmt.Sprintf(`
   188  resource "aws_cloudwatch_log_group" "alpha" {
   189      name = "foo-bar-%d"
   190      retention_in_days = 14
   191  }
   192  resource "aws_cloudwatch_log_group" "beta" {
   193      name = "foo-bar-%d"
   194  }
   195  resource "aws_cloudwatch_log_group" "charlie" {
   196      name = "foo-bar-%d"
   197      retention_in_days = 3653
   198  }
   199  `, rInt, rInt, rInt)
   200  }