RHINENG-21755: use null with multiple severity filters

Author: rverdile

manager/controllers/advisories_test.go

@@ -229,6 +229,23 @@ func TestAdvisoriesFilterSeverityNull(t *testing.T) {
 	assert.Equal(t, "CUSTOM-12", output.Data[0].ID)
 }
 
+func TestAdvisoriesFilterSeverityInWithNull(t *testing.T) {
+	output := testAdvisories(t, "/?sort=id&filter[severity]=in:2,null")
+	assert.Equal(t, 11, len(output.Data))
+	foundSeverity2 := false
+	foundNull := false
+	for _, adv := range output.Data {
+		if adv.ID == "RH-3" {
+			foundSeverity2 = true
+		}
+		if adv.ID == "CUSTOM-12" {
+			foundNull = true
+		}
+	}
+	assert.True(t, foundSeverity2)
+	assert.True(t, foundNull)
+}
+
 func TestAdvisoriesFilterApplicableSystems(t *testing.T) {
 	output := testAdvisories(t, "/?filter[applicable_systems]=gt:1")
 	assert.Equal(t, 1, len(output.Data))

manager/controllers/filter.go

@@ -77,9 +77,10 @@ func checkValueCount(operator string, nValues int) bool {
 }
 
 // Convert a single filter to where clauses
+// nolint funlen
 func (t *FilterData) ToWhere(fieldName string, attributes database.AttrMap) (string, []any, error) {
 	var err error
-	transformedOperator, transformedValues := t.transformParams(fieldName)
+	transformedOperator, transformedValues, hasNull := t.transformParams(fieldName)
 	var values = make([]any, len(transformedValues))
 	for i, v := range transformedValues {
 		fieldInfo, found := attributes[fieldName]
@@ -115,8 +116,16 @@ func (t *FilterData) ToWhere(fieldName string, attributes database.AttrMap) (str
 	case OpBetween:
 		return fmt.Sprintf("%s BETWEEN ? AND ? ", attributes[fieldName].DataQuery), values, nil
 	case OpIn:
+		if hasNull {
+			return fmt.Sprintf("(%s IN ? OR %s IS NULL) ",
+				attributes[fieldName].DataQuery, attributes[fieldName].DataQuery), []any{values}, nil
+		}
 		return fmt.Sprintf("%s IN (?) ", attributes[fieldName].DataQuery), []any{values}, nil
 	case OpNotIn:
+		if hasNull {
+			return fmt.Sprintf("(%s NOT IN ? AND %s IS NOT NULL) ",
+				attributes[fieldName].DataQuery, attributes[fieldName].DataQuery), []any{values}, nil
+		}
 		return fmt.Sprintf("%s NOT IN (?) ", attributes[fieldName].DataQuery), []any{values}, nil
 	case OpNull:
 		return fmt.Sprintf("%s IS NULL ", attributes[fieldName].DataQuery), []any{}, nil
@@ -127,39 +136,65 @@ func (t *FilterData) ToWhere(fieldName string, attributes database.AttrMap) (str
 	}
 }
 
-func (t *FilterData) transformParams(fieldName string) (transformedOperator string, transformedValues []string) {
-	if len(t.Values) == 1 && (t.Values[0] == "null" || t.Values[0] == "notnull") {
+func (t *FilterData) transformParams(fieldName string) (
+	transformedOperator string, transformedValues []string, hasNull bool) {
+	if len(t.Values) == 1 && (t.Values[0] == OpNull || t.Values[0] == OpNotNull) {
 		// handle special cases filter=null and filter=notnull
-		return t.Values[0], []string{"0"}
+		return t.Values[0], []string{"0"}, false
 	}
-	if fieldName != "advisory_type_name" {
-		// no change
-		return t.Operator, t.Values
+	// special case, in advisory_type_name filter expand "other" into list of what we mean by other
+	valuesToProcess := t.Values
+	operatorToUse := t.Operator
+	if fieldName == "advisory_type_name" {
+		transformedValues = make([]string, 0, len(t.Values))
+		for _, originalValue := range t.Values {
+			if originalValue == "other" {
+				transformedValues = append(transformedValues, database.OtherAdvisoryTypes...)
+			} else {
+				transformedValues = append(transformedValues, originalValue)
+			}
+		}
+		// If "other" was expanded, use the expanded list for further processing
+		if len(transformedValues) != len(t.Values) {
+			valuesToProcess = transformedValues
+			// Convert operator if needed
+			switch t.Operator {
+			case OpEq:
+				operatorToUse = OpIn
+			case OpNeq:
+				operatorToUse = OpNotIn
+			default:
+				operatorToUse = t.Operator
+			}
+		}
 	}
 
-	// special case, in advisory_type_name filter expand "other" into list of what we mean by other
-	transformedValues = make([]string, 0, len(t.Values))
-	for _, originalValue := range t.Values {
-		if originalValue == "other" {
-			transformedValues = append(transformedValues, database.OtherAdvisoryTypes...)
+	if fieldName == "severity" && (t.Operator == OpIn || t.Operator == OpNotIn) {
+		valuesToProcess, hasNull = separateNullFromValues(valuesToProcess)
+	}
+	return operatorToUse, valuesToProcess, hasNull
+}
+
+func separateNullFromValues(values []string) (regularValues []string, hasNull bool) {
+	hasNullValue := false
+
+	for _, v := range values {
+		if v == "null" {
+			hasNullValue = true
 		} else {
-			transformedValues = append(transformedValues, originalValue)
+			regularValues = append(regularValues, v)
 		}
 	}
 
-	if len(transformedValues) == len(t.Values) {
-		return t.Operator, t.Values
+	if hasNullValue && len(regularValues) == 0 {
+		return []string{"0"}, false
 	}
 
-	switch t.Operator {
-	case OpEq:
-		transformedOperator = OpIn
-	case OpNeq:
-		transformedOperator = OpNotIn
-	default:
-		transformedOperator = t.Operator
+	// null mixed with values e.g. in:2,null
+	if hasNullValue && len(regularValues) > 0 {
+		return regularValues, true
 	}
-	return transformedOperator, transformedValues
+	return regularValues, false
 }
 
 func (t Filters) ToQueryParams() string {

manager/controllers/filter_test.go

@@ -108,3 +108,32 @@ func TestFilterOtherAdvisoryTypes(t *testing.T) {
 	// Check the list is loaded from database correctly
 	assert.Equal(t, []string{"unknown", "unspecified"}, database.OtherAdvisoryTypes)
 }
+
+func TestFilterSeverityInWithNull(t *testing.T) {
+	filter := ParseFilterValue(ColumnFilter, "in:2,null")
+	attrMap := database.AttrMap{"severity": {DataQuery: "severity", OrderQuery: "severity", Parser: dummyParser}}
+	query, args, err := filter.ToWhere("severity", attrMap)
+
+	assert.NoError(t, err)
+	assert.Equal(t, "(severity IN ? OR severity IS NULL) ", query)
+	assert.Equal(t, 1, len(args))
+	assert.IsType(t, []any{}, args[0])
+	severityValues := args[0].([]any)
+	assert.Equal(t, 1, len(severityValues))
+	assert.Equal(t, "2", severityValues[0])
+}
+
+func TestFilterSeverityNotInWithNull(t *testing.T) {
+	filter := ParseFilterValue(ColumnFilter, "notin:2,3,null")
+	attrMap := database.AttrMap{"severity": {DataQuery: "severity", OrderQuery: "severity", Parser: dummyParser}}
+	query, args, err := filter.ToWhere("severity", attrMap)
+
+	assert.NoError(t, err)
+	assert.Equal(t, "(severity NOT IN ? AND severity IS NOT NULL) ", query)
+	assert.Equal(t, 1, len(args))
+	assert.IsType(t, []any{}, args[0])
+	severityValues := args[0].([]any)
+	assert.Equal(t, 2, len(severityValues))
+	assert.Equal(t, "2", severityValues[0])
+	assert.Equal(t, "3", severityValues[1])
+}