github.com/turtlemonvh/terraform@v0.6.9-0.20151204001754-8e40b6b855e8/builtin/providers/aws/resource_aws_route53_zone_test.go

package aws

import (
	"fmt"
	"sort"
	"testing"

	"github.com/hashicorp/terraform/helper/resource"
	"github.com/hashicorp/terraform/helper/schema"
	"github.com/hashicorp/terraform/terraform"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/route53"
)

func TestCleanPrefix(t *testing.T) {
	cases := []struct {
		Input, Prefix, Output string
	}{
		{"/hostedzone/foo", "/hostedzone/", "foo"},
		{"/change/foo", "/change/", "foo"},
		{"/bar", "/test", "/bar"},
	}

	for _, tc := range cases {
		actual := cleanPrefix(tc.Input, tc.Prefix)
		if actual != tc.Output {
			t.Fatalf("input: %s\noutput: %s", tc.Input, actual)
		}
	}
}

func TestCleanZoneID(t *testing.T) {
	cases := []struct {
		Input, Output string
	}{
		{"/hostedzone/foo", "foo"},
		{"/change/foo", "/change/foo"},
		{"/bar", "/bar"},
	}

	for _, tc := range cases {
		actual := cleanZoneID(tc.Input)
		if actual != tc.Output {
			t.Fatalf("input: %s\noutput: %s", tc.Input, actual)
		}
	}
}

func TestCleanChangeID(t *testing.T) {
	cases := []struct {
		Input, Output string
	}{
		{"/hostedzone/foo", "/hostedzone/foo"},
		{"/change/foo", "foo"},
		{"/bar", "/bar"},
	}

	for _, tc := range cases {
		actual := cleanChangeID(tc.Input)
		if actual != tc.Output {
			t.Fatalf("input: %s\noutput: %s", tc.Input, actual)
		}
	}
}

func TestAccAWSRoute53Zone_basic(t *testing.T) {
	var zone route53.GetHostedZoneOutput
	var td route53.ResourceTagSet

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { testAccPreCheck(t) },
		Providers:    testAccProviders,
		CheckDestroy: testAccCheckRoute53ZoneDestroy,
		Steps: []resource.TestStep{
			resource.TestStep{
				Config: testAccRoute53ZoneConfig,
				Check: resource.ComposeTestCheckFunc(
					testAccCheckRoute53ZoneExists("aws_route53_zone.main", &zone),
					testAccLoadTagsR53(&zone, &td),
					testAccCheckTagsR53(&td.Tags, "foo", "bar"),
				),
			},
		},
	})
}

func TestAccAWSRoute53Zone_private_basic(t *testing.T) {
	var zone route53.GetHostedZoneOutput

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { testAccPreCheck(t) },
		Providers:    testAccProviders,
		CheckDestroy: testAccCheckRoute53ZoneDestroy,
		Steps: []resource.TestStep{
			resource.TestStep{
				Config: testAccRoute53PrivateZoneConfig,
				Check: resource.ComposeTestCheckFunc(
					testAccCheckRoute53ZoneExists("aws_route53_zone.main", &zone),
					testAccCheckRoute53ZoneAssociatesWithVpc("aws_vpc.main", &zone),
				),
			},
		},
	})
}

func TestAccAWSRoute53Zone_private_region(t *testing.T) {
	var zone route53.GetHostedZoneOutput

	// record the initialized providers so that we can use them to
	// check for the instances in each region
	var providers []*schema.Provider
	providerFactories := map[string]terraform.ResourceProviderFactory{
		"aws": func() (terraform.ResourceProvider, error) {
			p := Provider()
			providers = append(providers, p.(*schema.Provider))
			return p, nil
		},
	}

	resource.Test(t, resource.TestCase{
		PreCheck:          func() { testAccPreCheck(t) },
		ProviderFactories: providerFactories,
		CheckDestroy:      testAccCheckRoute53ZoneDestroyWithProviders(&providers),
		Steps: []resource.TestStep{
			resource.TestStep{
				Config: testAccRoute53PrivateZoneRegionConfig,
				Check: resource.ComposeTestCheckFunc(
					testAccCheckRoute53ZoneExistsWithProviders("aws_route53_zone.main", &zone, &providers),
					testAccCheckRoute53ZoneAssociatesWithVpc("aws_vpc.main", &zone),
				),
			},
		},
	})
}

func testAccCheckRoute53ZoneDestroy(s *terraform.State) error {
	return testAccCheckRoute53ZoneDestroyWithProvider(s, testAccProvider)
}

func testAccCheckRoute53ZoneDestroyWithProviders(providers *[]*schema.Provider) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		for _, provider := range *providers {
			if provider.Meta() == nil {
				continue
			}
			if err := testAccCheckRoute53ZoneDestroyWithProvider(s, provider); err != nil {
				return err
			}
		}
		return nil
	}
}

func testAccCheckRoute53ZoneDestroyWithProvider(s *terraform.State, provider *schema.Provider) error {
	conn := provider.Meta().(*AWSClient).r53conn
	for _, rs := range s.RootModule().Resources {
		if rs.Type != "aws_route53_zone" {
			continue
		}

		_, err := conn.GetHostedZone(&route53.GetHostedZoneInput{Id: aws.String(rs.Primary.ID)})
		if err == nil {
			return fmt.Errorf("Hosted zone still exists")
		}
	}
	return nil
}

func testAccCheckRoute53ZoneExists(n string, zone *route53.GetHostedZoneOutput) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		return testAccCheckRoute53ZoneExistsWithProvider(s, n, zone, testAccProvider)
	}
}

func testAccCheckRoute53ZoneExistsWithProviders(n string, zone *route53.GetHostedZoneOutput, providers *[]*schema.Provider) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		for _, provider := range *providers {
			if provider.Meta() == nil {
				continue
			}
			if err := testAccCheckRoute53ZoneExistsWithProvider(s, n, zone, provider); err != nil {
				return err
			}
		}
		return nil
	}
}

func testAccCheckRoute53ZoneExistsWithProvider(s *terraform.State, n string, zone *route53.GetHostedZoneOutput, provider *schema.Provider) error {
	rs, ok := s.RootModule().Resources[n]
	if !ok {
		return fmt.Errorf("Not found: %s", n)
	}

	if rs.Primary.ID == "" {
		return fmt.Errorf("No hosted zone ID is set")
	}

	conn := provider.Meta().(*AWSClient).r53conn
	resp, err := conn.GetHostedZone(&route53.GetHostedZoneInput{Id: aws.String(rs.Primary.ID)})
	if err != nil {
		return fmt.Errorf("Hosted zone err: %v", err)
	}

	aws_comment := *resp.HostedZone.Config.Comment
	rs_comment := rs.Primary.Attributes["comment"]
	if rs_comment != "" && rs_comment != aws_comment {
		return fmt.Errorf("Hosted zone with comment '%s' found but does not match '%s'", aws_comment, rs_comment)
	}

	if !*resp.HostedZone.Config.PrivateZone {
		sorted_ns := make([]string, len(resp.DelegationSet.NameServers))
		for i, ns := range resp.DelegationSet.NameServers {
			sorted_ns[i] = *ns
		}
		sort.Strings(sorted_ns)
		for idx, ns := range sorted_ns {
			attribute := fmt.Sprintf("name_servers.%d", idx)
			dsns := rs.Primary.Attributes[attribute]
			if dsns != ns {
				return fmt.Errorf("Got: %v for %v, Expected: %v", dsns, attribute, ns)
			}
		}
	}

	*zone = *resp
	return nil
}

func testAccCheckRoute53ZoneAssociatesWithVpc(n string, zone *route53.GetHostedZoneOutput) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		rs, ok := s.RootModule().Resources[n]
		if !ok {
			return fmt.Errorf("Not found: %s", n)
		}

		if rs.Primary.ID == "" {
			return fmt.Errorf("No VPC ID is set")
		}

		var associatedVPC *route53.VPC
		for _, vpc := range zone.VPCs {
			if *vpc.VPCId == rs.Primary.ID {
				associatedVPC = vpc
			}
		}
		if associatedVPC == nil {
			return fmt.Errorf("VPC: %v is not associated to Zone: %v", n, cleanZoneID(*zone.HostedZone.Id))
		}
		return nil
	}
}

func testAccLoadTagsR53(zone *route53.GetHostedZoneOutput, td *route53.ResourceTagSet) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		conn := testAccProvider.Meta().(*AWSClient).r53conn

		zone := cleanZoneID(*zone.HostedZone.Id)
		req := &route53.ListTagsForResourceInput{
			ResourceId:   aws.String(zone),
			ResourceType: aws.String("hostedzone"),
		}

		resp, err := conn.ListTagsForResource(req)
		if err != nil {
			return err
		}

		if resp.ResourceTagSet != nil {
			*td = *resp.ResourceTagSet
		}

		return nil
	}
}

const testAccRoute53ZoneConfig = `
resource "aws_route53_zone" "main" {
	name = "hashicorp.com"
	comment = "Custom comment"

	tags {
		foo = "bar"
		Name = "tf-route53-tag-test"
	}
}
`

const testAccRoute53PrivateZoneConfig = `
resource "aws_vpc" "main" {
	cidr_block = "172.29.0.0/24"
	instance_tenancy = "default"
	enable_dns_support = true
	enable_dns_hostnames = true
}

resource "aws_route53_zone" "main" {
	name = "hashicorp.com"
	vpc_id = "${aws_vpc.main.id}"
}
`

const testAccRoute53PrivateZoneRegionConfig = `
provider "aws" {
	alias = "west"
	region = "us-west-2"
}

provider "aws" {
	alias = "east"
	region = "us-east-1"
}

resource "aws_vpc" "main" {
	provider = "aws.east"
	cidr_block = "172.29.0.0/24"
	instance_tenancy = "default"
	enable_dns_support = true
	enable_dns_hostnames = true
}

resource "aws_route53_zone" "main" {
	provider = "aws.west"
	name = "hashicorp.com"
	vpc_id = "${aws_vpc.main.id}"
	vpc_region = "us-east-1"
}
`