github.com/daveadams/terraform@v0.6.4-0.20160830094355-13ce74975936/builtin/providers/aws/resource_aws_sqs_queue_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/sqs"
    10  	"github.com/hashicorp/terraform/helper/acctest"
    11  	"github.com/hashicorp/terraform/helper/resource"
    12  	"github.com/hashicorp/terraform/terraform"
    13  )
    14  
    15  func TestAccAWSSQSQueue_basic(t *testing.T) {
    16  	queueName := fmt.Sprintf("sqs-queue-%s", acctest.RandString(5))
    17  	resource.Test(t, resource.TestCase{
    18  		PreCheck:     func() { testAccPreCheck(t) },
    19  		Providers:    testAccProviders,
    20  		CheckDestroy: testAccCheckAWSSQSQueueDestroy,
    21  		Steps: []resource.TestStep{
    22  			resource.TestStep{
    23  				Config: testAccAWSSQSConfigWithDefaults(queueName),
    24  				Check: resource.ComposeTestCheckFunc(
    25  					testAccCheckAWSSQSExistsWithDefaults("aws_sqs_queue.queue"),
    26  				),
    27  			},
    28  			resource.TestStep{
    29  				Config: testAccAWSSQSConfigWithOverrides(queueName),
    30  				Check: resource.ComposeTestCheckFunc(
    31  					testAccCheckAWSSQSExistsWithOverrides("aws_sqs_queue.queue"),
    32  				),
    33  			},
    34  			resource.TestStep{
    35  				Config: testAccAWSSQSConfigWithDefaults(queueName),
    36  				Check: resource.ComposeTestCheckFunc(
    37  					testAccCheckAWSSQSExistsWithDefaults("aws_sqs_queue.queue"),
    38  				),
    39  			},
    40  		},
    41  	})
    42  }
    43  
    44  func TestAccAWSSQSQueue_redrivePolicy(t *testing.T) {
    45  	resource.Test(t, resource.TestCase{
    46  		PreCheck:     func() { testAccPreCheck(t) },
    47  		Providers:    testAccProviders,
    48  		CheckDestroy: testAccCheckAWSSQSQueueDestroy,
    49  		Steps: []resource.TestStep{
    50  			resource.TestStep{
    51  				Config: testAccAWSSQSConfigWithRedrive(acctest.RandStringFromCharSet(5, acctest.CharSetAlpha)),
    52  				Check: resource.ComposeTestCheckFunc(
    53  					testAccCheckAWSSQSExistsWithDefaults("aws_sqs_queue.my_dead_letter_queue"),
    54  				),
    55  			},
    56  		},
    57  	})
    58  }
    59  
    60  // Tests formatting and compacting of Policy, Redrive json
    61  func TestAccAWSSQSQueue_Policybasic(t *testing.T) {
    62  	resource.Test(t, resource.TestCase{
    63  		PreCheck:     func() { testAccPreCheck(t) },
    64  		Providers:    testAccProviders,
    65  		CheckDestroy: testAccCheckAWSSQSQueueDestroy,
    66  		Steps: []resource.TestStep{
    67  			resource.TestStep{
    68  				Config: testAccAWSSQSConfig_PolicyFormat,
    69  				Check: resource.ComposeTestCheckFunc(
    70  					testAccCheckAWSSQSExistsWithOverrides("aws_sqs_queue.test-email-events"),
    71  				),
    72  			},
    73  		},
    74  	})
    75  }
    76  
    77  func testAccCheckAWSSQSQueueDestroy(s *terraform.State) error {
    78  	conn := testAccProvider.Meta().(*AWSClient).sqsconn
    79  
    80  	for _, rs := range s.RootModule().Resources {
    81  		if rs.Type != "aws_sqs_queue" {
    82  			continue
    83  		}
    84  
    85  		// Check if queue exists by checking for its attributes
    86  		params := &sqs.GetQueueAttributesInput{
    87  			QueueUrl: aws.String(rs.Primary.ID),
    88  		}
    89  		_, err := conn.GetQueueAttributes(params)
    90  		if err == nil {
    91  			return fmt.Errorf("Queue %s still exists. Failing!", rs.Primary.ID)
    92  		}
    93  
    94  		// Verify the error is what we want
    95  		_, ok := err.(awserr.Error)
    96  		if !ok {
    97  			return err
    98  		}
    99  	}
   100  
   101  	return nil
   102  }
   103  
   104  func testAccCheckAWSSQSExistsWithDefaults(n string) resource.TestCheckFunc {
   105  	return func(s *terraform.State) error {
   106  		rs, ok := s.RootModule().Resources[n]
   107  		if !ok {
   108  			return fmt.Errorf("Not found: %s", n)
   109  		}
   110  
   111  		if rs.Primary.ID == "" {
   112  			return fmt.Errorf("No Queue URL specified!")
   113  		}
   114  
   115  		conn := testAccProvider.Meta().(*AWSClient).sqsconn
   116  
   117  		params := &sqs.GetQueueAttributesInput{
   118  			QueueUrl:       aws.String(rs.Primary.ID),
   119  			AttributeNames: []*string{aws.String("All")},
   120  		}
   121  		resp, err := conn.GetQueueAttributes(params)
   122  
   123  		if err != nil {
   124  			return err
   125  		}
   126  
   127  		// checking if attributes are defaults
   128  		for k, v := range resp.Attributes {
   129  			if k == "VisibilityTimeout" && *v != "30" {
   130  				return fmt.Errorf("VisibilityTimeout (%s) was not set to 30", *v)
   131  			}
   132  
   133  			if k == "MessageRetentionPeriod" && *v != "345600" {
   134  				return fmt.Errorf("MessageRetentionPeriod (%s) was not set to 345600", *v)
   135  			}
   136  
   137  			if k == "MaximumMessageSize" && *v != "262144" {
   138  				return fmt.Errorf("MaximumMessageSize (%s) was not set to 262144", *v)
   139  			}
   140  
   141  			if k == "DelaySeconds" && *v != "0" {
   142  				return fmt.Errorf("DelaySeconds (%s) was not set to 0", *v)
   143  			}
   144  
   145  			if k == "ReceiveMessageWaitTimeSeconds" && *v != "0" {
   146  				return fmt.Errorf("ReceiveMessageWaitTimeSeconds (%s) was not set to 0", *v)
   147  			}
   148  		}
   149  
   150  		return nil
   151  	}
   152  }
   153  
   154  func testAccCheckAWSSQSExistsWithOverrides(n string) resource.TestCheckFunc {
   155  	return func(s *terraform.State) error {
   156  		rs, ok := s.RootModule().Resources[n]
   157  		if !ok {
   158  			return fmt.Errorf("Not found: %s", n)
   159  		}
   160  
   161  		if rs.Primary.ID == "" {
   162  			return fmt.Errorf("No Queue URL specified!")
   163  		}
   164  
   165  		conn := testAccProvider.Meta().(*AWSClient).sqsconn
   166  
   167  		params := &sqs.GetQueueAttributesInput{
   168  			QueueUrl:       aws.String(rs.Primary.ID),
   169  			AttributeNames: []*string{aws.String("All")},
   170  		}
   171  		resp, err := conn.GetQueueAttributes(params)
   172  
   173  		if err != nil {
   174  			return err
   175  		}
   176  
   177  		// checking if attributes match our overrides
   178  		for k, v := range resp.Attributes {
   179  			if k == "VisibilityTimeout" && *v != "60" {
   180  				return fmt.Errorf("VisibilityTimeout (%s) was not set to 60", *v)
   181  			}
   182  
   183  			if k == "MessageRetentionPeriod" && *v != "86400" {
   184  				return fmt.Errorf("MessageRetentionPeriod (%s) was not set to 86400", *v)
   185  			}
   186  
   187  			if k == "MaximumMessageSize" && *v != "2048" {
   188  				return fmt.Errorf("MaximumMessageSize (%s) was not set to 2048", *v)
   189  			}
   190  
   191  			if k == "DelaySeconds" && *v != "90" {
   192  				return fmt.Errorf("DelaySeconds (%s) was not set to 90", *v)
   193  			}
   194  
   195  			if k == "ReceiveMessageWaitTimeSeconds" && *v != "10" {
   196  				return fmt.Errorf("ReceiveMessageWaitTimeSeconds (%s) was not set to 10", *v)
   197  			}
   198  		}
   199  
   200  		return nil
   201  	}
   202  }
   203  
   204  func testAccAWSSQSConfigWithDefaults(r string) string {
   205  	return fmt.Sprintf(`
   206  resource "aws_sqs_queue" "queue" {
   207      name = "%s"
   208  }
   209  `, r)
   210  }
   211  
   212  func testAccAWSSQSConfigWithOverrides(r string) string {
   213  	return fmt.Sprintf(`
   214  resource "aws_sqs_queue" "queue" {
   215    name                       = "%s"
   216    delay_seconds              = 90
   217    max_message_size           = 2048
   218    message_retention_seconds  = 86400
   219    receive_wait_time_seconds  = 10
   220    visibility_timeout_seconds = 60
   221  }`, r)
   222  }
   223  
   224  func testAccAWSSQSConfigWithRedrive(name string) string {
   225  	return fmt.Sprintf(`
   226  resource "aws_sqs_queue" "my_queue" {
   227    name                       = "tftestqueuq-%s"
   228    delay_seconds              = 0
   229    visibility_timeout_seconds = 300
   230  
   231    redrive_policy = <<EOF
   232  {
   233      "maxReceiveCount": 3,
   234      "deadLetterTargetArn": "${aws_sqs_queue.my_dead_letter_queue.arn}"
   235  }
   236  EOF
   237  }
   238  
   239  resource "aws_sqs_queue" "my_dead_letter_queue" {
   240    name = "tfotherqueuq-%s"
   241  }
   242  `, name, name)
   243  }
   244  
   245  const testAccAWSSQSConfig_PolicyFormat = `
   246  variable "sns_name" {
   247    default = "tf-test-name-2"
   248  }
   249  
   250  variable "sqs_name" {
   251    default = "tf-test-sqs-name-2"
   252  }
   253  
   254  resource "aws_sns_topic" "test_topic" {
   255    name = "${var.sns_name}"
   256  }
   257  
   258  resource "aws_sqs_queue" "test-email-events" {
   259    name                       = "${var.sqs_name}"
   260    depends_on                 = ["aws_sns_topic.test_topic"]
   261    delay_seconds              = 90
   262    max_message_size           = 2048
   263    message_retention_seconds  = 86400
   264    receive_wait_time_seconds  = 10
   265    visibility_timeout_seconds = 60
   266  
   267    policy = <<EOF
   268  {
   269    "Version": "2012-10-17",
   270    "Id": "sqspolicy",
   271    "Statement": [
   272      {
   273        "Sid": "Stmt1451501026839",
   274        "Effect": "Allow",
   275        "Principal": "*",
   276        "Action": "sqs:SendMessage",
   277        "Resource": "arn:aws:sqs:us-west-2:470663696735:${var.sqs_name}",
   278        "Condition": {
   279          "ArnEquals": {
   280            "aws:SourceArn": "arn:aws:sns:us-west-2:470663696735:${var.sns_name}"
   281          }
   282        }
   283      }
   284    ]
   285  }
   286  EOF
   287  }
   288  
   289  resource "aws_sns_topic_subscription" "test_queue_target" {
   290    topic_arn = "${aws_sns_topic.test_topic.arn}"
   291    protocol  = "sqs"
   292    endpoint  = "${aws_sqs_queue.test-email-events.arn}"
   293  }
   294  `