Merge pull request #5 from gruntwork-io/rename-apply-options

Rename apply_options to terratest_options

Author: brikis98

apply.go

@@ -10,33 +10,33 @@ import (
 
 // Apply handles all setup required for a Terraform Apply operation but does not perform a destroy operation or do any cleanup.
 // The caller of this function is expected to call Destroy to clean up the Terraform template when done.
-func Apply(ao *ApplyOptions) (string, error) {
-	logger := log.NewLogger(ao.TestName)
+func Apply(options *TerratestOptions) (string, error) {
+	logger := log.NewLogger(options.TestName)
 	var output string
 
 	// SETUP
 	// Configure terraform to use Remote State.
-	err := aws.AssertS3BucketExists(ao.TfRemoteStateS3BucketRegion, ao.TfRemoteStateS3BucketName)
+	err := aws.AssertS3BucketExists(options.TfRemoteStateS3BucketRegion, options.TfRemoteStateS3BucketName)
 	if err != nil {
-		return output, fmt.Errorf("Test failed because the S3 Bucket '%s' does not exist in the '%s' region.\n", ao.TfRemoteStateS3BucketName, ao.TfRemoteStateS3BucketRegion)
+		return output, fmt.Errorf("Test failed because the S3 Bucket '%s' does not exist in the '%s' region.\n", options.TfRemoteStateS3BucketName, options.TfRemoteStateS3BucketRegion)
 	}
 
-	terraform.ConfigureRemoteState(ao.TemplatePath, ao.TfRemoteStateS3BucketName, ao.getTfStateFileName(), ao.TfRemoteStateS3BucketRegion, logger)
+	terraform.ConfigureRemoteState(options.TemplatePath, options.TfRemoteStateS3BucketName, options.getTfStateFileName(), options.TfRemoteStateS3BucketRegion, logger)
 
 	// TERRAFORM APPLY
 	// Download all the Terraform modules
 	logger.Println("Running terraform get...")
-	err = terraform.Get(ao.TemplatePath, logger)
+	err = terraform.Get(options.TemplatePath, logger)
 	if err != nil {
 		return output, fmt.Errorf("Failed to call terraform get successfully: %s\n", err.Error())
 	}
 
 	// Apply the Terraform template
 	logger.Println("Running terraform apply...")
-	if len(ao.RetryableTerraformErrors) > 0 {
-		output, err = terraform.ApplyAndGetOutputWithRetry(ao.TemplatePath, ao.Vars, ao.RetryableTerraformErrors, logger)
+	if len(options.RetryableTerraformErrors) > 0 {
+		output, err = terraform.ApplyAndGetOutputWithRetry(options.TemplatePath, options.Vars, options.RetryableTerraformErrors, logger)
 	} else {
-		output, err = terraform.ApplyAndGetOutput(ao.TemplatePath, ao.Vars, logger)
+		output, err = terraform.ApplyAndGetOutput(options.TemplatePath, options.Vars, logger)
 	}
 	if err != nil {
 		return output, fmt.Errorf("Failed to terraform apply: %s\n", err.Error())

apply_and_destroy.go

@@ -1,7 +1,7 @@
 package terratest
 
 // ApplyAndDestroy wraps all setup and teardown required for a Terraform Apply operation. It returns the output of the terraform operations.
-func ApplyAndDestroy(ao *ApplyOptions) (string, error) {
-	defer destroyHelper(ao, ao.getTfStateFileName())
-	return Apply(ao)
+func ApplyAndDestroy(options *TerratestOptions) (string, error) {
+	defer destroyHelper(options, options.getTfStateFileName())
+	return Apply(options)
 }

aws/region.go

@@ -11,7 +11,8 @@ import (
 
 func GetGloballyForbiddenRegions() []string {
 	return []string{
-		"us-west-2",
+		"us-west-2",		// Josh is using this region for his personal projects
+		"ap-northeast-2",	// This region seems to be running out of t2.micro instances with gp2 volumes
 	}
 }
 

destroy.go

@@ -8,16 +8,16 @@ import (
 )
 
 // Destroy both destroys all the given elements of the RandomResourceCollection and calls terraform destroy.
-func Destroy(ao *ApplyOptions, rand *RandomResourceCollection) (string, error) {
-	logger := log.NewLogger(ao.TestName)
+func Destroy(options *TerratestOptions, rand *RandomResourceCollection) (string, error) {
+	logger := log.NewLogger(options.TestName)
 
 	err := rand.DestroyResources()
 	if err != nil {
 		return "", fmt.Errorf("Failed to destroy random resource collection: %s", err.Error())
 	}
 
 	logger.Println("Running terraform destroy...")
-	output, err := destroyHelper(ao, ao.getTfStateFileName())
+	output, err := destroyHelper(options, options.getTfStateFileName())
 	if err != nil {
 		return output, fmt.Errorf("Failed to terraform destroy: %s", err.Error())
 	}
@@ -26,9 +26,9 @@ func Destroy(ao *ApplyOptions, rand *RandomResourceCollection) (string, error) {
 }
 
 // Helper function that calls terraform destroy
-func destroyHelper(ao *ApplyOptions, remoteStateS3ObjectName string) (string, error) {
-	logger := log.NewLogger(ao.TestName)
-	output, err := terraform.DestroyAndGetOutput(ao.TemplatePath, ao.Vars, logger)
+func destroyHelper(options *TerratestOptions, remoteStateS3ObjectName string) (string, error) {
+	logger := log.NewLogger(options.TestName)
+	output, err := terraform.DestroyAndGetOutput(options.TemplatePath, options.Vars, logger)
 	if err != nil {
 		logger.Printf(`Failed to terraform destroy.
 ** WARNING ** Terraform destroy has failed which means you must manually delete any resources created by the "terraform apply" run.
@@ -37,7 +37,7 @@ Terraform Template Path: %s
 AWS Region: <scroll up to see it>
 Remote State Location: s3://%s/%s
 Official Error Message: %s
-`, ao.TemplatePath, ao.TestName, ao.TfRemoteStateS3BucketName, remoteStateS3ObjectName, err.Error())
+`, options.TemplatePath, options.TestName, options.TfRemoteStateS3BucketName, remoteStateS3ObjectName, err.Error())
 		return output, err
 	}
 

output.go

@@ -5,7 +5,7 @@ import (
 	"github.com/gruntwork-io/terratest/log"
 )
 
-func Output(ao *ApplyOptions, key string) (string, error) {
-	logger := log.NewLogger(ao.TestName)
-	return terraform.Output(ao.TemplatePath, key, logger)
+func Output(options *TerratestOptions, key string) (string, error) {
+	logger := log.NewLogger(options.TestName)
+	return terraform.Output(options.TemplatePath, key, logger)
 }

apply_options.go terratest_options.goapply_options.go renamed to terratest_options.go

@@ -1,7 +1,7 @@
 package terratest
 
 // The options to be passed into any terratest.Apply or Destroy function
-type ApplyOptions struct {
+type TerratestOptions struct {
 	UniqueId		    string	      // A unique identifier for this terraform run.
 	TestName                    string            // the name of the test to run, for logging purposes.
 	TemplatePath                string            // the relative or absolute path to the terraform template to be applied.
@@ -12,15 +12,15 @@ type ApplyOptions struct {
 }
 
 // Initialize an ApplyOptions struct with default values
-func NewApplyOptions() *ApplyOptions {
-	return &ApplyOptions{
+func NewTerratestOptions() *TerratestOptions {
+	return &TerratestOptions{
 		TfRemoteStateS3BucketName: defaultTfRemoteStateS3BucketName,
 		TfRemoteStateS3BucketRegion: defaultTfRemoteStateS3BuckeRegion,
 	}
 }
 
-// generateTfStateFileName creates a path and filename used to reference a terraform tfstate file. E.g. this is
+// getTfStateFileName creates a path and filename used to reference a terraform tfstate file. E.g. this is
 // useful with S3 for deciding where the tfstate file should be within a given bucket.
-func (ao *ApplyOptions) getTfStateFileName() string {
-	return ao.UniqueId + "/terraform.tfstate"
+func (options *TerratestOptions) getTfStateFileName() string {
+	return options.UniqueId + "/terraform.tfstate"
 }

terratest_test.go

@@ -49,13 +49,13 @@ func TestTerraformApplyOnMinimalExample(t *testing.T) {
 	vars["ec2_instance_name"] = rand.UniqueId
 	vars["ec2_image"] = rand.AmiId
 
-	ao := NewApplyOptions()
-	ao.UniqueId = rand.UniqueId
-	ao.TestName = "Test - TestTerraformApplyOnMinimalExample"
-	ao.TemplatePath = path.Join(fixtureDir, "minimal-example")
-	ao.Vars = vars
+	options := NewTerratestOptions()
+	options.UniqueId = rand.UniqueId
+	options.TestName = "Test - TestTerraformApplyOnMinimalExample"
+	options.TemplatePath = path.Join(fixtureDir, "minimal-example")
+	options.Vars = vars
 
-	_, err = ApplyAndDestroy(ao)
+	_, err = ApplyAndDestroy(options)
 	if err != nil {
 		t.Fatalf("Failed to ApplyAndDestroy: %s", err.Error())
 	}
@@ -77,13 +77,13 @@ func TestApplyOrDestroyFailsOnTerraformError(t *testing.T) {
 	vars["ec2_instance_name"] = rand.UniqueId
 	vars["ec2_image"] = rand.AmiId
 
-	ao := NewApplyOptions()
-	ao.UniqueId = rand.UniqueId
-	ao.TestName = "Test - TestApplyOrDestroyFailsOnTerraformError"
-	ao.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
-	ao.Vars = vars
+	options := NewTerratestOptions()
+	options.UniqueId = rand.UniqueId
+	options.TestName = "Test - TestApplyOrDestroyFailsOnTerraformError"
+	options.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
+	options.Vars = vars
 
-	_, err = ApplyAndDestroy(ao)
+	_, err = ApplyAndDestroy(options)
 	if err != nil {
 		fmt.Printf("Received expected failure message: %s. Continuing on...", err.Error())
 	} else {
@@ -109,15 +109,15 @@ func TestTerraformApplyOnMinimalExampleWithRetryableErrorMessages(t *testing.T)
 	vars["ec2_instance_name"] = rand.UniqueId
 	vars["ec2_image"] = rand.AmiId
 
-	ao := NewApplyOptions()
-	ao.UniqueId = rand.UniqueId
-	ao.TestName = "Test - TestTerraformApplyOnMinimalExampleWithRetryableErrorMessages"
-	ao.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
-	ao.Vars = vars
-	ao.RetryableTerraformErrors = make(map[string]string)
-	ao.RetryableTerraformErrors["aws_instance.demo: Error launching source instance: InvalidKeyPair.NotFound"] = "This error was deliberately added to the template."
+	options := NewTerratestOptions()
+	options.UniqueId = rand.UniqueId
+	options.TestName = "Test - TestTerraformApplyOnMinimalExampleWithRetryableErrorMessages"
+	options.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
+	options.Vars = vars
+	options.RetryableTerraformErrors = make(map[string]string)
+	options.RetryableTerraformErrors["aws_instance.demo: Error launching source instance: InvalidKeyPair.NotFound"] = "This error was deliberately added to the template."
 
-	output, err := ApplyAndDestroy(ao)
+	output, err := ApplyAndDestroy(options)
 	if err != nil {
 		if strings.Contains(output, "**TERRAFORM-RETRY**") {
 			fmt.Println("Expected error was caught and a retry was attempted.")
@@ -147,15 +147,15 @@ func TestTerraformApplyOnMinimalExampleWithRetryableErrorMessagesDoesNotRetry(t
 	vars["ec2_instance_name"] = rand.UniqueId
 	vars["ec2_image"] = rand.AmiId
 
-	ao := NewApplyOptions()
-	ao.UniqueId = rand.UniqueId
-	ao.TestName = "Test - TestTerraformApplyOnMinimalExampleWithRetryableErrorMessagesDoesNotRetry"
-	ao.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
-	ao.Vars = vars
-	ao.RetryableTerraformErrors = make(map[string]string)
-	ao.RetryableTerraformErrors["I'm a message that shouldn't show up in the output"] = ""
+	options := NewTerratestOptions()
+	options.UniqueId = rand.UniqueId
+	options.TestName = "Test - TestTerraformApplyOnMinimalExampleWithRetryableErrorMessagesDoesNotRetry"
+	options.TemplatePath = path.Join(fixtureDir, "minimal-example-with-error")
+	options.Vars = vars
+	options.RetryableTerraformErrors = make(map[string]string)
+	options.RetryableTerraformErrors["I'm a message that shouldn't show up in the output"] = ""
 
-	output, err := ApplyAndDestroy(ao)
+	output, err := ApplyAndDestroy(options)
 	if err != nil {
 		if strings.Contains(output, "**TERRAFORM-RETRY**") {
 			t.Fatalf("Expected no terraform retry but instead a retry was attempted.")
@@ -196,13 +196,13 @@ func TestTerraformApplyAvoidsForbiddenRegion(t *testing.T) {
 	vars["ec2_instance_name"] = rand.UniqueId
 	vars["ec2_image"] = rand.AmiId
 
-	ao := NewApplyOptions()
-	ao.UniqueId = rand.UniqueId
-	ao.TestName = "Test - TestTerraformApplyAvoidsForbiddenRegion"
-	ao.TemplatePath = path.Join(fixtureDir, "minimal-example")
-	ao.Vars = vars
+	options := NewTerratestOptions()
+	options.UniqueId = rand.UniqueId
+	options.TestName = "Test - TestTerraformApplyAvoidsForbiddenRegion"
+	options.TemplatePath = path.Join(fixtureDir, "minimal-example")
+	options.Vars = vars
 
-	_, err = ApplyAndDestroy(ao)
+	_, err = ApplyAndDestroy(options)
 	if err != nil {
 		t.Fatalf("Failed to ApplyAndDestroy: %s", err.Error())
 	}