Allowing more comperators for the http analyzer

Author: jtuchscherer

pkg/analyze/host_http.go

@@ -3,6 +3,7 @@ package analyzer
 import (
 	"encoding/json"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 
@@ -11,6 +12,8 @@ import (
 	"github.com/replicatedhq/troubleshoot/pkg/collect"
 )
 
+var allowedCompareOperators = []string{"==", "!=", "=", "===", "!==", ">=", ">", ">==", "<", "<=", "<=="}
+
 type httpResult struct {
 	Error    *collect.HTTPError
 	Response *collect.HTTPResponse
@@ -73,8 +76,10 @@ func compareHostHTTPConditionalToActual(conditional string, result *httpResult)
 		return false, errors.New(`Conditional must begin with keyword "statusCode"`)
 	}
 
-	if parts[1] != "=" && parts[1] != "==" && parts[1] != "===" {
-		return false, errors.New(`Only supported operator is "=="`)
+	operator := parts[1]
+	// Check if operator is allowed
+	if !slices.Contains(allowedCompareOperators, operator) {
+		return false, fmt.Errorf("Operator %q is not supported. Must be one of: %s", operator, strings.Join(allowedCompareOperators, ", "))
 	}
 
 	i, err := strconv.Atoi(parts[2])
@@ -83,9 +88,26 @@ func compareHostHTTPConditionalToActual(conditional string, result *httpResult)
 	}
 
 	if result.Response == nil {
-		return false, err
+		return false, nil
+	}
+
+	switch operator {
+	case "==", "=", "===":
+		return result.Response.Status == i, nil
+	case "!=", "!==":
+		return result.Response.Status != i, nil
+	case ">=", ">==":
+		return result.Response.Status >= i, nil
+	case ">":
+		return result.Response.Status > i, nil
+	case "<=", "<==":
+		return result.Response.Status <= i, nil
+	case "<":
+		return result.Response.Status < i, nil
+	default:
+		// This should never happen due to the validation above
+		return false, fmt.Errorf("Operator %q is not supported. Must be one of: %s", operator, strings.Join(allowedCompareOperators, ", "))
 	}
-	return result.Response.Status == i, nil
 }
 
 func analyzeHTTPResult(analyzer *troubleshootv1beta2.HTTPAnalyze, fileName string, getCollectedFileContents getCollectedFileContents, title string) ([]*AnalyzeResult, error) {

pkg/analyze/host_http_test.go

@@ -2,6 +2,7 @@ package analyzer
 
 import (
 	"encoding/json"
+	"strconv"
 	"testing"
 
 	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
@@ -113,6 +114,62 @@ func TestAnalyzeHostHTTP(t *testing.T) {
 				},
 			},
 		},
+		{
+			name:      "invalid compare operator",
+			expectErr: true,
+			httpResult: &httpResult{
+				Response: &collect.HTTPResponse{
+					Status: 200,
+				},
+			},
+			hostAnalyzer: &troubleshootv1beta2.HTTPAnalyze{
+				CollectorName: "collector",
+				Outcomes: []*troubleshootv1beta2.Outcome{
+					{
+						Pass: &troubleshootv1beta2.SingleOutcome{
+							When:    "statusCode #$ 200",
+							Message: "passed",
+						},
+					},
+					{
+						Warn: &troubleshootv1beta2.SingleOutcome{
+							Message: "default",
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "!= compare operator",
+			httpResult: &httpResult{
+				Response: &collect.HTTPResponse{
+					Status: 201,
+				},
+			},
+			hostAnalyzer: &troubleshootv1beta2.HTTPAnalyze{
+				CollectorName: "collector",
+				Outcomes: []*troubleshootv1beta2.Outcome{
+					{
+						Pass: &troubleshootv1beta2.SingleOutcome{
+							When:    "statusCode != 200",
+							Message: "passed",
+						},
+					},
+					{
+						Warn: &troubleshootv1beta2.SingleOutcome{
+							Message: "default",
+						},
+					},
+				},
+			},
+			result: []*AnalyzeResult{
+				{
+					Title:   "HTTP Request",
+					IsPass:  true,
+					Message: "passed",
+				},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -137,3 +194,108 @@ func TestAnalyzeHostHTTP(t *testing.T) {
 		})
 	}
 }
+
+func TestAnalyzeHostHTTPHTTPCodesAndCompareOperators(t *testing.T) {
+	httpResult := &httpResult{
+		Response: &collect.HTTPResponse{
+			Status: 200,
+		},
+	}
+
+	tests := []struct {
+		name               string
+		expectedStatusCode int
+		comparator         string
+		expectOutcome      bool
+	}{
+		{
+			name:               "== 200",
+			expectedStatusCode: 200,
+			comparator:         "==",
+		},
+		{
+			name:               "=== 200",
+			expectedStatusCode: 200,
+			comparator:         "===",
+		},
+		{
+			name:               "= 200",
+			expectedStatusCode: 200,
+			comparator:         "=",
+		},
+		{
+			name:               "!= 201",
+			expectedStatusCode: 201,
+			comparator:         "!=",
+		},
+		{
+			name:               "!== 200",
+			expectedStatusCode: 201,
+			comparator:         "!==",
+		},
+		{
+			name:               ">= 200",
+			expectedStatusCode: 200,
+			comparator:         ">=",
+		},
+		{
+			name:               "> 199",
+			expectedStatusCode: 199,
+			comparator:         ">",
+		},
+		{
+			name:               ">== 200",
+			expectedStatusCode: 200,
+			comparator:         ">==",
+		},
+		{
+			name:               "<= 200",
+			expectedStatusCode: 200,
+			comparator:         "<=",
+		},
+		{
+			name:               "<= 201",
+			expectedStatusCode: 201,
+			comparator:         "<=",
+		},
+		{
+			name:               "< 201",
+			expectedStatusCode: 201,
+			comparator:         "<",
+		},
+		{
+			name:               "<== 200",
+			expectedStatusCode: 200,
+			comparator:         "<==",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			hostAnalyzer := &troubleshootv1beta2.HTTPAnalyze{
+				CollectorName: "registry",
+				Outcomes: []*troubleshootv1beta2.Outcome{
+					{
+						Pass: &troubleshootv1beta2.SingleOutcome{
+							When: "statusCode " + test.comparator + " " + strconv.Itoa(test.expectedStatusCode),
+						},
+					},
+				},
+			}
+
+			req := require.New(t)
+			b, err := json.Marshal(httpResult)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			getCollectedFileContents := func(filename string) ([]byte, error) {
+				return b, nil
+			}
+
+			result, err := (&AnalyzeHostHTTP{hostAnalyzer}).Analyze(getCollectedFileContents, nil)
+			req.NoError(err)
+			assert.Equal(t, 1, len(result))
+			assert.Equal(t, true, result[0].IsPass)
+		})
+	}
+}