def verify_submission2(self, global_navigation, sms_log):
view_all_data_page = global_navigation.navigate_to_all_data_page()
submission_log_page = view_all_data_page.navigate_to_submission_log_page(
fetch_(PROJECT_NAME, VALID_DATA_FOR_PROJECT).lower())
self.assertRegexpMatches(submission_log_page.get_submission_message(sms_log),
fetch_(SMS_SUBMISSION, from_(sms_log)))
self.assertEqual(self.driver.get_title(), "Submission Log")
def test_should_update_submission_log_when_subject_info_is_edited(self):
self.driver.go_to(url("/entity/subject/create/clinic/?web_view=True&"))
add_subject_page = AddSubjectPage(self.driver)
add_subject_page.add_subject_with(VALID_DATA_FOR_SUBJECT)
add_subject_page.submit_subject()
message = fetch_(SUCCESS_MESSAGE, from_(VALID_DATA_FOR_SUBJECT))
flash_message = add_subject_page.get_flash_message()
subject_short_code = get_subject_short_code(flash_message)
message = message % subject_short_code
self.assertIn(message, flash_message)
VALID_SMS_FOR_EDIT_SUBJECT[SMS] = VALID_SMS_FOR_EDIT_SUBJECT[
SMS].replace('short_code', subject_short_code, 1)
send_valid_sms_with(VALID_SMS_FOR_EDIT_SUBJECT)
submission_log_page = self.get_first_project_submission_log_page()
submission_log_page.search(subject_short_code)
self.assertIn(fetch_(SUB_LAST_NAME, VALID_DATA_FOR_SUBJECT),
submission_log_page.get_cell_value(1, 5))
self.driver.go_to(url("/entity/subjects/clinic/"))
subject_list_page = AllSubjectsListPage(self.driver)
self.driver.wait_for_page_load()
subject_list_page.select_subject_by_id(subject_short_code)
edit_subject_page = subject_list_page.click_edit_action_button()
edit_subject_page.add_subject_with(VALID_DATA_FOR_EDIT)
edit_subject_page.submit_subject()
submission_log_page = self.get_first_project_submission_log_page()
submission_log_page.search(subject_short_code)
self.assertIn(fetch_(SUB_LAST_NAME, VALID_DATA_FOR_EDIT),
submission_log_page.get_cell_value(1, 5))
def test_should_filter_by_name_and_id_of_datasender_and_subject(self):
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
send_valid_sms_with(SMS_REGISTER_SUBJECT)
send_valid_sms_with(SMS_WEB_SUBMISSION)
submission_log_page = self.go_to_submission_log_page()
submission_log_page.wait_for_table_data_to_load()
datasender_name = 'Tester'
submission_log_page.filter_by_datasender(datasender_name)
submission_log_page.wait_for_table_data_to_load()
self._verify_filtered_records_by_datasender_name_or_id(
datasender_name, submission_log_page)
project_name = fetch_("last_name", from_(SUBJECT_DATA))
submission_log_page.filter_by_subject(project_name)
submission_log_page.wait_for_table_data_to_load()
self._verify_filtered_records_by_subject_name_or_id(
project_name, submission_log_page)
datasender_id = 'rep276'
submission_log_page.refresh()
submission_log_page.filter_by_datasender(datasender_id)
submission_log_page.wait_for_table_data_to_load()
self._verify_filtered_records_by_datasender_name_or_id(
datasender_id, submission_log_page)
project_short_code = fetch_("short_code", from_(SUBJECT_DATA))
submission_log_page.refresh()
submission_log_page.filter_by_subject(project_short_code)
submission_log_page.wait_for_table_data_to_load()
self._verify_filtered_records_by_subject_name_or_id(
project_short_code, submission_log_page)
def associate(self, all_data_sender_page):
all_data_sender_page.select_a_data_sender_by_id(
fetch_(UID, from_(ASSOCIATE_DATA_SENDER)))
all_data_sender_page.associate_data_sender()
all_data_sender_page.select_project(
fetch_(PROJECT_NAME, from_(ASSOCIATE_DATA_SENDER)))
all_data_sender_page.click_confirm(wait=True)
def test_successful_association_of_data_sender(self):
all_data_sender_page = self.page
self.associate(all_data_sender_page)
self.assertEqual(
all_data_sender_page.get_project_names(
fetch_(UID, from_(ASSOCIATE_DATA_SENDER))),
fetch_(PROJECT_NAME, from_(ASSOCIATE_DATA_SENDER)))
def configure_list_of_choices_type_question(self, question_data):
"""
Function to select list of choices option and add the choices on the questionnaire page
Args:
question_data is to add the choices on the page
return self
"""
self.driver.find_drop_down(ANSWER_TYPE_DROPDOWN).set_selected(
LIST_OF_CHOICES_OPTION)
self.driver.find_element_by_id("choice_text0").clear()
index = 1
choices = fetch_(CHOICE, from_(question_data))
for choice in choices:
if index > 1:
self.driver.find(ADD_CHOICE_LINK).click()
box = self.driver.find_text_box(
by_id("choice_text%d" % (index - 1)))
box.send_keys(choice)
index += 1
box = self.driver.find_text_box(
by_xpath(CHOICE_XPATH_LOCATOR + "[1]" + CHOICE_TB_XPATH_LOCATOR))
box.send_keys(choices[0])
choice_type = fetch_(ALLOWED_CHOICE, from_(question_data))
if ONLY_ONE_ANSWER == choice_type:
self.driver.find_radio_button(ONLY_ONE_ANSWER_RB).click()
elif MULTIPLE_ANSWERS == choice_type:
self.driver.find_radio_button(MULTIPLE_ANSWER_RB).click()
return self
def test_delete_data_sender_and_re_register(self):
all_data_sender_page = self.page
self.delete_ds(all_data_sender_page)
self.assertEqual(all_data_sender_page.get_delete_success_message(),
DELETE_SUCCESS_TEXT)
global_navigation = GlobalNavigationPage(self.driver)
global_navigation.sign_out()
sms_tester_page = SMSTesterPage(self.driver)
self.send_sms(VALID_SMS, sms_tester_page)
self.assertEqual(sms_tester_page.get_response_message(),
SMS_ERROR_MESSAGE)
self.login()
self.driver.go_to(DATA_WINNER_CREATE_DATA_SENDERS)
add_data_sender_page = AddDataSenderPage(self.driver)
add_data_sender_page.enter_data_sender_details_from(VALID_DATA)
message = add_data_sender_page.get_success_message()
self.assertRegexpMatches(message, fetch_(SUCCESS_MSG,
from_(VALID_DATA)))
self.assertNotEqual(message.split()[-1],
fetch_(UID, from_(DELETE_DATA_SENDER)))
self.driver.wait_until_modal_dismissed(10)
global_navigation.sign_out()
self.send_sms(VALID_SMS, sms_tester_page)
self.assertEqual(sms_tester_page.get_response_message(),
fetch_(SUCCESS_MESSAGE, from_(VALID_SMS)))
self.login()
def edit_questionnaire(self, edit_questionnaire_page):
questions = fetch_(QUESTIONS, from_(NEW_QUESTIONNAIRE_DATA))
edit_questionnaire_page.select_question_link(3)
edit_questionnaire_page.configure_number_type_question(questions[0])
edit_questionnaire_page.add_question(questions[1])
self.assertEquals(edit_questionnaire_page.get_remaining_character_count(),
fetch_(CHARACTER_REMAINING, from_(NEW_QUESTIONNAIRE_DATA)))
edit_questionnaire_page.save_and_create_project_successfully()
def verify_submission1(self, global_navigation, sms_log):
view_all_project_page = global_navigation.navigate_to_view_all_project_page()
project_overview_project = view_all_project_page.navigate_to_project_overview_page(
fetch_(PROJECT_NAME, VALID_DATA_FOR_PROJECT).lower())
data_page = project_overview_project.navigate_to_data_page()
submission_log_page = data_page.navigate_to_all_data_record_page()
self.assertRegexpMatches(submission_log_page.get_submission_message(sms_log),
fetch_(SMS_SUBMISSION, from_(sms_log)))
def test_dissociate_ds_without_selecting_project(self):
all_data_sender_page = self.page
all_data_sender_page.select_a_data_sender_by_id(
fetch_(UID, from_(DISSOCIATE_DS_WITHOUT_SELECTING_PROJECT)))
all_data_sender_page.dissociate_data_sender()
all_data_sender_page.click_confirm()
self.assertEqual(
all_data_sender_page.get_error_message(),
fetch_(ERROR_MSG, from_(DISSOCIATE_DS_WITHOUT_SELECTING_PROJECT)))
def type_project_name(self, project_data):
project_name = fetch_(PROJECT_NAME, from_(project_data))
try:
gen_random = fetch_(GEN_RANDOM, from_(project_data))
except KeyError:
gen_random = False
if gen_random:
project_name += generateId()
self.driver.find_text_box(PROJECT_NAME_TB).enter_text(project_name)
return project_name
def test_successful_review_of_project(self):
review_page = self.prerequisites_of_create_project()
self.assertEqual(fetch_(PROJECT_PROFILE, from_(VALID_DATA)),
review_page.get_project_profile_details())
review_page.open_subject_accordion()
self.assertEqual(fetch_(SUBJECT_DETAILS, from_(VALID_DATA)),
review_page.get_subject_details())
review_page.open_questionnaire_accordion()
self.assertEqual(fetch_(QUESTIONNAIRE, from_(VALID_DATA)),
review_page.get_questionnaire())
def create_questionnaire(self, create_questionnaire_page):
create_questionnaire_page.create_questionnaire_with(QUESTIONNAIRE_DATA)
index = 3
for question in fetch_(QUESTIONS, from_(QUESTIONNAIRE_DATA)):
question_link_text = fetch_(QUESTION, from_(question))
self.assertEquals(create_questionnaire_page.get_question_link_text(index), question_link_text)
index += 1
self.assertEquals(create_questionnaire_page.get_remaining_character_count(),
fetch_(CHARACTER_REMAINING, from_(QUESTIONNAIRE_DATA)))
project_overview_page = create_questionnaire_page.save_and_create_project_successfully()
return project_overview_page
def review_project_summary(self, review_page):
self.assertEqual(fetch_(PROJECT_PROFILE, from_(VALID_DATA_REVIEW_AND_TEST)),
review_page.get_project_profile_details())
review_page.open_subject_accordion()
self.assertEqual(fetch_(SUBJECT_DETAILS, from_(VALID_DATA_REVIEW_AND_TEST)), review_page.get_subject_details())
# unreliable in firefox in CI, works fine locally
# review_page.open_data_sender_accordion()
# self.assertEqual(fetch_(DATA_SENDER_COUNT, from_(VALID_DATA_REVIEW_AND_TEST)),
# review_page.get_data_sender_count())
review_page.open_questionnaire_accordion()
self.assertEqual(fetch_(QUESTIONNAIRE, from_(VALID_DATA_REVIEW_AND_TEST)), review_page.get_questionnaire())
def test_end_to_end(self):
"""todo: failed randomly when run ft"""
self.email = None
self.do_org_registartion()
organization_sms_tel_number = self.set_organization_number()
self.activate_account()
global_navigation = self.do_login()
dashboard_page = global_navigation.navigate_to_dashboard_page()
create_project_page = dashboard_page.navigate_to_create_project_page()
create_project_page.select_report_type(VALID_DATA_FOR_PROJECT)
self.add_subject_type(create_project_page, VALID_SUBJECT_TYPE2[ENTITY_TYPE])
self.add_subject_type(create_project_page, VALID_SUBJECT_TYPE1[ENTITY_TYPE])
create_questionnaire_page = self.create_project(create_project_page)
self.create_questionnaire(create_questionnaire_page)
global_navigation.navigate_to_all_subject_page()
add_subject_page = AddSubjectPage(self.driver)
self.driver.go_to("http://localhost:8000/entity/subject/create/waterpoint/")
self.add_a_subject(add_subject_page)
all_data_senders_page = global_navigation.navigate_to_all_data_sender_page()
add_data_sender_page = all_data_senders_page.navigate_to_add_a_data_sender_page()
self.add_a_data_sender(add_data_sender_page)
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
self.send_sms(organization_sms_tel_number, VALID_DATA_FOR_SMS)
self.driver.go_to(DATA_WINNER_DASHBOARD_PAGE)
self.verify_submission1(global_navigation, SMS_DATA_LOG)
all_projects_page = global_navigation.navigate_to_view_all_project_page()
project_overview_page = all_projects_page.navigate_to_project_overview_page(
fetch_(PROJECT_NAME, from_(VALID_DATA_FOR_PROJECT)))
edit_project_page = project_overview_page.navigate_to_edit_project_page()
edit_project_page.continue_create_project()
edit_questionnaire_page = create_questionnaire_page
self.verify_questionnaire(edit_questionnaire_page)
self.edit_questionnaire(edit_questionnaire_page)
all_projects_page = global_navigation.navigate_to_view_all_project_page()
project_name = fetch_(PROJECT_NAME, from_(VALID_DATA_FOR_PROJECT))
activate_project_light_box = all_projects_page.open_activate_project_light_box(project_name)
self.assertEqual(activate_project_light_box.get_title_of_light_box(), "Activate this Project?")
project_overview_page = activate_project_light_box.activate_project()
self.assertEqual(project_overview_page.get_status_of_the_project(), "Active")
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
self.send_sms(organization_sms_tel_number, NEW_VALID_DATA_FOR_SMS)
self.driver.go_to(DATA_WINNER_DASHBOARD_PAGE)
self.verify_submission2(global_navigation, NEW_SMS_DATA_LOG)
def test_successful_addition_editing_of_data_sender(self):
add_data_sender_page = self.current_page
add_data_sender_page.enter_data_sender_details_from(VALID_DATA)
self.assertRegexpMatches(add_data_sender_page.get_success_message(),
fetch_(SUCCESS_MSG, from_(VALID_DATA)))
self.driver.go_to(DATA_WINNER_ALL_DATA_SENDERS_PAGE)
all_data_senders_page = AllDataSendersPage(self.driver)
all_data_senders_page.select_a_data_sender_by_mobile(VALID_DATA[MOBILE_NUMBER_WITHOUT_HYPHENS])
all_data_senders_page.select_edit_action()
self.current_page.enter_data_sender_details_from(VALID_EDIT_DATA)
self.assertRegexpMatches(self.current_page.get_success_message(),
fetch_(SUCCESS_MSG, from_(VALID_EDIT_DATA)))
def configure_number_type_question(self, question_data):
"""
Function to select number option and fill the details (min or max) on the questionnaire page
Args:
question_data is data to fill in the min and max fields
return self
"""
self.driver.find_drop_down(ANSWER_TYPE_DROPDOWN).set_selected(NUMBER_OPTION)
self.driver.find_text_box(NUMBER_MIN_LENGTH_TB).enter_text(fetch_(MIN, from_(question_data)))
self.driver.find_text_box(NUMBER_MAX_LENGTH_TB).enter_text(fetch_(MAX, from_(question_data)))
return self
def assert_fields_are_populated_properly_in_edit_page(
self, valid_registration_data):
self.assertEquals(
fetch_(NAME, from_(valid_registration_data)),
self.driver.find_text_box(NAME_TB).get_attribute('value'))
self.assertEquals(
fetch_(MOBILE_NUMBER, from_(valid_registration_data)),
self.driver.find_text_box(MOBILE_NUMBER_TB).get_attribute('value'))
self.assertEqual(
fetch_(COMMUNE, from_(valid_registration_data)),
self.driver.find_text_box(COMMUNE_TB).get_attribute('value'))
self.assertEqual(
fetch_(GPS, from_(valid_registration_data)),
self.driver.find_text_box(GPS_TB).get_attribute('value'))
def test_successful_addition_and_editing_of_data_sender(self):
add_data_sender_page = self.current_page
add_data_sender_page.enter_data_sender_details_from(VALID_DATA)
success_msg = add_data_sender_page.get_success_message()
self.assertIn(fetch_(SUCCESS_MSG, from_(VALID_DATA)), success_msg)
rep_id = self._parse(success_msg)
all_data_senders_page = AllDataSendersPage(self.driver)
all_data_senders_page.load()
all_data_senders_page.search_with(rep_id)
all_data_senders_page.select_a_data_sender_by_id(rep_id)
all_data_senders_page.select_edit_action()
self.current_page.enter_data_sender_details_from(VALID_EDIT_DATA)
self.assertRegexpMatches(self.current_page.get_success_message(),
fetch_(SUCCESS_MSG, from_(VALID_EDIT_DATA)))
def test_successful_dissociation_of_data_sender(self):
all_data_sender_page = self.page
if all_data_sender_page.get_project_names(
fetch_(UID, from_(ASSOCIATE_DATA_SENDER))) == "--":
self.associate(all_data_sender_page)
all_data_sender_page.select_a_data_sender_by_id(
fetch_(UID, from_(DISSOCIATE_DATA_SENDER)))
all_data_sender_page.dissociate_data_sender()
all_data_sender_page.select_project(
fetch_(PROJECT_NAME, from_(DISSOCIATE_DATA_SENDER)))
all_data_sender_page.click_confirm(wait=True)
self.assertEqual(
all_data_sender_page.get_project_names(
fetch_(UID, from_(DISSOCIATE_DATA_SENDER))), "--")
def test_successful_questionnaire_creation(self):
create_project_page = self.goto_dashboard().navigate_to_create_project_page()
create_project_page.create_project_with(CLINIC_PROJECT_DATA)
create_project_page.continue_create_project()
create_questionnaire_page = CreateQuestionnairePage(self.driver)
create_questionnaire_page.create_questionnaire_with(QUESTIONNAIRE_DATA_WITH_MANY_MC_QUSTIONS)
index = 3
for question in fetch_(QUESTIONS, from_(QUESTIONNAIRE_DATA_WITH_MANY_MC_QUSTIONS)):
question_link_text = fetch_(QUESTION, from_(question))
self.assertEquals(create_questionnaire_page.get_question_link_text(index), question_link_text)
index += 1
overview_page = create_questionnaire_page.save_and_create_project_successfully()
project_name = overview_page.get_project_title()
self.assertTrue(fetch_(PROJECT_NAME, from_(CLINIC_PROJECT_DATA)) in project_name)
def prerequisites_of_activate_account(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_confirmation_page, self.email = registration_page.successful_registration_with(REGISTRATION_DATA_FOR_SUCCESSFUL_REGISTRATION)
self.assertEquals(registration_confirmation_page.registration_success_message(),
fetch_(SUCCESS_MESSAGE, from_(REGISTRATION_DATA_FOR_SUCCESSFUL_REGISTRATION)))
return self.email
def test_register_ngo_with_existing_email_address(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_page.register_with(EXISTING_EMAIL_ADDRESS)
time.sleep(5)
self.assertEquals(registration_page.get_error_message(), fetch_(ERROR_MESSAGE,
from_(EXISTING_EMAIL_ADDRESS)))
def test_register_ngo_with_invalid_email_address(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_page.register_with(INVALID_EMAIL_FORMAT)
time.sleep(5)
self.assertEquals(registration_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(INVALID_EMAIL_FORMAT)))
def test_register_ngo_with_unmatched_passwords(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_page.register_with(UNMATCHED_PASSWORD)
time.sleep(5)
self.assertEquals(registration_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(UNMATCHED_PASSWORD)))
def test_login_without_entering_email_and_password(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
login_page.login_with(BLANK_CREDENTIALS)
self.assertEqual(login_page.get_error_message(), fetch_(ERROR_MESSAGE,
from_(BLANK_CREDENTIALS)))
def test_login_without_entering_email_address(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
login_page.login_with(BLANK_EMAIL_ADDRESS)
self.assertEqual(login_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(BLANK_EMAIL_ADDRESS)))
def test_login_with_invalid_format_email_address(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
login_page.login_with(INVALID_EMAIL_ID_FORMAT)
self.assertEqual(login_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(INVALID_EMAIL_ID_FORMAT)))
def test_login_with_unactivated_account_credentials(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
login_page.login_with(UNACTIVATED_ACCOUNT_CREDENTIALS)
self.assertEqual(login_page.get_error_message(),
fetch_(ERROR_MESSAGE,
from_(UNACTIVATED_ACCOUNT_CREDENTIALS)))
def test_login_with_valid_credentials(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
dashboard_page = login_page.do_successful_login_with(VALID_CREDENTIALS)
self.assertEqual(dashboard_page.welcome_message(),
fetch_(WELCOME_MESSAGE, from_(VALID_CREDENTIALS)))
def test_register_ngo_without_entering_data(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_page.register_with(WITHOUT_ENTERING_REQUIRED_FIELDS)
time.sleep(5)
self.assertEquals(registration_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(WITHOUT_ENTERING_REQUIRED_FIELDS)))
def test_register_ngo_with_invalid_web_url(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_page.register_with(INVALID_WEBSITE_URL)
time.sleep(5)
self.assertEquals(registration_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(INVALID_WEBSITE_URL)))
def test_login_with_invalid_password_credential(self):
self.driver.go_to(DATA_WINNER_LOGIN_PAGE)
login_page = LoginPage(self.driver)
login_page.login_with(INVALID_PASSWORD)
self.assertEqual(login_page.get_error_message(),
fetch_(ERROR_MESSAGE, from_(INVALID_PASSWORD)))
def test_registration_of_reporter_with_invalid_gps_with_comma(self):
"""
Function to test the registration of reporter with invalid GPS
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(INVALID_GPS_WITH_COMMA)
self.assertRegexpMatches(register_reporter_page.get_error_message(),
fetch_(ERROR_MSG, from_(INVALID_GPS_WITH_COMMA)))
def test_registration_of_reporter_with_unicode_in_gps(self):
"""
Function to test the registration of reporter with invalid GPS
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(WITH_UNICODE_IN_GPS)
self.assertRegexpMatches(register_reporter_page.get_error_message(),
fetch_(ERROR_MSG, from_(WITH_UNICODE_IN_GPS)))
def test_successful_registration(self):
self.driver.go_to(DATA_WINNER_REGISTER_PAGE)
registration_page = RegistrationPage(self.driver)
registration_confirmation_page, email = registration_page.successful_registration_with(REGISTRATION_DATA_FOR_SUCCESSFUL_REGISTRATION)
self.assertEquals(registration_confirmation_page.registration_success_message(),
fetch_(SUCCESS_MESSAGE,
from_(REGISTRATION_DATA_FOR_SUCCESSFUL_REGISTRATION)))
def test_sms_player_for_registration_of_existing_subject_short_code(self):
"""
Function to test the registration of the existing subject short code using sms submission with registered number
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(REGISTER_EXISTING_SUBJECT_SHORT_CODE)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(REGISTER_EXISTING_SUBJECT_SHORT_CODE)))
def test_successful_questionnaire_creation(self):
"""
Function to test the successful Creation of a Questionnaire with given details
"""
create_questionnaire_page = self.prerequisites_of_create_questionnaire()
create_questionnaire_page.create_questionnaire_with(QUESTIONNAIRE_DATA)
index = 2
for question in fetch_(QUESTIONS, from_(QUESTIONNAIRE_DATA)):
question_link_text = fetch_(QUESTION, from_(question)) + " " + fetch_(CODE, from_(question))
self.assertEquals(create_questionnaire_page.get_question_link_text(index), question_link_text)
index += 1
time.sleep(5)
self.assertEquals(create_questionnaire_page.get_remaining_character_count(),
fetch_(CHARACTER_REMAINING, from_(QUESTIONNAIRE_DATA)))
create_questionnaire_page.save_questionnaire()
time.sleep(3)
self.assertEqual(create_questionnaire_page.get_title(), "Data Senders")
def test_sms_player_for_registration_of_reporter_from_unknown_number(self):
"""
Function to test the registration of the reporter using sms submission with unregistered number
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(REGISTER_REPORTER_FROM_UNKNOWN_NUMBER)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(REGISTER_REPORTER_FROM_UNKNOWN_NUMBER)))
def test_sms_player_for_registration_of_new_subject(self):
"""
Function to test the registration of the new subject using sms submission with registered number
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(REGISTER_NEW_SUBJECT)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(SUCCESS_MESSAGE, from_(REGISTER_NEW_SUBJECT)))
def test_sms_player_for_unregistered_from_number(self):
"""
Function to test the error message on the sms submission page for unregistered number in from field
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(UNREGISTERED_FROM_NUMBER)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(UNREGISTERED_FROM_NUMBER)))
def test_sms_player_for_registration_of_reporter(self):
"""
Function to test the registration of the reporter using sms submission with registered number
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(REGISTER_REPORTER)
self.assertRegexpMatches(sms_tester_page.get_response_message(), fetch_(SUCCESS_MESSAGE, from_(REGISTER_REPORTER)))
def test_sms_player_for_exceeding_word_length(self):
"""
Function to test the error message on the sms submission page for exceeding word limit for word type question
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(EXCEED_NAME_LENGTH)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(EXCEED_NAME_LENGTH)))
def test_sms_player_for_plus_in_the_beginning(self):
"""
Function to test the error message on the sms submission page for plus sign in the beginning of SMS
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(PLUS_IN_THE_BEGINNING)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(PLUS_IN_THE_BEGINNING)))
def test_successful_sms_submission(self):
"""
Function to test the successful SMS submission
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(VALID_DATA)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(SUCCESS_MESSAGE, from_(VALID_DATA)))
def test_sms_player_without_entering_data(self):
"""
Function to test the error message on the sms submission page for blank field
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(BLANK_FIELDS)
self.assertEqual(sms_tester_page.get_error_message(), fetch_(ERROR_MSG, from_(BLANK_FIELDS)))
def test_sms_player_for_registration_with_invalid_geo_code(self):
"""
Function to test the registration of the new subject with invalid geo code using sms submission with registered number
"""
self.driver.go_to(DATA_WINNER_SMS_TESTER_PAGE)
sms_tester_page = SMSTesterPage(self.driver)
sms_tester_page.send_sms_with(REGISTER_INVALID_GEO_CODE)
self.assertEqual(sms_tester_page.get_response_message(), fetch_(ERROR_MSG, from_(REGISTER_INVALID_GEO_CODE)))
def test_registration_of_reporter_with_invalid_latitude_gps(self):
"""
Function to test the registration of reporter with invalid GPS
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(INVALID_LATITUDE_GPS)
self.assertRegexpMatches(register_reporter_page.get_error_message(),
fetch_(ERROR_MSG, from_(INVALID_LATITUDE_GPS)))
def test_registration_of_reporter_without_gps(self):
"""
Function to test the registration of reporter with invalid GPS
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(WITHOUT_GPS)
self.assertRegexpMatches(register_reporter_page.get_success_message(),
fetch_(SUCCESS_MSG, from_(WITHOUT_GPS)))
def test_registration_of_reporter_without_location_name(self):
"""
Function to test the registration of reporter without giving location name
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(WITHOUT_LOCATION_NAME)
self.assertRegexpMatches(register_reporter_page.get_success_message(),
fetch_(SUCCESS_MSG, from_(WITHOUT_LOCATION_NAME)))
def test_registration_of_reporter_without_entering_data(self):
"""
Function to test the registration of reporter without giving any data
"""
register_reporter_page = self.prerequisites_of_register_reporter()
register_reporter_page.register_with(BLANK_FIELDS)
time.sleep(5)
self.assertEqual(register_reporter_page.get_error_message(),
fetch_(ERROR_MSG, from_(BLANK_FIELDS)))
