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