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

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"regexp"
     6  	"strconv"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/aws/aws-sdk-go/aws"
    11  	"github.com/aws/aws-sdk-go/aws/awserr"
    12  	"github.com/aws/aws-sdk-go/service/lambda"
    13  	"github.com/hashicorp/terraform/helper/acctest"
    14  	"github.com/hashicorp/terraform/helper/resource"
    15  	"github.com/hashicorp/terraform/terraform"
    16  )
    17  
    18  func TestAccAWSLambdaEventSourceMapping_basic(t *testing.T) {
    19  	var conf lambda.EventSourceMappingConfiguration
    20  	rInt := acctest.RandInt()
    21  
    22  	resource.Test(t, resource.TestCase{
    23  		PreCheck:     func() { testAccPreCheck(t) },
    24  		Providers:    testAccProviders,
    25  		CheckDestroy: testAccCheckLambdaEventSourceMappingDestroy,
    26  		Steps: []resource.TestStep{
    27  			{
    28  				Config: testAccAWSLambdaEventSourceMappingConfig(rInt),
    29  				Check: resource.ComposeTestCheckFunc(
    30  					testAccCheckAwsLambdaEventSourceMappingExists("aws_lambda_event_source_mapping.lambda_event_source_mapping_test", &conf),
    31  					testAccCheckAWSLambdaEventSourceMappingAttributes(&conf),
    32  				),
    33  			},
    34  			{
    35  				Config: testAccAWSLambdaEventSourceMappingConfigUpdate(rInt),
    36  				Check: resource.ComposeTestCheckFunc(
    37  					testAccCheckAwsLambdaEventSourceMappingExists("aws_lambda_event_source_mapping.lambda_event_source_mapping_test", &conf),
    38  					resource.TestCheckResourceAttr("aws_lambda_event_source_mapping.lambda_event_source_mapping_test",
    39  						"batch_size",
    40  						strconv.Itoa(200)),
    41  					resource.TestCheckResourceAttr("aws_lambda_event_source_mapping.lambda_event_source_mapping_test",
    42  						"enabled",
    43  						strconv.FormatBool(false)),
    44  					resource.TestMatchResourceAttr(
    45  						"aws_lambda_event_source_mapping.lambda_event_source_mapping_test",
    46  						"function_arn",
    47  						regexp.MustCompile("example_lambda_name_update$"),
    48  					),
    49  				),
    50  			},
    51  		},
    52  	})
    53  }
    54  
    55  func TestAccAWSLambdaEventSourceMapping_importBasic(t *testing.T) {
    56  	resourceName := "aws_lambda_event_source_mapping.lambda_event_source_mapping_test"
    57  	rInt := acctest.RandInt()
    58  
    59  	resource.Test(t, resource.TestCase{
    60  		PreCheck:     func() { testAccPreCheck(t) },
    61  		Providers:    testAccProviders,
    62  		CheckDestroy: testAccCheckLambdaEventSourceMappingDestroy,
    63  		Steps: []resource.TestStep{
    64  			{
    65  				Config: testAccAWSLambdaEventSourceMappingConfig(rInt),
    66  			},
    67  
    68  			{
    69  				ResourceName:            resourceName,
    70  				ImportState:             true,
    71  				ImportStateVerify:       true,
    72  				ImportStateVerifyIgnore: []string{"enabled", "starting_position"},
    73  			},
    74  		},
    75  	})
    76  }
    77  
    78  func TestAccAWSLambdaEventSourceMapping_disappears(t *testing.T) {
    79  	var conf lambda.EventSourceMappingConfiguration
    80  
    81  	rInt := acctest.RandInt()
    82  
    83  	resource.Test(t, resource.TestCase{
    84  		PreCheck:     func() { testAccPreCheck(t) },
    85  		Providers:    testAccProviders,
    86  		CheckDestroy: testAccCheckLambdaEventSourceMappingDestroy,
    87  		Steps: []resource.TestStep{
    88  			{
    89  				Config: testAccAWSLambdaEventSourceMappingConfig(rInt),
    90  				Check: resource.ComposeTestCheckFunc(
    91  					testAccCheckAwsLambdaEventSourceMappingExists("aws_lambda_event_source_mapping.lambda_event_source_mapping_test", &conf),
    92  					testAccCheckAWSLambdaEventSourceMappingDisappears(&conf),
    93  				),
    94  				ExpectNonEmptyPlan: true,
    95  			},
    96  		},
    97  	})
    98  }
    99  
   100  func testAccCheckAWSLambdaEventSourceMappingDisappears(conf *lambda.EventSourceMappingConfiguration) resource.TestCheckFunc {
   101  	return func(s *terraform.State) error {
   102  		conn := testAccProvider.Meta().(*AWSClient).lambdaconn
   103  
   104  		params := &lambda.DeleteEventSourceMappingInput{
   105  			UUID: conf.UUID,
   106  		}
   107  
   108  		_, err := conn.DeleteEventSourceMapping(params)
   109  		if err != nil {
   110  			if err != nil {
   111  				return err
   112  			}
   113  		}
   114  
   115  		return resource.Retry(10*time.Minute, func() *resource.RetryError {
   116  			params := &lambda.GetEventSourceMappingInput{
   117  				UUID: conf.UUID,
   118  			}
   119  			_, err := conn.GetEventSourceMapping(params)
   120  			if err != nil {
   121  				cgw, ok := err.(awserr.Error)
   122  				if ok && cgw.Code() == "ResourceNotFoundException" {
   123  					return nil
   124  				}
   125  				return resource.NonRetryableError(
   126  					fmt.Errorf("Error retrieving Lambda Event Source Mapping: %s", err))
   127  			}
   128  			return resource.RetryableError(fmt.Errorf(
   129  				"Waiting for Lambda Event Source Mapping: %v", conf.UUID))
   130  		})
   131  	}
   132  }
   133  
   134  func testAccCheckLambdaEventSourceMappingDestroy(s *terraform.State) error {
   135  	conn := testAccProvider.Meta().(*AWSClient).lambdaconn
   136  
   137  	for _, rs := range s.RootModule().Resources {
   138  		if rs.Type != "aws_lambda_event_source_mapping" {
   139  			continue
   140  		}
   141  
   142  		_, err := conn.GetEventSourceMapping(&lambda.GetEventSourceMappingInput{
   143  			UUID: aws.String(rs.Primary.ID),
   144  		})
   145  
   146  		if err == nil {
   147  			return fmt.Errorf("Lambda event source mapping was not deleted")
   148  		}
   149  
   150  	}
   151  
   152  	return nil
   153  
   154  }
   155  
   156  func testAccCheckAwsLambdaEventSourceMappingExists(n string, mapping *lambda.EventSourceMappingConfiguration) resource.TestCheckFunc {
   157  	// Wait for IAM role
   158  	return func(s *terraform.State) error {
   159  		rs, ok := s.RootModule().Resources[n]
   160  		if !ok {
   161  			return fmt.Errorf("Lambda event source mapping not found: %s", n)
   162  		}
   163  
   164  		if rs.Primary.ID == "" {
   165  			return fmt.Errorf("Lambda event source mapping ID not set")
   166  		}
   167  
   168  		conn := testAccProvider.Meta().(*AWSClient).lambdaconn
   169  
   170  		params := &lambda.GetEventSourceMappingInput{
   171  			UUID: aws.String(rs.Primary.ID),
   172  		}
   173  
   174  		getSourceMappingConfiguration, err := conn.GetEventSourceMapping(params)
   175  		if err != nil {
   176  			return err
   177  		}
   178  
   179  		*mapping = *getSourceMappingConfiguration
   180  
   181  		return nil
   182  	}
   183  }
   184  
   185  func testAccCheckAWSLambdaEventSourceMappingAttributes(mapping *lambda.EventSourceMappingConfiguration) resource.TestCheckFunc {
   186  	return func(s *terraform.State) error {
   187  		uuid := *mapping.UUID
   188  		if uuid == "" {
   189  			return fmt.Errorf("Could not read Lambda event source mapping's UUID")
   190  		}
   191  
   192  		return nil
   193  	}
   194  }
   195  
   196  func testAccAWSLambdaEventSourceMappingConfig(rInt int) string {
   197  	return fmt.Sprintf(`
   198  resource "aws_iam_role" "iam_for_lambda" {
   199      name = "iam_for_lambda_%d"
   200      assume_role_policy = <<EOF
   201  {
   202    "Version": "2012-10-17",
   203    "Statement": [
   204      {
   205        "Action": "sts:AssumeRole",
   206        "Principal": {
   207          "Service": "lambda.amazonaws.com"
   208        },
   209        "Effect": "Allow",
   210        "Sid": ""
   211      }
   212    ]
   213  }
   214  EOF
   215  }
   216  
   217  resource "aws_iam_policy" "policy_for_role" {
   218      name = "policy_for_role_%d"
   219      path = "/"
   220      description = "IAM policy for for Lamda event mapping testing"
   221      policy = <<EOF
   222  {
   223    "Version": "2012-10-17",
   224    "Statement": [
   225        {
   226            "Effect": "Allow",
   227            "Action": [
   228              "kinesis:GetRecords",
   229              "kinesis:GetShardIterator",
   230              "kinesis:DescribeStream"
   231            ],
   232            "Resource": "*"
   233        },
   234        {
   235            "Effect": "Allow",
   236            "Action": [
   237              "kinesis:ListStreams"
   238            ],
   239            "Resource": "*"
   240        }
   241    ]
   242  }
   243  EOF
   244  }
   245  
   246  resource "aws_iam_policy_attachment" "policy_attachment_for_role" {
   247      name = "policy_attachment_for_role_%d"
   248      roles = ["${aws_iam_role.iam_for_lambda.name}"]
   249      policy_arn = "${aws_iam_policy.policy_for_role.arn}"
   250  }
   251  
   252  resource "aws_kinesis_stream" "kinesis_stream_test" {
   253      name = "kinesis_stream_test_%d"
   254      shard_count = 1
   255  }
   256  
   257  resource "aws_lambda_function" "lambda_function_test_create" {
   258      filename = "test-fixtures/lambdatest.zip"
   259      function_name = "%d_example_lambda_name_create"
   260      role = "${aws_iam_role.iam_for_lambda.arn}"
   261      handler = "exports.example"
   262      runtime = "nodejs4.3"
   263  }
   264  
   265  resource "aws_lambda_function" "lambda_function_test_update" {
   266      filename = "test-fixtures/lambdatest.zip"
   267      function_name = "%d_example_lambda_name_update"
   268      role = "${aws_iam_role.iam_for_lambda.arn}"
   269      handler = "exports.example"
   270      runtime = "nodejs4.3"
   271  }
   272  
   273  resource "aws_lambda_event_source_mapping" "lambda_event_source_mapping_test" {
   274  		batch_size = 100
   275  		event_source_arn = "${aws_kinesis_stream.kinesis_stream_test.arn}"
   276  		enabled = true
   277  		depends_on = ["aws_iam_policy_attachment.policy_attachment_for_role"]
   278  		function_name = "${aws_lambda_function.lambda_function_test_create.arn}"
   279  		starting_position = "TRIM_HORIZON"
   280  }`, rInt, rInt, rInt, rInt, rInt, rInt)
   281  }
   282  
   283  func testAccAWSLambdaEventSourceMappingConfigUpdate(rInt int) string {
   284  	return fmt.Sprintf(`
   285  resource "aws_iam_role" "iam_for_lambda" {
   286      name = "iam_for_lambda_%d"
   287      assume_role_policy = <<EOF
   288  {
   289    "Version": "2012-10-17",
   290    "Statement": [
   291      {
   292        "Action": "sts:AssumeRole",
   293        "Principal": {
   294          "Service": "lambda.amazonaws.com"
   295        },
   296        "Effect": "Allow",
   297        "Sid": ""
   298      }
   299    ]
   300  }
   301  EOF
   302  }
   303  
   304  resource "aws_iam_policy" "policy_for_role" {
   305      name = "policy_for_role_%d"
   306      path = "/"
   307      description = "IAM policy for for Lamda event mapping testing"
   308      policy = <<EOF
   309  {
   310    "Version": "2012-10-17",
   311    "Statement": [
   312        {
   313            "Effect": "Allow",
   314            "Action": [
   315              "kinesis:GetRecords",
   316              "kinesis:GetShardIterator",
   317              "kinesis:DescribeStream"
   318            ],
   319            "Resource": "*"
   320        },
   321        {
   322            "Effect": "Allow",
   323            "Action": [
   324              "kinesis:ListStreams"
   325            ],
   326            "Resource": "*"
   327        }
   328    ]
   329  }
   330  EOF
   331  }
   332  
   333  resource "aws_iam_policy_attachment" "policy_attachment_for_role" {
   334      name = "policy_attachment_for_role_%d"
   335      roles = ["${aws_iam_role.iam_for_lambda.name}"]
   336      policy_arn = "${aws_iam_policy.policy_for_role.arn}"
   337  }
   338  
   339  resource "aws_kinesis_stream" "kinesis_stream_test" {
   340      name = "kinesis_stream_test_%d"
   341      shard_count = 1
   342  }
   343  
   344  resource "aws_lambda_function" "lambda_function_test_create" {
   345      filename = "test-fixtures/lambdatest.zip"
   346      function_name = "%d_example_lambda_name_create"
   347      role = "${aws_iam_role.iam_for_lambda.arn}"
   348      handler = "exports.example"
   349      runtime = "nodejs4.3"
   350  }
   351  
   352  resource "aws_lambda_function" "lambda_function_test_update" {
   353      filename = "test-fixtures/lambdatest.zip"
   354      function_name = "%d_example_lambda_name_update"
   355      role = "${aws_iam_role.iam_for_lambda.arn}"
   356      handler = "exports.example"
   357      runtime = "nodejs4.3"
   358  }
   359  
   360  resource "aws_lambda_event_source_mapping" "lambda_event_source_mapping_test" {
   361  		batch_size = 200
   362  		event_source_arn = "${aws_kinesis_stream.kinesis_stream_test.arn}"
   363  		enabled = false
   364  		depends_on = ["aws_iam_policy_attachment.policy_attachment_for_role"]
   365  		function_name = "${aws_lambda_function.lambda_function_test_update.arn}"
   366  		starting_position = "TRIM_HORIZON"
   367  }`, rInt, rInt, rInt, rInt, rInt, rInt)
   368  }