public void TestSearchMultipleSearchConditionUsingMultiField(Enums.ResourceType resourceType, string fieldName1, string fieldName2, string condition1, string condition2)
{
Enums.ResourceType referenceResourceType1 = SystemTypeField.FieldResourceTypeMapper[fieldName1];
Enums.ResourceType referenceResourceType2 = SystemTypeField.FieldResourceTypeMapper[fieldName2];
string fieldAlias1 = $"{resourceType.ToResourceName()}.{fieldName1}";
string fieldAlias2 = $"{resourceType.ToResourceName()}.{fieldName2}";
//User id1 and id2 for first reference resource
//User id3 and id 4 for second reference resource
//Ex: Searching with 'Or' condition in P_Client and P_Resume resource
//P_Client:or=id1:id2 , P_Resume:or=id3:id4
//Use mid-list of ids (ex: 2 and 4) in recordNum(6) created to make sure there are some of data for verifying correctly.
string id1 = SystemFieldTypeHelper.GetResourceId(referenceResourceType1, records, 2);
string id2 = SystemFieldTypeHelper.GetResourceId(referenceResourceType1, records, 4);
string id3 = SystemFieldTypeHelper.GetResourceId(referenceResourceType2, records, 2);
string id4 = SystemFieldTypeHelper.GetResourceId(referenceResourceType2, records, 4);
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias1 },
{ DateTimeValidator.FieldAlias2, fieldAlias2 },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, id1 },
{ DateTimeValidator.ConditionValue2, id2 },
{ DateTimeValidator.ConditionValue3, id3 },
{ DateTimeValidator.ConditionValue4, id4 },
};
//Read & verify the field's value
SystemFieldTypeHelper.VerifyMultiSearchMultiFieldReferenceResource(resourceType, referenceResourceType1, referenceResourceType2, parameters);
}
public void TestSearchOrderField(Enums.ResourceType resourceType, List <string> fieldNames, string order)
{
string id = SystemFieldTypeHelper.GetResourceId(resourceType, records, 0); //Get first id
//Read & verify the field's value
SystemFieldTypeHelper.VerifyOrderSystemField(resourceType, fieldNames, order, id, recordNum, typeof(DateTime));
}
public void TestSearchMultipleSearchConditionUsingMultiFieldPhase(string fieldName1, string fieldName2, string condition1, string condition2)
{
Enums.ResourceType resourceType = Enums.ResourceType.Client;
string id = records.Data[$"{resourceType.ToPrivateEnum()}{fields.First()}data2{1}"].Id.ToString();
var phaseList = new Dictionary <int, string> {
{ 0, testData["data1"] }, { 1, testData["data2"] }, { 2, testData["data3"] },
{ 3, testData["data4"] }, { 4, testData["data5"] }, { 5, testData["data6"] }
}.Select(item =>
{
var phase = FieldHelper.CreatePhaseInstance(resourceType, id);
phase.DictionaryValues[fieldName1] = item.Value;
phase.DictionaryValues[fieldName2] = item.Value;
return(phase);
}).ToList();
List <string> ids = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(phaseList);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldName1 },
{ DateTimeValidator.FieldAlias2, fieldName2 },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, testData["data2"] },
{ DateTimeValidator.ConditionValue2, testData["data4"] },
};
//Read & verify the field's value
SystemFieldTypeHelper.VerifySearchDatePhase(resourceType, parameters, false);
}
/// <summary>
/// Verify multi search/single field result by resource of system field
/// </summary>
/// <param name="resourceType">Resource Type</param>
/// <param name="searchParameters">Search Paramters Class</param>
public static void VerifyMultiSearchOneFieldById(Enums.ResourceType resourceType, SearchParameters searchParameters, Dictionary <string, object> extraUrlParameters = null)
{
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();
ReadResponseData <XmlResource> result = SystemFieldTypeHelper.GetMultipleSearchResult(resourceType, firstFieldAlias, secondFieldAlias, firstCondition, secondCondition, firstCondValue.ToString(), secondCondValue.ToString(), extraUrlParameters);
Assert.That(result, MustBe.ReadSuccess(0), 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);
string realValue = null;
foreach (var item in result.Items)
{
if (firstFieldAlias == $"{resourceType.ToResourceName()}.{DeletedDataFields.P_UpdateBy}" || secondFieldAlias == $"{resourceType.ToResourceName()}.{DeletedDataFields.P_UpdateBy}")
{
XmlResource user = (item.DictionaryValues[$"{resourceType.ToResourceName()}.{DeletedDataFields.P_UpdateBy}"] as XmlResource).DictionaryValues["User"] as XmlResource;
realValue = user.DictionaryValues["User.P_Id"].ToString();
}
else
{
realValue = item.DictionaryValues[firstFieldAlias].ToString();
}
Assert.That(int.Parse(realValue), DateTimeValidator.ConditionsMap[firstCondition](int.Parse(firstCondValue), int.Parse(secondCondValue)).And.Matches(DateTimeValidator.ConditionsMap[secondCondition](int.Parse(secondCondValue), int.Parse(firstCondValue))), DateTimeValidator.ErrorMessage);
}
}
public void TestSearchField(Enums.ResourceType resourceType, string fieldName, string condition)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id1 = SystemFieldTypeHelper.GetRandomResourceId(resourceType, records, recordNum - 1);
string id2 = SystemFieldTypeHelper.GetRandomResourceId(resourceType, records, recordNum - 1);
Dictionary <string, string> parameters = GetDefaultParameters(fieldAlias, condition);
if (SystemTypeField.Id == fieldName)
{
parameters[DateTimeValidator.ConditionValue1] = id1;
parameters[DateTimeValidator.ConditionValue1] = id2;
}
//Read & verify the field's value
SystemFieldTypeHelper.VerifySingleSearchSystemField(resourceType.ToString(), parameters);
}
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);
}
}
}
public void TestSearchField(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType, string fieldName, string condition)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id1 = records.Data[$"{referenceResourceType.ToPrivateEnum()}2"].Id.ToString();
string id2 = records.Data[$"{referenceResourceType.ToPrivateEnum()}3"].Id.ToString();
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias },
{ DateTimeValidator.Condition1, condition },
{ DateTimeValidator.ConditionValue1, id1 },
{ DateTimeValidator.ConditionValue2, id2 },
};
//Read & verify the field's value
SystemFieldTypeHelper.VerifySingleSearchSystemFieldReferenceResource(resourceType, referenceResourceType, parameters);
}
public void TestMultipleSearchMultipleNumberField(string fieldName1, string fieldName2, string condition1, string condition2)
{
condition1 = condition1.ToLowerString();
condition2 = condition2.ToLowerString();
if (fieldName1.Contains("Date") && fieldName2.Contains("Date"))
{
Dictionary <string, string> conditionParameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldName1 },
{ DateTimeValidator.FieldAlias2, fieldName2 },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName1, indexFirstPhaseList) }, //Get phase value by public api because read phase private api could not retrieve RegistrationDate, Option alias
{ DateTimeValidator.ConditionValue2, PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName2, indexSecondPhaseList) }, //Get phase value by public api because read phase private api could not retrieve RegistrationDate, Option alias
};
SystemFieldTypeHelper.VerifySearchDatePhase(defaultResource, conditionParameters, false);
}
else
{
List <string> conditionValues = new List <string>();
conditionValues.Add((PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName1, indexFirstPhaseList)));
conditionValues.Add((PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName1, indexFirstPhaseList)));
conditionValues.Add((PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName2, indexSecondPhaseList)));
conditionValues.Add((PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName2, indexSecondPhaseList)));
string formatCond = PhaseHelper.GetFormatConditionDifferentFields(fieldName1, fieldName2, condition1, condition2, conditionValues[0], conditionValues[1], conditionValues[2], conditionValues[3]);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
{ PhaseApiFields.Condition, formatCond },
{ PhaseApiFields.Field, $"{fieldName1},{fieldName2}" },
};
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)
{
DateTimeValidator.ConditionalAssertions[condition1](item.DictionaryValues[fieldName1], conditionValues[0], conditionValues[1]);
DateTimeValidator.ConditionalAssertions[condition2](item.DictionaryValues[fieldName2], conditionValues[2], conditionValues[3]);
}
}
}
public void TestSearchFieldPhase(string fieldName, string condition)
{
Enums.ResourceType resourceType = Enums.ResourceType.Client;
Dictionary <string, string> resourceIds = new Dictionary <string, string>();
//Get resource ids
for (int i = 1; i <= 6; i++)
{
resourceIds[$"id{i}"] = GetResourceId(resourceType, i - 1);
}
var phaseList = new Dictionary <int, string> {
{ 0, resourceIds["id1"] }, { 1, resourceIds["id2"] }, { 2, resourceIds["id3"] },
{ 3, resourceIds["id4"] }, { 4, resourceIds["id5"] }, { 5, resourceIds["id6"] }
}.Select(item =>
{
var phase = FieldHelper.CreatePhaseInstance(resourceType, item.Value);
if (SystemTypeField.Id.Substring(2) != fieldName)
{
phase.DictionaryValues[fieldName] = ResourceHelper.DefaultUser;
}
return(phase);
}).ToList();
List <string> ids = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(phaseList);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assume.That(ids, Is.All.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Dictionary <string, string> parameters = GetDefaultParameters(fieldName, condition);
if (SystemTypeField.Id == fieldName)
{
//Choose different ids to make sure searching better (ex: if choose conditionValue1 = conditionValue1 = id1 so when using 'and' condition, we will not see the best searching)
parameters[DateTimeValidator.ConditionValue1] = resourceIds.Random();
parameters[DateTimeValidator.ConditionValue1] = resourceIds.Random();
}
//Read & verify the field's value
SystemFieldTypeHelper.VerifySingleSearchSystemField(nameof(Phase), parameters, new Dictionary <string, object>()
{
{ "resource", (int)resourceType }
});
}
public void TestSearchOrderFieldPhase(List <string> fieldNames, string order)
{
Enums.ResourceType resourceType = Enums.ResourceType.Client;
string id = SystemFieldTypeHelper.GetRandomResourceId(resourceType, records, 3); //Use any ids in created records
List <Phase> phaseList = new List <Phase>();
List <string> ids = new List <string>();
for (int i = 1; i <= recordNum; i++)
{
phaseList.Add(FieldHelper.CreatePhaseInstance(resourceType, id));
ids.AddRange(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(phaseList));
}
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assume.That(ids, Is.All.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
//Read & verify the field's value
SystemFieldTypeHelper.VerifyOrderPhaseSystemField(resourceType, fieldNames, order, ids.FirstOrDefault(), recordNum, typeof(DateTime));
}
public void TestSearchMultipleSearchConditionUsing1Field(Enums.ResourceType resourceType, string fieldName, string condition1, string condition2)
{
Enums.ResourceType referenceResourceType = SystemTypeField.FieldResourceTypeMapper[fieldName];
string fieldAlias = $"{resourceType.ToResourceName()}.{fieldName}";
string id1 = SystemFieldTypeHelper.GetResourceId(referenceResourceType, records, 2);
string id2 = SystemFieldTypeHelper.GetResourceId(referenceResourceType, records, 4);
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias },
{ DateTimeValidator.FieldAlias2, fieldAlias },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, id1 },
{ DateTimeValidator.ConditionValue2, id2 },
};
//Read & verify the field's value
SystemFieldTypeHelper.VerifyMultiSearchSingleFieldReferenceResource(resourceType, referenceResourceType, parameters);
}
