public void ValidGetMailIncomingAllow()
{
var handler = new DefaultManager();
var response = handler.Send <object>(MailIncoming.IncomingConfigurationAllow, string.Empty, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not get mail incoming allow");
}
private void SuccessPerform(Dictionary <string, string> request)
{
var manager = new ActionMenuManager(Endpoint);
var result = manager.Execute <List <GetMenuListResponse> >(request, System.Net.Http.HttpMethod.Get);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
public void TestSearchOptionDeleted(string optionDeleted)
{
OptionManager optionHandler = new OptionManager();
Dictionary <string, string> requestDic = new Dictionary <string, string>()
{
["columns"] = "alias,id,deleted",
["self"] = "true",
["deleted"] = optionDeleted,
};
var response = optionHandler.SearchOption(requestDic);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response.Result, PrIs.Not.Null.And.Not.Empty);
var listDeleted = response.Result.SelectMany(r => r.ContainsKey("children")?r.Children?.Select(c => c.ContainsKey("deleted")?c["deleted"]:""):new List <Object> {
""
}).ToList();
listDeleted.RemoveAll(c => c.Equals(""));
if (optionDeleted == "0")
{
PrAssert.That(listDeleted, PrIs.All.EqualTo(false), "Found a different deleted in the search result");
}
else if (optionDeleted == "1")
{
PrAssert.That(listDeleted, PrIs.All.EqualTo(true), "Found a different deleted in the search result");
PrAssert.That(response.Result.Select(r => r.Id), Has.Exactly(1).EqualTo(DeletedAlias.Data.Id), "The deleted option cannot be found!");
}
else
{
PrAssert.That(response.Result.Select(r => r.Id), Has.Exactly(1).EqualTo(DeletedAlias.Data.Id), "The deleted option cannot be found!");
}
}
private void ExecuteUpdateTest(string request, Guid targetId, Dictionary <string, object> expected)
{
var defaultManager = new DefaultManager();
var result = defaultManager.Send(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.PUT);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Can not update field");
// Check field is updated
var fieldManager = new FieldManager();
var readResult = fieldManager.GetFieldDetails(targetId);
PrAssert.That(readResult, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not read field");
var resultData = readResult.Result.Values[targetId].Properties;
foreach (var item in expected)
{
if (resultData.ContainsKey(item.Key) && item.Key != PropertyName.SType.GetEnumStringValue())
{
if (item.Key == PropertyName.Count.GetEnumStringValue())
{
PrAssert.That(Int32.Parse(resultData[item.Key].ToString()), PrIs.EqualTo((int)OptionCountMapper[Commons.FieldTypeAPI]), "Value is not matched");
}
else
{
PrAssert.That(resultData[item.Key].ToString(), PrIs.EqualTo(item.Value.ToString()), "Value is not matched");
}
}
}
}
public void InvalidJsonInRefreshTokenRequestTest(JsonTransformationType jsonTransformationType)
{
var tokenGetRequest = new GetTokenRequest
{
ExpiresIn = 600,
ExtPayload = new { sessionId = "qwer123" },
InvalidAfter = 10800,
Method = "password",
Service = "HRBC",
Credentials = new GetTokenRequest.CredentialsType
{
CompanyId = AuthenticationInfoProvider.Current.DefaultCompanyName,
UserId = AuthenticationInfoProvider.Current.DefaultUserLogin,
Password = AuthenticationInfoProvider.Current.DefaultUserPassword
}
};
var tokenGetResponse = (new DefaultManager(_testConnection)).Send <GetTokenResponse>(tokenGetRequest);
PrAssume.That(tokenGetResponse, PrIs.SuccessfulResponse(), "Failed to get a token for token refresh operation.");
var request = new RefreshTokenRequest
{
ExpiresIn = 600,
InvalidAfter = 10800,
Token = tokenGetResponse.Result.Token
};
PerformTest(tokenGetRequest, jsonTransformationType, CommonConstants.TokenRefreshUrl);
}
private static string GetOtherCompanyToken()
{
using (var creds = AuthenticationInfoProvider.Current.Manager.GetCompany(new CompanySpecBuilder().HavingUsers(new[] { new UserSpecBuilder() }).NotSelected()))
{
if (_otherCopmanyToken != null)
{
return _otherCopmanyToken;
}
using (var connection = new AuthApiConnection(TestConfig.GetValueFromConfig("AuthCoreURL"))
{
SuppressAuthentication = true
})
{
var getTokenRequest = new GetTokenRequest
{
Service = "HRBC",
Method = "password",
Credentials = new GetTokenRequest.CredentialsType
{
CompanyId = creds.Name,
UserId = creds.Users.Single().Login,
Password = creds.Users.Single().Password
},
ExpiresIn = 600,
InvalidAfter = 10800
};
var response = (new DefaultManager(connection)).Send<GetTokenResponse>(getTokenRequest);
Assume.That(response, PrIs.SuccessfulResponse(), "Failed to get a token");
return _invalidExpiredToken = response.Result.Token;
}
}
}
public void TestPutDuplicateParameters(SpecialData.Parameters parameter, Values value)
{
var handler = new MergeSettingsManager();
var response = handler.MergeSettings <MergeSettingsResponse>(value == Values.Same ? PutDuplicateParametersSameValue[parameter] : PutDuplicateParametersNotSameValue[parameter], System.Net.Http.HttpMethod.Put);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
}
private static PrivateData <object> CreateTestUser()
{
return(new PrivateData <object>(
(session, test) =>
{
return Task.Run(() =>
{
var request = new User
{
UserPName = "Test User",
UserPMail = $"{Utils.RandomString(10)}@gmail.com",
UserPPassword = "******",
UserPStartDate = DateTime.Now.ToString("yyyy/MM/dd"),
UserPLanguage = "en_us",
UserPDeptId = "1001",
UserPAdministrator = false
};
var handler = new UserManager();
var result = handler.Execute <User>(request, HttpMethod.Post);
PrAssume.That(result, PrIs.SuccessfulResponse(), "Create user is failed.");
UserId = result.Result.UserPId;
return new object();
});
},
(session, test, obj) => Task.Run(() =>
{
})));
}
public void ReadRequestValidTests(ValidParams param)
{
var userHandler = new UserManager();
var request = new Dictionary <string, string>
{
[FieldId] = UserId.ToString()
};
if (param != ValidParams.Null)
{
request[FieldName] = param == ValidParams.MultipleFields ? $"{FieldTos},{FieldNotice}" : $"User.P_{param}";
}
var result = userHandler.Execute <User>(request, string.Empty, HttpMethod.Get);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode((int)System.Net.HttpStatusCode.OK));
switch (param)
{
case ValidParams.TosAgreementDate:
PrAssert.That(result.Result.UserPTosAgreementDate, Has.No.Null);
break;
case ValidParams.NoticeReadDate:
PrAssert.That(result.Result.UserPNoticeReadDate, Has.No.Null);
break;
default:
PrAssert.That(result.Result.UserPTosAgreementDate, Has.No.Null);
PrAssert.That(result.Result.UserPNoticeReadDate, Has.No.Null);
break;
}
}
public void TestPutDuplicateParametersDefaultSender(SpecialData.Parameters parameter, Values value)
{
var handler = new UserManager();
var response = handler.Execute <User>(value == Values.Same ? PutDuplicateParametersSameValue[parameter] : PutDuplicateParametersNotSameValue[parameter], System.Net.Http.HttpMethod.Put);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
}
public void TestGetDuplicateParametersDefaultSender(SpecialData.Parameters parameter, Values value)
{
var handler = new UserManager();
var response = handler.Execute <User>(GetDuplicateParameters[value][parameter], string.Empty, System.Net.Http.HttpMethod.Get);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
public void ValidDuplicateUpdateCustomActionTest(CustomActionTestData.DuplicatePut duplicatePut)
{
var hanlder = new CustomActionManager();
var response = hanlder.CustomAction <UpdateCustomActionResponse>(CustomActionTestData.ValidDuplicateUpdateMapper[duplicatePut](PrepareData.Data.Id), HttpMethod.PUT.ToNetHttpMethod());
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not update custom action");
}
public void ValidGetCustomActionTest(CustomActionTestData.ValidUrl url, CustomActionTestData.ValidLabel validLabel, CustomActionTestData.ValidLabelValue validLabelValue, CustomActionTestData.ValidPlaceValue validPlaceValue)
{
var createRequest = CreateCustomActionTests.GetCreateRequest(CustomActionTestData.ValidUrlMapper[url],
CustomActionTestData.ValidLabelMapper[validLabel](CustomActionTestData.ValidLabelValueMapper[validLabelValue]),
CustomActionTestData.ValidPlaceValueMapper[validPlaceValue]);
var hanlder = new CustomActionManager();
var response = hanlder.CustomAction <CreateCustomActionResponse>(createRequest, HttpMethod.POST.ToNetHttpMethod());
if (validLabel == CustomActionTestData.ValidLabel.BothEnJa)
{
PrAssume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not create custom action");
var allCustomAction = hanlder.GetAllCustomActions();
CreateCustomActionTests.DeleteCustomAction(response.Result.Id);
PrAssert.That(allCustomAction.Result[response.Result.Id].Url, PrIs.EqualTo(CustomActionTestData.ValidUrlMapper[url]), "The url is not as expected");
PrAssert.That(allCustomAction.Result[response.Result.Id].Label.EnUs.Value, PrIs.EqualTo(CustomActionTestData.ValidLabelValueMapper[validLabelValue][CustomActionTestData.ValueParam]), "The En label value is not as expected");
PrAssert.That(allCustomAction.Result[response.Result.Id].Label.Ja.Value, PrIs.EqualTo(CustomActionTestData.ValidLabelValueMapper[validLabelValue][CustomActionTestData.ValueParam]), "The Ja label value is not as expected");
if (validLabelValue != CustomActionTestData.ValidLabelValue.MissingDefaultStringWithSpace && validLabelValue != CustomActionTestData.ValidLabelValue.MissingDefaultStringNoSpace)
{
PrAssert.That(allCustomAction.Result[response.Result.Id].Label.Ja.Default, PrIs.EqualTo(CustomActionTestData.ValidLabelValueMapper[validLabelValue][CustomActionTestData.DefaultParam]), "The Ja label default is not as expected");
PrAssert.That(allCustomAction.Result[response.Result.Id].Label.EnUs.Default, PrIs.EqualTo(CustomActionTestData.ValidLabelValueMapper[validLabelValue][CustomActionTestData.DefaultParam]), "The En label default is not as expected");
}
}
else
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Create custom action Successfully");
}
}
private void ExecuteTestCases(IEnumerable <KeyValuePair <string, string> > request)
{
var manager = new DefaultManager();
var result = manager.Send(EndPoint, request, HttpMethod.GET);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not read data download");
}
public void ReadValidDuplicateTests(ResourceId resourceId, ReadParam param, Enums.ValidDuplicated dupType)
{
var request = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(IdParam, PrepareUserField.Data[resourceId].First().ToString()),
new KeyValuePair <string, string>(SelectParam, Select.DisplayLabel.GetEnumStringValue())
};
var duplicateParam = param == ReadParam.Id ? IdParam : SelectParam;
var duplicateValue = string.Empty;
if (dupType == Enums.ValidDuplicated.SameValue)
{
duplicateValue = request.Where(x => x.Key == duplicateParam).FirstOrDefault().Value;
}
else
{
duplicateValue = duplicateParam == IdParam ? PrepareUserField.Data[resourceId].Last().ToString() : Select.DisplayCaption.GetEnumStringValue();
}
request.Add(new KeyValuePair <string, string>(duplicateParam, duplicateValue));
var defaultManager = new DefaultManager();
var result = defaultManager.Send <FieldDetailsResponse>(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.GET);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not read field details");
foreach (var item in request)
{
if (item.Key == IdParam)
{
PrAssert.That(result.Result.Values[Guid.Parse(item.Value)].Id, PrIs.Not.Null.Or.Empty);
}
}
}
public void ValidReadSelectTests(ResourceType testcase)
{
var request = new Dictionary <string, string>
{
["datasource"] = testcase.ToString().ToLower()
};
var reportHandler = new DefaultManager();
var result = reportHandler.Send <List <AvailableConstraintResponse> >(EndPoint, request, HttpMethod.GET);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Unreadable available select.");
for (int i = 0; i < result.Result.Count; i++)
{
if (ResourceTypeReferenceMapper.ContainsKey(testcase))
{
PrAssert.That(result.Result[i].Name, PrIs.EqualTo(ResourceTypeReferenceMapper[testcase].ToArray()[i].ToString().ToLower()));
foreach (var item in result.Result[i].Content)
{
PrAssert.That(item.Field.Split('.').First(), PrIs.EqualTo(ResourceTypeReferenceMapper[testcase].ToArray()[i].ToResourceName()), "Wrong field alias.");
}
}
else
{
PrAssert.That(result.Result[i].Name, PrIs.EqualTo(testcase.ToString().ToLower()));
foreach (var item in result.Result[i].Content)
{
PrAssert.That(item.Field.Split('.').First(), PrIs.EqualTo(testcase.ToResourceName()), "Wrong field alias.");
}
}
}
}
private static string PrepareExpiredToken()
{
if (_expiredToken != null)
{
return _expiredToken;
}
using (var connection = new AuthApiConnection(TestConfig.GetValueFromConfig("AuthCoreURL"))
{
SuppressAuthentication = true
})
{
var expiresInSeconds = 3;
var refreshRequest = new RefreshTokenRequest
{
ExpiresIn = expiresInSeconds,
InvalidAfter = 10800,
Token = AuthApiConnection.GetConnectionForCurrentTest().GetCookieValue("HRBCAUTH")
};
var response = (new DefaultManager(connection)).Send<GetTokenResponse>(refreshRequest);
Assume.That(response, PrIs.SuccessfulResponse(), "Failed to refresh a token");
System.Threading.Thread.Sleep((expiresInSeconds + 1) * 1000);
return _expiredToken = response.Result.Token;
}
}
public static PrivateData <List <int> > GetMailFilter()
{
return(new PrivateData <List <int> >(
(session, test) =>
{
return Task.Run(() =>
{
var handler = new DefaultManager();
var request = new Dictionary <string, object>()
{
[nameof(Name).ToLower()] = "filter name",
[Filter] = AdminMail,
};
var createResponse = handler.Send <object>(MailFilter.Filter, request.ToJson(), HttpMethod.POST);
var readResponse = handler.Send <ReadMailFiltersResponse>(MailFilter.Filters, string.Empty, HttpMethod.POST);
PrAssert.That(readResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not get mail filters");
PrAssert.That(readResponse.Result.Filters.Count, PrIs.GreaterThanOrEqualTo(1), "Number of mail filters is not as expected");
var result = new List <int>();
result = readResponse.Result.Filters.Select(f => f.Id).ToList();
return result;
});
},
(session, test, res) => Task.Run(() =>
{
})));
}
public void ValidGetJobPositionsTests()
{
var defaultManager = new DefaultManager(new MatchingProUIConnection(TestConfig.GetValueFromConfig("MatchingProWeb")));
var response = defaultManager.Send <object>(Endpoints.JobPositions, string.Empty, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
public void InvalidInjectionCreatePhaseEntry(InjectionInput injection, string param)
{
var handler = new DefaultManager();
var result = new List <Dictionary <string, object> >();
var dataItem = GetDataItem(RootPhaseOption.Data[ResourceId.Client].Id);
InjectionParam(injection, param, dataItem);
var phaseItem = GetCreatePhaseItem(dataItem, RecordsCreator);
InjectionParam(injection, param, phaseItem);
result.Add(phaseItem);
var request = new Dictionary <string, object>()
{
[ParamCreate] = result
};
InjectionParam(injection, param, request);
var createResponse = handler.SendAsync <CreatePhaseEntryResponse>(PhaseEntryTestData.PhaseEntryApi, request.ToJson(), HttpMethod.POST).Result;
if (param == ParamMemo)
{
PrAssert.That(createResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Unable to create Phase Entry");
}
else if (param == ParamOption)
{
PrAssert.That(createResponse, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.NotImplemented), "Still able to create Phase Entry");
}
else
{
PrAssert.That(createResponse, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able to create Phase Entry");
}
}
public void TestGetDuplicateParameters(Values value)
{
var handler = new MergeSettingsManager();
var response = handler.MergeSettings <MergeSettingsResponse>(GetDuplicateParameters[value], System.Net.Http.HttpMethod.Get);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
public void TestInvalidOriginalSearchMenuConditions(Parameters parameter, InvalidTestCases inputType)
{
var handler = new OriginalSearchManager();
var request = GetOriginalSearchConditionsParameters(ResourceId.Client);
if (inputType == InvalidTestCases.Missing)
{
request.Remove(parameter.ToString().ToLower());
}
else
{
request[parameter.ToString().ToLower()] = InvalidMaps[inputType].ToString();
}
if (Parameters.Limit == parameter && (inputType == InvalidTestCases.NoneExistedId || inputType == InvalidTestCases.BigInterger))
{
var response = handler.OriginalSearch <List <ConditionsDataResponse> >(GetOriginalSearchConditionsParameters(ResourceId.Client), System.Net.Http.HttpMethod.Get);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
PrAssert.That(response.Result.Count, PrIs.GreaterThan(0));
}
else
{
var response = handler.OriginalSearch <object>(request, System.Net.Http.HttpMethod.Get);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
}
public void UpdateValidSpecialTests(ResourceId resourceId, FieldTestType fieldTestType, ValidUpdateSpecial testcase)
{
var param = testcase.GetEnumStringValue();
// Generate properties
var properties = GenerateProperties(Commons.FieldTypeAPI);
// Get field id
var fieldId = fieldTestType == FieldTestType.UserDefine ? PrepareUserField.Data[resourceId].FirstOrDefault() : PrepareAppField.Data[resourceId].FirstOrDefault();
// Update properties of field
var fieldProperties = ReadFieldDetails(fieldId).Result.Values.FirstOrDefault().Value.Properties;
var updateValue = ValidUpdateSpecialMapper[testcase](fieldProperties, param);
properties[param] = updateValue;
// Generate request
var request = GenerateRequest(Parameters.Update, GenerateUpdateInfos(resourceId, fieldId, properties));
// Execute test
var defaultManager = new DefaultManager();
var result = defaultManager.Send(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.PUT);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Can not update field");
// Check field isn't updated
var readResult = ReadFieldDetails(fieldId);
PrAssert.That(readResult, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not read field");
if (!param.Equals(PropertyName.Enabled.GetEnumStringValue()))
{
var resultData = readResult.Result.Values[fieldId].Properties[param];
PrAssert.That(resultData, PrIs.Not.EqualTo(updateValue), "Value is updated");
}
}
public void InvalidGetMailServers()
{
var handler = new DefaultManager(PreparedConnection.Data);
var response = handler.Send <List <GetMailServerResponse> >(MailServer.Servers, string.Empty, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not create mail server");
}
public void UpdatePassOverCheckOldPasswordNumber()
{
var creds = AuthenticationInfoProvider.GetAuthSpecForCurrentTest();
var defaultUserName = creds.Companies.First().Value.Users.First().Login;
var defaultPassword = creds.Companies.First().Value.Users.First().Password;
int checkOldPasswords = 5;
List <string> arrPassword = new List <string>();
//Update a list of passwords
for (var i = 0; i < checkOldPasswords + 3; i++)
{
arrPassword.Add(TestContext.CurrentContext.Random.GetString(8, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
Common.UpdateNewPassword(arrPassword[i], LastPassword == string.Empty ? defaultPassword : LastPassword);
LastPassword = arrPassword[i];
}
//Update password
var updatePassRequest = new Dictionary <string, object>(Common.UpdatePasswordParameters);
updatePassRequest["oldPassword"] = LastPassword;
updatePassRequest["newPassword"] = arrPassword[checkOldPasswords + 1];
updatePassRequest["checkOldPasswords"] = checkOldPasswords;
var updatePassHandler = new UpdatePasswordManager();
var response = updatePassHandler.UpdatePassword(updatePassRequest, HttpMethod.Put);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
}
public static void DeleteMediumAccount(int mediumId)
{
var handler = new DefaultManager(CreateNewApiConnection());
var response = handler.Send <object>($"{MediumAccountEndpoint}/{mediumId}", string.Empty, TestCoreFramework.Enums.HttpMethod.DELETE);
Assume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
}
public void TestSearchOptionEnabled(string optionEnabled)
{
OptionManager optionHandler = new OptionManager();
Dictionary <string, string> requestDic = new Dictionary <string, string>()
{
["enabled"] = optionEnabled,
};
var response = optionHandler.SearchOption(requestDic);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response.Result, PrIs.Not.Null.And.Not.Empty);
var listEnabled = response.Result.SelectMany(r => r.ContainsKey("children") ? r.Children?.Select(c => c.ContainsKey("enabled") ? c["enabled"] : "") : new List <Object> {
""
}).ToList();
listEnabled.RemoveAll(c => c.Equals(""));
if (optionEnabled == "0")
{
PrAssert.That(listEnabled, PrIs.All.EqualTo(0), "Found a different enabled in the search result");
}
else if (optionEnabled == "1")
{
PrAssert.That(listEnabled, PrIs.All.EqualTo(1), "Found a different enabled in the search result");
}
}
public void UpdateValidSpecialTests(ResourceId resourceId, FieldKind fieldKind, ValidUpdateSpecial testcase)
{
var properties = GenerateProperties(Commons.FieldTypeAPI, Label.Min, Caption.Min, Search.True, Match.False, Web.False, Highlight.False, Require.False, DateTimeDefault.Date);
ValidUpdateRequestSpecialMapper[testcase](properties);
var fieldId = fieldKind == FieldKind.UserDefine ? PrepareUserField.Data[resourceId].FirstOrDefault() : PrepareAppField.Data[resourceId].FirstOrDefault();
var request = GenerateRequest(Parameters.Update, GenerateUpdateInfos(resourceId, fieldId, properties));
var defaultManager = new DefaultManager();
var result = defaultManager.Send(FieldManager.FieldHandlingRelativeUrl, JsonConvert.SerializeObject(request), HttpMethod.PUT);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Can not update field");
// Check field isn't updated
var fieldManager = new FieldManager();
var readResult = fieldManager.GetFieldDetails(fieldId);
PrAssert.That(readResult, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not read field");
if (testcase == ValidUpdateSpecial.UpdateEnabledProp)
{
PrAssert.That(readResult.Result.Values[fieldId].Properties.ContainsKey(properties.Last().Key), PrIs.EqualTo(false), "Value is updated");
}
else
{
var resultData = readResult.Result.Values[fieldId].Properties[properties.Last().Key];
PrAssert.That(resultData, PrIs.Not.EqualTo(properties.Last().Value), "Value is updated");
}
}
public void ValidDuplicateCustomActionReplaceTest(CustomActionTestData.DuplicateReplace duplicateReplace)
{
var hanlder = new CustomActionManager();
var replaceResponse = hanlder.Replace <object>(CustomActionTestData.ValidDuplicateActionReplaceMapper[duplicateReplace](PrepareData.Data.Id, RecordsCreator.Data[ResourceId.Client].Id), HttpMethod.POST.ToNetHttpMethod());
PrAssert.That(replaceResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not create custom action");
}
public static List <long> SortedProcessDataList(List <int> listResult, string orderField, string orderType, FieldType fieldType)
{
var recordHandler = new RecordManager();
var res = recordHandler.ReadRecords(
RecordRequestComposer.ComposeReadRequest()
.ForResource(Porters.TestCoreFramework.Enums.ResourceType.Process)
.WithIds(listResult.ToArray())
.Fields(ProcessClose, ProcessId, ProcessPhase, ProcessPhaseDate, ProcessUpdateDate, ProcessRegistrationDate, ProcessExpectedClosingDate, ProcessExpectedSalesAmount, orderField)
.Result);
PrAssume.That(res, PrIs.SuccessfulResponse(), "Can not read Process records");
var result = GetDataList(res.Result.Items, orderField, fieldType).OrderBy(item => item.Close).ThenByDescending(item => item.Phase).ThenByDescending(item => item.PhaseDate);
var sortedList = new List <ProcessData>();
if (orderField != ProcessId && orderField != string.Empty)
{
sortedList = ((orderType == "asc") ?
result.ThenBy(item => item.OrderField) :
result.ThenByDescending(item => item.OrderField))
.ThenByDescending(item => item.Id).ToList();
}
else
{
sortedList = ((orderType == "asc") ?
result.ThenBy(item => item.Id) :
result.ThenByDescending(item => item.Id)).ToList();
}
return(sortedList.Select(i => i.Id).ToList());
}