Add headers, expectedOutputUrl, and expectedRedirectResponseCode fields to URL map (#14118) (#23199)

[upstream:7ab204c263691cd7a96daedcde947e3b904b7e5f]

Signed-off-by: Modular Magician <magic-modules@google.com>

Author: modular-magician

.changelog/14118.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `headers`, `expected_output_url`, and `expected_redirect_response_code` fields to `test[]` in `google_compute_url_map` resource and made `service` field optional
+```

google/services/compute/resource_compute_url_map.go

@@ -2838,17 +2838,54 @@ tests per UrlMap.`,
 							Required:    true,
 							Description: `Path portion of the URL.`,
 						},
-						"service": {
-							Type:             schema.TypeString,
-							Required:         true,
-							DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName,
-							Description:      `The backend service or backend bucket link that should be matched by this test.`,
-						},
 						"description": {
 							Type:        schema.TypeString,
 							Optional:    true,
 							Description: `Description of this test case.`,
 						},
+						"expected_output_url": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Description: `The expected output URL evaluated by the load balancer containing the scheme, host, path and query parameters.
+
+For rules that forward requests to backends, the test passes only when expectedOutputUrl matches the request forwarded by the load balancer to backends. For rules with urlRewrite, the test verifies that the forwarded request matches hostRewrite and pathPrefixRewrite in the urlRewrite action. When service is specified, expectedOutputUrl's scheme is ignored.
+
+For rules with urlRedirect, the test passes only if expectedOutputUrl matches the URL in the load balancer's redirect response. If urlRedirect specifies httpsRedirect, the test passes only if the scheme in expectedOutputUrl is also set to HTTPS. If urlRedirect specifies stripQuery, the test passes only if expectedOutputUrl does not contain any query parameters.
+
+expectedOutputUrl is optional when service is specified.`,
+						},
+						"expected_redirect_response_code": {
+							Type:     schema.TypeInt,
+							Optional: true,
+							Description: `For rules with urlRedirect, the test passes only if expectedRedirectResponseCode matches the HTTP status code in load balancer's redirect response.
+
+expectedRedirectResponseCode cannot be set when service is set.`,
+						},
+						"headers": {
+							Type:        schema.TypeList,
+							Optional:    true,
+							Description: `HTTP headers for this request.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"name": {
+										Type:        schema.TypeString,
+										Required:    true,
+										Description: `Header name.`,
+									},
+									"value": {
+										Type:        schema.TypeString,
+										Required:    true,
+										Description: `Header value.`,
+									},
+								},
+							},
+						},
+						"service": {
+							Type:             schema.TypeString,
+							Optional:         true,
+							DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName,
+							Description:      `The backend service or backend bucket link that should be matched by this test.`,
+						},
 					},
 				},
 			},
@@ -5768,10 +5805,13 @@ func flattenComputeUrlMapTest(v interface{}, d *schema.ResourceData, config *tra
 			continue
 		}
 		transformed = append(transformed, map[string]interface{}{
-			"description": flattenComputeUrlMapTestDescription(original["description"], d, config),
-			"host":        flattenComputeUrlMapTestHost(original["host"], d, config),
-			"path":        flattenComputeUrlMapTestPath(original["path"], d, config),
-			"service":     flattenComputeUrlMapTestService(original["service"], d, config),
+			"description":                     flattenComputeUrlMapTestDescription(original["description"], d, config),
+			"host":                            flattenComputeUrlMapTestHost(original["host"], d, config),
+			"path":                            flattenComputeUrlMapTestPath(original["path"], d, config),
+			"headers":                         flattenComputeUrlMapTestHeaders(original["headers"], d, config),
+			"service":                         flattenComputeUrlMapTestService(original["service"], d, config),
+			"expected_output_url":             flattenComputeUrlMapTestExpectedOutputUrl(original["expectedOutputUrl"], d, config),
+			"expected_redirect_response_code": flattenComputeUrlMapTestExpectedRedirectResponseCode(original["expectedRedirectResponseCode"], d, config),
 		})
 	}
 	return transformed
@@ -5788,13 +5828,61 @@ func flattenComputeUrlMapTestPath(v interface{}, d *schema.ResourceData, config
 	return v
 }
 
+func flattenComputeUrlMapTestHeaders(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return v
+	}
+	l := v.([]interface{})
+	transformed := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		original := raw.(map[string]interface{})
+		if len(original) < 1 {
+			// Do not include empty json objects coming back from the api
+			continue
+		}
+		transformed = append(transformed, map[string]interface{}{
+			"name":  flattenComputeUrlMapTestHeadersName(original["name"], d, config),
+			"value": flattenComputeUrlMapTestHeadersValue(original["value"], d, config),
+		})
+	}
+	return transformed
+}
+func flattenComputeUrlMapTestHeadersName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeUrlMapTestHeadersValue(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeUrlMapTestService(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return v
 	}
 	return tpgresource.ConvertSelfLinkToV1(v.(string))
 }
 
+func flattenComputeUrlMapTestExpectedOutputUrl(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeUrlMapTestExpectedRedirectResponseCode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := tpgresource.StringToFixed64(strVal); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
 func flattenComputeUrlMapDefaultUrlRedirect(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return nil
@@ -10018,13 +10106,34 @@ func expandComputeUrlMapTest(v interface{}, d tpgresource.TerraformResourceData,
 			transformed["path"] = transformedPath
 		}
 
+		transformedHeaders, err := expandComputeUrlMapTestHeaders(original["headers"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedHeaders); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["headers"] = transformedHeaders
+		}
+
 		transformedService, err := expandComputeUrlMapTestService(original["service"], d, config)
 		if err != nil {
 			return nil, err
 		} else if val := reflect.ValueOf(transformedService); val.IsValid() && !tpgresource.IsEmptyValue(val) {
 			transformed["service"] = transformedService
 		}
 
+		transformedExpectedOutputUrl, err := expandComputeUrlMapTestExpectedOutputUrl(original["expected_output_url"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedExpectedOutputUrl); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["expectedOutputUrl"] = transformedExpectedOutputUrl
+		}
+
+		transformedExpectedRedirectResponseCode, err := expandComputeUrlMapTestExpectedRedirectResponseCode(original["expected_redirect_response_code"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedExpectedRedirectResponseCode); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["expectedRedirectResponseCode"] = transformedExpectedRedirectResponseCode
+		}
+
 		req = append(req, transformed)
 	}
 	return req, nil
@@ -10042,6 +10151,43 @@ func expandComputeUrlMapTestPath(v interface{}, d tpgresource.TerraformResourceD
 	return v, nil
 }
 
+func expandComputeUrlMapTestHeaders(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	req := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		if raw == nil {
+			continue
+		}
+		original := raw.(map[string]interface{})
+		transformed := make(map[string]interface{})
+
+		transformedName, err := expandComputeUrlMapTestHeadersName(original["name"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedName); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["name"] = transformedName
+		}
+
+		transformedValue, err := expandComputeUrlMapTestHeadersValue(original["value"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedValue); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["value"] = transformedValue
+		}
+
+		req = append(req, transformed)
+	}
+	return req, nil
+}
+
+func expandComputeUrlMapTestHeadersName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeUrlMapTestHeadersValue(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeUrlMapTestService(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	// This method returns a full self link from whatever the input is.
 	if v == nil || v.(string) == "" {
@@ -10074,6 +10220,14 @@ func expandComputeUrlMapTestService(v interface{}, d tpgresource.TerraformResour
 	return f.RelativeLink(), nil
 }
 
+func expandComputeUrlMapTestExpectedOutputUrl(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeUrlMapTestExpectedRedirectResponseCode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeUrlMapDefaultUrlRedirect(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	l := v.([]interface{})
 	if len(l) == 0 || l[0] == nil {

google/services/compute/resource_compute_url_map_generated_meta.yaml

@@ -398,6 +398,14 @@ fields:
     api_field: 'path_matchers.route_rules.url_redirect.strip_query'
   - field: 'test.description'
     api_field: 'tests.description'
+  - field: 'test.expected_output_url'
+    api_field: 'tests.expected_output_url'
+  - field: 'test.expected_redirect_response_code'
+    api_field: 'tests.expected_redirect_response_code'
+  - field: 'test.headers.name'
+    api_field: 'tests.headers.name'
+  - field: 'test.headers.value'
+    api_field: 'tests.headers.value'
   - field: 'test.host'
     api_field: 'tests.host'
   - field: 'test.path'