/// <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] }, }); }
public static void SendAndVerifyMergeRequest(HrbcRecordCreator record, MergeManager mergeHandler, ResourceId resourceId, int baseIndex, int mergeIndex, bool IsValidRequest = true) { var requestContent = new Dictionary <string, object>() { ["baseId"] = record.Data[$"{resourceId}{baseIndex}"].Id, ["mergedId"] = new List <ulong>() { record.Data[$"{resourceId}{mergeIndex}"].Id }, ["mapping"] = GetMapping(resourceId, record.Data[$"{resourceId}{baseIndex}"].Id, record.Data[$"{ResourceId.Client}{baseIndex}"].Id), }; var response = mergeHandler.MergeRecords <MergeResponse>(resourceId, requestContent, System.Net.Http.HttpMethod.Post); if (IsValidRequest) { PrAssert.That(response, PrIs.SuccessfulResponse()); PrAssert.That(response.Result.Id, PrIs.Not.Null); LoopAndVerifyCompleteMerge(response.Result.Id); } else { PrAssert.That(response, PrIs.ErrorResponse().With.HttpCode((int)HttpStatusCode.BadRequest)); PrAssert.That(response.Errors.Code, PrIs.EqualTo((int)ResultCode.InvalidParameter)); PrAssert.That(response.Errors.Error, PrIs.EqualTo("Invalid Parameter.")); } }
public TestReadInvalidInputUserField() : base() { // create request var fieldRequestBuilder = FieldRequest.CreateFields(); foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>()) { fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.File, "API automation test field", builder => builder.MimeType("image/gif,image/jpeg,image/png,image/bmp,image/x-ms-bmp").Height(50).DisplayType(DisplayType.SearchBoxMultiSelection), $"{resourceId}"); } var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content; customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> { FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource }); int testUser = 1; records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords() .Append(ResourceId.Client, content => content .Append("P_Name", "Test Client") .Append("P_Owner", testUser), "client1") .Append(ResourceId.Recruiter, content => content .Append("P_Name", "Test Recruiter") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")), "recruiter1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job2") .Append(ResourceId.Person, content => content .Append("P_Name", "Test Person") .Append("P_Owner", testUser), "person1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume2")); }
private void PrepareRecords() { // for provided user-defined field select an appropriate value Func <ResourceId, KeyValuePair <object, FieldPropertyCollection>, int, KeyValuePair <HrbcField, object> > userFieldDataGenerator = (resource, x, index) => new KeyValuePair <HrbcField, object>(new HrbcField(resource, x.Value.Name), GetTestDateTime()); // for provided resource append 2 records with all necessary fields populated Func <CreateRecordRequest.IBuilder, ResourceId, int, CreateRecordRequest.IBuilderWithResource> resourceAppender = (rq, resource, index) => rq.Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, index)) .Concat(ResourceMandatoryFields[resource](index).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value))) .Concat(DateFields.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetTestDateTime()))) .Concat(SearchConstants.SystemFieldsValues[resource].Where(x => DateFields.Contains(x.Key)).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetTestDateTime()))) .Concat(AdditionalFields(resource)), $"{resource}{index}") ; RecordsCreator = new HrbcRecordCreator(() => { var request = ResourceRequest.CreateRecords(); for (int i = 0; i < NumRecords; i++) { foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None })) { request = resourceAppender(request, resource, i); } } return(request as CreateRecordRequest.IBuilderWithResource); }); }
public TestReadOrderFieldUserField() : base() { InitFieldCreator(); int testUser = 1; records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords() .Append(ResourceId.Client, content => content .Append("P_Name", "Test Client") .Append("P_Owner", testUser), "client1") .Append(ResourceId.Recruiter, content => content .Append("P_Name", "Test Recruiter") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")), "recruiter1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job2") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job3") .Append(ResourceId.Person, content => content .Append("P_Name", "Test Person") .Append("P_Owner", testUser), "person1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume2") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume3")); }
/// <summary> /// Create an instance of resource that is used for Bulk Write testing. /// </summary> /// <param name="resourceType">Resource Type</param> /// <param name="itemType">Bulk Write Item Type</param> /// <param name="fieldAlias">Field Alias</param> /// <param name="fieldValue">Field value is used in case of Valid/Updated Item</param> /// <param name="isPhase">Phase related fields will be created automatically</param> /// <param name="index">Index to get resources from records </param> /// <returns></returns> private static XmlResource CreateBulkWriteTestResourceInstance(Enums.ResourceType resourceType, BulkWriteInputType itemType, HrbcRecordCreator records, HrbcRecordCreator referenceRecords, string fieldAlias, object fieldValue, bool isPhase, int index) { XmlResource result = null; switch (itemType) { case BulkWriteInputType.ValidItem: result = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, index); break; case BulkWriteInputType.InvalidItem: result = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, index); result.DictionaryValues[fieldAlias + "xxx"] = "Abc"; break; case BulkWriteInputType.UpdatedItem: result = ResourceHelper.CreateUpdatedResource(resourceType, records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString(), fieldAlias, fieldValue, isPhase, referenceRecords, index); break; case BulkWriteInputType.CreatedItem: result = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, fieldValue, referenceRecords, isPhase, index, referenceRecords); break; } return(result); }
public TestSearchCustomField() : base() { fixedFields = new HrbcFieldReader(new[] { "Client.P_Name", "Resume.P_CurrentSalary" }, new[] { FieldProperty.FieldType, FieldProperty.Min, FieldProperty.Max }); fixedRecords = new HrbcRecordReader(Enums.ResourceType.Client, new List <ulong> { 10001 }, () => FieldCollection.Builder().Append("Client.P_Name", "Client.P_Owner").Build()); readFields = new HrbcFieldReader(new[] { "Resume.P_CurrentSalary" }, new[] { FieldProperty.Min, FieldProperty.Max }); updateMinFields = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty((Enums.ResourceType)Enum.Parse(typeof(Enums.ResourceType), test.Parent.Properties.Get("Resource") as string, true), test.Parent.Properties.Get("Field") as string, FieldProperty.Min, data.Arguments[0]) }); updateMaxFields = new HrbcFieldUpdater((test, data) => new[] { CreateFieldUpdateSpecForSingleProperty((Enums.ResourceType)data.Arguments[0], (string)data.Arguments[1], FieldProperty.Max, data.Arguments[2]) }); customFields = new HrbcFieldCreator(Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>() .SelectMany(resource => new[] { new HrbcFieldCreator.FieldSpec { Resource = resource, Key = $"{resource}-1", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 1" }, new HrbcFieldCreator.FieldSpec { Resource = resource, Key = $"{resource}-2", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 2" }, new HrbcFieldCreator.FieldSpec { Resource = resource, Key = $"{resource}-3", FieldType = Enums.FieldType.Number, Label = $"Custom Field {resource} 3" } }), new List <FieldProperty> { FieldProperty.Name }); records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords() .Append(ResourceId.Client, content => content.Append("P_Name", "Record 1").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 10), "Client 10") .Append(ResourceId.Client, content => content.Append("P_Name", "Record 2").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 20), "Client 20") .Append(ResourceId.Client, content => content.Append("P_Name", "Record 3").Append("P_Owner", 1).Append(customFields.Data["Client-1"].Name, 30), "Client 30")); }
public static void BulkUpdateDateForRecordsCreator(HrbcRecordCreator RecordsCreator, string date, ValidTestCases testCase, int numRecords = 0) { var bulkManager = new BulkUpdateManager(); DateTime dateTime = DateTime.Parse(date); int plusMinutes = 0; foreach (ResourceId resource in Utils.Resources()) { for (var i = 0; i < numRecords; i++) { if (testCase == ValidTestCases.Less) { plusMinutes = -(numRecords - i); } else if (testCase == ValidTestCases.Greater) { plusMinutes = i; } var recordId = RecordsCreator.Data[$"{resource}{i}"].Id; var response = bulkManager.BulkUpdate <BulkUpdateResponse>(GetBulkUpdateContent(resource, new List <ulong> { recordId }, dateTime.AddMinutes(plusMinutes).ToString(SearchConstants.SearchApiFullDateTemplate)), System.Net.Http.HttpMethod.Post); PrAssume.That(response, PrIs.SuccessfulResponse()); if (GetBulkUpdateQueueStatus(response.Result.Id.ToString())) { continue; } } } }
private void PrepareRecords() { FirstSystemRecord = new HrbcRecordCreator(() => PrivateFixtureUtilities.ComposeRequestForAllParameters(() => OptionsReader.Data.Single().Value, CommonConstants.TestUserId).Build()); SecondSystemRecord = new HrbcRecordCreator(() => PrivateFixtureUtilities.ComposeRequestForAllParameters(() => OptionsReader.Data.Single().Value, CommonConstants.TestUserId).Build()); FirstUserRecords = new HrbcRecordCreator(() => PrivateFixtureUtilities.ComposeRequestForUserField(() => OptionsReader.Data.Single().Value, FieldCreator, CommonConstants.TestUserId).Build()); SecondUserRecords = new HrbcRecordCreator(() => PrivateFixtureUtilities.ComposeRequestForUserField(() => OptionsReader.Data.Single().Value, FieldCreatorOther, CommonConstants.TestUserId).Build()); }
private void PrepareRecords() { // for provided user-defined field select an appropriate value Func <ResourceId, KeyValuePair <object, FieldPropertyCollection>, bool, KeyValuePair <HrbcField, object> > userFieldDataGenerator = (resource, x, isAlt) => new KeyValuePair <HrbcField, object>(new HrbcField(resource, x.Value.Name), GetValueForUserField(x.Key.ToString(), isAlt)); // for provided resource append 2 records with all necessary fields populated Func <CreateRecordRequest.IBuilder, ResourceId, CreateRecordRequest.IBuilderWithResource> resourceAppender = (rq, resource) => rq.Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, false)) .Concat(ResourceMandatoryFields[resource](false).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value))) .Concat(SearchConstants.RequiredFieldTypes.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetFieldValueByFieldType(type, false)))) .Concat(SearchConstants.SystemFieldsValues[resource].Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetFieldValueByFieldType(field.Key, false)))), $"{resource}") .Append(resource, FieldCreator.Data.Where(x => x.Value.Field.Resource == resource).Select(x => userFieldDataGenerator(resource, x, true)) .Concat(ResourceMandatoryFields[resource](true).Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Key), field.Value))) .Concat(SearchConstants.RequiredFieldTypes.Select(type => new KeyValuePair <HrbcField, object>(new HrbcField(resource, SearchConstants.FieldTypeToApplicationFieldNameMap[type]), GetFieldValueByFieldType(type, true)))) .Concat(SearchConstants.SystemFieldsValues[resource].Select(field => new KeyValuePair <HrbcField, object>(new HrbcField(resource, field.Value), GetFieldValueByFieldType(field.Key, true)))), $"{resource} Alt"); RecordsCreator = new HrbcRecordCreator(() => { var request = ResourceRequest.CreateRecords(); foreach (var resource in Enum.GetValues(typeof(ResourceId)).Cast <ResourceId>().Except(new[] { ResourceId.None })) { request = resourceAppender(request, resource); } return(request as CreateRecordRequest.IBuilderWithResource); }); }
/// <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); }
private static void UpdateSystemResourceId(HrbcRecordCreator records, int index) { valueDictionary[ResourceFields.InputType.SystemClient] = records.Data[$"{ResourceId.Client}{index}"].Id; valueDictionary[ResourceFields.InputType.SystemRecruiter] = records.Data[$"{ResourceId.Recruiter}{index}"].Id; valueDictionary[ResourceFields.InputType.SystemJob] = records.Data[$"{ResourceId.Job}{index}"].Id; valueDictionary[ResourceFields.InputType.SystemCandidate] = records.Data[$"{ResourceId.Person}{index}"].Id; valueDictionary[ResourceFields.InputType.SystemResume] = records.Data[$"{ResourceId.Resume}{index}"].Id; }
public static List <int> GetNumberRecordCreator(HrbcRecordCreator RecordsCreator, ResourceId resource, int numRecords = 0, int indexElement = 0) { var list = new List <int>(); for (var i = indexElement; i < numRecords; i++) { list.Add(int.Parse(RecordsCreator.Data[$"{resource}{i}"].Id.ToString())); } return(list); }
/// <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 a request to update a single resource /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="getFieldValue"></param> /// <param name="expectedCode"></param> /// <param name="records"></param> /// <param name="idRelatedFieldCreatedAutomatically"></param> /// <param name="index"></param> /// <param name="referenceRecords"></param> public static void UpdateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false, int index = 0, HrbcRecordCreator referenceRecords = null) { XmlResource resource = ResourceHelper.CreateUpdatedResource(resourceType, records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString(), fieldAlias, getFieldValue(index), idRelatedFieldCreatedAutomatically, referenceRecords, index); var error = ResourceHelper.WriteResourceFail(resource, null); Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE); }
public BulkCombineFields(RecordTypes record, Filters filter, ResourceId resource, List <string> fieldNames, HrbcRecordCreator recordCreator, List <int> userIds) { Record = record; Filter = filter; Resource = resource; FieldNames = fieldNames; RecordCreator = recordCreator; UserIds = userIds; Fields = new Dictionary <string, string>(); InitFields(); }
/// <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="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="isPhase"></param> public static void ExecuteTestListItem(Enums.ResourceType resourceType, BulkWriteInputType firstItemType, BulkWriteInputType secondItemType, HrbcRecordCreator records, HrbcRecordCreator referenceRecords, string fieldAlias, HrbcRecordDelete cleaner, object fieldValue = null, bool isPhase = false) { //Preparation var resourceList = new List <XmlResource>() { BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, firstItemType, records, referenceRecords, fieldAlias, fieldValue, isPhase, 0), BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, secondItemType, records, referenceRecords, fieldAlias, fieldValue, isPhase, 1), }; WriteAndVerify(resourceType, resourceList, firstItemType, secondItemType, cleaner); }
/// <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 update a list of resources /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="records"></param> public static void UpdateListItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false, HrbcRecordCreator referenceRecord = null) { IEnumerable <XmlResource> resourceList = new int[] { 0, 1 }.Select(index => { return(ResourceHelper.CreateUpdatedResource(resourceType, records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString(), fieldAlias, getFieldValue(index), idRelatedFieldCreatedAutomatically, referenceRecord, index)); }); ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList); Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE); }
private static Dictionary <string, object> ValidReadGenericRecordRequest(ResourceId resource, ValidReadGenericRecord condition) { HrbcRecordCreator[] listRecords = new HrbcRecordCreator[] { FirstSystemRecord, SecondSystemRecord, FirstUserRecords, SecondUserRecords }; var requestDic = new Dictionary <string, object>() { ["resource"] = resource.GetHashCode(), }; ValidReadRecordMapper[condition](resource, listRecords, requestDic); ValidReadFieldsMapper[condition](resource, FieldCreator, requestDic); return(requestDic); }
/// <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 update a single resource /// </summary> /// <param name="resourceType"></param> /// <param name="fieldAlias"></param> /// <param name="fieldValue"></param> /// <param name="expectedCode"></param> /// <param name="records"></param> public static void UpdateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, HrbcRecordCreator records, Action <object> verifyActualValue = null, bool idRelatedFieldCreatedAutomatically = false, int index = 0, HrbcRecordCreator referenceRecords = null) { XmlResource resource = ResourceHelper.CreateUpdatedResource(resourceType, records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString(), fieldAlias, getFieldValue(index), idRelatedFieldCreatedAutomatically, referenceRecords, index); string id = ResourceHelper.WriteResource(resource, null); //Verify result Assert.That(id, MustBe.Not.Null.And.Not.Empty, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType)); Assert.That(id, MustBe.EqualTo(records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString())); ReadAndVerify(resourceType, fieldAlias, id, verifyActualValue); }
/// <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 a phase instance /// </summary> /// <param name="records"></param> /// <param name="resourceType"></param> /// <param name="index"></param> /// <returns></returns> public static Phase CreatePhaseInstance(HrbcRecordCreator records, Enums.ResourceType resourceType, int index = 0) { List <string> phaseList = OptionFieldHelper.GetOptionList($"Option.P_{resourceType.ToResourceName()}Phase"); return(new Phase { Id = "-1", Resource = ((int)resourceType).ToString(), ResourceId = records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString(), Date = Util.ToString(DateTime.Now), PhaseObject = new Option { ActualXMLTag = phaseList.First() } }); }
public static UpdateRecordRequest.IBuilderWithResource InitRecordsUpdater(HrbcRecordCreator records, HrbcOptionSearch PhaseSearcher) { UpdateRecordRequest.IBuilder result = ResourceRequest.UpdateRecords(); foreach (var value in records.Data.Values.Where(val => val.ResourceType != Enums.ResourceType.Contract)) { result.AddContent(value.ResourceType.ToPrivateEnum(), value.Id, content => content.AddField( new HrbcField(value.ResourceType.ToPrivateEnum(), "P_PhaseDate", ResourceType.Standard), Util.ToString(DateTime.Now) ). AddField( new HrbcField(value.ResourceType.ToPrivateEnum(), "P_Phase", ResourceType.Standard), GetMidPhaseOptionId(value.ResourceType, PhaseSearcher) ) ); } return(result as UpdateRecordRequest.IBuilderWithResource); }
private void InitHrbcCreatorRecord() { int testUser = 1; records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords() .Append(ResourceId.Client, content => content .Append("P_Name", "Test Client") .Append("P_Owner", testUser), "client1") .Append(ResourceId.Recruiter, content => content .Append("P_Name", "Test Recruiter") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")), "recruiter1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job2") .Append(ResourceId.Person, content => content .Append("P_Name", "Test Person") .Append("P_Owner", testUser), "person1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume2")); }
/// <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); }
public TestWriteCustomFieldInvalidInputWithScaleUserField() : base() { // create request var fieldRequestBuilder = FieldRequest.CreateFields(); foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>()) { fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Currency, "API automation test field", builder => builder.Searchable(false).Min(-99999999.9m).Max(9999999999998.9m).Required(false).Scale(1), $"{resourceId}-{OneScale}"); fieldRequestBuilder.Append((ResourceId)(int)resourceId, HRBCClientPrivate.API.Field.FieldType.Currency, "API automation test field", builder => builder.Searchable(false).Min(-99999999.99m).Max(9999999999998.99m).Required(false).Scale(2), $"{resourceId}-{TwoScale}"); } var fieldRequest = ((CreateFieldsRequest.IBuilderWithRecord)fieldRequestBuilder).Build().Content; customFields = new HrbcFieldCreator(fieldRequest, new List <FieldProperty> { FieldProperty.Id, FieldProperty.Name, FieldProperty.Resource }); int testUser = 1; records = new HrbcRecordCreator(() => ResourceRequest.CreateRecords() .Append(ResourceId.Client, content => content .Append("P_Name", "Test Client") .Append("P_Owner", testUser), "client1") .Append(ResourceId.Recruiter, content => content .Append("P_Name", "Test Recruiter") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")), "recruiter1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job1") .Append(ResourceId.Job, content => content .Append("P_Position", "Test Job") .Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")) .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter1")), "job2") .Append(ResourceId.Person, content => content .Append("P_Name", "Test Person") .Append("P_Owner", testUser), "person1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume1") .Append(ResourceId.Resume, content => content .Append("P_Owner", testUser) .Append("P_Candidate", new CreateRecordRequest.Reference("person1")), "resume2") /* Example of a progress element: * .Append(ResourceId.Process, * content => content * .Append("P_Owner", testUser) * .Append("P_Client", new CreateRecordRequest.Reference("client")) * .Append("P_Recruiter", new CreateRecordRequest.Reference("recruiter")) * .Append("P_Job", new CreateRecordRequest.Reference("job")) * .Append("P_Candidate", new CreateRecordRequest.Reference("person")) * .Append("P_Resume", new CreateRecordRequest.Reference("resume")), * "process") */ .Append(ResourceId.Sales, content => content //.Append("P_SalesAmount", 5000) .Append("P_Owner", testUser), "sales1") .Append(ResourceId.Activity, content => content .Append("P_Title", "Test Activity") .Append("P_Owner", testUser) .Append("P_FromDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")), "activity1") .Append(ResourceId.Contract, content => content .Append("P_Name", "Test Contract") //.Append("P_Owner", testUser) .Append("P_Client", new CreateRecordRequest.Reference("client1")), "contract1")); }