feat: add stringvalidator HTTPCode (#55)

Author: azrod

.changelog/55.txt

@@ -0,0 +1,3 @@
+```release-note:feature
+`stringvalidator` - Add new network validator `HTTPCode` to validate with settings the http code range allowed (Ex: 2xx).
+```

docs/stringvalidator/cases.md

@@ -32,7 +32,7 @@ func (r *xResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *
                 Optional:            true,
                 MarkdownDescription: "Username for ...",
                 Validators: []validator.String{
-                    fstringvalidator.IsNetwork([]fstringvalidator.CasesValidatorType{
+                    fstringvalidator.Cases([]fstringvalidator.CasesValidatorType{
                         fstringvalidator.CasesDisallowUpper,
                         fstringvalidator.CasesDisallowSpace,
                     }, true)

docs/stringvalidator/httpcode.md

@@ -0,0 +1,43 @@
+---
+hide:
+    - navigation
+---
+# `Cases`
+
+!!! quote inline end "Released in v1.15.0"
+
+This validator is used to check if the string contains a valid http status code.
+A parameter can be passed to allow a category of status codes.
+The following categories are available:
+
+* `1xx` - Informational responses
+* `2xx` - Successful responses
+* `3xx` - Redirection messages
+* `4xx` - Client error responses
+* `5xx` - Server error responses
+
+## How to use it
+
+The following example will check if the string does not contain any uppercase characters and does not contain any space characters.
+
+```go
+// Schema defines the schema for the resource.
+func (r *xResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+    resp.Schema = schema.Schema{
+        (...)
+            "status_code": schema.StringAttribute{
+                Optional:            true,
+                MarkdownDescription: "Allowed HTTP status code",
+                Validators: []validator.String{
+                    fstringvalidator.HTTPCode(stringvalidator.HTTPCodeParams{
+                      Allow1xx: false,
+                      Allow2xx: true,
+                      Allow3xx: true,
+                      Allow4xx: false,
+                      Allow5xx: false,
+           })
+                },
+            },
+```
+
+In this example, the validator will check if the string is a valid HTTP status code and will allow only 2xx and 3xx status codes.

docs/stringvalidator/index.md

@@ -41,3 +41,4 @@ import (
 ### Special
 
 - [`Not`](not.md) - This validator is used to negate the result of another validator.
+- [`HTTPCode`](httpcode.md) - This validator is used to check if the string contains a valid http status code.

stringvalidator/http_code.go

@@ -0,0 +1,155 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 Orange
+ * SPDX-License-Identifier: Mozilla Public License 2.0
+ *
+ * This software is distributed under the MPL-2.0 license.
+ * the text of which is available at https://www.mozilla.org/en-US/MPL/2.0/
+ * or see the "LICENSE" file for more details.
+ */
+
+package stringvalidator
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+)
+
+var _ validator.String = httpCode{}
+
+type httpCode struct {
+	allowedRanges []httpCodeParam
+}
+
+// Description describes the validation in plain text formatting.
+func (validator httpCode) Description(_ context.Context) string {
+	if len(validator.allowedRanges) == 0 {
+		return ""
+	}
+
+	description := ""
+
+	if len(validator.allowedRanges) == 1 {
+		description += fmt.Sprintf("The allowed HTTP status code pattern is %s", validator.allowedRanges[0].format)
+	} else {
+		description += "The following HTTP status codes patterns are allowed: "
+		for _, r := range validator.allowedRanges {
+			description += fmt.Sprintf("%s, ", r.format)
+		}
+		description = description[:len(description)-2] // remove the last comma and space
+	}
+
+	return description
+}
+
+// MarkdownDescription describes the validation in Markdown formatting.
+func (validator httpCode) MarkdownDescription(ctx context.Context) string {
+	if len(validator.allowedRanges) == 0 {
+		return ""
+	}
+
+	description := ""
+
+	if len(validator.allowedRanges) == 1 {
+		description += fmt.Sprintf("The allowed HTTP status code pattern is `%s`", validator.allowedRanges[0].format)
+	} else {
+		description += "The following HTTP status codes patterns are allowed: "
+		for _, r := range validator.allowedRanges {
+			description += fmt.Sprintf("`%s`, ", r.format)
+		}
+		description = description[:len(description)-2] // remove the last comma and space
+	}
+	return description
+}
+
+// Validate performs the validation.
+func (validator httpCode) ValidateString(
+	_ context.Context,
+	request validator.StringRequest,
+	response *validator.StringResponse,
+) {
+	if request.ConfigValue.IsNull() || request.ConfigValue.IsUnknown() {
+		return
+	}
+
+	// Check if the value is a valid HTTP status code in the allowed ranges
+	httpCode := request.ConfigValue.ValueString()
+
+	// convert the string to an integer
+	code, err := strconv.Atoi(httpCode)
+	if err != nil {
+		response.Diagnostics.AddError(
+			"Invalid HTTP code",
+			fmt.Sprintf("The value %s is not a valid HTTP status code", httpCode),
+		)
+		return
+	}
+
+	// if the status text is empty, it means the code is not valid
+	if v := http.StatusText(code); v == "" {
+		response.Diagnostics.AddError(
+			"Invalid HTTP code",
+			fmt.Sprintf("The value %s is not a valid HTTP status code defined by the HTTP RFC9110", httpCode),
+		)
+		return
+	}
+
+	// Check if the code is in the allowed ranges
+	for _, r := range validator.allowedRanges {
+		if code >= r.start && code <= r.end {
+			return
+		}
+	}
+
+	response.Diagnostics.AddError(
+		"Invalid HTTP code",
+		fmt.Sprintf("The value %s is not a valid HTTP status code in the allowed ranges", httpCode),
+	)
+}
+
+type HTTPCodeParams struct {
+	Allow1xx bool
+	Allow2xx bool
+	Allow3xx bool
+	Allow4xx bool
+	Allow5xx bool
+}
+
+type httpCodeParam struct {
+	format string
+	start  int
+	end    int
+}
+
+// HTTPCode validates that a string represents a valid HTTP status code.
+//
+// Parameters:
+//   - settings: HTTPCodeParams containing the configuration for the validator.
+//
+// Returns:
+//   - validator.String: A validator that checks if the string is a valid HTTP status code.
+func HTTPCode(settings HTTPCodeParams) validator.String {
+	return &httpCode{
+		allowedRanges: func() (ranges []httpCodeParam) {
+			if settings.Allow1xx {
+				ranges = append(ranges, httpCodeParam{start: 100, end: 199, format: "1xx"})
+			}
+			if settings.Allow2xx {
+				ranges = append(ranges, httpCodeParam{start: 200, end: 299, format: "2xx"})
+			}
+			if settings.Allow3xx {
+				ranges = append(ranges, httpCodeParam{start: 300, end: 399, format: "3xx"})
+			}
+			if settings.Allow4xx {
+				ranges = append(ranges, httpCodeParam{start: 400, end: 499, format: "4xx"})
+			}
+			if settings.Allow5xx {
+				ranges = append(ranges, httpCodeParam{start: 500, end: 599, format: "5xx"})
+			}
+			return ranges
+		}(),
+	}
+}