/// <summary> /// Send request to create a single resource /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="cleaner"></param> /// <param name="referenceRecords"></param> /// <param name="idRelatedFieldCreatedAutomatically"></param> /// <param name="index"></param> public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode, HrbcRecordDelete cleaner, HrbcRecordCreator referenceRecords, bool idRelatedFieldCreatedAutomatically = false, int index = 0) { XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(index), referenceRecords, idRelatedFieldCreatedAutomatically, index, referenceRecords); var error = ResourceHelper.WriteResourceFail(resource, cleaner); Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE); }
/// <summary> /// Send request to create a single resource /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="cleaner"></param> /// <param name="referenceRecords"></param> public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, HrbcRecordDelete cleaner, HrbcRecordCreator referenceRecords, Action <object> verifyActualValue, bool idRelatedFieldCreatedAutomatically = false, int index = 0) { XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(index), referenceRecords, idRelatedFieldCreatedAutomatically, index, referenceRecords); string id = ResourceHelper.WriteResource(resource, cleaner); //Verify result Assert.That(id, MustBe.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); ReadAndVerify(resourceType, fieldAlias, id, verifyActualValue); }
/// <summary> /// Send a request to create a list of resources /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="cleaner"></param> /// <param name="records"></param> /// <param name="idRelatedFieldCreatedAutomatically"></param> public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode, HrbcRecordDelete cleaner, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false) { var resourceList = new[] { 0, 1 }.Select(depKey => { return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(depKey), records, idRelatedFieldCreatedAutomatically, depKey, records)); }).ToList(); ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner); Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE); }
/// <summary> /// Send a request to create a list of resources /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="cleaner"></param> /// <param name="records"></param> /// <param name="verifyActualValue"></param> /// <param name="idRelatedFieldCreatedAutomatically"></param> public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, HrbcRecordDelete cleaner, HrbcRecordCreator records, Action <object> verifyActualValue = null, bool idRelatedFieldCreatedAutomatically = false) { var resourceList = new[] { 0, 1 }.Select(depKey => { return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(depKey), records, idRelatedFieldCreatedAutomatically, depKey, records)); }).ToList(); List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner); Assert.That(result, MustBe.SuccessfullyWritten(resourceList.Count), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); foreach (var item in result) { ReadAndVerify(resourceType, fieldAlias, item.Id, verifyActualValue); } }
/// <summary> /// Send a request to create a list of resources /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="cleaner"></param> /// <param name="records"></param> public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, object fieldValue, int expectedCode, HrbcRecordDelete cleaner, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false) { var resourceList = new[] { 0, 1 }.Select(depKey => { return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, fieldValue, records, idRelatedFieldCreatedAutomatically, depKey, records)); }).ToList(); if (fieldValue == null) { foreach (XmlResource item in resourceList) { item.DictionaryValues.Remove(fieldAlias); } } ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner); Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE); }
private static void WriteAndVerify(Enums.ResourceType resourceType, List <XmlResource> resourceList, BulkWriteInputType firstItemType, BulkWriteInputType secondItemType, HrbcRecordDelete cleaner) { //Write data List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, null); //In case a new resource is created, We add it to the cleaner if (result != null && result.Count > 0) { if (firstItemType != BulkWriteInputType.UpdatedItem) { cleaner.Delete(resourceType, result[0].Id); } if (secondItemType != BulkWriteInputType.UpdatedItem) { cleaner.Delete(resourceType, result[1].Id); } } //Verify result Assert.That(result, Is.Not.Null, "Create records operation failed. Response is null or cannot be parsed."); Assert.That(result.Count, Is.EqualTo(resourceList.Count), "Create records operation failed. Number of successfully inserted resources is not same as the number of records we intended to insert"); VerifyBulkWriteResultItem(firstItemType, result[0]); VerifyBulkWriteResultItem(secondItemType, result[1]); }
/// <summary> /// Execute all steps of Singe Item Bulk Write test /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias1"></param> /// <param name="fieldAlias2"></param> /// <param name="fieldValue"></param> /// <param name="records"></param> /// <param name="isPhase"></param> /// <param name="cleaner"></param> public static void ExecuteTestSingleItem(Enums.ResourceType resourceType, string fieldAlias1, string fieldAlias2, Func <string, int, object> getFieldValue, HrbcRecordCreator records, bool isPhase, HrbcRecordDelete cleaner, int index = 0, HrbcRecordCreator referenceRecords = null) { //Preparation XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias1, getFieldValue(fieldAlias1, index), records, isPhase, index, referenceRecords); resource.DictionaryValues[fieldAlias2] = getFieldValue(fieldAlias2, index); //Write data string id = ResourceHelper.WriteResource(resource, cleaner); //Verify result Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); }
/// <summary> /// Execute all steps of List Item Bulk Write test /// </summary> /// <param name="resourceType"></param> /// <param name="firstItemType"></param> /// <param name="secondItemType"></param> /// <param name="records"></param> /// <param name="referenceRecords"></param> /// <param name="fieldAlias"></param> /// <param name="cleaner"></param> /// <param name="getFieldValue"></param> /// <param name="isPhase"></param> public static void ExecuteTestListItem(Enums.ResourceType resourceType, BulkWriteInputType firstItemType, BulkWriteInputType secondItemType, HrbcRecordCreator records, HrbcRecordCreator referenceRecords, string fieldAlias, HrbcRecordDelete cleaner, Func <int, object> getFieldValue, bool isPhase = false, int startIndex = 0) { //Preparation var resourceList = new List <XmlResource>() { BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, firstItemType, records, referenceRecords, fieldAlias, getFieldValue(0), isPhase, startIndex), BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, secondItemType, records, referenceRecords, fieldAlias, getFieldValue(1), isPhase, startIndex + 1), }; WriteAndVerify(resourceType, resourceList, firstItemType, secondItemType, cleaner); }
public static void UpdateListItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input; var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected; IEnumerable <XmlResource> resourceList = new List <XmlResource> { ResourceHelper.CreateResourceInstance(records, resourceType, 0), ResourceHelper.CreateResourceInstance(records, resourceType, 1) }; List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); resourceList = ids.Select(item => { return(ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, fieldValue)); }); List <WriteResultItem> result = ResourceHelper.WriteResources(Enums.ResourceType.Activity, resourceList, cleaner); Assert.That(result, Is.Not.Null, "The response data is incorrect!"); Assert.That(result.Count, Is.EqualTo(resourceList.Count()), "The response data is incorrect!"); foreach (var item in result) { Assert.That(item.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE); Assert.That(item.Id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); ReadAndVerifyData(resourceType, item.Id, fieldAlias, expectedValue.ToString()); } }
public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input; var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected; XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType); resource.DictionaryValues[fieldAlias] = fieldValue; string id = ResourceHelper.WriteResource(resource, cleaner); Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); ReadAndVerifyData(resourceType, id, fieldAlias, expectedValue.ToString()); }
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input; var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected; var resourceList = new[] { 0, 1 }.Select(depKey => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey); resource.DictionaryValues[fieldAlias] = fieldValue; return(resource); }).ToList(); List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner); Assert.That(result, Is.Not.Null, "The response data is incorrect!"); Assert.That(result.Count, Is.EqualTo(resourceList.Count()), "The response data is incorrect!"); foreach (var item in result) { Assert.That(item.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE); Assert.That(item.Id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); ReadAndVerifyData(resourceType, item.Id, fieldAlias, expectedValue.ToString()); } }
public static void UpdateSingleItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType, 1); string id = ResourceHelper.WriteResource(resource, cleaner); Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType); resource = ResourceHelper.CreateUpdatedResource(resourceType, id, fieldAlias, fieldValue); var error = ResourceHelper.WriteResourceFail(resource, cleaner); Assert.That(error, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType)); Assert.That(error.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE); }
public static void UpdateListItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType); IEnumerable <XmlResource> resourceList = new List <XmlResource> { ResourceHelper.CreateResourceInstance(records, resourceType, 0), ResourceHelper.CreateResourceInstance(records, resourceType, 1) }; List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); resourceList = ids.Select(item => { return(ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, fieldValue)); }); ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList); Assert.That(result, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType)); Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE); }
//Invalid public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner) { var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType); var resourceList = new[] { 0, 1 }.Select(depKey => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey); resource.DictionaryValues[fieldAlias] = fieldValue; return(resource); }).ToList(); ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner); Assert.That(result, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE); }
public static void TestCreateListItem(Enums.ResourceType resourceType, Dictionary <string, ResourceFields.InputType> dictionaryAliasValue, bool isPhaseIncluded, HrbcRecordCreator referenceRecords, HrbcFieldReader fieldReader, HrbcRecordDelete cleaner) { string resourceName = resourceType.ToResourceName(); var resourceList = new[] { 0, 1 }.Select(depKey => { var resource = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, depKey); resource = AddValueForAllField(resource, dictionaryAliasValue, depKey, referenceRecords, fieldReader); if (isPhaseIncluded) { resource = AddPhaseToResource(resource, resourceName); } return(resource); }).ToList(); List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner); Assert.That(result, MustBe.SuccessfullyWritten(resourceList.Count), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); for (int i = 0; i < result.Count; i++) { ReadAndVerify(resourceType, dictionaryAliasValue, result[i].Id, i, referenceRecords, fieldReader); } }
/// <summary> /// Create Field Search Instance /// </summary> /// <param name="records">Hrbc Record Creator</param> /// <param name="cleaner">Hrbc Record Delete</param> /// <param name="resourceType">Resource Type</param> /// <param name="fieldAlias">Field Alias</param> /// <param name="fieldValues">List of field values</param> /// <param name="condition1">The First Condition</param> /// <param name="condition2">The Second Condition</param> /// <returns>Parameters</returns> public static Dictionary <string, string> CreateSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias, List <string> fieldValues, string condition) { string resourceName = resourceType.ToResourceName(); var fieldValuesToDict = fieldValues.Select((s, i) => new { s, i }).ToDictionary(x => x.i, x => x.s); var resourceList = fieldValuesToDict.Select(item => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key); resource.DictionaryValues[fieldAlias] = item.Value; return(resource); }); List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); return(new Dictionary <string, string>() { { DateTimeValidator.FieldAlias1, fieldAlias }, { DateTimeValidator.Condition1, condition }, { DateTimeValidator.ConditionValue1, fieldValuesToDict[2] }, { DateTimeValidator.ConditionValue2, fieldValuesToDict[4] }, }); }
/// <summary> /// Create Multiple Field Search Instance /// </summary> /// <param name="records">Hrbc Record Creator</param> /// <param name="cleaner">Hrbc Record Delete</param> /// <param name="resourceType">Resource Type</param> /// <param name="fieldAlias1">The First Field Alias</param> /// <param name="fieldAlias2">The Second Field Alias</param> /// <param name="fieldValues">List of field values</param> /// <param name="condition1">The First Condition</param> /// <param name="condition2">The Second Condition</param> /// <returns>Parameters</returns> public static Dictionary <string, string> CreateMultipleFieldSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias1, string fieldAlias2, List <string> fieldValues, string condition1, string condition2) { string resourceName = resourceType.ToResourceName(); var resourceList = new Dictionary <int, string> { { 0, fieldValues[0] }, { 1, fieldValues[1] }, { 2, fieldValues[2] }, { 3, fieldValues[3] }, { 4, fieldValues[4] }, { 5, fieldValues[5] } }.Select(item => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key); if (fieldAlias1.Contains(DateTimeSystemField.PhaseDate) || fieldAlias2.Contains(DateTimeSystemField.PhaseDate)) { List <string> phaseList = GetPhaseList(resourceType); resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option() { ActualXMLTag = phaseList.First() }; } if (fieldAlias1.Contains(DateTimeSystemField.ActivityFromDate) && !fieldAlias2.Contains(DateTimeSystemField.ActivityToDate)) { resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value; } else if (fieldAlias1.Contains(DateTimeSystemField.ActivityToDate) && !fieldAlias2.Contains(DateTimeSystemField.ActivityFromDate)) { resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityFromDate}"] = item.Value; } resource.DictionaryValues[fieldAlias1] = item.Value; resource.DictionaryValues[fieldAlias2] = item.Value; return(resource); }); List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); return(new Dictionary <string, string>() { { DateTimeValidator.FieldAlias1, fieldAlias1 }, { DateTimeValidator.FieldAlias2, fieldAlias2 }, { DateTimeValidator.Condition1, condition1 }, { DateTimeValidator.Condition2, condition2 }, { DateTimeValidator.ConditionValue1, fieldValues[2] }, { DateTimeValidator.ConditionValue2, fieldValues[4] }, }); }
/// <summary> /// Create Multiple Field Search Instance /// </summary> /// <param name="records">Hrbc Record Creator</param> /// <param name="cleaner">Hrbc Record Delete</param> /// <param name="resourceType">Resource Type</param> /// <param name="fieldAlias">Field Alias</param> /// <param name="fieldValues">List of field values</param> /// <param name="condition1">The First Condition</param> /// <param name="condition2">The Second Condition</param> /// <returns>Parameters</returns> public static Dictionary <string, string> CreateOneFieldSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias, List <string> fieldValues, string condition1, string condition2) { string resourceName = resourceType.ToResourceName(); var resourceList = new Dictionary <int, string> { { 0, fieldValues[0] }, { 1, fieldValues[1] }, { 2, fieldValues[2] }, { 3, fieldValues[3] }, { 4, fieldValues[4] }, { 5, fieldValues[5] } }.Select(item => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key); resource.DictionaryValues[fieldAlias] = item.Value; return(resource); }); List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); return(new Dictionary <string, string>() { { DateTimeValidator.FieldAlias1, fieldAlias }, { DateTimeValidator.FieldAlias2, fieldAlias }, { DateTimeValidator.Condition1, condition1 }, { DateTimeValidator.Condition2, condition2 }, { DateTimeValidator.ConditionValue1, fieldValues[2] }, { DateTimeValidator.ConditionValue2, fieldValues[4] }, }); }
/// <summary> /// Create Order Instance /// </summary> /// <param name="records">HrbcRecordCreator</param> /// <param name="cleaner">HrbcRecordDelete</param> /// <param name="resourceType">Resource Type</param> /// <param name="fieldsName">List Of Field Name</param> /// <param name="fieldValues">List Of Field Values</param> /// <returns>List of WriteResultItem</returns> public static List <WriteResultItem> CreateOrderInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, List <string> fieldsName, List <string> fieldValues) { string resourceName = resourceType.ToResourceName(); var resourceList = fieldValues.Select((s, i) => new { s, i }).ToDictionary(x => x.i, x => x.s).Select(item => { var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key); if (fieldsName.Count() == 1) // Single order { string fieldName = fieldsName.First(); if (fieldName == DateTimeSystemField.PhaseDate) { List <string> phaseList = GetPhaseList(resourceType); resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option() { ActualXMLTag = phaseList.First() }; } resource.DictionaryValues[$"{resourceName}.{fieldName}"] = item.Value; } else if (fieldsName.Count() == 2) // Multiple orders { string fieldName1 = fieldsName.First(); string fieldName2 = fieldsName.Last(); if ((fieldName1 == DateTimeSystemField.PhaseDate) || (fieldName2 == DateTimeSystemField.PhaseDate)) { List <string> phaseList = GetPhaseList(resourceType); resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option() { ActualXMLTag = phaseList.First() }; } if ((fieldName1 == DateTimeSystemField.ActivityFromDate) && !(fieldName2 == DateTimeSystemField.ActivityToDate)) { resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value; } else if ((fieldName1 == DateTimeSystemField.ActivityToDate) && !(fieldName2 == DateTimeSystemField.ActivityFromDate)) { resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value; resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityFromDate}"] = item.Value; } resource.DictionaryValues[$"{resourceName}.{fieldName1}"] = item.Value; resource.DictionaryValues[$"{resourceName}.{fieldName2}"] = item.Value; } return(resource); }); List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner); Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName)); return(ids); }
public static void TestCreateSingleItem(Enums.ResourceType resourceType, Dictionary <string, ResourceFields.InputType> dictionaryAliasValue, bool isPhaseIncluded, HrbcRecordCreator referenceRecords, HrbcFieldReader fieldReader, HrbcRecordDelete cleaner) { string resourceName = resourceType.ToResourceName(); XmlResource resource = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, 0); resource = AddValueForAllField(resource, dictionaryAliasValue, 0, referenceRecords, fieldReader); if (isPhaseIncluded) { resource = AddPhaseToResource(resource, resourceName); } string id = ResourceHelper.WriteResource(resource, cleaner); Assert.That(id, MustBe.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType)); ReadAndVerify(resourceType, dictionaryAliasValue, id, 0, referenceRecords, fieldReader); }