public void CheckGuidTest(string digest, string emailguid, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/user/pass_reset/{emailguid}", Method.GET);
request
.AddUrlSegment("emailguid", emailguid)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <RegisterRequestModel>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> checkguidResults;
var isCheckOtpDataValid = GlobalLogic.IsModelValid(response.Data, out checkguidResults);
if (!isCheckOtpDataValid)
{
var message = $"CheckGuid with success: {checkguidResults.Model.Success}."
.RequestInfo(client, request)
.WithValidationErrors(checkguidResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void LeadListTest(string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/lead/list?digest={digest}", Method.GET);
request
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <LeadListModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <LeadListModel.RootObject> leadListMainResults;
var isLeadListDataValid = GlobalLogic.IsModelValid(response.Data, out leadListMainResults);
if (!isLeadListDataValid)
{
var message = $"LeadList with success: {leadListMainResults.Model.Success} and results: {leadListMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(leadListMainResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void CheckOtpTest(string digest, string phone, int otp, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/user/otp_check", Method.GET);
request
.AddParameter("digest", digest)
.AddParameter("phone", phone)
.AddParameter("otp", otp)
.AddHeader("Authorization", auth);
var response = client.Execute <CheckOtpModel>(request);
GlobalLogic.EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <CheckOtpModel> checkotpResults;
var isCheckOtpDataValid = GlobalLogic.IsModelValid(response.Data, out checkotpResults);
if (!isCheckOtpDataValid)
{
var message = $"CheckOtp with success: {checkotpResults.Model.Success} and username: {checkotpResults.Model.Username}."
.RequestInfo(client, request)
.WithValidationErrors(checkotpResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void RecommendsTest(string digest, string guid, int user_id, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/recommends", Method.GET);
request
.AddParameter("digest", digest)
.AddParameter("guid", guid)
.AddParameter("user_id", user_id)
.AddHeader("Authorization", auth);
var response = client.Execute <RecommendsModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RecommendsModel.RootObject> recommendsMainResults;
var isRecommendsDataValid = GlobalLogic.IsModelValid(response.Data, out recommendsMainResults);
IList <ValidationResultModel <RecommendsModel.Item> > recommendsAndRecentlyAddedResults;
var areRecommendsAndRecentlyAddedItemsValid = GlobalLogic.IsModelArrayValid(response.Data.RecentlyAdded.Concat(response.Data.Recommendations), out recommendsAndRecentlyAddedResults);
if (!isRecommendsDataValid)
{
var message = $"Recommends with success: {recommendsMainResults.Model.Success}."
.RequestInfo(client, request)
.WithValidationErrors(recommendsMainResults.Results);
allErrorMessages.Add(message);
}
if (!areRecommendsAndRecentlyAddedItemsValid)
{
foreach (var recommendsAndRecentlyAddedResult in recommendsAndRecentlyAddedResults.Where(x => x.Results.Any()))
{
var message = $"RecentlyAdded item with Guid: {recommendsAndRecentlyAddedResult.Model.Guid}"
.RequestInfo(client, request)
.WithValidationErrors(recommendsAndRecentlyAddedResult.Results);
allErrorMessages.Add(message);
}
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void ClassifiedDataTest(string guid, string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/objects/{guid}", Method.GET);
request
.AddUrlSegment("guid", guid)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <ReadClassifiedModel.RootObject>(request);
if (response.StatusCode != HttpStatusCode.OK || response.Data == null || response.Data.Success == false)
{
throw new Exception(AssertMessages.StatusCodeErrorMessage(client.BuildUri(request), response.StatusCode, response.Content));
}
List <string> allErrorMessages = new List <string>();
ValidationResultModel <ReadClassifiedModel.RootObject> classifiedDataMainResults;
var isClassifiedDataValid = GlobalLogic.IsModelValid(response.Data, out classifiedDataMainResults);
ValidationResultModel <ReadClassifiedModel.Items> classifiedDataItemsResults;
var areClassifiedDataItemsValid = GlobalLogic.IsModelValid(response.Data.Items, out classifiedDataItemsResults);
if (!isClassifiedDataValid)
{
var message = $"Classified with success: {classifiedDataMainResults.Model.Success} and results: {classifiedDataMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(classifiedDataMainResults.Results);
allErrorMessages.Add(message);
}
if (!areClassifiedDataItemsValid)
{
var message = $"Classified items with guid: {classifiedDataItemsResults.Model.guid}"
.RequestInfo(client, request)
.WithValidationErrors(classifiedDataItemsResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void UploadImageTest(string digest, string auth, string guid)
{
foreach (string fileType in Data.Filetypes)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/file?digest={digest}", Method.POST);
request.RequestFormat = DataFormat.Json;
request
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new
{
username = Data.DealerName,
guid = guid,
file =
new
{
type = fileType,
name = Data.ImageName,
content = Data.FileContent
}
});
var response = client.Execute <UploadImageModel>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <UploadImageModel> UploadImageResults;
var isUploadImageValid = GlobalLogic.IsModelValid(response.Data, out UploadImageResults);
if (!isUploadImageValid)
{
var message = $"\r\nUploaded photo with success: '{UploadImageResults.Model.Success}' and Url: '{UploadImageResults.Model.Url}'\r\n"
.RequestInfo(client, request)
.WithValidationErrors(UploadImageResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
}
public void DealerLeadsTest(string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("lead/list?digest={digest}", Method.GET);
request
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <DealerLeadsModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <DealerLeadsModel.RootObject> dealerLeadsMainResults;
var isDealerLeadsDataValid = GlobalLogic.IsModelValid(response.Data, out dealerLeadsMainResults);
IList <ValidationResultModel <DealerLeadsModel.Item> > DealerLeadsItemResults;
var areDealerLeadsDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out DealerLeadsItemResults);
if (!isDealerLeadsDataValid)
{
var message = $"Dealer leads with success: {dealerLeadsMainResults.Model.Success} and results: {dealerLeadsMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(dealerLeadsMainResults.Results);
allErrorMessages.Add(message);
}
if (!areDealerLeadsDataItemsValid)
{
foreach (var DealerLeadsItemResult in DealerLeadsItemResults.Where(x => x.Results.Any()))
{
var message = $"Dealer lead item with Classified_id: {DealerLeadsItemResult.Model.Classified_id}"
.RequestInfo(client, request)
.WithValidationErrors(DealerLeadsItemResult.Results);
allErrorMessages.Add(message);
}
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void CertifiersTest(string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/certifiers?digest={digest}", Method.GET);
request
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <CertifiersModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <CertifiersModel.RootObject> certifiersMainResults;
var isCertifiersDataValid = GlobalLogic.IsModelValid(response.Data, out certifiersMainResults);
IList <ValidationResultModel <CertifiersModel.Item> > CertifiersItemResults;
var areCertifiersDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out CertifiersItemResults);
if (!isCertifiersDataValid)
{
var message = $"Certifiers with success: {certifiersMainResults.Model.Success} and results: {certifiersMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(certifiersMainResults.Results);
allErrorMessages.Add(message);
}
if (!areCertifiersDataItemsValid)
{
foreach (var CertifiersItemResult in CertifiersItemResults.Where(x => x.Results.Any()))
{
var message = $"Certifier item with Name: {CertifiersItemResult.Model.Name}"
.RequestInfo(client, request)
.WithValidationErrors(CertifiersItemResult.Results);
allErrorMessages.Add(message);
}
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void RegSourceTest(string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/user/reg_request_source?digest={digest}", Method.GET);
request
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <RegSourceModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegSourceModel.RootObject> regSourceMainResults;
var isRegSourceDataValid = GlobalLogic.IsModelValid(response.Data, out regSourceMainResults);
IList <ValidationResultModel <RegSourceModel.Item> > RegSourceItemResults;
var areRegSourceDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out RegSourceItemResults);
if (!isRegSourceDataValid)
{
var message = $"Registration source with success: {regSourceMainResults.Model.Success} and results: {regSourceMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(regSourceMainResults.Results);
allErrorMessages.Add(message);
}
if (!areRegSourceDataItemsValid)
{
foreach (var RegSourceItemResult in RegSourceItemResults.Where(x => x.Results.Any()))
{
var message = $"Source item with Name: {RegSourceItemResult.Model.Name}"
.RequestInfo(client, request)
.WithValidationErrors(RegSourceItemResult.Results);
allErrorMessages.Add(message);
}
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void DealerDataTest(string dealer, string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/users/{dealer_name}", Method.GET);
request
.AddUrlSegment("dealer_name", dealer)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response = client.Execute <DealerDataModel.RootObject>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <DealerDataModel.RootObject> dealerDataMainResults;
var isDealerDataValid = GlobalLogic.IsModelValid(response.Data, out dealerDataMainResults);
ValidationResultModel <DealerDataModel.Items> dealerDataItemResults;
var areDealerDataItemsValid = GlobalLogic.IsModelValid(response.Data.Items, out dealerDataItemResults);
if (!isDealerDataValid)
{
var message = $"Dealer with success: {dealerDataMainResults.Model.Success} and results: {dealerDataMainResults.Model.Results}."
.RequestInfo(client, request)
.WithValidationErrors(dealerDataMainResults.Results);
allErrorMessages.Add(message);
}
if (!areDealerDataItemsValid)
{
var message = $"Dealer items with user name: {dealerDataMainResults.Model.Items.User_name}"
.RequestInfo(client, request)
.WithValidationErrors(dealerDataMainResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void RegisterRequestValidTest(string digest, string auth, string contentType)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/user/reg_requests?digest={digest}", Method.POST);
request
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
name = "Testttt11",
phone = "+9198765418",
city = "New Delhi",
dealer_type = "1",
source = "Android_app"
});
var response = client.Execute <RegisterRequestModel>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> registerRequestResults;
var isRegisterRequestValid = GlobalLogic.IsModelValid(response.Data, out registerRequestResults);
if (!isRegisterRequestValid)
{
var message = $"Register Request with success: {registerRequestResults.Model.Success}"
.RequestInfo(client, request)
.WithValidationErrors(registerRequestResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void ValidateNphNumberTest(string dealer, string digest, string newPhone, string auth)
{
var generator = new Random();
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/users/{dealer_name}/phone?digest={digest}", Method.PUT);
var requestCounter = 0;
string newPhoneRandom;
IRestResponse <ValidateNphNumberModel> response;
do
{
newPhoneRandom = newPhone + generator.Next(0, 100000).ToString("D5");
request
.AddUrlSegment("dealer_name", dealer)
.AddUrlSegment("digest", digest)
.AddParameter("phone", newPhoneRandom)
.AddHeader("Authorization", auth);
response = client.Execute <ValidateNphNumberModel>(request);
} while (response.Data.Success == false && requestCounter++ < 5);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <ValidateNphNumberModel> validatenphnumberResults;
var isValidateNphNumberDataValid = GlobalLogic.IsModelValid(response.Data, out validatenphnumberResults);
if (!isValidateNphNumberDataValid)
{
var message = $"ValidateNphNumber with success: {validatenphnumberResults.Model.Success} and description: {validatenphnumberResults.Model.Description}."
.RequestInfo(client, request)
.WithValidationErrors(validatenphnumberResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void FeedbackTest(string digest, string auth, string contentType)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/user/feedback?digest={digest}", Method.POST);
request
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
username = Data.DealerName,
message = "Hello World!"
});
var response = client.Execute <RegisterRequestModel>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> feedbackResults;
var isFeedbackValid = GlobalLogic.IsModelValid(response.Data, out feedbackResults);
if (!isFeedbackValid)
{
var message = $"Feedback with success: {feedbackResults.Model.Success}"
.RequestInfo(client, request)
.WithValidationErrors(feedbackResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void SendOtpTest(string digest, string phone, string auth, string contentType)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("user/otp_set?digest={digest}", Method.POST);
request
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
phone = phone
});
var response = client.Execute <RegisterRequestModel>(request);
GlobalLogic.EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> sendotpResults;
var isSendOtpValid = GlobalLogic.IsModelValid(response.Data, out sendotpResults);
if (!isSendOtpValid)
{
var message = $"SendOtp with success: {sendotpResults.Model.Success}"
.RequestInfo(client, request)
.WithValidationErrors(sendotpResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void PhVerifyTest(string digest, string auth, string newPhone)
{
var generator = new Random();
var client = new RestClient(TestConfiguration.API.Location);
var request1 = new RestRequest("/sms/verify-phone-v2", Method.GET);
var requestCounter = 0;
string newPhoneRandom;
IRestResponse <PhVerifyModel> response1;
do
{
newPhoneRandom = newPhone + generator.Next(0, 100000).ToString("D5");
request1
.AddParameter("digest", digest)
.AddParameter("phone", newPhoneRandom)
.AddHeader("Authorization", auth);
response1 = client.Execute <PhVerifyModel>(request1);
} while (response1.Data.Success == false && requestCounter++ < 5);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <PhVerifyModel> phverifyResults;
var isPhVerifyDataValid = GlobalLogic.IsModelValid(response1.Data, out phverifyResults);
if (!isPhVerifyDataValid)
{
var message = $"PhVerify with success: {phverifyResults.Model.Success} and message: {phverifyResults.Model.Message}."
.RequestInfo(client, request1)
.WithValidationErrors(phverifyResults.Results);
allErrorMessages.Add(message);
}
/*var request3 = new RestRequest("/sms/verify-phone-v2", Method.GET);
*
* request3
* .AddParameter("digest", digest)
* .AddParameter("phone", newPhoneRandom)
* .AddParameter("code", response2.Data.Verify_code)
* .AddHeader("Authorization", auth);
*
* var response3 = client.Execute<RegisterRequestModel>(request3);
*
* EnsureOkResponseStatusCode(response3, client, request3);
*
* ValidationResultModel<RegisterRequestModel> codeVerifyResults;
* var isCodeVerifyDataValid = GlobalLogic.IsModelValid(response3.Data, out codeVerifyResults);
*
* if (!isCodeVerifyDataValid)
* {
* var message = $"CodeVerify with success: {codeVerifyResults.Model.Success}."
* .RequestInfo(client, request3)
* .WithValidationErrors(codeVerifyResults.Results);
*
* allErrorMessages.Add(message);
* }
*/
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void ResetPasswordViaEmailTest(string digest, string email, string password, string auth, string contentType)
{
var client = new RestClient(TestConfiguration.API.Location);
//Send Password Reset Email
var request1 = new RestRequest("user/pass_mail?digest={digest}", Method.POST);
request1
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
email = email
});
var response1 = client.Execute <RegisterRequestModel>(request1);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> presetEmailResults;
var isPResetEmailValid = GlobalLogic.IsModelValid(response1.Data, out presetEmailResults);
if (!isPResetEmailValid)
{
var message = $"PResetEmail with success: {presetEmailResults.Model.Success}"
.RequestInfo(client, request1)
.WithValidationErrors(presetEmailResults.Results);
allErrorMessages.Add(message);
}
//Get Guid
var request2 = new RestRequest("user/get_pass_reset?digest={digest}", Method.GET);
request2
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddParameter("email", email);
var response2 = client.Execute <GetGuidModel>(request2);
EnsureOkResponseStatusCode(response2, client, request2);
ValidationResultModel <GetGuidModel> getEmailResults;
var isGetEmailValid = GlobalLogic.IsModelValid(response2.Data, out getEmailResults);
if (!isGetEmailValid)
{
var message = $"GetEmail with success: {getEmailResults.Model.Success} and Guid: {getEmailResults.Model.Guid}."
.RequestInfo(client, request2)
.WithValidationErrors(getEmailResults.Results);
allErrorMessages.Add(message);
}
//Check Guid
var request3 = new RestRequest("/user/pass_reset/{guid}", Method.GET);
request3
.AddUrlSegment("guid", response2.Data.Guid)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response3 = client.Execute <RegisterRequestModel>(request3);
EnsureOkResponseStatusCode(response3, client, request3);
ValidationResultModel <RegisterRequestModel> checkguidResults;
var isCheckOtpDataValid = GlobalLogic.IsModelValid(response3.Data, out checkguidResults);
if (!isCheckOtpDataValid)
{
var message = $"CheckGuid with success: {checkguidResults.Model.Success}."
.RequestInfo(client, request3)
.WithValidationErrors(checkguidResults.Results);
allErrorMessages.Add(message);
}
//Change Password
var request4 = new RestRequest("/user/pass_reset/{guid}?digest={digest}", Method.POST);
request4
.AddUrlSegment("guid", response2.Data.Guid)
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
password = password
});
var response4 = client.Execute <RegisterRequestModel>(request4);
EnsureOkResponseStatusCode(response4, client, request4);
ValidationResultModel <RegisterRequestModel> chPassViaEmailResults;
var isChPassViaEmailDataValid = GlobalLogic.IsModelValid(response4.Data, out chPassViaEmailResults);
if (!isChPassViaEmailDataValid)
{
var message = $"ChPassViaEmail with success: {chPassViaEmailResults.Model.Success}."
.RequestInfo(client, request4)
.WithValidationErrors(chPassViaEmailResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void ClassifiedUploadsTest(string digest, string auth, string email, string dealerName, string phone, int user_id)
{
var client = new RestClient(TestConfiguration.API.Location);
var request1 = new RestRequest("/objects?digest={digest}", Method.POST);
//Create Classified
request1.RequestFormat = DataFormat.Json;
request1
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new
{
data =
new
{
user_id = dealerName,
year = "2000",
city = "noida",
model =
new
{
model = "astonmartin-db9",
brand = "astonmartin"
},
price = "777777",
variant_id = "astonmartin-db9-coupe",
km_driven = 22222,
owners = 1,
color = "white",
fuel_type = "Petrol",
transmission = "Manual",
engine = 3333,
body_type = "Sedan",
have_certificated = "no",
classified_phone = "+91-9999999999",
address = "Test",
status = 1,
source = "Cabinet"
}
});
var response1 = client.Execute <CreateClassifiedModel>(request1);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <CreateClassifiedModel> createClassifiedResults;
var isCreateClassifiedValid = GlobalLogic.IsModelValid(response1.Data, out createClassifiedResults);
if (!isCreateClassifiedValid)
{
var message = $"\r\nCreate Classified with success: '{createClassifiedResults.Model.Success}' and Guid: '{createClassifiedResults.Model.Guid}'\r\n"
.RequestInfo(client, request1)
.WithValidationErrors(createClassifiedResults.Results);
allErrorMessages.Add(message);
}
//Upload images
foreach (string fileType in Data.Filetypes)
{
var request2 = new RestRequest("/file?digest={digest}", Method.POST);
request2.RequestFormat = DataFormat.Json;
request2
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new
{
username = Data.DealerName,
guid = response1.Data.Guid,
file =
new
{
type = fileType,
name = Data.ImageName,
content = Data.FileContent
}
});
var response2 = client.Execute <UploadImageModel>(request2);
EnsureOkResponseStatusCode(response2, client, request2);
ValidationResultModel <UploadImageModel> UploadImageResults;
var isUploadImageValid = GlobalLogic.IsModelValid(response2.Data, out UploadImageResults);
if (!isUploadImageValid)
{
var message = $"\r\nUploaded photo with success: '{UploadImageResults.Model.Success}' and Url: '{UploadImageResults.Model.Url}'\r\n"
.RequestInfo(client, request2)
.WithValidationErrors(UploadImageResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
//Upload Certificate
var request3 = new RestRequest("/file?digest={digest}", Method.POST);
request3.RequestFormat = DataFormat.Json;
request3
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new
{
username = Data.DealerName,
guid = response1.Data.Guid,
file =
new
{
type = Data.FileTypePdf,
name = Data.PdfName,
content = Data.FileContentPdf
}
});
var response3 = client.Execute <UploadPdfModel>(request3);
EnsureOkResponseStatusCode(response3, client, request3);
ValidationResultModel <UploadPdfModel> UploadPdfResults;
var isUploadPdfValid = GlobalLogic.IsModelValid(response3.Data, out UploadPdfResults);
if (!isUploadPdfValid)
{
var message = $"\r\nUploaded photo with success: '{UploadPdfResults.Model.Success}' and Url: '{UploadPdfResults.Model.Url}'\r\n"
.RequestInfo(client, request3)
.WithValidationErrors(UploadPdfResults.Results);
allErrorMessages.Add(message);
}
//Update Classified
var request4 = new RestRequest("/objects/{guid}", Method.PUT);
request4.RequestFormat = DataFormat.Json;
request4
.AddUrlSegment("guid", response1.Data.Guid)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth)
.AddJsonBody(
new
{
data =
new
{
status = 3
}
});
var response4 = client.Execute <RegisterRequestModel>(request4);
EnsureOkResponseStatusCode(response4, client, request4);
ValidationResultModel <RegisterRequestModel> updateClassifiedResults;
var isupdateClassifiedsDataValid = GlobalLogic.IsModelValid(response4.Data, out updateClassifiedResults);
if (!isupdateClassifiedsDataValid)
{
var message = $"\r\nUpdate Classified with success: '{updateClassifiedResults.Model.Success}\r\n"
.RequestInfo(client, request4)
.WithValidationErrors(updateClassifiedResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void LeadsCreatingTest(string digest, string auth, string email, string dealerName, string phone, int user_id)
{
var client = new RestClient(TestConfiguration.API.Location);
var request1 = new RestRequest("/objects?digest={digest}", Method.POST);
//Create Classified
request1.RequestFormat = DataFormat.Json;
request1
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new
{
data =
new
{
user_id = dealerName,
year = "2000",
city = "noida",
model =
new
{
model = "astonmartin-db9",
brand = "astonmartin"
},
price = "777777",
variant_id = "astonmartin-db9-coupe",
km_driven = 22222,
owners = 1,
color = "white",
fuel_type = "Petrol",
transmission = "Manual",
engine = 3333,
body_type = "Sedan",
have_certificated = "no",
classified_phone = "+91-9999999999",
address = "Test",
status = 1,
source = "Cabinet"
}
});
var response1 = client.Execute <CreateClassifiedModel>(request1);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <CreateClassifiedModel> createClassifiedResults;
var isCreateClassifiedValid = GlobalLogic.IsModelValid(response1.Data, out createClassifiedResults);
if (!isCreateClassifiedValid)
{
var message = $"\r\nCreate Classified with success: '{createClassifiedResults.Model.Success}' and Guid: '{createClassifiedResults.Model.Guid}'\r\n"
.RequestInfo(client, request1)
.WithValidationErrors(createClassifiedResults.Results);
allErrorMessages.Add(message);
}
//Read Classified
var request2 = new RestRequest("/objects/{guid}", Method.GET);
request2
.AddUrlSegment("guid", response1.Data.Guid)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response2 = client.Execute <ReadClassifiedModel.RootObject>(request2);
if (response2.StatusCode != HttpStatusCode.OK || response2.Data == null || response2.Data.Success == false)
{
throw new Exception(AssertMessages.StatusCodeErrorMessage(client.BuildUri(request2), response2.StatusCode, response2.Content));
}
ValidationResultModel <ReadClassifiedModel.RootObject> classifiedDataMainResults;
var isClassifiedDataValid = GlobalLogic.IsModelValid(response2.Data, out classifiedDataMainResults);
if (!isClassifiedDataValid)
{
var message = $"Classified with success: {classifiedDataMainResults.Model.Success} and Id: {classifiedDataMainResults.Model.Items.id}."
.RequestInfo(client, request2)
.WithValidationErrors(classifiedDataMainResults.Results);
allErrorMessages.Add(message);
}
//Create Lead
var request3 = new RestRequest("/lead/create?digest={digest}", Method.POST);
request3
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(new{
classified_id = response2.Data.Items.id,
customer_email = email,
customer_name = dealerName,
customer_phone = phone,
dealer_id = user_id
});
var response3 = client.Execute <LeadModel.RootObject>(request3);
EnsureOkResponseStatusCode(response3, client, request3);
ValidationResultModel <LeadModel.RootObject> createLeadResults;
var isCreateLeadDataValid = GlobalLogic.IsModelValid(response3.Data, out createLeadResults);
if (!isCreateLeadDataValid)
{
var message = $"\r\nCreate Lead with success: '{createLeadResults.Model.Success}' and Lead id: '{createLeadResults.Model.LeadId}'\r\n"
.RequestInfo(client, request3)
.WithValidationErrors(createLeadResults.Results);
allErrorMessages.Add(message);
}
//Create Cross-Share Lead
var request4 = new RestRequest("/lead/cross-share?digest={digest}", Method.POST);
request4
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(new
{
lead_id = response3.Data.LeadId
});
var response4 = client.Execute <RegisterRequestModel>(request4);
EnsureOkResponseStatusCode(response4, client, request4);
ValidationResultModel <RegisterRequestModel> createCShLeadResults;
var isCreateCShLeadDataValid = GlobalLogic.IsModelValid(response4.Data, out createCShLeadResults);
if (!isCreateCShLeadDataValid)
{
var message = $"\r\nCreate Cross-Share Lead with success: '{createCShLeadResults.Model.Success}\r\n"
.RequestInfo(client, request4)
.WithValidationErrors(createCShLeadResults.Results);
allErrorMessages.Add(message);
}
//Update Classified
var request5 = new RestRequest("/objects/{guid}?digest={digest}", Method.PUT);
request5.RequestFormat = DataFormat.Json;
request5
.AddUrlSegment("guid", response1.Data.Guid)
.AddUrlSegment("digest", digest)
.AddHeader("Authorization", auth)
.AddParameter("data[status]", 3
);
/* .AddJsonBody(
* new
* {
* data =
* new
* {
* status = 3
* }
* });*/
var response5 = client.Execute <RegisterRequestModel>(request5);
EnsureOkResponseStatusCode(response5, client, request5);
ValidationResultModel <RegisterRequestModel> updateClassifiedResults;
var isupdateClassifiedsDataValid = GlobalLogic.IsModelValid(response5.Data, out updateClassifiedResults);
if (!isupdateClassifiedsDataValid)
{
var message = $"\r\nUpdate Classified with success: '{updateClassifiedResults.Model.Success}\r\n"
.RequestInfo(client, request5)
.WithValidationErrors(updateClassifiedResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void CreateClassifiedTest(string digest, string auth)
{
var client = new RestClient(TestConfiguration.API.Location);
var request = new RestRequest("/objects?digest={digest}", Method.POST);
request.RequestFormat = DataFormat.Json;
request
.AddHeader("Authorization", auth)
.AddUrlSegment("digest", digest)
.AddJsonBody(
new {
data =
new {
user_id = "Jane",
year = "2000",
city = "noida",
model =
new {
model = "astonmartin-db9",
brand = "astonmartin"
},
price = "777777",
variant_id = "astonmartin-db9-coupe",
km_driven = 22222,
owners = 1,
color = "white",
fuel_type = "Petrol",
transmission = "Manual",
engine = 3333,
body_type = "Sedan",
have_certificated = "no",
classified_phone = "+91-9999999999",
address = "Test",
status = 1,
source = "Cabinet"
}
});
var response = client.Execute <CreateClassifiedModel>(request);
EnsureOkResponseStatusCode(response, client, request);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <CreateClassifiedModel> createClassifiedResults;
var isCreateClassifiedValid = GlobalLogic.IsModelValid(response.Data, out createClassifiedResults);
if (!isCreateClassifiedValid)
{
var message = $"\r\nCreate Classified with success: '{createClassifiedResults.Model.Success}' and Guid: '{createClassifiedResults.Model.Guid}'\r\n"
.RequestInfo(client, request)
.WithValidationErrors(createClassifiedResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
//newphone name refactoring
public void ChangePhoneNumberTest(string dealer, string digest, string newPhone, int save, string auth)
{
var generator = new Random();
var client = new RestClient(TestConfiguration.API.Location);
var request1 = new RestRequest("/users/{dealer_name}/phone?digest={digest}", Method.PUT);
var requestCounter = 0;
string newPhoneRandom;
IRestResponse <ValidateNphNumberModel> response1;
do
{
newPhoneRandom = newPhone + generator.Next(0, 100000).ToString("D5");
request1
.AddUrlSegment("dealer_name", dealer)
.AddUrlSegment("digest", digest)
.AddParameter("phone", newPhoneRandom)
.AddHeader("Authorization", auth);
response1 = client.Execute <ValidateNphNumberModel>(request1);
} while (response1.Data.Success == false && requestCounter++ < 5);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
//refactor: inline out variable
// use correct naming: validateNphNumberResults
var isValidateNphNumberDataValid = GlobalLogic.IsModelValid(response1.Data, out var validateNphNumberResults);
if (!isValidateNphNumberDataValid)
{
var message = $"ValidateNphNumber with success: {validateNphNumberResults.Model.Success} and description: {validateNphNumberResults.Model.Description}."
.RequestInfo(client, request1)
.WithValidationErrors(validateNphNumberResults.Results);
allErrorMessages.Add(message);
}
var request2 = new RestRequest("/users/{dealer_name}/phone?digest={digest}", Method.PUT);
request2
.AddUrlSegment("dealer_name", dealer)
.AddUrlSegment("digest", digest)
.AddParameter("phone", newPhoneRandom)
.AddParameter("save", save)
.AddHeader("Authorization", auth);
var response2 = client.Execute <ValidateNphNumberModel>(request2);
EnsureOkResponseStatusCode(response2, client, request2);
//refactor: inline out variable
var isSaveNewNumberDataValid = GlobalLogic.IsModelValid(response2.Data, out var saveNewNumberResults);
if (!isSaveNewNumberDataValid)
{
var message = $"SaveNewNumber with success: {saveNewNumberResults.Model.Success} and description: {saveNewNumberResults.Model.Description}."
.RequestInfo(client, request2)
.WithValidationErrors(saveNewNumberResults.Results);
allErrorMessages.Add(message);
}
var request3 = new RestRequest("/users/{dealer_name}", Method.GET);
request3
.AddUrlSegment("dealer_name", dealer)
.AddParameter("digest", digest)
.AddHeader("Authorization", auth);
var response3 = client.Execute <DealerDataModel.RootObject>(request3);
if (!response3.Data.Items.Phone.Equals("91" + newPhoneRandom))
{
var message = $"Updated phone number from DealerData: {response3.Data.Items.Phone} doesn't equal the expected value: {newPhoneRandom}.";
allErrorMessages.Add(message);
}
var request4 = new RestRequest("/users/{dealer_name}/phone?digest={digest}", Method.PUT);
request4
.AddUrlSegment("dealer_name", dealer)
.AddUrlSegment("digest", digest)
.AddParameter("phone", Data.PhoneBack)
.AddParameter("save", save)
.AddHeader("Authorization", auth);
var response4 = client.Execute <ValidateNphNumberModel>(request4);
EnsureOkResponseStatusCode(response4, client, request4);
//refactor: inline out variable
var ischangeNumberBackDataValid = GlobalLogic.IsModelValid(response4.Data, out var changeNumberBackResults);
if (!ischangeNumberBackDataValid)
{
var message = $"ChangeNumberBack with success: {changeNumberBackResults.Model.Success} and description: {changeNumberBackResults.Model.Description}."
.RequestInfo(client, request4)
.WithValidationErrors(changeNumberBackResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
public void ResetPasswordViaPhoneTest(string digest, string phone, string password, string auth, string contentType)
{
var client = new RestClient(TestConfiguration.API.Location);
//Send OTP
var request1 = new RestRequest("user/otp_set?digest={digest}", Method.POST);
request1
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
phone = phone
});
var response1 = client.Execute <RegisterRequestModel>(request1);
EnsureOkResponseStatusCode(response1, client, request1);
List <string> allErrorMessages = new List <string>();
ValidationResultModel <RegisterRequestModel> sendOtpResults;
var isSendOtpValid = GlobalLogic.IsModelValid(response1.Data, out sendOtpResults);
if (!isSendOtpValid)
{
var message = $"SendOtp with success: {sendOtpResults.Model.Success}"
.RequestInfo(client, request1)
.WithValidationErrors(sendOtpResults.Results);
allErrorMessages.Add(message);
}
//Get OTP
var request2 = new RestRequest("user/otp_get?digest={digest}", Method.GET);
request2
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddParameter("phone", phone);
var response2 = client.Execute <GetOtpModel>(request2);
EnsureOkResponseStatusCode(response2, client, request2);
ValidationResultModel <GetOtpModel> getOtpResults;
var isGetOtpValid = GlobalLogic.IsModelValid(response2.Data, out getOtpResults);
if (!isGetOtpValid)
{
var message = $"GetOtp with success: {getOtpResults.Model.Success} and Otp: {getOtpResults.Model.Otp_code}."
.RequestInfo(client, request2)
.WithValidationErrors(sendOtpResults.Results);
allErrorMessages.Add(message);
}
//Check OTP
var request3 = new RestRequest("/user/otp_check", Method.GET);
request3
.AddParameter("digest", digest)
.AddParameter("phone", phone)
.AddParameter("otp", response2.Data.Otp_code)
.AddHeader("Authorization", auth);
var response3 = client.Execute <CheckOtpModel>(request3);
EnsureOkResponseStatusCode(response3, client, request3);
ValidationResultModel <CheckOtpModel> checkOtpResults;
var isCheckOtpDataValid = GlobalLogic.IsModelValid(response3.Data, out checkOtpResults);
if (!isCheckOtpDataValid)
{
var message = $"CheckOtp with success: {checkOtpResults.Model.Success} and username: {checkOtpResults.Model.Username}."
.RequestInfo(client, request3)
.WithValidationErrors(checkOtpResults.Results);
allErrorMessages.Add(message);
}
//Change Password
var request4 = new RestRequest("user/renew_pass?digest={digest}", Method.POST);
request4
.AddUrlSegment("digest", digest)
.AddHeader("Content-Type", contentType)
.AddHeader("Authorization", auth)
.AddJsonBody(new
{
phone = phone,
otp = response2.Data.Otp_code,
password = password
});
var response4 = client.Execute <RegisterRequestModel>(request4);
EnsureOkResponseStatusCode(response4, client, request4);
ValidationResultModel <RegisterRequestModel> updatePasswordResults;
var isUpdatePasswordValid = GlobalLogic.IsModelValid(response4.Data, out updatePasswordResults);
if (!isUpdatePasswordValid)
{
var message = $"UpdatePassword with success: {updatePasswordResults.Model.Success}"
.RequestInfo(client, request4)
.WithValidationErrors(updatePasswordResults.Results);
allErrorMessages.Add(message);
}
if (allErrorMessages.Any())
{
var allMessages = string.Join("\r\n\r\n", allErrorMessages);
throw new Exception(allMessages);
}
}
