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