public void TestUserIdValid(ValidUserIdTestCases inputType)
{
var parameterRequest = new Dictionary <string, object>(ResetUserPasswordParameters);
parameterRequest.Remove("forcePasswordChange");
PrivateApiResponse <ResetUserPasswordResponse> response = null;
if (inputType == ValidUserIdTestCases.AdminRole)
{
var resetUserPassHandler = new ResetUserPasswordManager();
response = resetUserPassHandler.ResetUserPassword(parameterRequest, HttpMethod.Post);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
PrAssert.That(response.Result.Password.Count(), PrIs.GreaterThanOrEqualTo(1));
LastPassword = response.Result.Password;
}
else
{
Common common = new Common();
var info = AuthenticationInfoProvider.Current.Manager.GetAllAvailableUsers(new UserSpecBuilder().Admin(false));
response = common.LoginAndSendRequestWithOtherAccount <ResetUserPasswordResponse>(info.First().Company.Name, info.First().Login, info.First().Password, "/privateapi/authentication/reset-user-password", parameterRequest);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
PrAssert.That(response.Result.Password.Count(), PrIs.GreaterThanOrEqualTo(1));
}
LastPassword = response.Result.Password;
}
public void InvalidEntrySpecial(InvalidSpecialCondition inputType)
{
var defaultCompanyLoginId = TestContext.CurrentContext.Test.Properties.Get("companyName").ToString();
var defaultUserName = TestContext.CurrentContext.Test.Properties.Get("adminUserLogin").ToString();
var tokenFromCurrentCompany = Common.RefreshToken(defaultCompanyLoginId, defaultUserName);
var resetPassHandler = new ResetPasswordManager();
var parameterRequest = new Dictionary <string, object>(Common.ResetPasswordParameters);
PrivateApiResponse <object> response = null;
parameterRequest["companyLoginId"] = defaultCompanyLoginId;
parameterRequest["username"] = defaultUserName;
parameterRequest["newPassword"] = NewPassword;
parameterRequest["token"] = tokenFromCurrentCompany;
if (inputType == InvalidSpecialCondition.WrongContentType)
{
response = resetPassHandler.ResetPassword(parameterRequest, System.Net.Http.HttpMethod.Post, Common.InvalidEntrySpecialTestCasesMapper[InvalidSpecialCondition.WrongContentType].ToString());
}
else
{
string jsonContent = string.Empty;
if (inputType == InvalidSpecialCondition.BrokenJsonFormat)
{
jsonContent = "{\"companyLoginId\": \"" + defaultCompanyLoginId + "\", \"username\": \"" + defaultUserName + "\", \"newPassword\": \"" + NewPassword + "\", \"token\": \"" + Common.RefreshToken(defaultCompanyLoginId, defaultUserName) + "\"";
}
else
{
jsonContent = Common.InvalidEntrySpecialTestCasesMapper[inputType].ToString();
}
response = resetPassHandler.ResetPassword(jsonContent, System.Net.Http.HttpMethod.Post);
}
LastPassword = Common.CheckUpdatedPassword(response) ? parameterRequest["newPassword"].ToString() : string.Empty;
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(InvalidSpecialCondition.WrongContentType == inputType ? System.Net.HttpStatusCode.UnsupportedMediaType : System.Net.HttpStatusCode.BadRequest));
}
public void InvalidEntrySpecial(InvalidSpecialCondition inputType)
{
var defaultUserId = TestContext.CurrentContext.Test.Properties.Get("adminUserId");
var resetUserPassHandler = new ResetUserPasswordManager();
var parameterRequest = new Dictionary <string, object>(Common.ResetUserPasswordParameters);
PrivateApiResponse <ResetUserPasswordResponse> response = null;
if (inputType == InvalidSpecialCondition.WrongContentType)
{
response = resetUserPassHandler.ResetUserPassword(parameterRequest, System.Net.Http.HttpMethod.Post, Common.InvalidEntrySpecialTestCasesMapper[InvalidSpecialCondition.WrongContentType].ToString());
}
else
{
string jsonContent = string.Empty;
if (inputType == InvalidSpecialCondition.BrokenJsonFormat)
{
jsonContent = "{\"userId\": \"" + defaultUserId + "\"";
}
else
{
jsonContent = Common.InvalidEntrySpecialTestCasesMapper[inputType].ToString();
}
response = resetUserPassHandler.ResetUserPassword(jsonContent, System.Net.Http.HttpMethod.Post);
}
LastPassword = Common.GetResetUserPassword(response);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(inputType == InvalidSpecialCondition.WrongContentType ? System.Net.HttpStatusCode.UnsupportedMediaType : System.Net.HttpStatusCode.BadRequest));
}
private void VerifyData(ResourceId resourceId, ValidTestCases inputType)
{
PrivateApiResponse <RecordsGetResponseItem> originalRecordData = null;
switch (inputType)
{
case ValidTestCases.BaseId:
//Read base id existed
originalRecordData = GetResultRecordData(resourceId, new int[] { GetRecordId(resourceId, 1) });
PrAssert.That(originalRecordData.Result.Total, Is.EqualTo(1), "Base id does not existed in database!");
break;
case ValidTestCases.MergeId:
//Read merge id is not existed
originalRecordData = GetResultRecordData(resourceId, new int[] { GetRecordId(resourceId, 4) });
PrAssert.That(originalRecordData, PrIs.WithHttpCode(System.Net.HttpStatusCode.InternalServerError));
break;
case ValidTestCases.ArrayMergeId:
//Read array merge id are not existed
originalRecordData = GetResultRecordData(resourceId, new int[] { GetRecordId(resourceId, 6), GetRecordId(resourceId, 7) });
PrAssert.That(originalRecordData, PrIs.WithHttpCode(System.Net.HttpStatusCode.InternalServerError));
break;
case ValidTestCases.Mapping:
//Read elements are correct value
string[] keys = ValuesMapper[resourceId].Keys.ToArray();
originalRecordData = GetResultRecordData(resourceId, new int[] { GetRecordId(resourceId, 8) }, keys);
string keyValue = string.Empty;
string recordValue = string.Empty;
List <int> ids = new List <int>();
foreach (var record in originalRecordData.Result.Items)
{
foreach (var key in keys)
{
keyValue = ValuesMapper[resourceId][key].ToString();
if (key == $"{resourceId.ToString()}.P_Phase")
{
recordValue = JsonConvert.DeserializeObject <List <int> >(record[key].ToString()).Single().ToString();
keyValue = OptionsClientReader.Data.Single().Value.RecordId.ToString();
}
else if (key.Contains("P_UpdatedBy") || key.Contains("P_RegisteredBy") || key.Contains("P_Owner"))
{
recordValue = JsonConvert.DeserializeObject <List <int> >(record[key].ToString()).Single().ToString();
}
else
{
recordValue = record[key].ToString();
}
PrAssert.That(recordValue, Is.EqualTo(keyValue), "Field value is not correct!");
}
}
break;
}
}
private static void VerifyDataForEachField(PrivateApiResponse <Dictionary <string, object> > response, FieldQueryParameters field, int index, Operations op, bool searchMail = false)
{
if (BadRequestCases.Contains($"{field.ToString()}.{op.ToString()}"))
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
else
if (IgnoredTempCases.Contains($"{field.ToString()}.{op.ToString()}"))
{
//Nothing to do, b/c the response does not contain for this parameters
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
else
{
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
PrAssert.That(response.Result["totalHits"], PrIs.GreaterThan(0), "The response is empty.");
foreach (var result in JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(response.Result["hits"].ToString()))
{
var fieldName = field.GetEnumStringValue();
if (field == FieldQueryParameters.Body)
{
fieldName = "preview";
}
Assertions[op](result[fieldName].ToString(), MappingValues[field](index, searchMail ? DateListMultipleMail.ElementAt(NumberOfMail / 2) : DateListSingleMail.ElementAt(NumberOfMail / 2)).ToString());
}
}
}
private void PerformParameterTestForUploadOperation(FileUploadRequest reqeust, int expectedErrorCode, bool isExpectedSuccess)
{
var handler = new DefaultManager();
var str = Newtonsoft.Json.JsonConvert.SerializeObject(reqeust).Replace("/n", Environment.NewLine).Replace("/0", '\u0000'.ToString());
PrivateApiResponse <FileUploadResponse> response = null;
using (LogHelper.LoggerForCurrentTest.EnterReproStep("Send an upload file request with special string parameter's value."))
{
response = handler.Send <FileUploadResponse>(FileStorageManager.EndPoint, str, HttpMethod.POST);
}
try
{
if (isExpectedSuccess)
{
PrAssert.That(response, PrIs.SuccessfulResponse());
}
else
{
PrAssert.That(response, PrIs.ErrorResponse().And.ErrorCode(expectedErrorCode).And.HttpCode(400));
}
}
finally
{
var id = response?.Result?.Id;
if (id != null)
{
new FileStorageManager().Delete(id);
}
}
}
public async Task <PrivateApiResponse> Register([FromBody] RegisterModel user)
{
var response = new PrivateApiResponse();
try
{
using (var connection = GetConnection())
{
connection.Open();
if (DoesUserExist(user.Email))
{
response.ApiResponseCode = ApiResponseCode.UserAlreadyExistsEmail;
}
else
{
var insertResponse = await InsertUser(user, connection);
response.ResponseCode = insertResponse.ResponseCode;
if (insertResponse.Success)
{
var databaseUser = GetUserFrom(user.Email);
response.Email = databaseUser.Email;
response.FirstName = databaseUser.FirstName;
response.LastName = databaseUser.LastName;
response.Token = insertResponse.Token;
}
}
}
}
catch
{
response.ApiResponseCode = ApiResponseCode.InternalError;
}
return(response);
}
public void DeleteValidOption(RequestType requestType, PhysicalCases inputType)
{
var optionHandler = new OptionManager();
PrivateApiResponse <List <OptionDeleteResponse> > response = null;
var ids = new List <string>();
var urlParameters = new Dictionary <string, string> {
["operation"] = "delete"
};
switch (inputType)
{
case PhysicalCases.No:
ids = GetIdsFromCurrentContext(requestType, "singleParentOptionCreateResponse", "multipleParentOptionCreateResponse");
break;
case PhysicalCases.True:
ids = GetIdsFromCurrentContext(requestType, "singleParentOptionCreateResponse", "multipleParentOptionCreateResponse");
urlParameters["physical"] = "true";
break;
case PhysicalCases.False:
ids = GetIdsFromCurrentContext(requestType, "singleChildrenOptionCreateResponse", "multipleChildrenOptionCreateResponse");
urlParameters["physical"] = "false";
break;
}
response = optionHandler.DeleteOptions(ids, urlParameters);
PrAssert.That(response, PrIs.SuccessfulResponse(), $"Option Delete operation was not successful. HTTP response code is {response.HttpStatusCode}");
//Verify
foreach (var id in ids)
{
Common.VerifyOptionNotExist(int.Parse(id));
}
}
public void InvalidEntrySpecial(InvalidSpecialCondition inputType)
{
var creds = AuthenticationInfoProvider.GetAuthSpecForCurrentTest();
var defaultPassword = creds.Users.Values.Single().Password.ToString();
var updatePassHandler = new UpdatePasswordManager();
var parameterRequest = new Dictionary <string, object>(Common.UpdatePasswordParameters);
PrivateApiResponse <object> response = null;
if (inputType == InvalidSpecialCondition.WrongContentType)
{
response = updatePassHandler.UpdatePassword(parameterRequest, System.Net.Http.HttpMethod.Put, InvalidEntrySpecialTestCasesMapper[InvalidSpecialCondition.WrongContentType].ToString());
}
else
{
string jsonContent = string.Empty;
if (inputType == InvalidSpecialCondition.BrokenJsonFormat)
{
jsonContent = string.Format(InvalidEntrySpecialTestCasesMapper[InvalidSpecialCondition.BrokenJsonFormat].ToString(), defaultPassword);
}
else
{
jsonContent = InvalidEntrySpecialTestCasesMapper[inputType].ToString();
}
response = updatePassHandler.UpdatePassword(jsonContent, System.Net.Http.HttpMethod.Put);
}
LastPassword = Common.CheckUpdatedPassword(response) ? NewPassword : string.Empty;
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
public static void VerifySearchResult(PrivateApiResponse <SearchResponse> response, ResourceId resourceId, SearchDateFieldCases.TestCases cases, string fieldName, bool isAsc, HrbcRecordCreator RecordsCreator, int NumRecordsEachCase, string DateTimeResponseFormat)
{
PrAssert.That(response, PrIs.SuccessfulResponse(), "Search unsuccesfull");
PrAssert.That(response.Result.Items, PrIs.Not.Null.And.Not.Empty, "Null or Empty search response");
PrAssert.That(response.Result.Items.Count, PrIs.GreaterThanOrEqualTo(NumRecordsEachCase), "Unexpected numbers of search results");
List <int> ids = response.Result.Items;
for (int i = (int)cases * NumRecordsEachCase; i < (int)cases * NumRecordsEachCase + NumRecordsEachCase; i++)
{
PrAssert.That(ids.Contains((int)RecordsCreator.Data[$"{resourceId}{i}"].Id), "The expected id is not in search result");
}
var recordHandler = new RecordManager();
var res = recordHandler.ReadRecords(
RecordRequestComposer.ComposeReadRequest()
.ForResource((Porters.TestCoreFramework.Enums.ResourceType)(int) resourceId)
.WithIds(ids.ToArray())
.Fields(fieldName, $"{ resourceId}.P_Id")
.Result);
List <long> expectedIdsList;
if (isAsc)
{
expectedIdsList = res.Result.Items.OrderBy(item => DateTime.ParseExact(item[fieldName].ToString(), DateTimeResponseFormat, System.Globalization.CultureInfo.InvariantCulture)).Select(s => (long)s[$"{resourceId}.P_Id"]).ToList();
}
else
{
expectedIdsList = res.Result.Items.OrderByDescending(item => DateTime.ParseExact(item[fieldName].ToString(), DateTimeResponseFormat, System.Globalization.CultureInfo.InvariantCulture)).Select(s => (long)s[$"{resourceId}.P_Id"]).ToList();
}
for (int i = 0; i < ids.Count; i++)
{
PrAssert.That(expectedIdsList[i], PrIs.EqualTo(ids[i]), "The search result is not order as expected");
}
}
private void PerformTest(PrivateApiResponse <UnlockUserResponse> result, string testcase = null)
{
PrAssert.That(result, PrIs.ErrorResponse().With.HttpCode(System.Net.HttpStatusCode.BadRequest));
if (testcase == InvalidSpecial.ErrorConnectDb.ToString())
{
PrivateApiConnection.GetConnectionForCurrentTest().Authenticate(DefaultUser.Company.Name, DefaultUser.Login, DefaultUser.Password);
}
}
public static void AssertIsValueEquals(this PrivateApiResponse actualResponse,
PrivateApiResponse expectedResponse)
{
Assert.That(actualResponse, Is.Not.Null);
Assert.That(actualResponse.Signature, Is.EqualTo(expectedResponse.Signature));
Assert.That(actualResponse.Nonce, Is.EqualTo(expectedResponse.Nonce));
Assert.That(actualResponse.ServerId, Is.EqualTo(expectedResponse.ServerId));
Assert.That(actualResponse.Body, Is.EqualTo(expectedResponse.Body));
}
private static void VerifyData(PrivateApiResponse <CreateTemplateReplaceResponse> result)
{
var handler = new DefaultManager();
var response = handler.Send <GetTemplateResponse>(TemplateEndPoint, new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>(IdParam, Id.ToString())
}, HttpMethod.GET);
PrAssume.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
PrAssert.That(response.Result.Subject, PrIs.EqualTo(result.Result.Subject), "Subject does not match.");
PrAssert.That(response.Result.Body, PrIs.EqualTo(result.Result.Body), "Body does not match.");
}
private static void VerifyResetLayoutResponse(HrbcSublistManager handler, PrivateApiResponse <SublistsMenuResponse> resetResponse)
{
foreach (var key in resetResponse.Result.Values.Keys)
{
var sublistRequest = SublistMenuTestData.GetSublistMenuDefaultRequest(resetResponse.Result.Values[key].Id, SublistMenuTestData.ValidUnixTimeStamp);
var sublistResponse = handler.SublistMenuDefault <SublistMenuDefaultResponse>(sublistRequest, HttpMethod.GET.ToNetHttpMethod());
PrAssume.That(sublistResponse, PrIs.SuccessfulResponse(), "Can not get sublist menu default");
foreach (var field in resetResponse.Result.Values[key].IdFields.Enabled)
{
PrAssert.That(sublistResponse.Result.IdFields.Enabled.Contains(field), "Response not contains the expected fields");
}
}
}
private static void ExceptedCases(PrivateApiResponse <Dictionary <string, object> > response, string field, string op)
{
if (BadRequestCases.Contains($"{field.ToString()}.{op.ToString()}"))
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest));
}
else
if (IgnoredTempCases.Contains($"{field.ToString()}.{op.ToString()}"))
{
//Nothing to do, b/c the response does not contain for this parameters
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
}
}
private void PerformTestForRepetitiveParametersInUrl(bool allAreSame, HttpMethod httpMethod)
{
PerformTestWithPreparedData((id) =>
{
var handler = new DefaultManager();
using (LogHelper.LoggerForCurrentTest.EnterReproStep("Send a request with repetitive parameter in URL"))
{
PrivateApiResponse <FileUploadResponse> result = handler.Send <FileUploadResponse>(FileStorageManager.EndPoint, new[] { new KeyValuePair <string, string>("id", allAreSame ? id : id + "1")
, new KeyValuePair <string, string>("id", id)
, new KeyValuePair <string, string>("id", allAreSame ? id : id + "2") }, httpMethod);
PrAssert.That(result, PrIs.ErrorResponse());
}
});
}
private async Task <PrivateApiResponse> InsertUser(RegisterModel model, SqlConnection connection)
{
var user = Models.User.CreateFrom(model);
var response = new PrivateApiResponse();
try
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
using (var command = new SqlCommand("CreateUser", connection))
{
command.CommandType = CommandType.StoredProcedure;
var userIdParam = new SqlParameter("@UserId", SqlDbType.Int)
{
Direction = ParameterDirection.Output
};
var errorCode = new SqlParameter("@ResponseCode", SqlDbType.Int)
{
Direction = ParameterDirection.Output
};
command.Parameters.Add(userIdParam);
command.Parameters.Add(errorCode);
command.Parameters.AddWithValue("@email", user.Email);
command.Parameters.AddWithValue("@firstName", user.FirstName);
command.Parameters.AddWithValue("@lastName", user.LastName);
command.Parameters.AddWithValue("@dob", user.DateOfBirth);
command.Parameters.AddWithValue("@password", user.PasswordHash);
command.Parameters.AddWithValue("@salt", user.Salt);
command.ExecuteNonQuery();
var outErrorCode = (errorCode.Value as int?) ?? 0;
if (outErrorCode == 0)
{
response.ApiResponseCode = ApiResponseCode.Success;
response.Token = await CreateToken(user);
}
else
{
response.ApiResponseCode = (ApiResponseCode)outErrorCode;
}
}
} catch
{
response.ApiResponseCode = ApiResponseCode.InternalError;
}
return(response);
}
private PrivateApiResponse <HrbcQueueResponse> GetRequestQueueMapping(Dictionary <string, string> hrbcQueueRequest)
{
var hrbcQueueHandler = new QueueManager(false);
var hrbcQueueResult = new PrivateApiResponse <HrbcQueueResponse>();
for (int i = 1; i <= MaximumDelay; i++)
{
Thread.Sleep(1000);
var result = hrbcQueueHandler.Queue <string>(hrbcQueueRequest, string.Empty, System.Net.Http.HttpMethod.Get);
var status = result.Result.Split(',').Where(item => item.Contains("status")).ToArray();
if (status.SingleOrDefault().Contains("finished"))
{
break;
}
}
return(hrbcQueueHandler.Queue <HrbcQueueResponse>(hrbcQueueRequest, string.Empty, System.Net.Http.HttpMethod.Get));
}
/// <summary>
/// Create/Update a child/parent option
/// </summary>
/// <param name="operation">Insert or Update</param>
/// <param name="node">Children or parent</param>
/// <param name="inputType">Test cases</param>
/// <param name="optionParameter">Paremeters</param>
private static void WriteAndVerifyOption(Operation operation, OptionNestingType node, InvalidOptionCases inputType, string optionParameter)
{
string valueInput = OptionData.InvalidOptionMapper[inputType].ToString();
PrivateApiResponse <List <OptionWriteResponse> > response = null;
switch (inputType)
{
case InvalidOptionCases.Missing:
response = WriteInvalidMissingOption(operation, node, optionParameter);
Common.AssertWriteUnsuccessOption(response, ResultCode.ParameterInsufficient);
break;
default:
response = WriteInvalidOption(operation, node, optionParameter, valueInput);
Common.AssertWriteUnsuccessOption(response, ResultCode.InvalidValue);
break;
}
}
private void VerifyData(PrivateApiResponse <GetMenuContentEditResponse> reponse, string type, List <int> value)
{
var expected = 0;
if (type == "AllParams")
{
PrAssert.That(reponse.Result.Data.Count, PrIs.EqualTo(DataVerificationCreator.Data.Values.Count));
}
else
{
foreach (var item in DataVerificationCreator.Data.Values)
{
if (type == ParamsMapper[Params.MenuId] && item.Value.MenuId == value.First() ||
type == ParamsMapper[Params.ActionMenuId] && item.Value.ActionMenuId == value.First())
{
expected++;
}
}
PrAssert.That(reponse.Result.Data.Count, PrIs.EqualTo(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);
}
private void PerformTestForAdditionalParametersInJson(Func <JObject, JObject> entrypointSelector, bool isExpectedSuccess, string parameterName, string parameterValue)
{
const string propNamePlaceholder = "prop_name_placeholder";
const string propValuePlaceholder = "prop_value_placeholder";
var hanlder = new DefaultManager();
var request = GenerateUploadFileRequest(fileSize: defaultContent.Length.ToString());
var jObj = JObject.FromObject(request);
entrypointSelector(jObj).Add(new JProperty(propNamePlaceholder, propValuePlaceholder));
var requestString = jObj.ToString().Replace(propNamePlaceholder, parameterName).Replace(propValuePlaceholder, parameterValue);
PrivateApiResponse <FileUploadResponse> response = null;
using (LogHelper.LoggerForCurrentTest.EnterReproStep("Send an upload file request an additional parameter in JSON"))
{
response = hanlder.Send <FileUploadResponse>(FileStorageManager.EndPoint, requestString, HttpMethod.POST);
}
try
{
if (isExpectedSuccess)
{
PrAssert.That(response, PrIs.SuccessfulResponse());
}
else
{
PrAssert.That(response, PrIs.ErrorResponse());
}
}
finally
{
hanlder.Send(FileStorageManager.EndPoint, new Dictionary <string, string> {
["id"] = response?.Result?.Id
}, HttpMethod.DELETE);
}
}
public async Task <PrivateApiResponse> Login([FromBody] LoginModel user)
{
var response = new PrivateApiResponse();
try
{
if (!DoesUserExist(user.Email))
{
response.ApiResponseCode = ApiResponseCode.UserDoesNotExistEmail;
return(response);
}
using (var connection = GetConnection())
{
connection.Open();
var databaseUser = GetUserFrom(user.Email);
if (databaseUser.PasswordsMatch(user.Password))
{
response.ApiResponseCode = ApiResponseCode.Success;
response.Token = await CreateToken(databaseUser);
response.Email = databaseUser.Email;
response.FirstName = databaseUser.FirstName;
response.LastName = databaseUser.LastName;
}
else
{
response.ApiResponseCode = ApiResponseCode.IncorrectPassword;
}
}
}
catch
{
response.ApiResponseCode = ApiResponseCode.InternalError;
}
return(response);
}
public void InvalidJsonFormat(InvalidSpecialCondition inputType)
{
PrivateApiResponse <object> response = null;
var mappingHandler = new MappingManager();
if (inputType == InvalidSpecialCondition.WrongContentType)
{
response = mappingHandler.ExchangeMapping <object>(GetDefaultExchangeMapping(Mode.Import, ResourceId.Client, MappingId), System.Net.Http.HttpMethod.Put, InvalidEntrySpecialTestCasesMapper[InvalidSpecialCondition.WrongContentType].ToString());
}
else
{
string jsonContent = string.Empty;
if (inputType == InvalidSpecialCondition.BrokenJsonFormat)
{
jsonContent = JsonConvert.SerializeObject(GetDefaultExchangeMapping(Mode.Import, ResourceId.Client, MappingId)).Remove(0, 1);
}
else
{
jsonContent = InvalidEntrySpecialTestCasesMapper[inputType].ToString();
}
response = mappingHandler.ExchangeMapping <object>(jsonContent, System.Net.Http.HttpMethod.Put);
}
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(InvalidSpecialCondition.WrongContentType == inputType ? System.Net.HttpStatusCode.UnsupportedMediaType : System.Net.HttpStatusCode.BadRequest));
}
private void CheckResponseIsSuccessAndAllAreEqualTo(PrivateApiResponse <DateTimeConvertResponse> response, string expectedResult, int expectedLength = 1)
{
PrAssert.That(response, PrIs.SuccessfulResponse());
PrAssert.That(response?.Result?.DateTimes, Is.Not.Null.And.Length.EqualTo(expectedLength).And.All.EqualTo(expectedResult));
}
private static void VerifyDataForFullParams(Dictionary <string, object> request, PrivateApiResponse <Dictionary <string, object> > response, QueryLogic queryLogic, From from, To to, Cc cc, Bcc bcc, Subject subject, Body body, Date date, Box box, Attachment attachment)
{
ExceptedCases(response, FieldQueryParameters.From.ToString(), from.ToString());
ExceptedCases(response, FieldQueryParameters.To.ToString(), to.ToString());
ExceptedCases(response, FieldQueryParameters.Cc.ToString(), cc.ToString());
ExceptedCases(response, FieldQueryParameters.Bcc.ToString(), bcc.ToString());
ExceptedCases(response, FieldQueryParameters.Subject.ToString(), subject.ToString());
ExceptedCases(response, FieldQueryParameters.Body.ToString(), body.ToString());
ExceptedCases(response, FieldQueryParameters.Date.ToString(), date.ToString());
ExceptedCases(response, FieldQueryParameters.Box.ToString(), box.ToString());
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK));
var hits = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(response.Result["hits"].ToString());
if (box == Box.Two)
{
PrAssert.That(hits.Count, PrIs.EqualTo(0), "Still able to get box 2.");
}
else
{
PrAssert.That(response.Result["totalHits"], PrIs.GreaterThan(0), "The response is empty.");
if (queryLogic == QueryLogic.And)
{
foreach (var result in hits)
{
PrAssert.That(
CompareValues[from.ToString()](result[FieldQueryParameters.From.GetEnumStringValue()], FromMail) &&
CompareValues[to.ToString()](result[FieldQueryParameters.To.GetEnumStringValue()], ToMails.First()) &&
CompareValues[subject.ToString()](result[FieldQueryParameters.Subject.GetEnumStringValue()], SubjectMail) &&
CompareValues[body.ToString()](result["preview"].ToString(), BodyMail) &&
CompareValues[date.ToString()](result[FieldQueryParameters.Date.GetEnumStringValue()], DateListMultipleMail.ElementAt(NumberOfMail / 2)) &&
CompareValues[box != Box.Missing ? Operations.Eq.ToString() : box.ToString()](result[FieldQueryParameters.Box.GetEnumStringValue()], box == Box.One ? 1 : 2) &&
CompareValues[attachment != Attachment.Missing ? Operations.Eq.ToString() : attachment.ToString()](result[FieldQueryParameters.HasAttachment.GetEnumStringValue()], attachment == Attachment.Zero ? 0 : 1)
);
}
}
else
{
foreach (var result in hits)
{
PrAssert.That(
CompareValues[from.ToString()](result[FieldQueryParameters.From.GetEnumStringValue()], FromMail) ||
CompareValues[to.ToString()](result[FieldQueryParameters.To.GetEnumStringValue()], ToMails.First()) ||
CompareValues[subject.ToString()](result[FieldQueryParameters.Subject.GetEnumStringValue()], SubjectMail) ||
CompareValues[body.ToString()](result["preview"].ToString(), BodyMail) ||
CompareValues[date.ToString()](result[FieldQueryParameters.Date.GetEnumStringValue()], DateListMultipleMail.ElementAt(NumberOfMail / 2)) ||
CompareValues[box != Box.Missing ? Operations.Eq.ToString() : box.ToString()](result[FieldQueryParameters.Box.GetEnumStringValue()], box == Box.One ? 1 : 2) ||
CompareValues[attachment != Attachment.Missing ? Operations.Eq.ToString() : attachment.ToString()](result[FieldQueryParameters.HasAttachment.GetEnumStringValue()], attachment == Attachment.Zero ? 0 : 1)
);
}
}
}
}
public static void AssertWriteUnsuccessOption(PrivateApiResponse <List <OptionWriteResponse> > response, ResultCode resultCode = ResultCode.Ok)
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(HttpStatusCode.BadRequest).And.ErrorCode((int)resultCode));
}
public static void AssumeWriteSuccessOption(PrivateApiResponse <List <OptionWriteResponse> > response)
{
PrAssume.That(response, PrIs.SuccessfulResponse(), $"Option Create operation was not successful. HTTP response code is {response.HttpStatusCode}");
}
/// <summary>
/// https://github.com/Fairlay/PrivateApiDocumentation#fairlay-private-api-documentation-v0
/// </summary>
public static string FormatIntoApiResponseMessage(this PrivateApiResponse response) =>
$"{Convert.ToBase64String(response.Signature)}|{response.Nonce}|{response.ServerId}|" +
response.Body;
public static Dictionary <string, object> BuildCreateTemplateWithProcessRequest(PrivateApiResponse <List <OptionSearchResponse> > optionPhaseProcess, PrivateApiResponse <List <OptionSearchResponse> > optionEndReason, PhaseType phaseType, CommonEnums phaseMemo, EndFlag endFlag, EndReason endReason)
{
var request = new Dictionary <string, object>(DefaultCreateRequest);
var phases = new Dictionary <string, object>
{
[Phase.Resource.GetEnumStringValue()] = ResourceId.Process,
[Phase.Phase.GetEnumStringValue()] = optionPhaseProcess.Result.First()?.Children?.LastOrDefault()?.Alias,
[Phase.PhaseDate.GetEnumStringValue()] = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"),
};
PhaseTypeMapperValue[phaseType](phases);
CommonMapperValue[phaseMemo.ToString()](Phase.PhaseMemo.GetEnumStringValue(), phases);
EndFlagMapperValue[endFlag](phases);
EndReasonMapperValue[endReason](new List <string> {
optionEndReason.Result.First().Alias, optionEndReason.Result.Last().Alias
}, phases);
request[Parameters.Phase.GetEnumStringValue()] = phases;
return(request);
}
