private static SearchRequest GetDefaultSearchFilters(ResourceId resource)
{
return(SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(
OperatorType.Or, new List <SearchFilter> {
SearchHelpers.SearchFilters[SearchFilterType.NumIn](resource, "P_Id", CurrentDateTime, Timezone, RecordsCreator)
}));
}
public void EnumParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).
BooleanFilter(OperatorType.And, new List <SearchFilter>
{
new SearchFilter
{
Area = "TEXT",
SplitMode = "AND",
SearchType = "COND_FREEWORD",
Operator = "IN",
Value = SearchValue.CreateConst("TEST")
},
new SearchFilter
{
Operator = "=",
SearchType = "COND_DATE2",
Timezone = "UTC",
Field = new SearchField
{
Type = "FIELD",
Route = $"{resource}.A_TestDate1"
},
Value = SearchValue.CreatePeriod("+P2Y", "DAY")
}
});
request.Conditions.OrderBy.First().Direction = "DESC";
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
public static void VerifySearchByDateField(ResourceId resource, ValidTestCases testCase, string fieldName, Directions direction, string currentDateTime, string timezone, int numRecords, HrbcRecordCreator hrbcRecordCreator)
{
SearchValue searchValue1 = null;
SearchValue searchValue2 = null;
DateTime dateTimeGreater = DateTime.Parse(currentDateTime);
DateTime dateTimeLess = DateTime.Parse(currentDateTime);
if (testCase == ValidTestCases.EqualsTo)
{
searchValue1 = searchValue2 = SearchValue.CreateDate(currentDateTime);
}
else
if (testCase == ValidTestCases.Greater)
{
searchValue1 = SearchValue.CreateDate(currentDateTime);
searchValue2 = SearchValue.CreateDate(dateTimeGreater.AddMinutes(numRecords - 1).ToString(SearchConstants.SearchApiFullDateTemplate));
}
else
{
searchValue2 = SearchValue.CreateDate(currentDateTime);
searchValue1 = SearchValue.CreateDate(dateTimeLess.AddMinutes(-numRecords).ToString(SearchConstants.SearchApiFullDateTemplate));
}
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter($"{resource.ToString()}.{fieldName}", OperatorType.Between, timezone, searchValue1, searchValue2);
request.Conditions.OrderBy = GetOrderByType(resource, fieldName, direction);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.SuccessfulResponse());
Assertions[direction](response.Result.Items, resource, hrbcRecordCreator, numRecords);
}
public void TimezoneDstTest(ResourceId resource, TestCoreFramework.Enums.FieldType fieldType, string fieldCategory, string timezone, int timeOffset, Func <string> fieldNameProvider)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fieldNameProvider(), OperatorType.Eq, timezone, AltTestDateTime.AddHours(timeOffset).ToString(SearchConstants.SearchApiFullDateTemplate));
var expectedId = RecordsCreator.Data[$"{resource} Alt"].Id;
PerformHappyPathTest(resource, request, (int)expectedId);
}
public void MultipleValidSearchCondition(ResourceId resource, OperatorType boolFilterType, SearchFilterType firstFilterType, SearchFilterType secondFilterType, string firstFieldName, string secondFieldName)
{
var firstExpectedId = RecordsCreatorForNumCond.Data[$"{resource}0"].Id;
var secondExpectedId = RecordsCreatorForNumCond.Data[$"{resource}1"].Id;
var searchFilters = new List <SearchFilter>();
searchFilters.Add(SearchHelpers.SearchFilters[firstFilterType](resource, firstFieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond));
searchFilters.Add(SearchHelpers.SearchFilters[secondFilterType](resource, secondFieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond));
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(boolFilterType, searchFilters);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response?.Result?.Status, PrIs.Not.Null.And.EqualTo("OK"));
PrAssert.That(response?.Result?.Total, PrIs.Not.Null.And.GreaterThanOrEqualTo(1));
if (boolFilterType == OperatorType.And)
{
if (TwoRecordsBeReturned(firstFilterType) && TwoRecordsBeReturned(secondFilterType))
{
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedId).And.Contains(secondExpectedId));
}
else
{
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedId).Or.Contains(secondExpectedId));
}
}
else
{
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedId).And.Contains(secondExpectedId));
}
}
public void RouteParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).
NumFilter($"{resource}.A_TestNumberScale0", OperatorType.Eq, 1234);
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
public void TextParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).
TextFilter("A_TestSingleLineText", OperatorType.Eq, null, "test");
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
private static Dictionary <string, Func <SearchRequest> > PrepareDateCases(ResourceId resource, Func <string> fullFieldName, DateTime testValue, DateTime altTestValue)
{
Func <OperatorType, DateTime, SearchRequest> dateOpRequestCreator =
(op, value) => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, value.ToString(SearchConstants.SearchApiFullDateTemplate));
Func <OperatorType, DateTime, SearchRequest> periodOpRequestCreator =
(op, value) => SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fullFieldName(), op, DefaultTimezone, System.Xml.XmlConvert.ToString(Truncate(value - DateTime.Now)), crop: "HOUR");
return(new Dictionary <string, Func <SearchRequest> >
{
["Date - LessOrEqual <= -- value is equal"] = () => dateOpRequestCreator(OperatorType.Le, testValue),
["Date - LessOrEqual <= -- value is less"] = () => dateOpRequestCreator(OperatorType.Le, (testValue).AddDays(2)),
["Date - Less <"] = () => dateOpRequestCreator(OperatorType.Lt, (testValue).AddDays(2)),
["Date - Equal ="] = () => dateOpRequestCreator(OperatorType.Eq, testValue),
["Date - NotEqual !="] = () => dateOpRequestCreator(OperatorType.Neq, altTestValue),
[$"Date - Greater > {ImportantCaseMarker}"] = () => dateOpRequestCreator(OperatorType.Gt, (testValue).AddDays(-2)),
["Date - GreaterOrEqual >= -- value is equal"] = () => dateOpRequestCreator(OperatorType.Ge, testValue),
["Date - GreaterOrEqual >= -- value is greater"] = () => dateOpRequestCreator(OperatorType.Ge, (testValue).AddDays(-2)),
["Period - LessOrEqual <= -- value is equal"] = () => periodOpRequestCreator(OperatorType.Le, testValue),
["Period - LessOrEqual <= -- value is less"] = () => periodOpRequestCreator(OperatorType.Le, testValue.AddDays(2)),
["Period - Less <"] = () => periodOpRequestCreator(OperatorType.Lt, (testValue).AddDays(2)),
["Period - Equal ="] = () => periodOpRequestCreator(OperatorType.Eq, testValue),
["Period - NotEqual !="] = () => periodOpRequestCreator(OperatorType.Neq, altTestValue),
["Period - Greater >"] = () => periodOpRequestCreator(OperatorType.Gt, (testValue).AddDays(-2)),
["Period - GreaterOrEqual >= -- value is equal"] = () => periodOpRequestCreator(OperatorType.Ge, testValue),
["Period - GreaterOrEqual >= -- value is greater"] = () => periodOpRequestCreator(OperatorType.Ge, (testValue).AddDays(-2))
});
}
public void PeriodParamterValidationTest(ResourceId resource, VerificationCaseType testCase, PrivateApiResponseCode expectedCode, Action <SearchRequest, Func <string, string> > requestUpdater, string caseDescription)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).
DateFilter($"{resource}.A_TestDate1", OperatorType.Gt, "Asia/Tokyo", "P1M", null);
PerformValidationTest(request, resource, testCase, expectedCode, requestUpdater);
}
public void InvalidSearchBySystemUpdateDateField(ResourceId resource, SearchHelpers.InvalidTestCases testCase, string fieldName)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter($"{resource.ToString()}.{fieldName}", OperatorType.Eq, Timezone, SearchHelpers.DateTimeMap[testCase].ToString());
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.ErrorResponse());
}
public void InvalidSearchByCustomDateField(ResourceId resource, FieldType fieldType, string fieldName, Func <string> fieldNameProvider, SearchHelpers.InvalidTestCases testCase)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).DateFilter(fieldNameProvider(), OperatorType.Eq, Timezone, SearchHelpers.DateTimeMap[testCase].ToString());
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.ErrorResponse());
}
public void SuccessfulSearch_AreaAllOnly_SplitModeNOT(ResourceId resource, TestCoreFramework.Enums.FieldType fieldType, OperatorType op, string fieldCategory)
{
var value = GetFieldValueByFieldType(fieldType, resource, fieldCategory).ToString();
value = SearchValueTransformationsByOperator[op](value);
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).FreewordFilter(op, null, "NOT", "ALL", value);
PerformSuccessfulInvertedSearchTest(resource, request);
}
public void SuccessfulSearch_FileOnly_SplitModeAnd_PrcKeyword(ResourceId resource, FileType fileType, OperatorType op)
{
var value = $"Sample {fileType.ToString().ToUpper()}File {fileType} PRC";
value = SearchValueTransformationsByOperator[op](value);
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).FreewordFilter(op, null, "NOT", "FILES", value);
PerformSuccessfulInvertedSearchTest(resource, request);
}
public void SuccessfulSearch_TextOnly_SplitModeOR(ResourceId resource, TestCoreFramework.Enums.FieldType fieldType, OperatorType op, string fieldCategory)
{
var value = GetFieldValueByFieldType(fieldType, resource, fieldCategory).ToString();
value = SearchValueTransformationsByOperator[op](value) + " SomeRandomString";
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).FreewordFilter(op, null, "OR", "TEXT", value);
PerformSuccessfulSearchTest(resource, request);
}
public void SearchEqualOpAccessEndpointTests(AccessState accessState, HttpStatusCode httpStatusCode, ResultCode resultCode)
{
AccessEndpointManager accessEndpointHandler = new AccessEndpointManager();
string value = "memo";
var requestSearch = SearchRequestComposer.GetBuilderWithRestrictions(ResourceId.Client).TextFilter($"{ResourceId.Client}.P_Memo", OperatorType.Eq, null, value);
var response = accessEndpointHandler.AccessEndpoint <SearchResponse>(accessState, SearchManager.EndPoint, requestSearch, HttpMethod.Post);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(httpStatusCode).And.ErrorCode((int)resultCode));
}
private static Dictionary <string, Func <SearchRequest> > PrepareTextCases(ResourceId resource, Func <string> fullFieldName, string testValue)
{
return(new Dictionary <string, Func <SearchRequest> >
{
["StartsWith operator"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).TextFilter(fullFieldName(), OperatorType.StartsWith, null, testValue.Substring(0, 5)),
["IN operator"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).TextFilter(fullFieldName(), OperatorType.In, null, testValue.Substring(3, 5)),
["IN operator one character"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).TextFilter(fullFieldName(), OperatorType.In, null, testValue.Substring(3, 1)),
[$"Equals operator {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).TextFilter(fullFieldName(), OperatorType.Eq, null, testValue)
});
}
private static Dictionary <string, Func <SearchRequest> > PrepareNumAllCases(ResourceId resource, Func <string> fullFieldName, object testValue)
{
var range = (testValue as string[]);
return(new Dictionary <string, Func <SearchRequest> >
{
[$"1:1 match {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumAllFilter(fullFieldName(), range),
["Search is narrower"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumAllFilter(fullFieldName(), range.Skip(1))
});
}
public void SearchSystemApplicationFieldCore(ResourceId resourceId, string field, SearchDateFieldCases.TestCases cases, bool isAsc)
{
var expectedOperator = cases == SearchDateFieldCases.TestCases.EqualsTo ? OperatorType.Eq : cases == SearchDateFieldCases.TestCases.Less ? OperatorType.Lt : OperatorType.Gt;
var requestBuilder = SearchRequestComposer.GetBuilderWithRestrictions(resourceId)
.WithSort(isAsc, $"{resourceId.ToString()}.{field}");
var request = requestBuilder.DateFilter($"{resourceId.ToString()}.{field}", expectedOperator,
"Asia/Tokyo", CreateDateTime.ToString(SearchConstants.SearchApiShortDateTemplate));
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
SearchDateFieldCases.VerifySearchResult(response, resourceId, cases, $"{resourceId.ToString()}.{field}", isAsc, RecordsCreator, NumRecordsEachCase, DateResponseFormat);
}
private void PerformHappyPathBoolNotTest(ResourceId resource, SearchRequest request)
{
var expectedId = RecordsCreator.Data[$"{resource}"].Id;
var boolNotRequest = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanNotFilter(request.Conditions.Filter);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(boolNotRequest);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response?.Result?.Status, PrIs.Not.Null.And.EqualTo("OK"));
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Not.Contains(expectedId));
}
public void PerformSearchWithExcessiveParametersTest_ForSublistSearch(string parameterPath, bool allSame)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(ResourceId.Client, limit: 10, offset: 0)
.SubqueryFilter("Client.P_Id", ResourceId.Job, "Job.P_Id", SearchFilter.CreateNum("Job.P_Id", ">", 0));
var requestString = GetRequestStringWithExcessiveParameters(request, parameterPath, allSame ? null : "10010");
var connection = PrivateApiConnection.GetConnectionForCurrentTest();
using (var response = connection.SendAsync(SearchManager.EndPoint, requestString, System.Net.Http.HttpMethod.Post).Result)
{
PrAssert.That(!response.IsSuccessStatusCode, "A request with an extra parameter was successful while expected fail");
}
}
public void PerformSearchWithExcessiveParametersTest_ForSimpleNumSearch(string parameterPath, bool allSame)
{
var request = SearchRequestComposer.GetBuilderWithRestrictions(ResourceId.Client, limit: 10, offset: 0)
.NumFilter("Client.P_Id", SearchHandlingComponent.Enums.OperatorType.Gt, 0);
var requestString = GetRequestStringWithExcessiveParameters(request, parameterPath, allSame ? null : "TEST_PROPERTY_VALUE");
var connection = PrivateApiConnection.GetConnectionForCurrentTest();
using (var response = connection.SendAsync(SearchManager.EndPoint, requestString, System.Net.Http.HttpMethod.Post).Result)
{
PrAssert.That(!response.IsSuccessStatusCode, "A request with wrong HTTP method was successful, while expected fail");
}
}
public void SearchUserFieldCore(ResourceId resourceId, SearchDateFieldCases.TestCases cases, bool isAsc)
{
var expectedOperator = cases == SearchDateFieldCases.TestCases.EqualsTo ? OperatorType.Eq : cases == SearchDateFieldCases.TestCases.Less ? OperatorType.Lt : OperatorType.Gt;
var request = SearchRequestComposer.GetBuilderWithRestrictions(resourceId)
.WithSort(isAsc, $"{resourceId}.{FieldCreator.Data[$"{resourceId}_{TestCoreFramework.Enums.FieldType.DateTime}"].Name}")
.DateFilter($"{resourceId}.{FieldCreator.Data[$"{resourceId}_{TestCoreFramework.Enums.FieldType.DateTime}"].Name}", expectedOperator,
"Asia/Tokyo", CreateDateTime.ToString(SearchConstants.SearchApiFullDateTemplate));
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
SearchDateFieldCases.VerifySearchResult(response, resourceId, cases, $"{resourceId.ToString()}.{FieldCreator.Data[$"{resourceId}_{TestCoreFramework.Enums.FieldType.DateTime}"].Name}", isAsc, RecordsCreator, NumRecordsEachCase, DateTimeResponseFormat);
}
private static Dictionary <string, Func <SearchRequest> > PrepareNumCases(ResourceId resource, Func <string> fullFieldName, object testValue, object altTestValue)
{
return(new Dictionary <string, Func <SearchRequest> >
{
["LessOrEqual <= -- value is equal"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Le, testValue),
["LessOrEqual <= -- value is less"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Le, (double)testValue + 1),
["Less <"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Lt, (double)testValue + 1),
["Equal ="] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Eq, testValue),
["NotEqual !="] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Neq, altTestValue),
[$"Greater > {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Gt, (double)testValue - 1),
["GreaterOrEqual >= -- value is equal"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Ge, testValue),
["GreaterOrEqual >= -- value is greater"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumFilter(fullFieldName(), OperatorType.Ge, (double)testValue - 1)
});
}
private void PerformHappyPathSubqueryTest(ResourceId resource, SearchRequest request)
{
var expectedId = RecordsCreator.Data[$"{resource}"].Id;
var subqueryRequest = SearchRequestComposer.GetBuilderWithRestrictions(resource).SubqueryFilter($"{resource}.P_Id", resource, $"{resource}.P_Id", request.Conditions.Filter);
//request.Conditions.Filter.Field.Route, resource, request.Conditions.Filter.Field.Route, request.Conditions.Filter);//(request.Conditions.Filter);
//TODO: uncomment the line above and set bug 39348
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(subqueryRequest);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response?.Result?.Status, PrIs.Not.Null.And.EqualTo("OK"));
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(expectedId));
}
public void MultipleInvalidSearchCondition(ResourceId resource, OperatorType boolFilterType, SearchFilterType firstFilterType, SearchFilterType secondFilterType, string firstFieldName, string secondFieldName)
{
var searchFilters = new List <SearchFilter>();
searchFilters.Add(SearchHelpers.SearchFilters[firstFilterType](resource, firstFieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond));
var secondSearchFilter = SearchHelpers.SearchFilters[secondFilterType](resource, secondFieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond);
secondSearchFilter.Operator = "Invalid Operator";
searchFilters.Add(secondSearchFilter);
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(boolFilterType, searchFilters);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.ErrorResponse());
}
public void SuccessfulSearch_FileOnly_SplitModeNot(ResourceId resource, FileType fileType, OperatorType op)
{
var value = $"Sample {fileType.ToString().ToUpper()}File {fileType} SomeRandomString";
value = SearchValueTransformationsByOperator[op](value);
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).FreewordFilter(op, null, "NOT", "FILES", value);
if (!NotReadableFiles.Contains(fileType))
{
PerformSuccessfulSearchTest(resource, request);
}
else
{
PerformSuccessfulInvertedSearchTest(resource, request);
}
}
public void MultipleSearchWithDifferentCondition(ResourceId resource, OperatorType boolFilterType, SearchFilterType filterType, string fieldName)
{
var firstExpectedIdOfFirstCondition = RecordsCreatorForFirstCondition.Data[$"{resource}0"].Id;
var secondExpectedIdOfFirstCondition = RecordsCreatorForFirstCondition.Data[$"{resource}1"].Id;
var firstExpectedIdOfSecondCondition = RecordsCreatorForSecondCondition.Data[$"{resource}0"].Id;
var secondExpectedIdOfSecondCondition = RecordsCreatorForSecondCondition.Data[$"{resource}1"].Id;
var searchFilters = ListSearchFilters[filterType](resource, fieldName, CurrentDateTime, Timezone);
var request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(boolFilterType, searchFilters);
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response?.Result?.Status, PrIs.Not.Null.And.EqualTo("OK"));
if (boolFilterType == OperatorType.And)
{
if (filterType.ToString().Contains("Date") || filterType == SearchFilterType.FreeWord)
{
PrAssert.That(response?.Result?.Total, PrIs.Not.Null.And.GreaterThanOrEqualTo(1));
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedIdOfFirstCondition).And.Contains(secondExpectedIdOfFirstCondition)
.And.Contains(firstExpectedIdOfSecondCondition).And.Contains(secondExpectedIdOfSecondCondition));
}
else
{
PrAssert.That(response?.Result?.Items, PrIs.Null.Or.Empty);
}
}
else
{
PrAssert.That(response?.Result?.Total, PrIs.Not.Null.And.GreaterThanOrEqualTo(1));
if (filterType == SearchFilterType.NumIn || filterType == SearchFilterType.NumOperator)
{
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedIdOfFirstCondition).And.Contains(firstExpectedIdOfSecondCondition));
}
else
{
PrAssert.That(response?.Result?.Items, PrIs.Not.Null.And.Contains(firstExpectedIdOfFirstCondition).And.Contains(secondExpectedIdOfFirstCondition)
.Or.Contains(firstExpectedIdOfSecondCondition).And.Contains(secondExpectedIdOfSecondCondition));
}
}
}
public void SearchWrongOperatorInBoolCondition(ResourceId resource, SearchFilterType filterType, OperatorType boolFilterType, SearchFilterType subFilterType, string fieldName)
{
var searchFilter = SearchHelpers.SearchFilters[subFilterType](resource, fieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond);
SearchRequest request = null;
if (filterType == SearchFilterType.BoolAndOr)
{
request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(boolFilterType, new[] { searchFilter });
}
else
{
request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanNotFilter(searchFilter);
}
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.ErrorResponse());
}
private static Dictionary <string, Func <SearchRequest> > PrepareNumMinMaxCases(ResourceId resource, Func <string> fullFieldName, object testValue, object altTestValue, TestCoreFramework.Enums.FieldType fieldType)
{
if (fieldType == TestCoreFramework.Enums.FieldType.OptionCheckbox)
{
var range = (testValue as string[]).Select(Convert.ToDouble);
return(new Dictionary <string, Func <SearchRequest> >
{
[$"Min equals first item, max -- last {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumMinMaxFilter(fullFieldName(), range.First(), range.Last())
});
}
else
{
return(new Dictionary <string, Func <SearchRequest> >
{
[$"Strictly within range {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumMinMaxFilter(fullFieldName(), ((double)testValue) - 1, ((double)testValue) + 1),
["Test value equals min"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumMinMaxFilter(fullFieldName(), ((double)testValue), ((double)testValue) + 1),
["Test value equals max"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumMinMaxFilter(fullFieldName(), ((double)testValue) - 1, ((double)testValue)),
["Test value equals max and min"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumMinMaxFilter(fullFieldName(), ((double)testValue), ((double)testValue))
});
}
}
private static Dictionary <string, Func <SearchRequest> > PrepareNumInCases(ResourceId resource, Func <string> fullFieldName, object testValue, object altTestValue, TestCoreFramework.Enums.FieldType fieldType)
{
if (fieldType == TestCoreFramework.Enums.FieldType.OptionCheckbox)
{
var range = (testValue as string[]);
return(new Dictionary <string, Func <SearchRequest> >
{
[$"1:1 match {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumInFilter(fullFieldName(), range),
["Search is wider"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumInFilter(fullFieldName(), range.Append("42")),
["Search is narrower"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumInFilter(fullFieldName(), range.Skip(1)),
["Search is partially matching"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumInFilter(fullFieldName(), range.Skip(1).Append("42"))
});
}
else
{
return(new Dictionary <string, Func <SearchRequest> >
{
[$"Value inside range {ImportantCaseMarker}"] = () => SearchRequestComposer.GetBuilderWithRestrictions(resource).NumInFilter(fullFieldName(), new[] { 0, testValue, altTestValue, 100010 })
});
}
}