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); } } }