private ErrorCode WriteResourceFail(Enums.ResourceType resourceType, XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, (resourceType == Enums.ResourceType.Process ? processCleaner : cleaner).DeleteMany));
}
private List <string> WriteResources(Enums.ResourceType resourceType, byte[] data)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resourceType.ToString(), data, cleaner.DeleteMany));
}
private string WriteResource(Enums.ResourceType resourceType, XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleaner.Delete));
}
private ErrorCode WriteResourceFail(Enums.ResourceType resourceType, XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, cleanupAction: null));
}
/// <summary>
/// Write a phase by using Phase API
/// </summary>
/// <param name="phase"></param>
/// <returns></returns>
public static string WriteResource(Phase phase)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess <Phase>(phase, null));
}
private ErrorCode WriteResourcesFail(IEnumerable <Attachment> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resources.ToList(), null));
}
/// <summary>
/// Verify field data
/// </summary>
/// <param name="id"></param>
/// <param name="paramtersDic"></param>
private void VerifyFieldData(int id, Dictionary <string, object> paramtersDic)
{
List <string> fieldList = new List <string>()
{
"Person.P_Owner",
"Person.P_Name",
"Person.P_Reading",
"Person.P_Memo",
"Person.P_Telephone",
"Person.P_Fax",
"Person.P_Mail",
"Person.P_Mobile",
"Person.P_MobileMail",
"Person.P_Country",
"Person.P_Zipcode",
"Person.P_Prefecture",
"Person.P_City",
"Person.P_Street",
//"Person.P_RegistrationDate",
//"Person.P_RegisteredBy",
//"Person.P_UpdateDate",
//"Person.P_UpdatedBy",
"Person.P_Phase",
"Person.P_PhaseDate",
//"Person.P_PhaseCalendar",
"Person.P_PhaseMemo",
};
string fields = string.Join(",", fieldList);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", "Person.P_Id:eq=" + id },
{ "field", fields }
};
ReadResponseData <Candidate> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Candidate>(parameters);
Assert.IsTrue(result != null && result.Items != null && result.Items.Count > 0,
string.Format(Enums.Message.READ_RESOURCE_FAILED, "Candidate"));
foreach (KeyValuePair <string, object> parameter in paramtersDic)
{
foreach (Candidate item in result.Items)
{
switch (parameter.Key)
{
//User type
case "Person.P_Owner":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as User).Id, "Owner is not match!");
break;
//Option type
case "Person.P_Phase":
case "Person.P_PhaseCalendar":
StringAssert.Contains(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Option).ActualXMLTag, "Option is not match!");
break;
default:
StringAssert.Contains(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as string), "Common type is not match!");
break;
}
}
}
}
/// <summary>
/// Verify data of fields
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="inputType">Value type</param>
/// <param name="fieldName">Field name</param>
/// <param name="fieldValue">Field value</param>
private void ReadAndVerifyData(Enums.ResourceType resourceType, ReadValidInput inputType, string fieldName, string fieldValue)
{
ReadResponseData <Field> result = null;
int startFromParamValue = 0;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ FieldApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ FieldApiFields.Resource, (int)resourceType },
};
switch (inputType)
{
case ReadValidInput.RandomStart:
var totalCount = GetAllFields(resourceType).Count;
startFromParamValue = Util.GetRandomNumber(1, (totalCount > 200 ? 200 : totalCount) - 1);
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.StartEqualToTotalSubtract1:
totalCount = GetAllFields(resourceType).Count;
startFromParamValue = (totalCount > 200 ? 200 : totalCount) - 1;
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.Active0:
case ReadValidInput.Active1:
case ReadValidInput.ActiveMinus1:
//To test IsActive feature we need as many fields as possible so the result would be most accurate
parameters.Add(FieldApiFields.Count, MaxReadBatchSize);
parameters.Add(fieldName, fieldValue);
break;
case ReadValidInput.NoParameter:
if (fieldName == FieldApiFields.Active)
{
//To test IsActive feature we need as many fields as possible so the result would be most accurate
parameters.Add(FieldApiFields.Count, MaxReadBatchSize);
}
break;
default:
parameters.Add(fieldName, fieldValue);
break;
}
result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Field"));
switch (inputType)
{
case ReadValidInput.NoParameter:
if (fieldName == FieldApiFields.Count)
{
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
}
if (fieldName == FieldApiFields.Start)
{
Assert.That(result.Start, Is.EqualTo(SystemApiHelper.defaultStart), Enums.Message.START_ERROR);
}
if (fieldName == FieldApiFields.Active)
{
//Without active, verify that both of active 0 and 1 existed
VerifyFieldsHaveProperActiveStatus(result, GetAllFields(resourceType)); //VerifyActiveStatus(parameters, result, resourceType, -1); // All : -1
}
break;
case ReadValidInput.Count10:
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.RandomCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.MaxCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.Start0:
Assert.That(result.Start, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.START_ERROR);
break;
case ReadValidInput.RandomStart:
case ReadValidInput.StartEqualToTotalSubtract1:
Assert.That(result.Start, Is.EqualTo(startFromParamValue), Enums.Message.START_ERROR);
break;
case ReadValidInput.Active1:
VerifyFieldsHaveProperActiveStatus(result, GetActiveFields(resourceType));
break;
case ReadValidInput.Active0:
VerifyFieldsHaveProperActiveStatus(result, GetInactiveFields(resourceType));
break;
case ReadValidInput.ActiveMinus1:
VerifyFieldsHaveProperActiveStatus(result, GetAllFields(resourceType));
break;
}
}
private ErrorCode WriteResourcesFail(Enums.ResourceType resourceType, IEnumerable <XmlResource> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resources.ToList(), cleanupAction: null));
}
/// <summary>
/// Verify multi search/multi field result by date/datetime/age
/// </summary>
/// <param name="resourceType"> Resource Type</param>
/// <param name="fieldAlias">Field Alias</param>
/// <param name="condition1">Condition 1</param>
/// <param name="condition2">Condition 2</param>
/// <param name="conditionValue1">Condition Value 1</param>
/// <param name="conditionValue2">Condition Value 2</param>
/// <returns>empty</returns>
public static void VerifySearchDate(Enums.ResourceType resourceType, Dictionary <string, string> parameters, bool isDate = true)
{
string fieldAlias1 = parameters[FieldAlias1];
string fieldAlias2 = parameters[FieldAlias2];
string condition1 = parameters[Condition1];
string condition2 = parameters[Condition2];
string conditionValue1 = parameters[ConditionValue1];
string conditionValue2 = parameters[ConditionValue2];
string formatCond = GetFormatCondition(fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1, conditionValue2);
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", fieldAlias1 == fieldAlias2 ? fieldAlias1 : string.Format("{0},{1}", fieldAlias1, fieldAlias2) }
};
ReadResponseData <XmlResource> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters);
switch (condition1 + condition2)
{
case Eq + Gt:
//case Eq + Le:
case Eq + Ge:
case Eq + Eq:
case Le + Gt:
case Le + Ge:
case Le + Eq:
case Lt + Gt:
case Lt + Ge:
case Lt + Eq:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.That(result.Count, Is.EqualTo(0), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(0), Enums.Message.COUNT_ERROR);
break;
case Or + Or:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.ParameterIsInvalid), Enums.Message.WRONG_ERROR_CODE);
break;
default:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.IsNotNull(result, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.IsNotNull(result.Items, string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
Assert.Greater(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.Greater(result.Items.Count, 0, Enums.Message.COUNT_ERROR);
if (fieldAlias1 == fieldAlias2)
{
VerifyValueOneField(result.Items, parameters, isDate);
}
else
{
VerifyValueMultipleField(result.Items, parameters, isDate);
}
break;
}
}
private void InitFullScopeAdapter(ApplicationType appType)
{
appInfo = GetDefaultApplication(appType);
adapter = GetDefaultAdapter(appType);
}
public void TestReadUserWithDuplicateParameters(string param, bool isDuplicatedValue)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
List <int> duplicatedParameters = new List <int>();
switch (param)
{
case FieldApiFields.Resource:
int client = (int)Enums.ResourceType.Client;
int activity = (int)Enums.ResourceType.Activity;
if (isDuplicatedValue)
{
duplicatedParameters = new List <int>()
{
client, client, client
};
}
else
{
duplicatedParameters = new List <int>()
{
activity, client, activity
};
}
break;
case FieldApiFields.Active:
if (isDuplicatedValue)
{
duplicatedParameters = new List <int>()
{
1, 1, 1
};
}
else
{
duplicatedParameters = new List <int>()
{
0, 1, 0
};
}
break;
case FieldApiFields.Count:
case FieldApiFields.Start:
if (isDuplicatedValue)
{
duplicatedParameters = new List <int>()
{
10, 10, 10
};
}
else
{
duplicatedParameters = new List <int>()
{
10, 11, 12
};
}
break;
}
parameters.Add(param, duplicatedParameters);
ErrorCode result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail <Field>(parameters);
Assert.That(result, MustBe.MatchingErrorCode(Enums.PublicAPIResultCode.ParameterIsInvalid), Enums.Message.WRONG_ERROR_CODE);
}
public override void SetUp()
{
base.SetUp();
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
//////////////////////////////////////////////////////////////////////////////////////
// NEW Client
clientId = (new ResourceCreator <Client>(publicApiAdapter)).Create();
Assume.That(!string.IsNullOrEmpty(clientId), "Unable to create Client");
// Adding id into the static list for further cleanup
listClientId.Add(clientId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Recruiter
Recruiter recruiter = new Recruiter()
{
Id = "-1",
Owner = "1",
Client = clientId,
Name = "Recruiter " + DateTime.Now.ToString("yyyy/MM/dd hh:mm:ss")
};
// Create New Resource
recruiterId = publicApiAdapter.WriteSuccess(recruiter, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(recruiterId), "Unable to create Recruiter");
// Adding id into the static list for further cleanup
listRecruiterId.Add(recruiterId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Job
Job job = new Job()
{
Id = "-1",
Owner = "1",
Client = clientId,
Recruiter = recruiterId,
};
jobId = publicApiAdapter.WriteSuccess(job, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(jobId), "Unable to create Job");
// Adding id into the static list for further cleanup
listJobId.Add(jobId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Resume
resumeId = (new ResourceCreator <Resume>(publicApiAdapter)).Create();
Assume.That(!string.IsNullOrEmpty(resumeId), "Unable to create Resume");
// Adding id into the static list for further cleanup
listResumeId.Add(resumeId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Sales
salesId = WriteSales();
Assume.That(!string.IsNullOrEmpty(salesId), "Unable to create Sales");
// Adding id into the static list for further cleanup
listSalesId.Add(salesId);
}
private Handler ReadResource(Enums.ResourceType resourceType, Dictionary <string, object> urlParameter)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().Read(resourceType.ToString(), urlParameter));
}
private ErrorCode WriteResourcesFail(IEnumerable <XmlResource> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resources.ToList(), cleaner.DeleteMany));
}
private void InitPublicApiConnections(ApplicationType appType)
{
appInfo = GetDefaultApplication(appType);
adapter = GetDefaultAdapter(appType);
}
//private List<string> WriteResources(IEnumerable<Attachment> resources)
//{
// return PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resources.ToList()) ;
//}
private ErrorCode WriteResourceFail(Attachment resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, null));
}
/// <summary>
/// Verify field data
/// </summary>
/// <param name="id"></param>
/// <param name="paramtersDic"></param>
private void VerifyFieldData(string id, Dictionary <string, object> paramtersDic)
{
List <string> fieldList = new List <string>();
foreach (KeyValuePair <string, object> item in paramtersDic)
{
fieldList.Add(item.Key);
}
string fields = string.Join(",", fieldList);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", "Process.P_Id:eq=" + id },
{ "field", fields }
};
ReadResponseData <Process> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Process>(parameters);
Assert.IsTrue(result != null && result.Items != null && result.Items.Count > 0,
string.Format(Enums.Message.READ_RESOURCE_FAILED, "Process"));
foreach (KeyValuePair <string, object> parameter in paramtersDic)
{
foreach (Process item in result.Items)
{
switch (parameter.Key)
{
//User type
case "Process.P_Owner":
case "Process.P_JobOwner":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as User).Id, "Owner is not match!");
break;
//Resource type
case "Process.P_Job":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Job).Id, "Job is not match!");
break;
case "Process.P_Client":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Client).Id, "Client is not match!");
break;
case "Process.P_Resume":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Resume).Id, "Resume is not match!");
break;
case "Process.P_Candidate":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Candidate).Id, "Candidate is not match!");
break;
case "Process.P_Recruiter":
Assert.AreEqual(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Recruiter).Id, "Recruiter is not match!");
break;
//Option type
case "Process.P_Close":
case "Process.P_CloseReason":
case "Process.P_PhaseCalendar":
case "Process.P_Phase":
StringAssert.Contains(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as Option).ActualXMLTag, "Option is not match!");
break;
default:
StringAssert.Contains(parameter.Value.ToString(),
(item.DictionaryValues[parameter.Key] as string), "Common type is not match!");
break;
}
}
}
}
private string WriteResource(Attachment resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, null));
}
//Prepare some reference resource
private void PrepareData()
{
//////////////////////////////////////////////////////////////////////////////////////
// NEW Client
clientId = (new ResourceCreator <Client>(PublicApiAdapter.CreateAdapterForDefaultConnection())).Create();
Assume.That(!string.IsNullOrEmpty(clientId), "Unable to create Candidate");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListClientId.Add(clientId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Recruiter
Recruiter recruiter = new Recruiter()
{
Id = "-1",
Owner = "1",
Client = clientId
};
// Create New Resource
recruiterId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(recruiter, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(recruiterId), "Unable to create Recruiter");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListRecruiterId.Add(recruiterId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Job
Job job = new Job()
{
Id = "-1",
Owner = "1",
Client = clientId,
Recruiter = recruiterId,
};
jobId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(job, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(jobId), "Unable to create new resource");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListJobId.Add(jobId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Candidate
Candidate Candidate = new Candidate()
{
Id = "-1",
Owner = "1",
};
// Create New Resource
candidateId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(Candidate, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(candidateId), "Unable to create new resource");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListCandidateId.Add(candidateId);
//////////////////////////////////////////////////////////////////////////////////////
// NEW Resume
Resume resume = new Resume()
{
Id = "-1",
Candidate = candidateId,
Owner = "1",
};
// Create New Resource
resumeId = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resume, cleanupAction: null);
Assume.That(!string.IsNullOrEmpty(resumeId), "Unable to create new resource");
// Adding id into the static list for further cleanup
PublicAPISetUp.ListResumeId.Add(resumeId);
}
private ErrorCode WriteResourceFail(XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, cleaner.DeleteMany));
}
public void TestReadUserType(string userType)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ RequestType, 1 },
{ UserType, userType }
};
if (userType.Equals("Missing"))
{
parameters.Remove(UserType);
}
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 the not use Count/Start case
Assert.AreEqual(DefaultStart, result.Start, Enums.Message.START_ERROR); // default: 0
Assert.GreaterOrEqual(DefaultCount, result.Count, Enums.Message.COUNT_ERROR); //default: 10
//Verify the type of fields
ResourceHelper.VerifyTypeOfField(result.Items, fields);
//user_type search conditions :
//-1 : users of all types can be acquired.
// 0 : “System Administrators” can be acquired.
// 1 : “Standard Users” can be acquired.
//Missing: Like user type -1, users of all types can be acquired.
//User Type. (0: Normal User; 1: System Administrator).
if (userType.Equals("-1") || userType.Equals("Missing"))
{
//Verify user_type = -1
bool flag1 = false;
bool flag2 = false;
foreach (User user in result.Items)
{
if (user.Type == "1")
{
flag1 = true;
}
if (user.Type == "0")
{
flag2 = true;
}
}
Assert.That(flag1 && flag2, "The user type is incorrect!");
}
else if (userType.Equals("0"))
{
//Verify if list of Users is Admin Users
Assert.That(result.Items.OfType <User>().Select(user => user.Type),
Is.All.EqualTo("1"), "The user type is incorrect!");
}
else if (userType.Equals("1"))
{
//Verify if list of Users is Standard Users
Assert.That(result.Items.OfType <User>().Select(user => user.Type),
Is.All.EqualTo("0"), "The user type is incorrect!");
}
}
/// <summary>
/// Write a phase by using Phase API
/// </summary>
/// <param name="phase"></param>
/// <returns></returns>
public static ErrorCode WritePhaseFail(Phase phase)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail <Phase>(phase, null));
}
private Dictionary <string, object> GetUrlParameter(ReadSpecialInvalidInput inputType)
{
Dictionary <string, object> result = new Dictionary <string, object>()
{
[FieldApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[FieldApiFields.Resource] = (int)Enums.ResourceType.Client,
};
switch (inputType)
{
case ReadSpecialInvalidInput.ActiveEquals2:
result[FieldApiFields.Active] = 2;
break;
case ReadSpecialInvalidInput.ActiveEqualsNegative2:
result[FieldApiFields.Active] = -2;
break;
case ReadSpecialInvalidInput.CountEquals0:
result[FieldApiFields.Count] = 0;
break;
case ReadSpecialInvalidInput.CountOver200:
result[FieldApiFields.Count] = 201;
break;
case ReadSpecialInvalidInput.MissingPartition:
result.Remove(FieldApiFields.Partition);
break;
case ReadSpecialInvalidInput.MissingResource:
result.Remove(FieldApiFields.Resource);
break;
case ReadSpecialInvalidInput.ResourceName:
result[FieldApiFields.Resource] = Enums.ResourceType.Client.ToLowerString();
break;
case ReadSpecialInvalidInput.StartEqualsTotal:
Dictionary <string, object> urlParameters1 = new Dictionary <string, object>()
{
[FieldApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[FieldApiFields.Resource] = (int)Enums.ResourceType.Client,
};
ReadResponseData <Field> result1 = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(urlParameters1);
Assume.That(result1, MustBe.Not.Null, "The response data is null or cannot be parsed to ReadResponseData!");
result[FieldApiFields.Start] = result1.Total;
break;
case ReadSpecialInvalidInput.StartGreaterThanTotal:
Dictionary <string, object> urlParameters2 = new Dictionary <string, object>()
{
[FieldApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[FieldApiFields.Resource] = (int)Enums.ResourceType.Client,
};
ReadResponseData <Field> result2 = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(urlParameters2);
Assume.That(result2, MustBe.Not.Null, "The response data is null or cannot be parsed to ReadResponseData");
result[FieldApiFields.Start] = result2.Total + 1;
break;
}
return(result);
}
/// <summary>
/// Write a phase by using Phase API
/// </summary>
/// <param name="phase"></param>
/// <returns></returns>
public static ErrorCode WritePhasesFail(IEnumerable <Phase> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail <Phase>(resources.ToList(), null));
}
private ErrorCode WriteResourceFail(PublicApiAdapter adapter, XmlResource resource)
{
return(adapter.WriteFail(resource, cleaner.DeleteMany));
}
private ErrorCode WriteResourcesFail(Enums.ResourceType resourceType, byte[] data)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resourceType.ToString(), data, cleaner.DeleteMany));
}
public void TestReadMultiOrder(Enums.ResourceType resourceType, string fieldName1, string fieldName2)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
List <string> fieldList = new List <string>()
{
resourceName + "." + fieldName1, resourceName + "." + fieldName2
};
string fieldAlias1 = fieldList.First();
string fieldAlias2 = fieldList.Last();
string optionMaster1 = GetOptionMaster(fieldAlias1);
Assume.That(optionMaster1, Is.Not.Null.And.Not.Empty, "Cannot get the master option!");
List <string> optionList1 = OptionFieldHelper.GetOptionList(optionMaster1);
Assume.That(optionList1, Is.Not.Null.And.Not.Empty, "Cannot get the option list!");
string fieldValue1 = optionList1.First();
string fieldValue2 = optionList1.Last();
string fieldValue3 = optionList1.Random();
string optionMaster2 = GetOptionMaster(fieldAlias2);
Assume.That(optionMaster2, Is.Not.Null.And.Not.Empty, "Cannot get the master option!");
List <string> optionList2 = OptionFieldHelper.GetOptionList(optionMaster2);
Assume.That(optionList2, Is.Not.Null.And.Not.Empty, "Cannot get the option list!");
string fieldValue4 = optionList1.First();
string fieldValue5 = optionList1.Last();
string fieldValue6 = optionList1.Random();
List <XmlResource> resourceList = new Dictionary <int, string[]>
{
[1] = new string[] { fieldValue1, fieldValue2 },
[2] = new string[] { fieldValue3, fieldValue4 },
[3] = new string[] { fieldValue5, fieldValue6 }
}
.Select(item =>
{
var resource = CreateResourceInstance(resourceType, item.Key);
resource.DictionaryValues[fieldAlias1] = new Option()
{
ActualXMLTag = item.Value[0]
};
resource.DictionaryValues[fieldAlias2] = new Option()
{
ActualXMLTag = item.Value[1]
};
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}:desc,{1}:asc", fieldAlias1, fieldAlias2) },
};
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!");
}
private List <string> WriteResources(Enums.ResourceType resourceType, IEnumerable <XmlResource> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resources.ToList(), cleaner.DeleteMany));
}
public void TestCreateUpdateRecruiterInOneRequest()
{
List <Recruiter> recruiterList = new List <Recruiter>();
string clientId = (new ResourceCreator <Client>(PublicApiAdapter.CreateAdapterForDefaultConnection())).Create();
string recruiterId = CreateRecruiterResourceSpecifiedData(clientId);
Recruiter recruiter1 = new Recruiter
{
Id = recruiterId,
Owner = "1",
Name = "Jacky Nam 1",
Client = clientId,
Division = "Sample Text 1",
Telephone = "083-08125-235",
Mail = "*****@*****.**",
ZipCode = "0123",
Memo = "Sample Text Memo 1"
};
Recruiter recruiter2 = new Recruiter
{
Id = "-1",
Owner = "1",
Name = "Jacky Nam 2",
Client = clientId,
Division = "Sample Text 2",
Telephone = "083-08125-235",
Mail = "*****@*****.**",
ZipCode = "0123",
Memo = "Sample Text Memo 2"
};
recruiterList.Add(recruiter1);
recruiterList.Add(recruiter2);
List <string> idList = PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(recruiterList);
int resourceId = -1;
bool parsed = Int32.TryParse(idList[0], out resourceId);
Assert.IsTrue(parsed);
Assert.IsTrue(resourceId > 0, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, "Recruiter"));
PublicAPISetUp.ListRecruiterId.Add(idList[0]);
PublicAPISetUp.ListRecruiterId.Add(idList[1]);
PublicAPISetUp.ListClientId.Add(clientId);
//Verify data
Dictionary <string, object> fields1 = new Dictionary <string, object>()
{
{ "Recruiter.P_Name", recruiter1.Name },
{ "Recruiter.P_Owner", recruiter1.Owner },
{ "Recruiter.P_Client", recruiter1.Client },
{ "Recruiter.P_Division", recruiter1.Division },
{ "Recruiter.P_Telephone", recruiter1.Telephone },
{ "Recruiter.P_Mail", recruiter1.Mail },
{ "Recruiter.P_Zipcode", recruiter1.ZipCode },
{ "Recruiter.P_Memo", recruiter1.Memo }
};
VerifyFieldData(Int32.Parse(idList[0]), fields1);
Dictionary <string, object> fields2 = new Dictionary <string, object>()
{
{ "Recruiter.P_Name", recruiter2.Name },
{ "Recruiter.P_Owner", recruiter2.Owner },
{ "Recruiter.P_Client", recruiter2.Client },
{ "Recruiter.P_Division", recruiter2.Division },
{ "Recruiter.P_Telephone", recruiter2.Telephone },
{ "Recruiter.P_Mail", recruiter2.Mail },
{ "Recruiter.P_Zipcode", recruiter2.ZipCode },
{ "Recruiter.P_Memo", recruiter2.Memo }
};
VerifyFieldData(Int32.Parse(idList[1]), fields2);
}
