data-source/aws_availability_zones: Add blacklisted_names and blackli…

…sted_zone_ids arguments

Reference: #8462

Output from acceptance testing:

```
--- PASS: TestAccAWSAvailabilityZones_basic (9.66s)
--- PASS: TestAccAWSAvailabilityZones_stateFilter (9.90s)
--- PASS: TestAccAWSAvailabilityZones_BlacklistedZoneIds (10.80s)
--- PASS: TestAccAWSAvailabilityZones_BlacklistedNames (10.80s)
```

aws/data_source_aws_availability_zones.go

@@ -17,6 +17,16 @@ func dataSourceAwsAvailabilityZones() *schema.Resource {
 		Read: dataSourceAwsAvailabilityZonesRead,
 
 		Schema: map[string]*schema.Schema{
+			"blacklisted_names": {
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"blacklisted_zone_ids": {
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
 			"names": {
 				Type:     schema.TypeList,
 				Computed: true,
@@ -68,11 +78,24 @@ func dataSourceAwsAvailabilityZonesRead(d *schema.ResourceData, meta interface{}
 		return aws.StringValue(resp.AvailabilityZones[i].ZoneName) < aws.StringValue(resp.AvailabilityZones[j].ZoneName)
 	})
 
+	blacklistedNames := d.Get("blacklisted_names").(*schema.Set)
+	blacklistedZoneIDs := d.Get("blacklisted_zone_ids").(*schema.Set)
 	names := []string{}
 	zoneIds := []string{}
 	for _, v := range resp.AvailabilityZones {
-		names = append(names, aws.StringValue(v.ZoneName))
-		zoneIds = append(zoneIds, aws.StringValue(v.ZoneId))
+		name := aws.StringValue(v.ZoneName)
+		zoneID := aws.StringValue(v.ZoneId)
+
+		if blacklistedNames.Contains(name) {
+			continue
+		}
+
+		if blacklistedZoneIDs.Contains(zoneID) {
+			continue
+		}
+
+		names = append(names, name)
+		zoneIds = append(zoneIds, zoneID)
 	}
 
 	if err := d.Set("names", names); err != nil {

aws/data_source_aws_availability_zones_test.go

@@ -88,6 +88,42 @@ func TestAccAWSAvailabilityZones_basic(t *testing.T) {
 	})
 }
 
+func TestAccAWSAvailabilityZones_BlacklistedNames(t *testing.T) {
+	allDataSourceName := "data.aws_availability_zones.all"
+	blacklistedDataSourceName := "data.aws_availability_zones.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckAwsAvailabilityZonesConfigBlacklistedNames(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAvailabilityZonesBlacklisting(allDataSourceName, blacklistedDataSourceName),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAWSAvailabilityZones_BlacklistedZoneIds(t *testing.T) {
+	allDataSourceName := "data.aws_availability_zones.all"
+	blacklistedDataSourceName := "data.aws_availability_zones.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckAwsAvailabilityZonesConfigBlacklistedZoneIds(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsAvailabilityZonesBlacklisting(allDataSourceName, blacklistedDataSourceName),
+				),
+			},
+		},
+	})
+}
+
 func TestAccAWSAvailabilityZones_stateFilter(t *testing.T) {
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck:  func() { testAccPreCheck(t) },
@@ -128,6 +164,40 @@ func testAccCheckAwsAvailabilityZonesMeta(n string) resource.TestCheckFunc {
 	}
 }
 
+func testAccCheckAwsAvailabilityZonesBlacklisting(allDataSourceName, blacklistedDataSourceName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		allResourceState, ok := s.RootModule().Resources[allDataSourceName]
+		if !ok {
+			return fmt.Errorf("Resource does not exist: %s", allDataSourceName)
+		}
+
+		blacklistedResourceState, ok := s.RootModule().Resources[blacklistedDataSourceName]
+		if !ok {
+			return fmt.Errorf("Resource does not exist: %s", blacklistedDataSourceName)
+		}
+
+		for _, attribute := range []string{"names.#", "zone_ids.#"} {
+			allValue, ok := allResourceState.Primary.Attributes[attribute]
+
+			if !ok {
+				return fmt.Errorf("cannot find %s in %s resource state attributes: %+v", attribute, allDataSourceName, allResourceState.Primary.Attributes)
+			}
+
+			blacklistedValue, ok := blacklistedResourceState.Primary.Attributes[attribute]
+
+			if !ok {
+				return fmt.Errorf("cannot find %s in %s resource state attributes: %+v", attribute, blacklistedDataSourceName, blacklistedResourceState.Primary.Attributes)
+			}
+
+			if allValue == blacklistedValue {
+				return fmt.Errorf("expected %s attribute value difference, got: %s", attribute, allValue)
+			}
+		}
+
+		return nil
+	}
+}
+
 func testAccCheckAwsAvailabilityZoneState(n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
@@ -179,6 +249,26 @@ const testAccCheckAwsAvailabilityZonesConfig = `
 data "aws_availability_zones" "availability_zones" { }
 `
 
+func testAccCheckAwsAvailabilityZonesConfigBlacklistedNames() string {
+	return fmt.Sprintf(`
+data "aws_availability_zones" "all" {}
+
+data "aws_availability_zones" "test" {
+  blacklisted_names = ["${data.aws_availability_zones.all.names[0]}"]
+}
+`)
+}
+
+func testAccCheckAwsAvailabilityZonesConfigBlacklistedZoneIds() string {
+	return fmt.Sprintf(`
+data "aws_availability_zones" "all" {}
+
+data "aws_availability_zones" "test" {
+  blacklisted_zone_ids = ["${data.aws_availability_zones.all.zone_ids[0]}"]
+}
+`)
+}
+
 const testAccCheckAwsAvailabilityZonesStateConfig = `
 data "aws_availability_zones" "state_filter" {
 	state = "available"

website/docs/d/availability_zones.html.markdown

@@ -40,6 +40,8 @@ resource "aws_subnet" "secondary" {
 
 The following arguments are supported:
 
+* `blacklisted_names` - (Optional) List of blacklisted Availability Zone names.
+* `blacklisted_zone_ids` - (Optional) List of blacklisted Availability Zone IDs.
 * `state` - (Optional) Allows to filter list of Availability Zones based on their
 current state. Can be either `"available"`, `"information"`, `"impaired"` or
 `"unavailable"`. By default the list includes a complete set of Availability Zones