578 lines
19 KiB
C#
578 lines
19 KiB
C#
/*
|
|
* dbMango
|
|
*
|
|
* Copyright 2025 Deutsche Bank AG
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
using NUnit.Framework.Legacy;
|
|
using Rms.Risk.Mango.Pivot.Core.Models;
|
|
using Rms.Risk.Mango.Pivot.UI.Pivot;
|
|
|
|
namespace Tests.Rms.Risk.Mango;
|
|
|
|
[TestFixture]
|
|
public class ExtraFilterDefinitionTests
|
|
{
|
|
private ExtraFilterDefinition _extraFilterDefinition = null!;
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
_extraFilterDefinition = new()
|
|
{
|
|
Filter =
|
|
[
|
|
new()
|
|
{
|
|
ControlType = ExtraFilterDefinition.ControlTypeDropDown,
|
|
AllowMultiselect = true,
|
|
DisplayName = "Test DropDown",
|
|
FieldName = "DropDownField",
|
|
DefaultValue = "DefaultValue"
|
|
},
|
|
|
|
new()
|
|
{
|
|
ControlType = ExtraFilterDefinition.ControlTypeDatePicker,
|
|
AllowMultiselect = false,
|
|
DisplayName = "Test DatePicker",
|
|
FieldName = "DatePickerField",
|
|
DefaultValue = "2023-01-01"
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldReturnDefaultValues_WhenNoChildrenInExtraFilter()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup();
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.AreEqual(new HashSet<string> { "DefaultValue" }, result[0].Value);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeStart);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldReturnNoValues_WhenNoDefaultsAndNoChildrenInExtraFilter()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup();
|
|
var extraFilterDefinition = new ExtraFilterDefinition
|
|
{
|
|
Filter =
|
|
[
|
|
new()
|
|
{
|
|
ControlType = ExtraFilterDefinition.ControlTypeDropDown,
|
|
AllowMultiselect = false,
|
|
DisplayName = "Test DropDown",
|
|
FieldName = "DropDownField",
|
|
},
|
|
|
|
new()
|
|
{
|
|
ControlType = ExtraFilterDefinition.ControlTypeDatePicker,
|
|
AllowMultiselect = false,
|
|
DisplayName = "Test DatePicker",
|
|
FieldName = "DatePickerField",
|
|
}
|
|
]
|
|
};
|
|
// Act
|
|
var result = extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.AreEqual(new HashSet<string>(), result[0].Value);
|
|
Assert.AreEqual(null, result[1].RangeStart);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldReturnAny_ForMultiselectAndNoValueSelected()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup();
|
|
var extraFilterDefinition = new ExtraFilterDefinition()
|
|
{
|
|
Filter =
|
|
[
|
|
new()
|
|
{
|
|
ControlType = ExtraFilterDefinition.ControlTypeDropDown,
|
|
AllowMultiselect = true,
|
|
DisplayName = "Test DropDown",
|
|
FieldName = "DropDownField"
|
|
}
|
|
]
|
|
};
|
|
|
|
// Act
|
|
var result = extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, result.Count);
|
|
Assert.AreEqual(new HashSet<string> { ExtraFilterDefinition.Any }, result[0].Value);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldParseDropDownValuesCorrectly()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Condition = FilterExpressionTree.ExpressionGroup.ConditionType.Or,
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.FieldExpression
|
|
{
|
|
Field = "DropDownField",
|
|
Condition = FilterExpressionTree.FieldConditionType.EqualTo,
|
|
Argument = "Value1"
|
|
},
|
|
|
|
new FilterExpressionTree.FieldExpression
|
|
{
|
|
Field = "DropDownField",
|
|
Condition = FilterExpressionTree.FieldConditionType.EqualTo,
|
|
Argument = "Value2"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsTrue(result[0].MultipleSelected);
|
|
CollectionAssert.AreEquivalent(new[] { "Value1", "Value2" }, result[0].Value!);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldParseMultiSelectDatePickerValuesCorrectly()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Condition = FilterExpressionTree.ExpressionGroup.ConditionType.And,
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.FieldExpression
|
|
{
|
|
Field = "DatePickerField",
|
|
Condition = FilterExpressionTree.FieldConditionType.GreaterThanOrEqualTo,
|
|
Argument = "2023-01-01"
|
|
},
|
|
|
|
new FilterExpressionTree.FieldExpression
|
|
{
|
|
Field = "DatePickerField",
|
|
Condition = FilterExpressionTree.FieldConditionType.LessThanOrEqualTo,
|
|
Argument = "2023-12-31"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsTrue(result[1].MultipleSelected);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeStart);
|
|
Assert.AreEqual("2023-12-31", result[1].RangeEnd);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseExtraFilter_ShouldParseSingleSelectDatePickerValuesCorrectly()
|
|
{
|
|
// Arrange
|
|
var extraFilter = new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.ExpressionGroup
|
|
{
|
|
Condition = FilterExpressionTree.ExpressionGroup.ConditionType.And,
|
|
Children =
|
|
[
|
|
new FilterExpressionTree.FieldExpression
|
|
{
|
|
Field = "DatePickerField",
|
|
Condition = FilterExpressionTree.FieldConditionType.EqualTo,
|
|
Argument = "2023-01-01"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseExtraFilter(extraFilter);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsFalse(result[1].MultipleSelected);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeStart);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeEnd);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateExtraFilter_ShouldGenerateCorrectExpressionGroup_MultiSelect()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = true,
|
|
Value = ["Value1", "Value2"]
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = true,
|
|
RangeStart = "2023-01-01",
|
|
RangeEnd = "2023-12-31"
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateExtraFilter(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, result.Condition);
|
|
Assert.AreEqual(2, result.Children.Count);
|
|
|
|
var dropDownGroup = result.Children[0] as FilterExpressionTree.ExpressionGroup;
|
|
Assert.IsNotNull(dropDownGroup);
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.Or, dropDownGroup!.Condition);
|
|
Assert.AreEqual(2, dropDownGroup.Children.Count);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.EqualTo, ((FilterExpressionTree.FieldExpression)dropDownGroup.Children[0]).Condition);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.EqualTo, ((FilterExpressionTree.FieldExpression)dropDownGroup.Children[1]).Condition);
|
|
|
|
var datePickerGroup = result.Children[1] as FilterExpressionTree.ExpressionGroup;
|
|
Assert.IsNotNull(datePickerGroup);
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, datePickerGroup!.Condition);
|
|
Assert.AreEqual(2, datePickerGroup.Children.Count);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.GreaterThanOrEqualTo, ((FilterExpressionTree.FieldExpression)datePickerGroup.Children[0]).Condition);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.LessThanOrEqualTo, ((FilterExpressionTree.FieldExpression)datePickerGroup.Children[1]).Condition);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateExtraFilter_ShouldGenerateCorrectExpressionGroup_SingleSelect()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false,
|
|
Value = ["Value1"]
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false,
|
|
RangeStart = "2023-01-01",
|
|
RangeEnd = "2023-01-01"
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateExtraFilter(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, result.Condition);
|
|
Assert.AreEqual(2, result.Children.Count);
|
|
|
|
var dropDownGroup = result.Children[0] as FilterExpressionTree.ExpressionGroup;
|
|
Assert.IsNotNull(dropDownGroup);
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, dropDownGroup!.Condition);
|
|
Assert.AreEqual(1, dropDownGroup.Children.Count);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.EqualTo, ((FilterExpressionTree.FieldExpression)dropDownGroup.Children[0]).Condition);
|
|
|
|
var datePickerGroup = result.Children[1] as FilterExpressionTree.ExpressionGroup;
|
|
Assert.IsNotNull(datePickerGroup);
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, datePickerGroup!.Condition);
|
|
Assert.AreEqual(1, datePickerGroup.Children.Count);
|
|
Assert.AreEqual(FilterExpressionTree.FieldConditionType.EqualTo, ((FilterExpressionTree.FieldExpression)datePickerGroup.Children[0]).Condition);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateExtraFilter_ShouldGenerateCorrectExpressionGroup_NoValues()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateExtraFilter(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(FilterExpressionTree.ExpressionGroup.ConditionType.And, result.Condition);
|
|
Assert.AreEqual(0, result.Children.Count);
|
|
}
|
|
[Test]
|
|
public void ParseQueryParameters_ShouldReturnDefaultValues_WhenQueryParametersAreEmpty()
|
|
{
|
|
// Arrange
|
|
var queryParameters = new Dictionary<string, string>();
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseQueryParameters(queryParameters);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsFalse(result[0].MultipleSelected);
|
|
Assert.IsNull(result[0].Value);
|
|
Assert.IsFalse(result[1].MultipleSelected);
|
|
Assert.IsNull(result[1].RangeStart);
|
|
Assert.IsNull(result[1].RangeEnd);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseQueryParameters_ShouldParseDropDownValuesCorrectly()
|
|
{
|
|
// Arrange
|
|
var queryParameters = new Dictionary<string, string>
|
|
{
|
|
{ "DropDownField", "Value1,Value2" }
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseQueryParameters(queryParameters);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsTrue(result[0].MultipleSelected);
|
|
CollectionAssert.AreEquivalent(new[] { "Value1", "Value2" }, result[0].Value!);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseQueryParameters_ShouldParseDatePickerValuesCorrectly()
|
|
{
|
|
// Arrange
|
|
var queryParameters = new Dictionary<string, string>
|
|
{
|
|
{ "DatePickerField", "2023-01-01,2023-12-31" }
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseQueryParameters(queryParameters);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsTrue(result[1].MultipleSelected);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeStart);
|
|
Assert.AreEqual("2023-12-31", result[1].RangeEnd);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseQueryParameters_ShouldHandleSingleDatePickerValue()
|
|
{
|
|
// Arrange
|
|
var queryParameters = new Dictionary<string, string>
|
|
{
|
|
{ "DatePickerField", "2023-01-01" }
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseQueryParameters(queryParameters);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsFalse(result[1].MultipleSelected);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeStart);
|
|
Assert.AreEqual("2023-01-01", result[1].RangeEnd);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseQueryParameters_ShouldIgnoreUnknownFields()
|
|
{
|
|
// Arrange
|
|
var queryParameters = new Dictionary<string, string>
|
|
{
|
|
{ "UnknownField", "SomeValue" }
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.ParseQueryParameters(queryParameters);
|
|
|
|
// Assert
|
|
Assert.AreEqual(2, result.Count);
|
|
Assert.IsFalse(result[0].MultipleSelected);
|
|
Assert.IsNull(result[0].Value);
|
|
Assert.IsFalse(result[1].MultipleSelected);
|
|
Assert.IsNull(result[1].RangeStart);
|
|
Assert.IsNull(result[1].RangeEnd);
|
|
}
|
|
[Test]
|
|
public void CreateQueryParameters_ShouldReturnEmptyDictionary_WhenValuesAreEmpty()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateQueryParameters(values);
|
|
|
|
// Assert
|
|
Assert.IsEmpty(result);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateQueryParameters_ShouldGenerateCorrectQueryParameters_ForDropDown()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = true,
|
|
Value = ["Value1", "Value2"]
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateQueryParameters(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, result.Count);
|
|
Assert.IsTrue(result.ContainsKey("DropDownField"));
|
|
Assert.AreEqual("Value1,Value2", result["DropDownField"]);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateQueryParameters_ShouldGenerateCorrectQueryParameters_ForDatePicker()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = true,
|
|
RangeStart = "2023-01-01",
|
|
RangeEnd = "2023-12-31"
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateQueryParameters(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, result.Count);
|
|
Assert.IsTrue(result.ContainsKey("DatePickerField"));
|
|
Assert.AreEqual("2023-01-01,2023-12-31", result["DatePickerField"]);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateQueryParameters_ShouldHandleSingleDatePickerValue()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false,
|
|
RangeStart = "2023-01-01",
|
|
RangeEnd = "2023-01-01"
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateQueryParameters(values);
|
|
|
|
// Assert
|
|
Assert.AreEqual(1, result.Count);
|
|
Assert.IsTrue(result.ContainsKey("DatePickerField"));
|
|
Assert.AreEqual("2023-01-01", result["DatePickerField"]);
|
|
}
|
|
|
|
[Test]
|
|
public void CreateQueryParameters_ShouldIgnoreEmptyValues()
|
|
{
|
|
// Arrange
|
|
var values = new List<ExtraFilterDefinition.FilterValue>
|
|
{
|
|
new()
|
|
{
|
|
MultipleSelected = false,
|
|
Value = []
|
|
},
|
|
new()
|
|
{
|
|
MultipleSelected = false,
|
|
RangeStart = null,
|
|
RangeEnd = null
|
|
}
|
|
};
|
|
|
|
// Act
|
|
var result = _extraFilterDefinition.CreateQueryParameters(values);
|
|
|
|
// Assert
|
|
Assert.IsEmpty(result);
|
|
}
|
|
|
|
}
|