Add support for Api Gateway method request validators.

aws/provider.go

@@ -239,6 +239,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_api_gateway_method_response":              resourceAwsApiGatewayMethodResponse(),
 			"aws_api_gateway_method_settings":              resourceAwsApiGatewayMethodSettings(),
 			"aws_api_gateway_model":                        resourceAwsApiGatewayModel(),
+			"aws_api_gateway_request_validator":            resourceAwsApiGatewayRequestValidator(),
 			"aws_api_gateway_resource":                     resourceAwsApiGatewayResource(),
 			"aws_api_gateway_rest_api":                     resourceAwsApiGatewayRestApi(),
 			"aws_api_gateway_stage":                        resourceAwsApiGatewayStage(),

aws/resource_aws_api_gateway_method.go

@@ -76,6 +76,11 @@ func resourceAwsApiGatewayMethod() *schema.Resource {
 				ConflictsWith: []string{"request_parameters"},
 				Deprecated:    "Use field request_parameters instead",
 			},
+
+			"request_validator_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
 		},
 	}
 }
@@ -121,6 +126,10 @@ func resourceAwsApiGatewayMethodCreate(d *schema.ResourceData, meta interface{})
 		input.AuthorizerId = aws.String(v.(string))
 	}
 
+	if v, ok := d.GetOk("request_validator_id"); ok {
+		input.RequestValidatorId = aws.String(v.(string))
+	}
+
 	_, err := conn.PutMethod(&input)
 	if err != nil {
 		return fmt.Errorf("Error creating API Gateway Method: %s", err)
@@ -156,6 +165,7 @@ func resourceAwsApiGatewayMethodRead(d *schema.ResourceData, meta interface{}) e
 	d.Set("authorization_type", out.AuthorizationType)
 	d.Set("authorizer_id", out.AuthorizerId)
 	d.Set("request_models", aws.StringValueMap(out.RequestModels))
+	d.Set("request_validator_id", out.RequestValidatorId)
 
 	return nil
 }
@@ -226,6 +236,22 @@ func resourceAwsApiGatewayMethodUpdate(d *schema.ResourceData, meta interface{})
 		})
 	}
 
+	if d.HasChange("request_validator_id") {
+		var request_validator_id *string
+		if v, ok := d.GetOk("request_validator_id"); ok {
+			// requestValidatorId cannot be an empty string; it must either be nil
+			// or it must have some value. Otherwise, updating fails.
+			if s := v.(string); len(s) > 0 {
+				request_validator_id = &s
+			}
+		}
+		operations = append(operations, &apigateway.PatchOperation{
+			Op:    aws.String("replace"),
+			Path:  aws.String("/requestValidatorId"),
+			Value: request_validator_id,
+		})
+	}
+
 	method, err := conn.UpdateMethod(&apigateway.UpdateMethodInput{
 		HttpMethod:      aws.String(d.Get("http_method").(string)),
 		ResourceId:      aws.String(d.Get("resource_id").(string)),

aws/resource_aws_api_gateway_method_test.go

@@ -87,6 +87,44 @@ func TestAccAWSAPIGatewayMethod_customauthorizer(t *testing.T) {
 	})
 }
 
+func TestAccAWSAPIGatewayMethod_customrequestvalidator(t *testing.T) {
+	var conf apigateway.Method
+	rInt := acctest.RandInt()
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAWSAPIGatewayMethodDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAWSAPIGatewayMethodConfigWithCustomRequestValidator(rInt),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAWSAPIGatewayMethodExists("aws_api_gateway_method.test", &conf),
+					testAccCheckAWSAPIGatewayMethodAttributes(&conf),
+					resource.TestCheckResourceAttr(
+						"aws_api_gateway_method.test", "http_method", "GET"),
+					resource.TestCheckResourceAttr(
+						"aws_api_gateway_method.test", "authorization", "NONE"),
+					resource.TestCheckResourceAttr(
+						"aws_api_gateway_method.test", "request_models.application/json", "Error"),
+					resource.TestMatchResourceAttr(
+						"aws_api_gateway_method.test", "request_validator_id", regexp.MustCompile("^[a-z0-9]{6}$")),
+				),
+			},
+
+			{
+				Config: testAccAWSAPIGatewayMethodConfigWithCustomRequestValidatorUpdate(rInt),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAWSAPIGatewayMethodExists("aws_api_gateway_method.test", &conf),
+					testAccCheckAWSAPIGatewayMethodAttributesUpdate(&conf),
+					resource.TestCheckResourceAttr(
+						"aws_api_gateway_method.test", "request_validator_id", ""),
+				),
+			},
+		},
+	})
+}
+
 func testAccCheckAWSAPIGatewayMethodAttributes(conf *apigateway.Method) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		if *conf.HttpMethod != "GET" {
@@ -357,3 +395,76 @@ resource "aws_api_gateway_method" "test" {
 }
 `, rInt)
 }
+
+func testAccAWSAPIGatewayMethodConfigWithCustomRequestValidator(rInt int) string {
+	return fmt.Sprintf(`
+resource "aws_api_gateway_rest_api" "test" {
+  name = "tf-acc-test-apig-method-custom-req-validator-%d"
+}
+
+resource "aws_api_gateway_resource" "test" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  parent_id = "${aws_api_gateway_rest_api.test.root_resource_id}"
+  path_part = "test"
+}
+
+resource "aws_api_gateway_request_validator" "validator" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  name = "paramsValidator"
+  validate_request_parameters = true
+}
+
+resource "aws_api_gateway_method" "test" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  resource_id = "${aws_api_gateway_resource.test.id}"
+  http_method = "GET"
+  authorization = "NONE"
+
+  request_models = {
+    "application/json" = "Error"
+  }
+
+  request_parameters = {
+    "method.request.header.Content-Type" = false,
+	  "method.request.querystring.page" = true
+  }
+
+  request_validator_id = "${aws_api_gateway_request_validator.validator.id}"
+}
+`, rInt)
+}
+
+func testAccAWSAPIGatewayMethodConfigWithCustomRequestValidatorUpdate(rInt int) string {
+	return fmt.Sprintf(`
+resource "aws_api_gateway_rest_api" "test" {
+  name = "tf-acc-test-apig-method-custom-req-validator-%d"
+}
+
+resource "aws_api_gateway_resource" "test" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  parent_id = "${aws_api_gateway_rest_api.test.root_resource_id}"
+  path_part = "test"
+}
+
+resource "aws_api_gateway_request_validator" "validator" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  name = "paramsValidator"
+  validate_request_parameters = true
+}
+
+resource "aws_api_gateway_method" "test" {
+  rest_api_id = "${aws_api_gateway_rest_api.test.id}"
+  resource_id = "${aws_api_gateway_resource.test.id}"
+  http_method = "GET"
+  authorization = "NONE"
+
+  request_models = {
+    "application/json" = "Error"
+  }
+
+  request_parameters = {
+	  "method.request.querystring.page" = false
+  }
+}
+`, rInt)
+}

aws/resource_aws_api_gateway_request_validator.go

@@ -0,0 +1,154 @@
+package aws
+
+import (
+	"fmt"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/service/apigateway"
+	"github.com/hashicorp/terraform/helper/schema"
+	"log"
+	"strings"
+)
+
+func resourceAwsApiGatewayRequestValidator() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsApiGatewayRequestValidatorCreate,
+		Read:   resourceAwsApiGatewayRequestValidatorRead,
+		Update: resourceAwsApiGatewayRequestValidatorUpdate,
+		Delete: resourceAwsApiGatewayRequestValidatorDelete,
+
+		Schema: map[string]*schema.Schema{
+			"rest_api_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"validate_request_body": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  false,
+			},
+
+			"validate_request_parameters": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  false,
+			},
+		},
+	}
+}
+
+func resourceAwsApiGatewayRequestValidatorCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).apigateway
+
+	input := apigateway.CreateRequestValidatorInput{
+		Name:                      aws.String(d.Get("name").(string)),
+		RestApiId:                 aws.String(d.Get("rest_api_id").(string)),
+		ValidateRequestBody:       aws.Bool(d.Get("validate_request_body").(bool)),
+		ValidateRequestParameters: aws.Bool(d.Get("validate_request_parameters").(bool)),
+	}
+
+	out, err := conn.CreateRequestValidator(&input)
+	if err != nil {
+		return fmt.Errorf("Error creating Request Validator: %s", err)
+	}
+
+	d.SetId(*out.Id)
+
+	return nil
+}
+
+func resourceAwsApiGatewayRequestValidatorRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).apigateway
+
+	input := apigateway.GetRequestValidatorInput{
+		RequestValidatorId: aws.String(d.Id()),
+		RestApiId:          aws.String(d.Get("rest_api_id").(string)),
+	}
+
+	out, err := conn.GetRequestValidator(&input)
+	if err != nil {
+		if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == apigateway.ErrCodeNotFoundException {
+			d.SetId("")
+			return nil
+		}
+		return err
+	}
+
+	d.Set("name", out.Name)
+	d.Set("validate_request_body", out.ValidateRequestBody)
+	d.Set("validate_request_parameters", out.ValidateRequestParameters)
+
+	return nil
+}
+
+func resourceAwsApiGatewayRequestValidatorUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).apigateway
+	log.Printf("[DEBUG] Updating Request Validator %s", d.Id())
+
+	operations := make([]*apigateway.PatchOperation, 0)
+
+	if d.HasChange("name") {
+		operations = append(operations, &apigateway.PatchOperation{
+			Op:    aws.String("replace"),
+			Path:  aws.String("/name"),
+			Value: aws.String(d.Get("name").(string)),
+		})
+	}
+
+	if d.HasChange("validate_request_body") {
+		operations = append(operations, &apigateway.PatchOperation{
+			Op:    aws.String("replace"),
+			Path:  aws.String("/validateRequestBody"),
+			Value: aws.String(fmt.Sprintf("%t", d.Get("validate_request_body").(bool))),
+		})
+	}
+
+	if d.HasChange("validate_request_parameters") {
+		operations = append(operations, &apigateway.PatchOperation{
+			Op:    aws.String("replace"),
+			Path:  aws.String("/validateRequestParameters"),
+			Value: aws.String(fmt.Sprintf("%t", d.Get("validate_request_parameters").(bool))),
+		})
+	}
+
+	input := apigateway.UpdateRequestValidatorInput{
+		RequestValidatorId: aws.String(d.Id()),
+		RestApiId:          aws.String(d.Get("rest_api_id").(string)),
+		PatchOperations:    operations,
+	}
+
+	_, err := conn.UpdateRequestValidator(&input)
+	if err != nil {
+		return err
+	}
+
+	log.Printf("[DEBUG] Updated Request Validator %s", d.Id())
+
+	return resourceAwsApiGatewayRequestValidatorRead(d, meta)
+}
+
+func resourceAwsApiGatewayRequestValidatorDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).apigateway
+	log.Printf("[DEBUG] Deleting Request Validator %s", d.Id())
+
+	_, err := conn.DeleteRequestValidator(&apigateway.DeleteRequestValidatorInput{
+		RequestValidatorId: aws.String(d.Id()),
+		RestApiId:          aws.String(d.Get("rest_api_id").(string)),
+	})
+	if err != nil {
+		// XXX: Figure out a way to delete the method that depends on the request validator first
+		// otherwise the validator will be dangling until the API is deleted
+		if !strings.Contains(err.Error(), apigateway.ErrCodeConflictException) {
+			return fmt.Errorf("Deleting Request Validator failed: %s", err)
+		}
+	}
+
+	return nil
+}