/// <summary>
/// Verifying a search date
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="searchParameters">Search parameters</param>
/// <param name="extraUrlParameters">Extra url parameters</param>
/// <param name="isDate">True/False</param>
public static void VerifySearchDate(Enums.ResourceType resourceType, SearchParameters searchParameters, int resultCode, Dictionary <string, object> extraUrlParameters = null, bool isDate = true)
{
string firstFieldAlias = searchParameters.FirstFieldAlias;
string secondFieldAlias = searchParameters.SecondFieldAlias;
string firstCondition = searchParameters.FirstCondition;
string secondCondition = searchParameters.SecondCondition;
string firstCondValue = searchParameters.FirstCondValue.ToString();
string secondCondValue = searchParameters.SecondCondValue.ToString();
string formatCond = DateTimeValidator.GetFormatCondition(firstFieldAlias, secondFieldAlias, firstCondition, secondCondition, firstCondValue, secondCondValue);
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", firstFieldAlias == secondFieldAlias ? firstFieldAlias : string.Format("{0},{1}", firstFieldAlias, secondFieldAlias) }
};
if (extraUrlParameters != null)
{
urlParameters = urlParameters.Concat(extraUrlParameters).GroupBy(d => d.Key).ToDictionary(d => d.Key, d => d.First().Value);
}
if (resultCode == Enums.PublicAPIResultCode.DateTimeOutOfRange)
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.MatchingErrorCode(resultCode), Enums.Message.WRONG_ERROR_CODE);
}
else
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.IsNotNull(result.Items, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.That(result.Count, Is.GreaterThanOrEqualTo(0), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.GreaterThanOrEqualTo(0), Enums.Message.COUNT_ERROR);
if (firstFieldAlias == secondFieldAlias)
{
VerifyValueOneField(result.Items, searchParameters, isDate);
}
else
{
VerifyValueMultipleField(result.Items, searchParameters, isDate);
}
}
}
public void TestMultipleSearch1NumberField(string fieldName, string condition1, string condition2)
{
condition1 = condition1.ToLowerString();
condition2 = condition2.ToLowerString();
string conditionValue1 = string.Empty;
string conditionValue2 = string.Empty;
conditionValue1 = PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName, indexFirstPhaseList); //Get phase value by public api because read phase private api could not retrieve RegistrationDate, Option alias
conditionValue2 = PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName, indexSecondPhaseList); //Get phase value by public api because read phase private api could not retrieve RegistrationDate, Option alias
//Read & verify the field's value
if (fieldName == PhaseApiFields.RegistrationDate || fieldName == PhaseApiFields.UpdateDate || fieldName == PhaseApiFields.Date)
{
Dictionary <string, string> conditionParameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldName },
{ DateTimeValidator.FieldAlias2, fieldName },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, conditionValue1 },
{ DateTimeValidator.ConditionValue2, conditionValue2 },
};
SystemFieldTypeHelper.VerifySearchDatePhase(defaultResource, conditionParameters, false);
}
else
{
string formatCond = DateTimeValidator.GetFormatCondition(fieldName, fieldName, condition1, condition2, conditionValue1, conditionValue2);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
{ PhaseApiFields.Condition, formatCond },
{ PhaseApiFields.Field, fieldName },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
foreach (var item in result.Items)
{
Assert.That(int.Parse(item.DictionaryValues[fieldName].ToString()), DateTimeValidator.ConditionsMap[condition1](int.Parse(conditionValue1), int.Parse(conditionValue2)).And.Matches(DateTimeValidator.ConditionsMap[condition2](int.Parse(conditionValue2), int.Parse(conditionValue1))), DateTimeValidator.ErrorMessage);
}
}
}