public void TestReadValidFieldParameters(Enums.ResourceType resourceType, string fieldName, ValidFieldInput valueInput)
{
string field = string.Empty;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)resourceType },
};
if (valueInput == ValidFieldInput.SingleValue)
{
field = fieldName;
}
else
{
field = $"{fieldName},{fieldName},{fieldName},{fieldName}";
}
parameters.Add(PhaseApiFields.Field, field);
XmlHandler result = PublicApiAdapter.CreateAdapterForDefaultConnection().Read <Phase>(parameters) as XmlHandler;
Assert.NotNull(result, "Failed to parse the server's response!");
ReadResponseData <Option> parseResult = XmlHelper.ParseXMLString <ReadResponseData <Option> >(result.RawContent);
Assert.That(parseResult, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Phase"));
//Verify that the result contains field name only
VerifyFieldParameter(result, fieldName);
}
/// <summary>
/// Send a request to read resource. Parse response's xml to ReadResponseData.
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="urlParameters">Url parameters</param>
/// <returns>List of xml resource</returns>
public static List <XmlResource> ReadResource(Enums.ResourceType resourceType, Dictionary <string, object> urlParameters, int count = 0)
{
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(count), "Read resource failed!");
return(result.Items);
}
public void TestNoneTelephoneField(Enums.ResourceType resourceType, FieldType fieldType, SameResultSymbolType symbolType)
{
int symbolIndex = GetSymbolIndex(symbolType);
string fieldName = customFields.Data[$"{resourceType}-{fieldType}"].Field.Name;
Dictionary <string, object> urlParam1 = new Dictionary <string, object>()
{
[ResourceHelper.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
["keyword"] = KeywordHelper.GetKeywordBasedOnSymbolType(fieldName, symbolType, symbolIndex),
[ResourceHelper.FieldAlias] = string.Join(",", CommonConstant.NoneTelephoneTextField[resourceType]) + $",{resourceType.ToResourceName()}.P_Id",
};
ReadResponseData <XmlResource> result1 = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToResourceName(), urlParam1);
Assert.That(result1, MustBe.ReadSuccess(1), "Read resource failed!");
Assert.That(result1.Items.Random().DictionaryValues[customFields.Data[$"{resourceType}-{fieldType}"].Field.ToAlias()],
Does.Contain(KeywordHelper.GetFieldValueBasedOnSymbolType(fieldName, symbolType, symbolIndex, false)),
"The expected field doesn't contain the expected keyword!");
Dictionary <string, object> urlParam2 = new Dictionary <string, object>()
{
[ResourceHelper.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
["keyword"] = KeywordHelper.GetFieldValueBasedOnSymbolType(fieldName, symbolType, symbolIndex, false),
[ResourceHelper.FieldAlias] = string.Join(",", CommonConstant.NoneTelephoneTextField[resourceType]) + $",{resourceType.ToResourceName()}.P_Id",
};
ReadResponseData <XmlResource> result2 = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToResourceName(), urlParam2);
Assert.That(result2, MustBe.ReadSuccess(1), "Read resource failed!");
Assert.IsTrue(ResourceHelper.CompareList(result1.Items, result2.Items, $"{resourceType.ToResourceName()}.P_Id"), "Results are different!");
}
/// <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);
}
}
private static void ReadAndVerify(Enums.ResourceType resourceType, string fieldAlias, string id, Action <object> verifyActualValue = null)
{
ReadResponseData <XmlResource> result = ResourceHelper.ReadResourceById(resourceType, fieldAlias, id);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
verifyActualValue?.Invoke(result.Items[0].DictionaryValues[fieldAlias]);
}
public static void ReadAndVerify(Enums.ResourceType resourceType, Dictionary <string, ResourceFields.InputType> fieldAlias, string id, int index, HrbcRecordCreator expectedRecords, HrbcFieldReader fieldReader)
{
ReadResponseData <XmlResource> result = ResourceHelper.ReadResourceById(resourceType, string.Join(",", fieldAlias.Keys), id);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
VerifyFieldValue(resourceType, fieldAlias, result.Items[0], index, expectedRecords, fieldReader);
}
private static void ReadAndVerify(Enums.ResourceType resourceType, string fieldAlias, string id, string expectedValue)
{
ReadResponseData <XmlResource> result = ResourceHelper.ReadResourceById(resourceType, fieldAlias, id);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
Assert.That(result.Items[0].DictionaryValues[fieldAlias], MustBe.EqualTo(expectedValue), "The field value is not written correctly!");
}
private void ReadAndVerify(Enums.ResourceType resourceType, string fieldAlias, string id)
{
ReadResponseData <XmlResource> result = ResourceHelper.ReadResourceById(resourceType, fieldAlias, id);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
VerifyFieldValue(resourceType, fieldAlias, result.Items[0].DictionaryValues[fieldAlias]);
}
/// <summary>
/// Verify multi search/multi field result by datetime/date/age of Phase system field
/// </summary>
/// <param name="fieldAlias1">Field Alias 1</param>
/// <param name="fieldAlias2">Field Alias 2</param>
/// <param name="condition1">Condition 1</param>
/// <param name="condition2">Condition 2</param>
/// <param name="conditionValue1">Condition Value 1</param>
/// <param name="conditionValue2">Condition Value 2</param>
/// <returns>empty</returns>
public static void VerifySearchDatePhase(Enums.ResourceType resourceType, Dictionary <string, string> parameters, bool isDate = true)
{
string fieldAlias1 = parameters[DateTimeValidator.FieldAlias1];
string fieldAlias2 = parameters[DateTimeValidator.FieldAlias2];
string condition1 = parameters[DateTimeValidator.Condition1];
string condition2 = parameters[DateTimeValidator.Condition2];
string conditionValue1 = parameters[DateTimeValidator.ConditionValue1];
string conditionValue2 = parameters[DateTimeValidator.ConditionValue2];
string formatCond = DateTimeValidator.GetFormatCondition(fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1, conditionValue2);
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", fieldAlias1 == fieldAlias2 ? fieldAlias1 : string.Format("{0},{1}", fieldAlias1, fieldAlias2) },
{ "resource", (int)resourceType }
};
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(nameof(Phase), urlParameters);
switch (condition1 + condition2)
{
case DateTimeValidator.Eq + DateTimeValidator.Gt:
case DateTimeValidator.Eq + DateTimeValidator.Ge:
case DateTimeValidator.Eq + DateTimeValidator.Eq:
case DateTimeValidator.Le + DateTimeValidator.Gt:
case DateTimeValidator.Le + DateTimeValidator.Ge:
case DateTimeValidator.Le + DateTimeValidator.Eq:
case DateTimeValidator.Lt + DateTimeValidator.Gt:
case DateTimeValidator.Lt + DateTimeValidator.Ge:
case DateTimeValidator.Lt + DateTimeValidator.Eq:
Assert.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
break;
case DateTimeValidator.Or + DateTimeValidator.Or:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.ParameterIsInvalid), Enums.Message.WRONG_ERROR_CODE);
break;
default:
Assert.Greater(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.Greater(result.Items.Count, 0, Enums.Message.COUNT_ERROR);
if (fieldAlias1 == fieldAlias2)
{
DateTimeValidator.VerifyValueOneField(result.Items, parameters, isDate);
}
else
{
DateTimeValidator.VerifyValueMultipleField(result.Items, parameters, isDate);
}
break;
}
}
private int GetTotalByResource(Enums.ResourceType resourceType)
{
var urlParameters = new Dictionary <string, object>()
{
[DeletedDataFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
};
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assume.That(result, MustBe.Not.Null, "The response data is null or cannot be parsed to ReadResponseData!");
Assume.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
return(result.Total);
}
/// <summary>
/// Read and verify datetime field value by phase
/// </summary>
/// <param name="resourceName">Resource Name</param>
/// <param name="id">Resource Id</param>
/// <param name="fieldAlias">Field Alias</param>
/// <returns>empty</returns>
public static void ReadAndVerifyAutoDesignatedDateForPhase(Enums.ResourceType resourceType, string id, string fieldName)
{
string resourceName = resourceType.ToResourceName();
ReadResponseData <XmlResource> result = FieldHelper.ReadPhase(resourceType, id, new List <string> {
fieldName
});
Assume.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
DateTime tempDate;
Assert.That(DateTime.TryParse(result.Items[0].DictionaryValues[fieldName].ToString(), out tempDate), ErrorMessage);
}
/// <summary>
/// Help Read and Verify Test Order
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="fieldsName">List of field name</param>
/// <param name="orderType">Enum Order type : Asc, Desc, MultiOrders, OrderEmpty</param>
/// <param name="smallestId">The smallest ID of this type of resource create by Private Fixture</param>
/// <param name="valueType">Type of the field need to be sorted</param>
public static void ReadPhaseAndVerify(Enums.ResourceType resourceType, List <string> fieldsName, OrderType orderType, string smallestId, Type valueType, int count)
{
string resourceName = nameof(Phase);
string idField = "Id";
Dictionary <string, Type> sortOrders = new Dictionary <string, Type>();
string order = string.Empty;
string field = string.Empty;
switch (orderType)
{
case OrderType.MultiOrders:
string fieldAlias1 = $"{fieldsName.First()}";
string fieldAlias2 = $"{fieldsName.Last()}";
order = $"{fieldAlias1}:{OrderType.Asc.ToLowerString()},{fieldAlias2}:{OrderType.Desc.ToLowerString()}";
field = $"{fieldAlias1},{fieldAlias2}";
sortOrders.Add($"{fieldAlias1}:{OrderType.Asc.ToLowerString()}", valueType);
sortOrders.Add($"{fieldAlias2}:{OrderType.Desc.ToLowerString()}", valueType);
break;
case OrderType.OrderEmpty:
order = field = $"{fieldsName.FirstOrDefault()}";
break;
default:
field = $"{fieldsName.FirstOrDefault()}";
order = $"{field}:{orderType.ToLowerString()}";
sortOrders.Add(order, valueType);
break;
}
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ PartitionParameter, AuthenticationInfoProvider.Current.DefaultPartition },
{ OrderParameter, order },
{ FieldParameter, $"{idField},{field}" },
{ ConditionParameter, $"{idField}:ge={smallestId}" },
};
urlParameter.Add(ResourceParameter, (int)resourceType);
if (orderType == OrderType.OrderEmpty)
{
ReadOrderFailed(resourceName, urlParameter);
}
else
{
ReadResponseData <XmlResource> items = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceName, urlParameter);
Assert.That(items, MustBe.ReadSuccess(count), "Read resource failed!");
List <XmlResource> sortedItems = ResourceHelper.SortList(items.Items, sortOrders);
Assert.IsTrue(ResourceHelper.CompareList(items.Items, sortedItems, idField), Enums.Message.SORT_INCORRECT);
}
}
public void TestReadValidIdInput(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType, string fieldName)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id = records.Data[$"{referenceResourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadReferenceResource(resourceType, id, fieldAlias);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
XmlResource referenceResource = result.Items[0].DictionaryValues[fieldAlias] as XmlResource;
Assert.That((referenceResource.DictionaryValues[referenceResourceType.ToString()] as XmlResource).DictionaryValues[$"{referenceResourceType.ToResourceName()}.P_Id"], Is.EqualTo(id), $"{fieldAlias} does not match!");
}
/// <summary>
/// Read and verify datetime field value by phase
/// </summary>
/// <param name="resourceName">Resource Name</param>
/// <param name="id">Resource Id</param>
/// <param name="fieldAlias">Field Alias</param>
/// <returns>empty</returns>
public static void ReadAndVerifyNoValidationDateForPhase(Enums.ResourceType resourceType, string id, string fieldAlias)
{
string resourceName = resourceType.ToResourceName();
string registrationDateAlias = SystemTypeField.RegistrationDate.Substring(2);
string updateDateAlias = SystemTypeField.UpdateDate.Substring(2);
ReadResponseData <XmlResource> result = FieldHelper.ReadPhase(resourceType, id, new List <string> {
registrationDateAlias, updateDateAlias
});
Assume.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
VerifyLessOrGreaterThanDateTime(result, fieldAlias, registrationDateAlias, updateDateAlias);
}
public void ReadValidItemStateNormalYear(Enums.ResourceType resourceType, ValidTestCases.ItemState itemState, DateTimeField.ReadValidInput inputValue)
{
string resourceName = resourceType.ToResourceName();
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ ResourceHelper.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", $"{resourceName}.P_UpdateDate:gt={ValidTestCases.ValidInputMapper[inputValue]}" },
};
ValidTestCases.ItemStateMapper[itemState](urlParameters);
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), Enums.Message.WRONG_ERROR_CODE);
}
//To-do: update this method when reading phase-entry fixture is done!
private string ReadPhaseBasedOnResource(Enums.ResourceType resourceType, int index)
{
Dictionary <string, object> urlParameters = new Dictionary <string, object>
{
[PhaseApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[PhaseApiFields.Resource] = (int)resourceType,
[PhaseApiFields.ResourceId] = updatingRecords.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id,
[PhaseApiFields.Field] = "Id"
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(urlParameters);
Assume.That(result, MustBe.ReadSuccess(1), "Cannot read the phase!");
return(result.Items.First().Id);
}
public void TestSearchCondition(string requestType)
{
Dictionary <string, object> urlParameters = new Dictionary <string, object>();
if (requestType != null)
{
urlParameters[PartitionApiFields.RequestType] = requestType;
}
PublicAPIConnection connection = new PublicAPIConnection(singleCompanyAppInfo.Key, singleCompanyAppInfo.Secret);
ReadResponseData <Partition> result = PublicApiAdapter.CreateAdapter(connection, singleCompanyAppInfo.Company.Partition).ReadSuccess <Partition>(urlParameters);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Partition"));
}
private void PerformTest(Enums.ResourceType resource, Dictionary <string, object> request, ItemState state, ulong min, ulong max, int total)
{
request["condition"] = $"{resource.ToResourceName()}.P_Id:ge={min},{resource.ToResourceName()}.P_Id:le={max}";
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resource.ToString(), request);
Assert.That(result, MustBe.ReadSuccess(request.ContainsKey("count") ? (int)request["count"] : 10), Enums.Message.COUNT_ERROR);
if (state == ItemState.All || state == ItemState.Existing)
{
Assert.That(result.Total, Is.GreaterThanOrEqualTo(total), Enums.Message.TOTAL_ERROR);
}
else
{
Assert.That(result.Total, Is.GreaterThanOrEqualTo(total), Enums.Message.TOTAL_ERROR);
}
}
private void PerformTest(string resourceName, Dictionary <string, object> request, bool isFieldProperty, int expectedCode)
{
var connection = PublicApiAdapter.CreateAdapterForDefaultConnection();
if (isFieldProperty && expectedCode == Enums.PublicAPIResultCode.Success)
{
var result = connection.ReadSuccess(resourceName, request);
Assert.That(result, MustBe.ReadSuccess(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
else
{
ErrorCode result = connection.ReadFail(resourceName, request);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
}
/// <summary>
/// Verify multi search/multi field result by resource of system field
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="resourceType">Reference resource type</param>
/// <param name="parameters">Parameters of condition search</param>
public static void VerifyMultiSearchMultiFieldReferenceResource(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType1, Enums.ResourceType referenceResourceType2, Dictionary <string, string> parameters)
{
string fieldAlias1 = parameters[DateTimeValidator.FieldAlias1];
string fieldAlias2 = parameters[DateTimeValidator.FieldAlias2];
string condition1 = parameters[DateTimeValidator.Condition1];
string condition2 = parameters[DateTimeValidator.Condition2];
int conditionValue1 = int.Parse(parameters[DateTimeValidator.ConditionValue1].ToString());
int conditionValue2 = int.Parse(parameters[DateTimeValidator.ConditionValue2].ToString());
int conditionValue3 = int.Parse(parameters[DateTimeValidator.ConditionValue3].ToString());
int conditionValue4 = int.Parse(parameters[DateTimeValidator.ConditionValue4].ToString());
ReadResponseData <XmlResource> result = GetMultipleSearchMultipleFieldResult(resourceType, fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1.ToString(), conditionValue2.ToString(), conditionValue3.ToString(), conditionValue4.ToString());
switch (condition1 + condition2)
{
case DateTimeValidator.Eq + DateTimeValidator.Gt:
//case DateTimeValidator.Eq + DateTimeValidator.Ge:
//case DateTimeValidator.Eq + DateTimeValidator.Eq:
case DateTimeValidator.Le + DateTimeValidator.Gt:
//case DateTimeValidator.Le + DateTimeValidator.Ge:
//case DateTimeValidator.Le + DateTimeValidator.Eq:
case DateTimeValidator.Lt + DateTimeValidator.Gt:
case DateTimeValidator.Lt + DateTimeValidator.Ge:
case DateTimeValidator.Lt + DateTimeValidator.Eq:
Assert.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
break;
default:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.Greater(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.Greater(result.Items.Count, 0, Enums.Message.COUNT_ERROR);
int realValue1 = 0;
int realValue2 = 0;
foreach (var item in result.Items)
{
realValue1 = GetValueField(referenceResourceType1, item, fieldAlias1, "resource");
realValue2 = GetValueField(referenceResourceType2, item, fieldAlias2, "resource");
DateTimeValidator.ConditionalAssertions[condition1](realValue1, conditionValue1, conditionValue2);
DateTimeValidator.ConditionalAssertions[condition2](realValue2, conditionValue3, conditionValue4);
}
break;
}
}
private List <XmlResource> ReadSuccess(Enums.ResourceType resourceType, string FieldName, string fieldValue)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{FieldName}";
var urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", $"{resourceName}.P_Id:eq={fieldValue}" },
{ "field", fieldAlias }
};
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
return(result.Items);
}
/// <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);
}
}
}
/// <summary>
/// Read and verify datetime field value by phase
/// </summary>
/// <param name="resourceName">Resource Name</param>
/// <param name="id">Resource Id</param>
/// <param name="fieldAlias">Field Alias</param>
/// <param name="value">Field Value</param>
/// <returns>empty</returns>
public static void ReadAndVerifyDateForPhase(Enums.ResourceType resourceType, string id, string fieldName, string value)
{
string resourceName = resourceType.ToResourceName();
ReadResponseData <XmlResource> result = FieldHelper.ReadPhase(resourceType, id, new List <string> {
fieldName
});
Assume.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
//Year 0000 is invalid date in C# so could not convert to datetime
if (value.Contains(Year0000))
{
Assert.That(result.Items[0].DictionaryValues[fieldName].ToString(), Is.EqualTo(value), ErrorMessage);
}
else
{
Assert.That(Convert.ToDateTime(result.Items[0].DictionaryValues[fieldName]), Is.EqualTo(Convert.ToDateTime(value)), ErrorMessage);
}
}
public void ReadSpecialItemState(Enums.ResourceType resourceType, ValidTestCases.ItemState itemState, string parameter, string expression, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ ResourceHelper.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ parameter, $"{resourceName}.{expression}" }
};
ValidTestCases.ItemStateMapper[itemState](urlParameters);
if (expectedCode == Enums.PublicAPIResultCode.Success)
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), Enums.Message.WRONG_ERROR_CODE);
Assert.That(result.Total, Is.GreaterThanOrEqualTo(TotalNumberOfRecordSet), Enums.Message.TOTAL_ERROR);
}
else
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
}
/// <summary>
/// Read and verify data
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="fieldName">Field name</param>
/// <param name="fieldValue">Field value</param>
private void ReadSuccessKeywordAndEmptyData(Enums.ResourceType resourceType, string fieldName, string fieldValue)
{
string fieldAlias = $"{resourceType.ToResourceName()}.{fieldName}";
if ((fieldName == SearchFields.JobReferenceTelephone ||
fieldName == SearchFields.ProcessReferenceTelephone ||
fieldName == SearchFields.ResumeReferenceTelephone ||
fieldName == SearchFields.SalesReferenceClientOwner))
{
fieldAlias = string.Empty;
}
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "keywords", fieldValue },
{ "field", fieldAlias }
};
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
}
private void SendAndVerifyResult(Dictionary <string, object> urlParameters, Enums.ResourceType resourceType, ValidTestCases.ValidParameterValue parameter, string suffix, int expectedCode, ulong min, ulong max, int total)
{
string resourceName = resourceType.ToResourceName();
ValidTestCases.ParameterValueMapper[parameter](urlParameters, total, records.Data[$"{resourceType.ToPrivateEnum()}{1}"].Id.ToString(), resourceName, suffix);
if (expectedCode == Enums.PublicAPIResultCode.DateTimeOutOfRange)
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
else
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), Enums.Message.COUNT_ERROR);
if (!parameter.ToLowerString().Contains("condition"))
{
Assert.That(result.Total, Is.GreaterThanOrEqualTo(total), Enums.Message.TOTAL_ERROR);
}
else
{
Assert.That(result.Total, Is.GreaterThanOrEqualTo(0), Enums.Message.TOTAL_ERROR);
}
}
}
private static void Assertions(Enums.ResourceType resourceType, ReadResponseData <XmlResource> result)
{
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
Assert.That(result.Items, Is.Not.Null, string.Format("Read {0}'s resource to be empty!", resourceType));
Assert.That(result, MustBe.ReadSuccess(0), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Verify data of fields
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="inputType">Value type</param>
/// <param name="fieldName">Field name</param>
/// <param name="fieldValue">Field value</param>
private void ReadAndVerifyData(Enums.ResourceType resourceType, ReadValidInput inputType, string fieldName, string fieldValue)
{
int startFromParamValue = 0;
string resourceId = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
string phaseId = string.Empty;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)resourceType },
};
switch (inputType)
{
case ReadValidInput.RandomStart:
startFromParamValue = Util.GetRandomNumber(1, MaxReadBatchSize - 1);
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.StartEqualToTotalSubtract1:
startFromParamValue = MaxReadBatchSize - 1;
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.NoParameter:
break;
case ReadValidInput.ResourceId:
parameters.Add(fieldName, resourceId);
parameters.Add(PhaseApiFields.Field, nameof(PhaseApiFields.ResourceId));
break;
case ReadValidInput.Id:
phaseId = PhaseHelper.CreatePhase(resourceType, resourceId);
parameters.Add(fieldName, phaseId);
parameters.Add(PhaseApiFields.Field, nameof(PhaseApiFields.Id));
break;
default:
parameters.Add(fieldName, fieldValue);
break;
}
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Phase"));
switch (inputType)
{
case ReadValidInput.NoParameter:
if (fieldName == PhaseApiFields.Count)
{
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
}
if (fieldName == PhaseApiFields.Start)
{
Assert.That(result.Start, Is.EqualTo(SystemApiHelper.defaultStart), Enums.Message.START_ERROR);
}
break;
case ReadValidInput.Count10:
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.RandomCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.MaxCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.Start0:
case ReadValidInput.Start0000:
Assert.That(result.Start, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.START_ERROR);
break;
case ReadValidInput.RandomStart:
case ReadValidInput.StartEqualToTotalSubtract1:
Assert.That(result.Start, Is.EqualTo(startFromParamValue), Enums.Message.START_ERROR);
break;
case ReadValidInput.ResourceId:
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Items[0].ResourceId, Is.EqualTo(resourceId), $"resourceId {resourceId} does not match!");
break;
case ReadValidInput.Id:
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Items[0].Id, Is.EqualTo(phaseId), $"phaseId {phaseId} does not match!");
break;
}
}
public void TestMultipleSearchMultipleFields(Enums.ResourceType resourceType, ReadInvalidInputTestData.ItemState itemState, string firstFieldName, string secondFieldName, string firstCondition, string secondCondition)
{
ItemStateHelper.SearchParameters searchParameters = null;
string firstFieldAlias = $"{resourceType.ToResourceName()}.{firstFieldName}";
string secondFieldAlias = $"{resourceType.ToResourceName()}.{secondFieldName}";
var extraUrlParameters = new Dictionary <string, object>();
if (itemState != ReadInvalidInputTestData.ItemState.None)
{
extraUrlParameters.Add(DeletedDataFields.ItemState, itemState.ToLowerString());
}
var itemStateType = itemState == ReadInvalidInputTestData.ItemState.None ? ReadInvalidInputTestData.ItemState.All : itemState;
searchParameters = new ItemStateHelper.SearchParameters(firstFieldAlias, secondFieldAlias, firstCondition, secondCondition, null, null, null, null);
//Result code
var resultCode = (((firstFieldName == DeletedDataFields.P_UpdateDate) && firstCondition.ContainsStrings(new string[] { DateTimeValidator.Le, DateTimeValidator.Lt }) ||
(secondFieldName == DeletedDataFields.P_UpdateDate) && secondCondition.ContainsStrings(new string[] { DateTimeValidator.Le, DateTimeValidator.Lt })) &&
(itemState == ReadInvalidInputTestData.ItemState.Deleted || itemState == ReadInvalidInputTestData.ItemState.All))
? Enums.PublicAPIResultCode.DateTimeOutOfRange : Enums.PublicAPIResultCode.Success;
//Get result for condition inputs
var extraConditionParam = new Dictionary <string, object>(extraUrlParameters);
extraConditionParam["condition"] = $"{resourceType.ToResourceName()}.P_Id:ge={ItemStateHelper.RecordIds[itemStateType](resourceType, RecordNum, recordsIn90Days, recordsOver90Days, deletedRecordsMapping)["Min"]},{resourceType.ToResourceName()}.P_Id:le={ItemStateHelper.RecordIds[itemStateType](resourceType, RecordNum, recordsIn90Days, recordsOver90Days, deletedRecordsMapping)["Max"]}";
var result = ItemStateHelper.GetAllResults(resourceType, $"{firstFieldAlias},{secondFieldAlias}", 0, MaxCount, extraConditionParam).Items;
FirstFieldNameValues[firstFieldName](result, searchParameters, resourceType, itemStateType, firstFieldAlias, RecordNum);
SecondFieldNameValues[secondFieldName](result, searchParameters, resourceType, itemStateType, secondFieldAlias, RecordNum);
//Read & verify data
string formatCond = PhaseHelper.GetFormatConditionDifferentFields(firstFieldAlias, secondFieldAlias, firstCondition, secondCondition,
searchParameters.FirstCondValue.ToString(),
searchParameters.SecondCondValue.ToString(),
searchParameters.ThirdCondValue.ToString(),
searchParameters.FourCondValue.ToString()
);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", $"{firstFieldAlias},{secondFieldAlias}" },
{ "count", MaxCount },
};
if (extraUrlParameters != null)
{
parameters = parameters.Concat(extraUrlParameters).GroupBy(d => d.Key).ToDictionary(d => d.Key, d => d.First().Value);
}
if (resultCode == Enums.PublicAPIResultCode.DateTimeOutOfRange)
{
var response = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail(resourceType.ToString(), parameters);
Assert.That(response, MustBe.MatchingErrorCode(resultCode), Enums.Message.WRONG_ERROR_CODE);
}
else
{
var response = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), parameters);
Assert.That(response, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType));
object firstRealValue = null;
object secondRealValue = null;
foreach (var item in response.Items)
{
firstRealValue = RealValues[firstFieldName](item, firstFieldAlias);
secondRealValue = RealValues[secondFieldName](item, secondFieldAlias);
DateTimeValidator.ConditionalAssertions[firstCondition](firstRealValue, firstFieldName == DeletedDataFields.P_UpdateDate ? Util.ParseDateTime(searchParameters.FirstCondValue.ToString()) : searchParameters.FirstCondValue,
firstFieldName == DeletedDataFields.P_UpdateDate ? Util.ParseDateTime(searchParameters.SecondCondValue.ToString()) : searchParameters.SecondCondValue);
DateTimeValidator.ConditionalAssertions[secondCondition](secondRealValue, secondFieldName == DeletedDataFields.P_UpdateDate ? Util.ParseDateTime(searchParameters.ThirdCondValue.ToString()) : searchParameters.ThirdCondValue
, secondFieldName == DeletedDataFields.P_UpdateDate ? Util.ParseDateTime(searchParameters.FourCondValue.ToString()) : searchParameters.FourCondValue);
}
}
}
