public void ValidDeleteFieldSpecial(ResourceId resource, CommonMapperValue.ValidDelete mode)
{
var fieldUUID = PreparedFieldId.Data[$"{resource}0"];
var fieldUUIDSecondValue = PreparedFieldId.Data[$"{resource}1"];
var fieldUUIDApplicationField = ApplicationFieldId.Data[resource];
var listUUID = new List <Guid> {
fieldUUID
};
if (mode == CommonMapperValue.ValidDelete.Multiple)
{
listUUID.Add(fieldUUIDSecondValue);
}
if (mode == CommonMapperValue.ValidDelete.Mix)
{
listUUID.Add(fieldUUIDApplicationField);
}
var response = CommonHelpers.DeleteField(listUUID);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(HttpStatusCode.NoContent), "Can not delete Field");
}
public void TestReadFieldValid(ResourceId resource, ValidReadId validReadId, Selects.ValidSelect select)
{
var firstUuidUser = FieldsCreator.Data[$"{resource}-{Defines.FieldTypeApi.ToString()}-0"].Guid.ToString();
var secondUuidUser = FieldsCreator.Data[$"{resource}-{Defines.FieldTypeApi.ToString()}-1"].Guid.ToString();
var firstUuidApp = TextHelpers.Guid[TextHelpers.FieldTypes.Application](resource, null, Defines.FieldTypeApi, TextHelpers.ApplicationFieldNames[Defines.FieldTypeApi]().First()).ToString();
var secondUuidApp = TextHelpers.Guid[TextHelpers.FieldTypes.Application](resource, null, Defines.FieldTypeApi, TextHelpers.ApplicationFieldNames[Defines.FieldTypeApi]().Last()).ToString();
var idParams = ValidReadUUIDMapperValue[validReadId](firstUuidUser, secondUuidUser, firstUuidApp, secondUuidApp, SystemFields.GetSytemFieldUuidByFieldType(resource, FieldType.Mail));
var sel = Selects.SelectMapperValue[select];
var request = new List <KeyValuePair <string, string> >();
request.AddRange(idParams);
request.AddRange(sel);
var handler = new DefaultManager();
var response = handler.Send <FieldDetailsResponse>(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
//Verify
Selects.VerifyContainExpectedSelect(response.Result, select);
}
public void DuplicateParameters(Fields field, Values value)
{
var defaultUserId = TestContext.CurrentContext.Test.Properties.Get("adminUserId");
var ParametersSameValue = new Dictionary <Fields, object>
{
[Fields.UserId] = "{\"userId\": \"" + defaultUserId + "\", \"userId\": \"" + defaultUserId + "\"}",
[Fields.ForcePasswordChange] = "{\"userId\": \"" + defaultUserId + "\", \"forcePasswordChange\": true, \"forcePasswordChange\": true}"
};
var ParametersNotSameValue = new Dictionary <Fields, object>
{
[Fields.UserId] = "{\"userId\": \"" + defaultUserId + "\", \"userId\": \"11115887\"}",
[Fields.ForcePasswordChange] = "{\"userId\": \"" + defaultUserId + "\", \"forcePasswordChange\": true, \"forcePasswordChange\": false}"
};
var resetUserPassHandler = new ResetUserPasswordManager();
var response = resetUserPassHandler.ResetUserPassword(value == Values.Same ? ParametersSameValue[field] : ParametersNotSameValue[field], System.Net.Http.HttpMethod.Post);
LastPassword = Common.GetResetUserPassword(response);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public void TestInvalidDeleteFieldLayout(InvalidValue invalid)
{
var handler = new DefaultManager();
var dictionaryValues = new Dictionary <string, object>
{
[IdParam] = LayoutUuids[ResourceId.Client]
};
InvalidValueMapper[invalid](dictionaryValues, IdParam);
var request = new List <KeyValuePair <string, string> >();
if (invalid != InvalidValue.MissingParam)
{
request.Add(new KeyValuePair <string, string>(IdParam, LayoutUuids[ResourceId.Client].ToString()));
request.Add(new KeyValuePair <string, string>(IdParam, dictionaryValues[IdParam].ToString()));
}
var response = handler.Send <object>(FieldManager.FieldLayoutApiRelativeUrl, request, HttpMethod.DELETE);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public void ValidSpecialCustomActionReplaceTest(ResourceId resourceId, string fieldName)
{
string fieldAlias = $"{resourceId.ToAlias()}.{fieldName}";
var recordHandler = new RecordManager();
var res = recordHandler.ReadRecords(
RecordRequestComposer.ComposeReadRequest()
.ForResource((TestCoreFramework.Enums.ResourceType)(int) resourceId)
.WithIds((int)RecordsCreator.Data[resourceId].Id)
.Fields($"{resourceId.ToAlias()}.P_Id", fieldAlias)
.Result);
var recordValue = res.Result.Items[0];
if (fieldName.EndsWith("Date") || fieldName == "P_Owner")
{
recordValue[fieldAlias] = recordValue[fieldAlias].ToString().Replace("/", "-").Replace("[\r\n", "").Replace("\r\n]", "").Split('.')[0].Trim();
}
var requestUrl = $"hrbc1-web.localvm/{{{{{fieldAlias}}}}}";
var expectUrl = $"hrbc1-web.localvm/{recordValue[fieldAlias].ToString()}";
var createRequest = CreateCustomActionTests.GetCreateRequest(requestUrl,
CustomActionTestData.ValidLabelMapper[CustomActionTestData.ValidLabel.BothEnJa](CustomActionTestData.ValidLabelValueMapper[CustomActionTestData.ValidLabelValue.StringNoSpaceBoth]),
CustomActionTestData.ValidPlaceValueMapper[CustomActionTestData.ValidPlaceValue.Client]);
var hanlder = new CustomActionManager();
var response = hanlder.CustomAction <CreateCustomActionResponse>(createRequest, HttpMethod.POST.ToNetHttpMethod());
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not create custom action");
var resourceName = resourceId == ResourceId.Person ? "candidate" : resourceId.ToString().ToLower();
var replaceRequest = GetReplaceRequest(response.Result.Id,
new Dictionary <string, object>
{
[resourceName] = resourceId == ResourceId.None ? 0 : RecordsCreator.Data[resourceId].Id,
});
hanlder = new CustomActionManager();
var replaceResponse = hanlder.Replace <ReplaceCustomActionResponse>(replaceRequest, HttpMethod.POST.ToNetHttpMethod());
PrAssert.That(replaceResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not create custom action");
var convertedUrl = WebUtility.UrlDecode(replaceResponse.Result.Url).Trim();
PrAssert.That(convertedUrl, PrIs.EqualTo(expectUrl), "Can not create custom action");
}
private static void CreateSettings(List <int> resource, List <int> options, List <int> agents, List <int> depts, List <int> unique, List <int> searchOwners = null, string timePeriod = null)
{
var handler = new DashboardManager(DashboardHelpers.DashboardRegistrationEndPoint);
var originalRequest = new Dictionary <string, object>()
{
["settings"] = new Dictionary <string, object>()
{
["options"] = options,
["owners"] = new Dictionary <string, object>()
{
["agents"] = agents,
["depts"] = depts,
},
["unique"] = unique
},
["resource"] = resource,
["type"] = DashboardHelpers.Types.History.ToString().ToLower()
};
if (searchOwners != null)
{
var request = originalRequest["settings"] as Dictionary <string, object>;
request["searchOwners"] = searchOwners;
originalRequest["settings"] = request;
}
if (resource == null)
{
originalRequest.Remove("resource");
var request = originalRequest["settings"] as Dictionary <string, object>;
request.Remove("unique");
request["timePeriod"] = new Dictionary <string, string>
{
["type"] = timePeriod
};
originalRequest["settings"] = request;
}
var response = handler.SendDashboard <object>(originalRequest, HttpMethod.Put);
PrAssume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
}
public void TestSearchOptionField(ValidOptionField optionField)
{
OptionManager optionHandler = new OptionManager();
Dictionary <string, string> requestDic = new Dictionary <string, string>()
{
["id"] = PrepareUpdatedOption.Data.Id.ToString(),
["self"] = "true",
["columns"] = ValidFieldMapper[optionField],
};
var response = optionHandler.SearchOption(requestDic);
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response.Result, PrIs.Not.Null.And.Not.Empty);
var actualOption = response.Result.SingleOrDefault();
PrAssert.That(actualOption, PrIs.Not.Null.And.Not.Empty);
if (optionField == ValidOptionField.CreatedById || optionField == ValidOptionField.CreatedByName)
{
PrAssert.That(actualOption.ContainsKey(ValidFieldMapper[optionField].Split('.')[0]), PrIs.EqualTo(true), $"The result doesnt contain key {ValidFieldMapper[optionField].Split('.')[0]}");
PrAssert.That(actualOption.CreateBy.ContainsKey(ValidFieldMapper[optionField].Split('.')[1]), PrIs.EqualTo(true), $"The result doesnt contain key {ValidFieldMapper[optionField].Split('.')[1]}");
PrAssert.That(actualOption.CreateBy[ValidFieldMapper[optionField].Split('.')[1]], PrIs.EqualTo(1).Or.EqualTo("Test Tester"), $"The result actual value is {actualOption.CreateBy[ValidFieldMapper[optionField].Split('.')[1]]}");
}
else if (optionField == ValidOptionField.UpdatedById || optionField == ValidOptionField.UpdatedByName)
{
PrAssert.That(actualOption.ContainsKey(ValidFieldMapper[optionField].Split('.')[0]), PrIs.EqualTo(true), $"The result doesnt contain key {ValidFieldMapper[optionField].Split('.')[0]}");
PrAssert.That(actualOption.UpdateBy.ContainsKey(ValidFieldMapper[optionField].Split('.')[1]), PrIs.EqualTo(true), $"The result doesnt contain key {ValidFieldMapper[optionField].Split('.')[1]}");
PrAssert.That(actualOption.UpdateBy[ValidFieldMapper[optionField].Split('.')[1]], PrIs.EqualTo(1).Or.EqualTo("Test Tester"), $"The result actual value is {actualOption.UpdateBy[ValidFieldMapper[optionField].Split('.')[1]]}");
}
else if (optionField == ValidOptionField.All)
{
foreach (var field in Enum.GetValues(typeof(ValidOptionField)).Cast <ValidOptionField>().Where(v => v != ValidOptionField.All))
{
PrAssert.That(response.Result.Select(r => r.ContainsKey(ValidFieldMapper[field].Split('.')[0])), PrIs.All.EqualTo(true), $"{field} cannot be found");
}
}
else
{
PrAssert.That(response.Result.Select(r => r.ContainsKey(ValidFieldMapper[optionField])), PrIs.All.EqualTo(true), $"{optionField} cannot be found");
}
}
public void ReadHrbcCoreTmpCompanyInfoValidTest(UserType userType, ValidTestCases inputType)
{
ApiResponse <HrbcCoreTmpCompanyInfoResponse> response = null;
var creds = AuthenticationInfoProvider.GetAuthSpecForCurrentTest();
var companyName = creds.Companies.First().Value.Metadata["companyName"].ToString();
var companyLoginId = creds.Companies.First().Value.Name;
var adminLogin = creds.Companies.First().Value.Users.First().Login;
var adminPassword = creds.Companies.First().Value.Users.First().Password;
var dbInfoHost = creds.Companies.First().Value.Metadata["dbInfoHost"].ToString();
var dbInfoPort = creds.Companies.First().Value.Metadata["dbInfoPort"].ToString();
var dbInfoUserName = creds.Companies.First().Value.Metadata["dbInfoUserName"].ToString();
var dbInfoPassword = creds.Companies.First().Value.Metadata["dbInfoPassword"].ToString();
var companyInfoHandler = new HrbcCoreManager();
var requestDefault = new Dictionary <string, string>()
{
["companyId"] = CompanyId
};
if (inputType != ValidTestCases.Default)
{
requestDefault["fullMode"] = ValidMapperValues[inputType].ToString().ToLower();
}
if (UserType.User == userType)
{
var request = new Dictionary <string, string>(requestDefault);
response = companyInfoHandler.LoginAndSendRequestWithOtherAccount <HrbcCoreTmpCompanyInfoResponse>(CompanyName, NormalUserLogin, NormalUserPassword, HrbcCoreManager.GetTmpCompanyInfoEndpoint, request);
companyInfoHandler.ReAuthenticate(CompanyName, adminLogin, adminPassword);
}
else
{
response = companyInfoHandler.SendHrbcCoreTmpCompanyInfo <HrbcCoreTmpCompanyInfoResponse>(_testConnection, requestDefault, System.Net.Http.HttpMethod.Get);
}
creds.Dispose();
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(HttpStatusCode.OK));
//Verify data
VerifyData(response, inputType, new CompanyInfo(CompanyId, companyName, companyLoginId, $"PRC{CompanyId}", dbInfoHost, dbInfoPort, dbInfoUserName, dbInfoPassword));
}
public void ReadingPasswordSettings(int companyId)
{
var request = new Dictionary <string, string>()
{
["id"] = companyId.ToString(),
};
var handler = new WebPasswordManager();
var response = handler.Password <PasswordSettingsResponse>(request, System.Net.Http.HttpMethod.Get);
PrAssert.That(response, PrIs.SuccessfulResponse());
if (companyId == Common.OldCompanyId)
{
PrAssert.That(response.Result.CheckComplexity, PrIs.EqualTo(false), "The check complexity is not as expected");
}
else
{
PrAssert.That(response.Result.CheckComplexity, PrIs.EqualTo(true), "The check complexity is not as expected");
PrAssert.That(response.Result.AccountLockOut.MaxFails, PrIs.EqualTo(5), "The max fails is not as expected");
PrAssert.That(response.Result.History.Count, PrIs.EqualTo(3), "The count is not as expected");
PrAssert.That(response.Result.Expiration.Days, PrIs.EqualTo(90), "The days is not as expected");
}
}
private static void VerifyData(PrivateApiResponse <TopDashboardDataResponse> response, string timePeriod)
{
PrAssert.That(response.Result.Data.Resources, PrIs.Not.Null.And.Not.Empty.And.EqualTo(Resources));
PrAssert.That(response.Result.Data.Type, PrIs.Not.Null.And.Not.Empty.And.Contains(DashboardHelpers.Types.History.ToString().ToLower()));
VerifyOptions(response.Result.Data.Result.Settings.Options, OptionsJob);
VerifyOptions(response.Result.Data.Result.Settings.Options, OptionsResume);
VerifyOptions(response.Result.Data.Result.Settings.Options, OptionsProcess);
PrAssert.That(response.Result.Data.Result.Settings.Owners.Agents, PrIs.Not.Null.And.Not.Empty.And.Contains(-1));
PrAssert.That(response.Result.Data.Result.Settings.Owners.Depts, PrIs.Not.Null.And.Not.Empty.And.Contains(1001));
VerifyOptions(response.Result.Data.Result.Settings.Options, response.Result.Data.Result.Data.Select(item => int.Parse(item.Key)).ToList());
VerifyOptions(response.Result.Data.Result.Settings.Unique, Uniques);
VerifyOptions(response.Result.Data.Result.Settings.SearchOwners, SearchOwners);
PrAssert.That(response.Result.Data.Result.Settings.TimePeriod.Type, PrIs.EqualTo(timePeriod));
VerifyLabels(response.Result.Labels.Job.Values, JobAliases);
VerifyLabels(response.Result.Labels.Resume.Values, ResumeAliases);
VerifyLabels(response.Result.Labels.Process.Values, ProcessAliases);
}
public void InvalidTests(string param, Invalid invalid)
{
// Generate request
var id = SystemFields.GetSystemFieldId(ResourceId.Client, SystemFieldAlias);
var dictionary = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(Selects.IdParam, id.ToString())
};
dictionary.AddRange(Selects.SelectMapperValue[Selects.ValidSelect.DisplayLabel]);
// Replace invalid parameter value
var index = dictionary.FindIndex(x => x.Key == param);
dictionary[index] = InvalidMapper[invalid](param);
// Execute test
var defaultManager = new DefaultManager();
var result = defaultManager.Send <FieldDetailsResponse>(FieldManager.FieldHandlingRelativeUrl, dictionary, HttpMethod.GET);
PrAssert.That(result, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still read field details successfully");
}
public void LoginNormalUserAndSendRequestWithHeaderContainsAdminUserIdTest()
{
var creds = AuthenticationInfoProvider.GetAuthSpecForCurrentTest();
var adminUserPassword = creds.Companies.First().Value.Users.First().Password;
var adminUserLogin = creds.Companies.First().Value.Users.First().Login;
var adminUserId = creds.Companies.First().Value.Users.First().Metadata["userId"].ToString();
var companyId = creds.Companies.First().Value.Id;
var companyName = creds.Companies.First().Value.Name;
creds.Dispose();
var headerValue = GetFormatIdentityHeader(companyId, adminUserId, DefaultService);
//Login by normal user
Connection = new PrivateApiConnection(TestConfig.GetValueFromConfig("InternalServerURL"));
Connection.Authenticate(companyName, NormalUserLogin, NormalUserPassword);
var internalHandler = new InternalApiManager(Connection);
var response = internalHandler.SendRequestWithIdentityHeader(InternalAuthRequest, "X-IDENTITY", headerValue, HttpMethod.Post);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.Unauthorized));
}
public void ResetPasswordInjectionTests(InjectionParam key, InjectionInput value)
{
var token = Common.GetToken();
var defaultUser = CommonData.GetDefaultUser();
var requestDic = new Dictionary <string, object>()
{
["companyLoginId"] = defaultUser.Company.Name,
["username"] = defaultUser.Login,
["newPassword"] = "******",
["token"] = token.Result.Token,
["checkOldPasswords"] = CheckOldPasswords,
};
requestDic[String.Format("{0}{1}", key.ToString().Substring(0, 1).ToLower(), key.ToString().Substring(1))] = InjectionInputMapper[value];
var passwordMng = new ResetPasswordManager();
var oldPassword = Common.GetOldPassword();
var response = passwordMng.ResetPassword <ResetPasswordResponse>(requestDic, HttpMethod.Post);
Common.RecoverOldPassword(requestDic, passwordMng, oldPassword);
defaultUser.Dispose();
PrAssert.That(response, PrIs.ErrorResponse().With.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public void TestInvalidBodyJson(OriginalSearchHelpers.InvalidSpecialCondition inputType)
{
var handler = new DefaultManager();
var bulkDeleteContentObject = DefaultBulkDeleteParametersWithRecordIds(ResourceId.Client, new List <string> {
RecordsCreator.Data[$"{ResourceId.Client}0"].Id.ToString()
});
string jsonContent = string.Empty;
if (inputType == OriginalSearchHelpers.InvalidSpecialCondition.BrokenJsonFormat)
{
jsonContent = JsonConvert.SerializeObject(bulkDeleteContentObject).ToString().Substring(1);
}
else
{
jsonContent = DashboardHelpers.InvalidBodyJsonTestCasesMapper[inputType].ToString();
}
var response = handler.Send <object>(BulkDeleteEndpoint, jsonContent, HttpMethod.POST);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public void InvalidUpdateFolderTests(FolderParam param, Invalid testcase)
{
var request = new Dictionary <string, string>
{
["id"] = FolderTest.Data.ToString(),
["name"] = "TestUpdate",
["type"] = "public"
};
if (testcase == Invalid.Missing)
{
request.Remove(FolderParamMapper[param]);
}
else
{
request[FolderParamMapper[param]] = InvalidMapper[testcase];
}
var reportHandler = new DefaultManager();
var result = reportHandler.Send <FolderResponse>(EndPoint, request, HttpMethod.PUT);
PrAssert.That(result, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still update folder successful.");
}
public void ValidCreateField(FieldType fieldType, ResourceId resourceId, Properties.PropertyName property, string value)
{
var handler = new DefaultManager();
var properties = GenerateRequiredProperties(fieldType, Properties.Label.Max);
properties[property.GetEnumStringValue()] = value;
string request = PrepareCreateRequest(resourceId, properties);
PrAssert.That(request, PrIs.Not.EqualTo(string.Empty));
var response = handler.Send <FieldCreateResponse>(CreateEndPoint, request, HttpMethod.POST);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Create Field");
var fieldHandler = new FieldManager();
var readResponse = fieldHandler.GetFieldDetails(response.Result.Id);
CommonHelpers.DeleteField(new[] { response.Result.Id });
PrAssert.That(readResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Read Field");
PrAssert.That(readResponse.Result.Values.Count, PrIs.EqualTo(1), "Can not read Field");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.SType.GetEnumStringValue()], PrIs.EqualTo($"{(int)fieldType}"), "Not as expected s.type");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.Label.GetEnumStringValue()], PrIs.EqualTo(CommonMapperValue.LabelMapperValue[Properties.Label.Max]), "Not as expected d.label.ja");
NumberHelpers.VerifyProperties(readResponse.Result.Values.First().Value.Properties, properties);
}
public void InvalidJsonCreateMenuTest(InvalidSpecialCondition json)
{
var handler = new DefaultManager();
var requestJson = new Dictionary <string, object>
{
["resource"] = (int)ResourceId.Client,
["label"] = new Dictionary <string, object>
{
["en_us"] = new Dictionary <string, object>
{
["value"] = SublistMenuTestData.ValidLabelMapper[SublistMenuTestData.LabelValue.StringNoSpaceBoth]
},
["ja"] = new Dictionary <string, object>
{
["value"] = SublistMenuTestData.ValidLabelMapper[SublistMenuTestData.LabelValue.StringNoSpaceBoth]
},
},
}.ToJson();
var createResponse = handler.SendAsync <object>(SublistMenuTestData.MenuEndPoint, SublistMenuTestData.InvalidBodyJsonTestCasesMapper[json](requestJson), HttpMethod.POST).Result;
PrAssert.That(createResponse, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able to use menu api with wrong method");
}
public void TestInvalidUpdateFieldLayoutByCellContentInjection(CellContent param, Enums.InvalidInjection invalid)
{
var handler = new DefaultManager();
var fieldUuid = FieldsCreator.Data[$"{ResourceId.Client}-{FieldType.SingleLineText.ToString()}-0"].Guid;
var request = GenerateUpdateFieldLayoutRequest(ResourceId.Client, LayoutUuids[ResourceId.Client], FieldUuids[ResourceId.Client], Title.MinJa, UpdateCellLayout.MinX, UpdateCellContent.Field);
var updateParam = request[UpdateParameters.Update.GetEnumStringValue()] as Dictionary <string, object>;
var uuidParam = updateParam[LayoutUuids[ResourceId.Client].ToString()] as Dictionary <string, object>;
var cells = (uuidParam[Parameters.Cells.GetEnumStringValue()] as List <Dictionary <string, object> >).First();
var cellContent = cells[Cell.Content.GetEnumStringValue()] as Dictionary <string, object>;
cellContent.Remove(CellContent.Field.GetEnumStringValue());
cellContent[param.GetEnumStringValue()] = MapperData.InvalidInjectionMapper[invalid];
cells[Cell.Content.GetEnumStringValue()] = cellContent;
uuidParam[Parameters.Cells.GetEnumStringValue()] = new List <Dictionary <string, object> > {
cells
};
updateParam[LayoutUuids[ResourceId.Client].ToString()] = uuidParam;
request[UpdateParameters.Update.GetEnumStringValue()] = updateParam;
var response = handler.Send <object>(FieldManager.FieldLayoutApiRelativeUrl, JsonConvert.SerializeObject(request), HttpMethod.PUT);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public static PrivateData <List <OptionCreateResponse> > GetCreateOptionCustomFixture(int levelNesting)
{
return(new PrivateData <List <OptionCreateResponse> >(
(session, test) =>
{
return Task.Run(() =>
{
Dictionary <string, object> request = GetNestChildrenDictionary(levelNesting);
request["parent_id"] = 0;
var optionHandler = new OptionManager();
var result = optionHandler.CreateOption(request);
PrAssume.That(result, PrIs.SuccessfulResponse(), "Cannot prepare option");
return result.Result;
});
},
(session, test, res) => Task.Run(() =>
{
var optionHandler = new OptionManager();
var response = optionHandler.DeleteOptions(res.Select(r => r.Id).Reverse());
PrAssume.That(response, PrIs.SuccessfulResponse());
})));
}
public void TestDeleteGlobalSmtpAdmin(Global global)
{
var handler = new DefaultManager();
//Create
var request = GenerateCreateGlobalRequest(global, GlobalValidServer.Yahoo, GlobalValidPort.Imap, Login.Valid, Password.Valid, SmtpEnableStartTls.One, SmtpSslCheckServerIdentity.Zero, SmtpSslOnConnect.One);
var response = handler.Send <CreateSmtpResponse>(SmtpEndPoint, JsonConvert.SerializeObject(request), HttpMethod.POST);
PrAssume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
//Delete
var responseDeleted = handler.Send <object>(SmtpEndPoint,
new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(Parameters.Global.GetEnumStringValue(), global == Global.Zero ? "0" : "1")
}, HttpMethod.DELETE);
PrAssert.That(responseDeleted, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
//Verify
VerifyDeletedData(global, response.Result.Id);
}
public static 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))
{
PrAssert.That(resultData[item.Key].ToString(), PrIs.EqualTo(item.Value.ToString()), "Value is not matched");
}
}
}
public void SearchWrongOperatorInSubCondition(ResourceId resource, OperatorType boolFilterType, SearchFilterType filterType, OperatorType operatorType, string fieldName)
{
var searchFilter = SearchHelpers.SearchFilters[filterType](resource, fieldName, CurrentDateTime, Timezone, RecordsCreatorForNumCond);
searchFilter.Operator = SearchRequestComposer.OperatorTypeMap[operatorType];
SearchRequest request = null;
if (boolFilterType != OperatorType.Not)
{
request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanFilter(boolFilterType, new[] { searchFilter });
}
else
{
request = SearchRequestComposer.GetBuilderWithRestrictions(resource).BooleanNotFilter(searchFilter);
}
var handler = new DefaultManager();
var response = handler.Send <SearchResponse>(request);
PrAssert.That(response, PrIs.ErrorResponse());
}
public void InvalidDuplicateParamGetAclActionListTests(Params param, DuplicateValues value)
{
string unixTime = Utils.DateTimeToUnix(null).ToString();
var request = new Dictionary <string, string>()
{
[Params._.ToString()] = unixTime
}.ToList <KeyValuePair <string, string> >();
if (value == DuplicateValues.Same)
{
request.Add(new KeyValuePair <string, string>(param.ToString(), unixTime));
}
else if (value == DuplicateValues.NotSame)
{
request.Add(new KeyValuePair <string, string>(param.ToString(), Utils.DateTimeToUnix(null).ToString()));
}
var defaultManager = new DefaultManager();
var response = defaultManager.Send <object>(Endpoint, request, HttpMethod.GET);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode((int)System.Net.HttpStatusCode.OK));
}
public void ValidDuplicateGetMails(string param, Enums.ValidDuplicated validDuplicated)
{
var handler = new DefaultManager();
var request = new Dictionary <string, object>();
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.One](request, GetAndHiddenTestData.PageNumber, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.One](request, GetAndHiddenTestData.PageSize, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.One](request, GetAndHiddenTestData.SortOrder, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Box](request, GetAndHiddenTestData.SortField, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.One](request, GetAndHiddenTestData.ShowHidden, new List <int>());
var otherValue = new Dictionary <string, object>();
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Ten](otherValue, GetAndHiddenTestData.PageNumber, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Ten](otherValue, GetAndHiddenTestData.PageSize, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Zero](otherValue, GetAndHiddenTestData.SortOrder, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Date](otherValue, GetAndHiddenTestData.SortField, new List <int>());
GetAndHiddenTestData.ValidGetMailsMapperValue[GetAndHiddenTestData.Valid.Zero](otherValue, GetAndHiddenTestData.ShowHidden, new List <int>());
Helpers.DuplicateParam(param, request, otherValue, validDuplicated);
var response = handler.Send <GetMailsResponse>(MailGetAndHidden.GetMails, request.ToJson().ReplaceDuplicate(param), HttpMethod.POST);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Still able to get mails");
}
public static void BulkUpdateDateForRecordsCreator(HrbcRecordCreator RecordsCreator, string date, int numRecords = 0)
{
var bulkManager = new BulkUpdateManager();
DateTime dateTime = DateTime.Parse(date);
foreach (ResourceId resource in Utils.Resources())
{
for (var i = 0; i < numRecords; i++)
{
var recordId = RecordsCreator.Data[$"{resource}{i}"].Id;
var response = bulkManager.BulkUpdate <BulkUpdateResponse>(GetBulkUpdateContent(resource, new List <ulong> {
recordId
}, dateTime.ToString(SearchConstants.SearchApiFullDateTemplate)), System.Net.Http.HttpMethod.Post);
PrAssume.That(response, PrIs.SuccessfulResponse());
if (GetBulkUpdateQueueStatus(response.Result.Id.ToString()))
{
continue;
}
}
}
}
public void InvalidInjectionUpdateFieldSpecial(Enum param, Enums.InvalidInjection invalidInjection)
{
string fieldUUID = PreparedFieldId.Data[ResourceId.Client].ToString();
string parameter = param.GetEnumStringValue() == Properties.Parameters.Guid.GetEnumStringValue() ? fieldUUID : param.GetEnumStringValue();
var handler = new DefaultManager();
var properties = NumberHelpers.GenerateRequiredProperties((int)FieldType.Number, Properties.Label.Min);
if (param.GetType() == typeof(Properties.PropertyName))
{
properties[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var updateParam = NumberHelpers.GenerateUpdateParam(ResourceId.Client, properties);
if (param.GetEnumStringValue() != Properties.Parameters.Guid.GetEnumStringValue() && param.GetEnumStringValue() != Properties.Parameters.Update.GetEnumStringValue() && param.GetType() == typeof(Properties.Parameters))
{
updateParam[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var idParam = new Dictionary <string, object>
{
[fieldUUID] = updateParam
};
if (param.GetEnumStringValue() == Properties.Parameters.Guid.GetEnumStringValue())
{
idParam[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var request = new Dictionary <string, object>
{
[Properties.Parameters.Update.GetEnumStringValue()] = idParam
};
if (param.GetEnumStringValue() == Properties.Parameters.Update.GetEnumStringValue())
{
request[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.PUT);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able update Field");
}
public void IdentityHeaderJsonWebTokenTest()
{
var creds = AuthenticationInfoProvider.GetAuthSpecForCurrentTest();
var adminUserPassword = creds.Companies.First().Value.Users.First().Password;
var adminUserLogin = creds.Companies.First().Value.Users.First().Login;
var adminUserId = creds.Companies.First().Value.Users.First().Metadata["userId"].ToString();
var companyId = creds.Companies.First().Value.Id;
var companyName = creds.Companies.First().Value.Name;
creds.Dispose();
var headerValue = new Dictionary <string, object>
{
["CID"] = companyId,
["UID"] = adminUserId,
["SERVICE"] = DefaultService,
};
var internalHandler = new InternalApiManager(InitPrivateApiConnection(companyName, adminUserLogin, adminUserPassword));
var response = internalHandler.SendRequestWithIdentityHeaderConvertJwt <object>(InternalAuthRequest, headerValue, HttpMethod.Post);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.Unauthorized));
}
public void UpdateRequestValidTests(ValidParams param)
{
var userHandler = new UserManager();
var request = new Dictionary <string, string>
{
[FieldId] = UserId.ToString()
};
if (param == ValidParams.MultipleFields)
{
request[FieldTos] = TestDate;
request[FieldNotice] = TestDate;
}
else
{
request[$"User.P_{param}"] = TestDate;
}
var result = userHandler.Execute <object>(request, HttpMethod.Put);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode((int)System.Net.HttpStatusCode.NoContent));
}
public void MergeDeletedId(ResourceId resourceId, Parameters parameter)
{
var parameters = GetDefaultParameters(resourceId);
switch (parameter)
{
case Parameters.MergedId:
parameters["mergedId"] = PrepareDeletedIdsData.Data[resourceId].Ids[0][0].ToString();
break;
case Parameters.BaseId:
parameters["baseId"] = PrepareDeletedIdsData.Data[resourceId].Ids[0][0].ToString();
parameters["mergedId"] = PrepareDeletedIdsData.Data[resourceId].Ids[1][0].ToString();
parameters["mapping"] = GetMapping(resourceId, $"{resourceId.ToString()}.P_Id", PrepareDeletedIdsData.Data[resourceId].Ids[0][0].ToString());
break;
}
var mergeHandler = new MergeManager();
var response = mergeHandler.MergeRecords <MergeResponse>(resourceId, parameters, System.Net.Http.HttpMethod.Post);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public void ValidDuplicatedParamsTests(Params param, Duplicated type)
{
var request = type == Duplicated.SameValue
? DuplicatedPutRequestSameValue(ActionMenuEndpointType.PutActionMenuLabel, param)
: DuplicatedPutRequestNotSameValue(ActionMenuEndpointType.PutActionMenuLabel, param);
var manager = new ActionMenuManager(Endpoint);
var result = manager.Execute <Dictionary <string, string> >(request, System.Net.Http.HttpMethod.Put);
PrAssert.That(result, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent));
PrAssert.That(result.Result["status"], PrIs.EqualTo("ok"));
var verifyKeys = request.Split('\"');
var expectedLabel = "Test Update Label";
foreach (var item in verifyKeys)
{
if (item.Contains("id_am_content"))
{
VerifyData(item, expectedLabel);
break;
}
}
}
