public void TestUpdateRecruiterNonNullToNull()
{
string id = PrepareRecruiter();
Recruiter resource = new Recruiter
{
Id = id,
Name = string.Empty
};
id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Recruiter"));
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Recruiter.P_Name", string.Empty },
};
VerifyFieldData(int.Parse(id), fields);
}
public void TestCreateGeneralFieldSettingValidation(Enums.ResourceType resourceType, string property)
{
string fieldAlias = customFields.Data[$"{resourceType}-{property}"].Field.ToAlias();
Assume.That(fieldAlias, Is.Not.Null.And.Not.Empty, "Cannot create a user field for " + resourceType);
//Create a resource entry with having attachment
Attachment attachment = new Attachment()
{
FileName = FileNameDefault,
ContentType = ContentTypeDefault,
Content = ContentDefault,
};
XmlResource resource = CreateResourceInstance(resourceType);
resource.DictionaryValues[fieldAlias] = attachment;
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleaner.Delete);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
}
public void TestUpdateContractNullToNonNull()
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
//Create a Contract
string id = string.Empty;
string clientId = (new ResourceCreator <Client>(PublicApiAdapter.CreateAdapterForDefaultConnection())).Create();
Assume.That(!string.IsNullOrEmpty(clientId));
Contract resource = new Contract
{
Id = "-1",
Client = clientId,
Name = string.Empty
};
id = publicApiAdapter.WriteSuccess(resource, null);
Assert.That(id, Is.Not.Null.And.Not.Empty);
PublicAPISetUp.ListContractId.Add(id);
PublicAPISetUp.ListClientId.Add(clientId);
resource = new Contract
{
Id = id,
Name = Util.GetUniqueString(20, false)
};
id = publicApiAdapter.WriteSuccess(resource, null);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Contract"));
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Contract.P_Name", resource.Name },
};
VerifyFieldData(id, fields);
}
/// <summary>
/// Creates a new Recruiter
/// </summary>
/// <param name="clientId">Client Id</param>
/// <returns></returns>
private string CreateRecruiterResourceSpecifiedData(string clientId)
{
//Create a Recruiter
string id = string.Empty;
Recruiter resource = new Recruiter
{
Id = "-1",
Owner = "1",
Client = clientId,
Name = "The porters company in japan - Tokyo"
};
id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
PublicAPISetUp.ListRecruiterId.Add(id);
int resourceId = -1;
bool parsed = Int32.TryParse(id, out resourceId);
Assume.That(parsed);
Assume.That(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Recruiter"));
return(id);
}
public void TestReadSalesWhiteListKeyword(bool isSingle)
{
string value = isSingle ? nameKeyword : string.Format("{0},{1}", nameKeyword, memoKeyword);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "keywords", value }
};
ReadResponseData <Sales> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Sales>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.Success, result.Code,
string.Format(Enums.Message.READ_RESOURCE_FAILED, "Sales"));
//Verify existing of XML element
ResourceHelper.VerifyListContainElement(result.Items, fields.Keys.ToList());
//Verify the Count/Start/Total
Assert.AreEqual(result.Start, 0, Enums.Message.START_ERROR);
Assert.LessOrEqual(result.Count, 10, Enums.Message.COUNT_ERROR); //Default: 10
Assert.GreaterOrEqual(result.Total, isSingle? 1 : 2, Enums.Message.TOTAL_ERROR);
//Verify the type of fields in fieldList
ResourceHelper.VerifyTypeOfField(result.Items, fields);
//Verify the keyword
foreach (Sales sales in result.Items)
{
if (isSingle)
{
StringAssert.Contains(nameKeyword, sales.BillingClient,
string.Format(Enums.Message.KEYWORD_NOT_MATCH, isSingle, "Sales's Billing Client", value));
}
else
{
Assert.IsTrue(sales.BillingClient.Contains(nameKeyword) || sales.BillingName.Contains(memoKeyword),
string.Format(Enums.Message.KEYWORD_NOT_MATCH, isSingle, "Sales's Billing Client & Name", value));
}
}
}
public void TestUpdateContractNonNullToNull()
{
string id = PrepareContract();
Contract resource = new Contract
{
Id = id,
Name = string.Empty
};
id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, null);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Contract"));
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Contract.P_Name", string.Empty },
};
VerifyFieldData(id, fields);
}
public void TestReadPartitionStartGreaterMaxStart()
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "request_type", 1 },
{ "start", 0 }
};
ReadResponseData <Partition> beforeResult = publicApiAdapter.ReadSuccess <Partition>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.Success, beforeResult.Code, string.Format(Enums.Message.READ_RESOURCE_FAILED, "User"));
//Read Max number + 1 of Start
parameters["start"] = beforeResult.Total + 1;
XmlHandler result = publicApiAdapter.Read <Partition>(parameters) as XmlHandler;
Assert.NotNull(result, "Result is null!");
ErrorCode errorCode = XmlHelper.ParseXMLString <ErrorCode>(result.RawContent);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, errorCode.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadUserRequestType(int requestType)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "request_type", requestType }
};
ReadResponseData <User> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <User>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.Success, result.Code, string.Format(Enums.Message.READ_RESOURCE_FAILED, "User"));
//Verify existing of XML element
ResourceHelper.VerifyListContainElement(result.Items, fields.Keys.ToList());
//Verify existing of Count/Total/Start
Assert.GreaterOrEqual(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.GreaterOrEqual(result.Total, 0, Enums.Message.TOTAL_ERROR);
Assert.GreaterOrEqual(result.Start, 0, Enums.Message.START_ERROR);
//Verify the type of fields
ResourceHelper.VerifyTypeOfField(result.Items, fields);
}
public void TestReadOtherValidInput(Enums.ResourceType resourceType, string lengthType, Enums.TextType textType)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = string.Format("{0}.{1}", resourceName, AppField);
//Check registered application field
CheckRegisteredField(resourceType, AppField);
uint characterNumber = GetStringLength(lengthType);
string fieldValue = Util.GetRandomText(textType, characterNumber);
XmlResource resource = CreateResourceInstance(resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleaner.Delete);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
//Read & verify the field's value
ReadAndVerifyData(resourceType, id, fieldAlias, fieldValue);
}
public void TestUpdateProcessInvalidPhaseDate(string fieldAlias, object fieldValue)
{
Process resource = CreateProcessWithPhase();
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(id), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Process"));
resource = new Process()
{
Id = id,
Phase = new Option()
{
ActualXMLTag = PhaseList.Last()
},
PhaseDate = Util.ToString(DateTime.Now),
};
resource.DictionaryValues[fieldAlias] = fieldValue;
ErrorCode error = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, cleanupAction: null);
Assert.NotNull(error, "Error code is null!");
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidPhase, error.Code, "Wrong error code!");
}
public void TestUpdateFieldUsingEmpty_Fail(string fieldName, string fieldValue)
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Client client = new Client()
{
Id = "-1",
Owner = "1",
};
client.DictionaryValues[fieldName] = fieldValue;
// Create New Resource
string clientId = publicApiAdapter.WriteSuccess(client, null);
Assume.That(!string.IsNullOrEmpty(clientId), "Unable to create new resource");
// Adding id into the static list for further cleanup
ids.Add(clientId);
// Update Resource
client = new Client()
{
Id = clientId,
};
client.DictionaryValues[fieldName] = string.Empty;
XmlHandler handler = publicApiAdapter.Write(client, AuthenticationInfoProvider.Current.DefaultPartition) as XmlHandler;
Assert.NotNull(handler);
Assert.NotNull(handler.XML);
Assert.AreEqual(HttpStatusCode.OK, handler.HttpCode);
ErrorCode xmlCode = XmlHelper.ParseXMLString <ErrorCode>(handler.RawContent);
Assert.NotNull(xmlCode);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, xmlCode.Code,
string.Format("It shouldn't be possible to update resource: {0} using Empty Value", clientId));
}
/// <summary>
/// Send a request to read resource. Parse response's xml to ReadResponseData.
/// </summary>
/// <param name="resourceName"></param>
/// <param name="id"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <returns>empty</returns>
private void ReadAndVerifyData(Enums.ResourceType resourceType, string id, string fieldAlias, string fieldValue)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
if (fieldValue == "InvalidFieldAlias")
{
fieldAlias = "A_TestXXX";
fieldValue = "(Content)";
}
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", $"{resourceName}.P_Id:eq={id}" },
{ "field", $"{fieldAlias}{fieldValue}" }
};
XmlHandler xmlResult = PublicApiAdapter.CreateAdapterForDefaultConnection().Read(resourceType.ToString(), urlParameters) as XmlHandler;
ReadResponseData <ErrorCode> parseResult = XmlHelper.ParseXMLString <ReadResponseData <ErrorCode> >(xmlResult.RawContent);
Assert.That(parseResult.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Get alias by id
/// </summary>
/// <param name="level"></param>
/// <param name="id"></param>
/// <returns>string</returns>
private string GetAliasById(int level, string id)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "level", -1 }
};
XmlHandler resultAllLevel = PublicApiAdapter.CreateAdapterForDefaultConnection().Read <Option>(parameters) as XmlHandler;
Assert.NotNull(resultAllLevel, "Failed to parse the server's response!");
ReadResponseData <Option> parseResult = XmlHelper.ParseXMLString <ReadResponseData <Option> >(resultAllLevel.RawContent);
Assert.That(parseResult.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
string levelOption = "Option/Item"; // Level: 0
for (int i = 1; i <= level; i++)
{
levelOption += "/Items/Item";
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(resultAllLevel.RawContent);
XmlNodeList listAllLevel = doc.SelectNodes(levelOption);
string alias = null;
foreach (XmlNode item in listAllLevel)
{
if (item.SelectSingleNode("Option.P_Id").InnerText == id)
{
alias = item.SelectSingleNode("Option.P_Alias").InnerText;
break;
}
}
//alias = listAllLevel.Cast<XmlNode>().Select(x => x.SelectSingleNode("Option.P_Alias").InnerText).FirstOrDefault(x => x == id);
return(alias);
}
public void ReadSpecialItemState(Enums.ResourceType resourceType, ValidTestCases.ItemState itemState, string parameter, string expression, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ ResourceHelper.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ parameter, $"{resourceName}.{expression}" }
};
ValidTestCases.ItemStateMapper[itemState](urlParameters);
if (expectedCode == Enums.PublicAPIResultCode.Success)
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.ReadSuccess(0), Enums.Message.WRONG_ERROR_CODE);
Assert.That(result.Total, Is.GreaterThanOrEqualTo(TotalNumberOfRecordSet), Enums.Message.TOTAL_ERROR);
}
else
{
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail(resourceType.ToString(), urlParameters);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
}
public void TestWithAllParametersSuccess(int requestType, int count, int start)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "request_type", requestType },
{ "count", count },
{ "start", start },
};
ReadResponseData <Partition> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Partition>(parameters);
Assert.NotNull(result, "Result is null!");
Assert.AreEqual(result.Count, count, "Count is not matched!");
Assert.AreEqual(0, result.Code, "Code is not equal to 0!");
Assert.NotNull(result.Items, "Item element is null!");
Assert.AreEqual(result.Items.Count, count, "Item count is not matched!");
List <string> fieldList = new List <string>()
{
"Partition.P_Id", "Partition.P_Name", "Partition.P_CompanyId"
};
ResourceHelper.VerifyListContainElement <Partition>(result.Items, fieldList);
}
public void TestCreateProcessReferenceField()
{
Process resource = CreateProcess();
resource.JobOwner = 1;
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
int resourceId = -1;
bool parsed = int.TryParse(id, out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Process"));
PublicAPISetUp.ListProcessId.Add(id);
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Process.P_JobOwner", resource.JobOwner }
};
VerifyFieldData(id, fields);
}
/// <summary>
/// Send a request to read resource. Parse response's xml to ReadResponseData.
/// </summary>
/// <param name="resourceName"></param>
/// <param name="type"></param>
/// <param name="num"></param>
/// <returns>empty</returns>
private void ReadAndVerifyCount(Enums.ResourceType resourceType, string type, int num)
{
string errorMessage = "The {0} value is wrong in response data";
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "requestType", 0 },
{ "resource", (int)resourceType },
{ "count", num },
};
if (type == "WithoutCount")
{
parameters.Remove("count");
}
ReadResponseData <Attachment> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Attachment>(parameters);
Assert.AreEqual(result.Code, Enums.PublicAPIResultCode.Success, string.Format("Read {0}' attachment failed", resourceType.ToString()));
Assert.That(result.Items.Count, Is.EqualTo(num), string.Format(errorMessage, "Count"));
Assert.That(result.Count, Is.EqualTo(num), string.Format(errorMessage, "Count"));
}
public void TestCreateProcessMultipleLine(string str)
{
Process resource = CreateProcessWithPhase();
resource.PhaseMemo = str;
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
int resourceId = -1;
bool parsed = Int32.TryParse(id, out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Process"));
PublicAPISetUp.ListProcessId.Add(id);
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Process.P_PhaseMemo", resource.PhaseMemo }
};
VerifyFieldData(id, fields);
}
public void TestCreateProcessCurrency(string value)
{
Process resource = CreateProcess();
resource.ExpectedSalesAmount = Util.GetRandomNumber().ToString();
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
int resourceId = -1;
bool parsed = int.TryParse(id, out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Process"));
PublicAPISetUp.ListProcessId.Add(id);
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Process.P_ExpectedSalesAmount", resource.ExpectedSalesAmount }
};
VerifyFieldData(id, fields);
}
public void TestReadEmptyOrder(Enums.ResourceType resourceType)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = string.Format("{0}.{1}", resourceName, AppField1);
//Check registered application field
CheckRegisteredField(resourceType, AppField1);
string idField = (resourceType == Enums.ResourceType.Candidate) ? "Person.P_Id" : resourceType.ToString() + ".P_Id";
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "order", fieldAlias },
};
Handler handler = PublicApiAdapter.CreateAdapterForDefaultConnection().Read(resourceType.ToString(), urlParameter);
Assert.That(handler, Is.Not.Null, "Cannot read resource!");
ErrorCode result = XmlHelper.ParseXMLString <ErrorCode>(handler.RawContent);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), "Error code is not matched!");
}
public void TestCreateProcessDateField()
{
Process resource = CreateProcess();
resource.ExpectedClosingDate = Util.ToString(DateTime.Now.AddMonths(1), true);
string id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleanupAction: null);
int resourceId = -1;
bool parsed = int.TryParse(id, out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Process"));
PublicAPISetUp.ListProcessId.Add(id);
//Verify data
Dictionary <string, object> fields = new Dictionary <string, object>()
{
{ "Process.P_ExpectedClosingDate", resource.ExpectedClosingDate }
};
VerifyFieldData(id, fields);
}
public void TestValidSingleSearch1TextField(string fieldName, PhaseHelper.TextConditions inputCondition)
{
string condition = inputCondition.ToLowerString();
string phaseMemo = records.Data[$"{defaultResource.ToPrivateEnum()}0"].PhaseEntryContents.Random().PhaseMemo;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
{ PhaseApiFields.Condition, $"{fieldName}:{condition}={phaseMemo}" },
{ PhaseApiFields.Field, fieldName },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
foreach (var item in result.Items)
{
ResourceHelper.VerifySuffixTextType(condition, phaseMemo, item.Memo);
}
}
public void TestReadUserOptionParentOutput(int level)
{
// Get id from Hrbc creator
string id = null;
switch (level)
{
case 0:
id = options.Data[0].Id.ToString();
break;
case 1:
id = options.Data[0].Children[0].Id.ToString();
break;
case 2:
id = options.Data[0].Children[0].Children[0].Id.ToString();
break;
case 3:
id = options.Data[0].Children[0].Children[0].Children[0].Id.ToString();
break;
}
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "level", -1 }
};
XmlHandler result = PublicApiAdapter.CreateAdapterForDefaultConnection().Read <Option>(parameters) as XmlHandler;
Assert.NotNull(result, "Failed to parse the server's response!");
ReadResponseData <Option> parseResult = XmlHelper.ParseXMLString <ReadResponseData <Option> >(result.RawContent);
Assert.That(parseResult.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
//Verify the Alias
VerifyParentById(result, level, id);
}
/// <summary>
/// Creates a new Job
/// </summary>
/// <param name="clientId">Client Id</param>
/// <param name="recruiterId">Recruiter Id</param>
/// <returns>Job Id as string</returns>
private string CreateJobResourceSpecifiedData(string clientId, string recruiterId)
{
//Create a Job
string id = string.Empty;
Job resource = new Job
{
Id = "-1",
Owner = "1",
Client = clientId,
Recruiter = recruiterId,
Position = "Job Position"
};
id = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, null);
int resourceId = -1;
bool parsed = Int32.TryParse(id, out resourceId);
Assume.That(parsed);
Assume.That(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Job"));
return(id);
}
public void TestUpdateSalesMultipleLineString(string text)
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
string id = string.Empty;
Sales resource = new Sales();
resource.Id = salesId;
Option option = new Option()
{
ActualXMLTag = optionSalesPhase
};
resource.Phase = option;
resource.PhaseMemo = text;
id = publicApiAdapter.WriteSuccess(resource, cleanupAction: null);
Assume.That(null != id, "Can not create the resource entry for Sales!!!");
// Adding id into the static list for further cleanup
listSalesId.Add(id);
int resourceId = -1;
bool parsed = Int32.TryParse(id, out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, "Can not update the resource entry for required sales!!!");
//Verify data
string fields = "Sales.P_PhaseMemo";
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", "Sales.P_Id:eq=" + id },
{ "field", fields }
};
ReadResponseData <Sales> result = publicApiAdapter.ReadSuccess <Sales>(parameters);
Assert.AreEqual(text, result.Items[0].PhaseMemo, "Sales Phase Memo is not matched!");
}
private void ReadSuccessAndVerifyData(Enums.ResourceType resourceType, string fieldName, string fieldValue, FieldTypes fieldType)
{
string fieldAlias = $"{resourceType.ToResourceName()}.{fieldName}";
string normalPhoneText = string.Empty;
string specialPhoneText = string.Empty;
switch (fieldType)
{
case FieldTypes.SystemField:
normalPhoneText = NormalPhoneTextSystem;
specialPhoneText = SpecialPhoneTextSystem;
break;
case FieldTypes.ApplicationField:
normalPhoneText = NormalPhoneTextApp;
specialPhoneText = SpecialPhoneTextApp;
break;
case FieldTypes.UserField:
normalPhoneText = NormalPhoneTextUser;
specialPhoneText = SpecialPhoneTextUser;
break;
}
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "keywords", fieldValue },
{ "field", fieldAlias },
{ "count", 200 } //max count
};
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.That(result.Total, Is.GreaterThanOrEqualTo(RecordNumber), Enums.Message.TOTAL_ERROR);
Assert.That(result.Items.Where(item => (item.DictionaryValues[fieldAlias].ToString() == normalPhoneText) || item.DictionaryValues[fieldAlias].ToString() == specialPhoneText).Count, Is.GreaterThanOrEqualTo(RecordNumber), "The keyword does not search correctlly!");
}
public void TestValidSingleSearchNumberField(string fieldName, string condition)
{
string conditionValue1 = PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName, indexFirstPhaseList);
string conditionValue2 = PhaseHelper.GeneratePhaseNumberType(defaultResource, fieldName, indexSecondPhaseList);
string tempCond = $"{fieldName}:{condition}={conditionValue1}";
string formatCond = condition == DateTimeValidator.Or ? $"{tempCond}:{conditionValue2}" : tempCond;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
{ PhaseApiFields.Condition, formatCond },
{ PhaseApiFields.Field, fieldName },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
//Read & verify the field's value
if (fieldName == PhaseApiFields.RegistrationDate || fieldName == PhaseApiFields.UpdateDate || fieldName == PhaseApiFields.Date)
{
Dictionary <string, string> conditionParameters = new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldName },
{ DateTimeValidator.Condition1, condition },
{ DateTimeValidator.ConditionValue1, conditionValue1 },
{ DateTimeValidator.ConditionValue2, conditionValue2 },
};
DateTimeValidator.VerifySingleSearchSystemFieldPhase(defaultResource, conditionParameters);
}
else
{
foreach (var item in result.Items)
{
DateTimeValidator.ConditionalAssertions[condition](int.Parse(item.DictionaryValues[fieldName].ToString()), int.Parse(conditionValue1), int.Parse(conditionValue2));
}
}
}
/// <summary>
/// Creates a new Resume
/// </summary>
/// <returns>Resume id</returns>
private string PrepareResume()
{
string candidateId = string.Empty;
string id = string.Empty;
int resourceId = -1;
bool parsed = false;
if (PublicAPISetUp.ListResumeId.Count > 0)
{
id = PublicAPISetUp.ListResumeId.Random();
}
else
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
if (PublicAPISetUp.ListCandidateId.Count > 0)
{
candidateId = PublicAPISetUp.ListCandidateId.Random();
}
else
{
candidateId = (new ResourceCreator <Candidate>(publicApiAdapter)).Create();
//Assert.IsNotNullOrEmpty(candidateId);
parsed = Int32.TryParse(candidateId, out resourceId);
Assume.That(parsed);
Assume.That(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Candidate"));
PublicAPISetUp.ListCandidateId.Add(candidateId);
}
Resume resource = CreateResumeResourceSpecifiedData(candidateId);
id = publicApiAdapter.WriteSuccess(resource, cleanupAction: null);
//Assert.IsNotNullOrEmpty(id);
resourceId = -1;
parsed = Int32.TryParse(id, out resourceId);
Assume.That(parsed);
Assume.That(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Resume"));
PublicAPISetUp.ListResumeId.Add(id);
}
return(id);
}
public void TestUpdateFieldUsingEmpty_Fail(string fieldName, string fieldValue)
{
Candidate candidate = new Candidate()
{
Id = "-1",
Owner = "1",
};
candidate.DictionaryValues[fieldName] = fieldValue;
// Create New Resource
string candidateId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(candidate, null);
Assume.That(!string.IsNullOrEmpty(candidateId), "Unable to create new resource");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListCandidateId.Add(candidateId);
// Update Resource
candidate = new Candidate()
{
Id = candidateId,
};
candidate.DictionaryValues[fieldName] = string.Empty;
XmlHandler handler = PublicApiAdapter.CreateAdapterForDefaultConnection().Write(candidate, AuthenticationInfoProvider.Current.DefaultPartition) as XmlHandler;
Assert.NotNull(handler);
Assert.NotNull(handler.XML);
Assert.AreEqual(HttpStatusCode.OK, handler.HttpCode);
XElement xmlCode = handler.XML.Descendants("Code").First();
Assert.NotNull(xmlCode);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue.ToString(), xmlCode.Value,
string.Format("It shouldn't be possible to update resource: {0} using Empty Value", candidateId));
}
public void TestReadSingleOrder(Enums.ResourceType resourceType, DisplayType displayType, string order)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = customFields.Data[$"{resourceType}-{displayType}-field1"].Field.ToAlias();
string fieldValue1 = optionList.First();
string fieldValue2 = optionList.Last();
string fieldValue3 = optionList.Random();
List <XmlResource> resourceList = new Dictionary <int, string> {
{ 1, fieldValue1 }, { 2, fieldValue2 }, { 3, fieldValue3 }
}
.Select(item => {
var resource = CreateResourceInstance(resourceType, item.Key);
resource.DictionaryValues[fieldAlias] = new Option()
{
ActualXMLTag = item.Value
};
return(resource);
})
.ToList();
List <string> idList = WriteResources(resourceType, resourceList);
Assume.That(idList, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "order", string.Format("{0}:{1}", fieldAlias, order) },
};
Handler handler = PublicApiAdapter.CreateAdapterForDefaultConnection().Read(resourceType.ToString(), urlParameter);
Assert.That(handler, Is.Not.Null, "Cannot read resource!");
ErrorCode result = XmlHelper.ParseXMLString <ErrorCode>(handler.RawContent);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), "Error code is not matched!");
}