Refactor

Signed-off-by: Abdulbois <abdulbois.tursunov@dsr-corporation.com>

Author: Abdulbois

utils/validator/url_liveness_test.go

@@ -17,35 +17,50 @@
 package validator
 
 import (
+	"net/http"
+	"net/http/httptest"
 	"net/url"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-func TestURLLivenessCheck(t *testing.T) {
-	negativeTests := []string{
-		"https://dcl-test.org",
-		"https://httpbin.org/status/404",
-		"https://httpbin.org/status/500",
-	}
-	positiveTests := []string{
-		"http://github.com/",             // Redirects to https://github.com/
-		"https://httpbin.org/status/401", // Private repo
-		"https://httpbin.org/status/403", // Unavailable for some reason
+func TestIsLiveURL(t *testing.T) {
+	tests := []struct {
+		name       string
+		statusCode int
+		want       bool
+	}{
+		{"200 OK", http.StatusOK, true},
+		{"301 redirect", http.StatusMovedPermanently, true},
+		{"401 unauthorized", http.StatusUnauthorized, true},
+		{"403 forbidden", http.StatusForbidden, true},
+		{"451 unavailable for legal reasons", http.StatusUnavailableForLegalReasons, true},
+		{"404 not found", http.StatusNotFound, false},
+		{"500 internal server error", http.StatusInternalServerError, false},
+		{"502 bad gateway", http.StatusBadGateway, false},
 	}
 
-	for _, testUrl := range negativeTests {
-		u, err := url.ParseRequestURI(testUrl)
-		require.NoError(t, err)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				require.Equal(t, http.MethodHead, r.Method)
+				require.NotEmpty(t, r.Header.Get("User-Agent"))
+				w.WriteHeader(tt.statusCode)
+			}))
+			defer srv.Close()
+
+			u, err := url.ParseRequestURI(srv.URL)
+			require.NoError(t, err)
 
-		require.False(t, _isLiveURL(u))
+			require.Equal(t, tt.want, isLiveURL(u))
+		})
 	}
+}
 
-	for _, testUrl := range positiveTests {
-		u, err := url.ParseRequestURI(testUrl)
-		require.NoError(t, err)
+func TestIsLiveURLUnreachable(t *testing.T) {
+	u, err := url.ParseRequestURI("http://192.0.2.1:1")
+	require.NoError(t, err)
 
-		require.True(t, _isLiveURL(u))
-	}
+	require.False(t, isLiveURL(u))
 }

utils/validator/validations.go

@@ -53,23 +53,27 @@ func requiredIfBit0Set(fl validator.FieldLevel) bool {
 }
 
 func isValidHttpOrHttpsUrl(fl validator.FieldLevel) bool { //nolint:stylecheck
-	return _validURL(fl, "http", "https")
+	return validURL(fl, "http", "https")
 }
 
 func isValidHttpsUrl(fl validator.FieldLevel) bool { //nolint:stylecheck
-	return _validURL(fl, "https")
+	return validURL(fl, "https")
 }
 
 var allowed4XXStatusCodes = []int{
 	http.StatusUnauthorized,
 	http.StatusForbidden,
 	http.StatusUnavailableForLegalReasons,
 }
-var httpClient = &http.Client{Timeout: 10 * time.Second}
 
-func _validURL(fl validator.FieldLevel, allowedSchemas ...string) bool {
+const (
+	livenessCheckTimeout = 10 * time.Second
+)
+
+var httpClient = &http.Client{Timeout: livenessCheckTimeout}
+
+func validURL(fl validator.FieldLevel, allowedSchemes ...string) bool {
 	raw := fl.Field().String()
-	// Field is empty, or omitempty is set, skip checks
 	if raw == "" {
 		return true
 	}
@@ -79,28 +83,32 @@ func _validURL(fl validator.FieldLevel, allowedSchemas ...string) bool {
 		return false
 	}
 
-	isSchemaAllowed := false
-	for _, schema := range allowedSchemas {
-		if u.Scheme == schema {
-			isSchemaAllowed = true
-
-			break
-		}
+	if !isSchemeAllowed(u.Scheme, allowedSchemes) {
+		return false
 	}
 
-	if _isLiveURL(u) || !isSchemaAllowed {
-		return isSchemaAllowed
+	return isLiveURL(u)
+}
+
+func isSchemeAllowed(scheme string, allowed []string) bool {
+	for _, s := range allowed {
+		if scheme == s {
+			return true
+		}
 	}
 
 	return false
 }
 
-func _isLiveURL(u *url.URL) bool {
+func isLiveURL(u *url.URL) bool {
 	if config.DisableURLLivenessCheck {
 		return true
 	}
-	// HEAD request only retrieves headers, not the body
-	req, err := http.NewRequestWithContext(context.Background(), http.MethodHead, u.String(), nil)
+
+	ctx, cancel := context.WithTimeout(context.Background(), livenessCheckTimeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodHead, u.String(), nil)
 	if err != nil {
 		return false
 	}
@@ -111,7 +119,7 @@ func _isLiveURL(u *url.URL) bool {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode >= 200 && resp.StatusCode < 400 {
+	if resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusBadRequest {
 		return true
 	}