class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
self.data_layer.connect_to_wifi()
result = self.loop.initial_test_checks()
if result:
self.loop.phone_login()
self.loop.allow_permission_phone_login()
self.UTILS.element.waitForElements(DOM.Loop.app_header, "Loop main view")
self.apps.kill_all()
time.sleep(2)
_ = setup_translations(self)
self.expected_message = _("No problem! Just share the following link and they can call you back from"\
" any browser.")
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
self.wait_for_element_displayed(*DOM.Loop.not_a_user_explanation, timeout=10)
not_a_user_explanation = self.marionette.find_element(*DOM.Loop.not_a_user_explanation)
self.UTILS.test.test(not_a_user_explanation.text == self.expected_message, "Message found: {} (Expected: {}".\
format(not_a_user_explanation.text, self.expected_message))
share_options = self.UTILS.element.getElements(DOM.Loop.share_link_options, "Sharing options")
self.UTILS.test.test(len(share_options) == 3, "There are {} sharing options (Expected: 3)".\
format(len(share_options)))
share_by_others = self.UTILS.element.getElement(DOM.Loop.share_panel_others_share, "Share by others")
share_by_others.tap()
self.marionette.switch_to_frame()
self.UTILS.element.getElement((DOM.Loop.share_others_header[0],
DOM.Loop.share_others_header[1].format(_("Share with:"))),
"Share with Header")
options = self.UTILS.element.getElements((DOM.Loop.share_others_options[0],
DOM.Loop.share_others_options[1].\
format(_("Share with:"))), "Options buttons")
self.UTILS.test.test(len(options) == 3, "There are {} options (Expected: 3)".format(len(options)))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Insert test contact
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
_ = setup_translations(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
self.marionette.switch_to_frame()
msg_dom = (DOM.Loop.connection_error_msg[0], DOM.Loop.connection_error_msg[1].format(_("connection failure")))
self.wait_for_element_displayed(*msg_dom,
timeout=15)
error_msg = self.marionette.find_element(*msg_dom)
self.UTILS.test.test(error_msg, "Error message due to connection failure was found")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the contact details.
self.contacts.view_contact(self.contact['name'])
# Edit the contact.
self.contacts.press_edit_contact_button()
# Check the items.
self.UTILS.element.waitForElements(DOM.Contacts.edit_update_button, "Edit 'upate' button")
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Final screenshot", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the contact details.
self.contacts.view_contact(self.contact['name'])
# Edit the contact.
self.contacts.press_edit_contact_button()
# Check the items.
self.UTILS.element.waitForElements(DOM.Contacts.edit_update_button,
"Edit 'upate' button")
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Final screenshot", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
# Remove the phone number from the contact and insert it.
self.test_contact = MockContact(tel={'type': '', 'value': ''})
self.UTILS.general.insertContact(self.test_contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Add a number and add it to an existing contact.
self.dialer.launch()
self.dialer.enterNumber(self.phone_number)
self.dialer.addThisNumberToContact(self.test_contact["name"])
self.UTILS.test.test(self.apps.displayed_app.name == self.dialer.app_name, "After adding number to contact we are taken back to Dialer")
# Verify that this contact has been modified in contacts.
self.apps.kill_all()
self.contacts.launch()
self.contacts.view_contact(self.test_contact["name"])
contact_phone_number = self.UTILS.element.getElement(DOM.Contacts.view_contact_tel_field, "Contact telephone number")
self.UTILS.test.test(self.phone_number in contact_phone_number.text, "Contact correctly updated with new phone number")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
audio_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("audio"))
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
self.UTILS.test.test(audio_btn, "Audio button present in contact")
self.UTILS.test.test(video_btn, "Video button present in contact")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.contact = MockContact()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
self.contacts.start_create_new_contact()
done_button = self.UTILS.element.getElement(DOM.Contacts.done_button, "Done button")
self.UTILS.test.test(not done_button.is_enabled(), "Done button is not enabled")
contFields = self.contacts.get_contact_fields()
"""
Put the contact details into each of the fields (this method
clears each field first).
"""
self.contacts.replace_str(contFields['tel'], self.contact["tel"]["value"])
done_button = self.UTILS.element.getElement(DOM.Contacts.done_button, "Done button")
self.UTILS.test.test(done_button.is_enabled(), "Done button is not enabled")
done_button.tap()
self.contacts.view_contact(self.contact["tel"]["value"])
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.phone_number2 = self.UTILS.general.get_config_variable("short_phone_number", "custom")
self.test_contact = MockContact(tel={'type': 'Mobile', 'value': self.phone_number2})
self.UTILS.general.insertContact(self.test_contact)
# Generate an entry in the call log
self.dialer.launch()
self.dialer.callLog_clearAll()
self.dialer.createMultipleCallLogEntries(self.phone_number, 1)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the call log and add to our contact.
self.dialer.callLog_addToContact(self.phone_number, self.test_contact["name"])
# Verify that this contact has been modified in contacts.
self.contacts.launch()
self.contacts.view_contact(self.test_contact["name"])
self.UTILS.element.waitForElements(("xpath", DOM.Contacts.view_contact_tels_xpath.format(self.phone_number)),
"Telephone number {} in contact".format(self.phone_number))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Search for our new contact.
self.contacts.view_contact(self.contact["name"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot of contact:", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Prepare the contact.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def toggle_fav(self, contact_name):
self.contacts.view_contact(contact_name)
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (before tap)")
fav_btn.tap()
self.contacts.go_back_from_contact_details()
def test_run(self):
self.contacts.launch()
# View the details of our contact and make him a favourite.
self.UTILS.reporting.logResult("info", "<b>Setting up a contact in favourites ...</b>")
self.toggle_fav(self.contact["name"])
self.UTILS.element.waitForElements(DOM.Contacts.favourites_section, "Favourites section")
self.UTILS.reporting.logResult("info", "<b>Removing contact from favourites ...</b>")
self.toggle_fav(self.contact['name'])
self.UTILS.element.waitForNotElements(DOM.Contacts.favourites_section, "Favourites section")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.dialer = Dialer(self)
# Get details of our test contacts.
self.test_contact = MockContact()
self.UTILS.general.insertContact(self.test_contact)
self.contact_name = self.test_contact["givenName"]
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.dialer.launch()
contacts_option_btn = self.UTILS.element.getElement(DOM.Dialer.option_bar_contacts, "Contacts option")
contacts_option_btn.tap()
self.UTILS.iframe.switchToFrame(*DOM.Dialer.contacts_sub_iframe, via_root_frame=False)
self.contacts.view_contact(self.contact_name, header_check=False)
phone_field = self.UTILS.element.getElement(DOM.Contacts.view_contact_tel_field, "Telephone number")
phone_field.tap()
# The call is tested.
self.UTILS.iframe.switchToFrame(*DOM.Dialer.frame_locator_calling)
self.UTILS.element.waitForElements(("xpath", DOM.Dialer.outgoing_call_numberXP.format(self.test_contact["name"])),
"Outgoing call found with number matching {}".format(self.test_contact["name"]))
self.dialer.hangUp()
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Import contact (adjust the correct number).
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
# Start a new SMS and add the message and contact name.
self.messages.startNewSMS()
self.messages.selectAddContactButton()
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.contact["givenName"], False)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.checkIsInToField(self.contact["name"], True)
# Remove it.
self.messages.removeContactFromToField(self.contact["name"])
# Verify the contact name is no longer present before removing it.
self.messages.checkIsInToField(self.contact["name"], False)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
self.data_layer.connect_to_wifi()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(
DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
header = self.marionette.find_element(*DOM.Loop.app_header)
self.UTILS.test.test(header, "Firefox Hello launched successfully")
class main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.loop = Loop(self)
self.contacts = Contacts(self)
self.connect_to_network()
self.loop.initial_test_checks()
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
self.apps.kill_all()
time.sleep(2)
_ = setup_translations(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
header = self.marionette.find_element(*DOM.Loop.app_header)
self.UTILS.test.test(header, "Firefox Hello launched successfully")
self.UTILS.iframe.switch_to_frame(*DOM.Loop.frame_locator)
phone_btn = self.marionette.find_element(*DOM.Loop.wizard_login_phone_number)
self.UTILS.test.test(phone_btn, "Login using phone number button present")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Get details of our test contacts.
self.contact = MockContact()
self.contact['tel'] = None
self.contact['email'] = None
self.UTILS.general.insertContact(self.contact)
self.data_layer.connect_to_wifi()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
self.wait_for_element_not_present(
DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("audio"),
timeout=5)
self.UTILS.reporting.info("No audio call button present, as expected")
self.wait_for_element_not_present(
DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"),
timeout=5)
self.UTILS.reporting.info("No video call button present, as expected")
class test_main(GaiaTestCase):
test_msg = "Test."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.contact = MockContact(givenName='AAAAAAAAAAAAAAAALEX',
familyName='SMITHXXXXXXXX',
name='AAAAAAAAAAAAAAAALEX SMITHXXXXXXXX',
tel={
'type': 'Mobile',
'value': self.phone_number
})
self.UTILS.general.insertContact(self.contact)
self.cp_incoming_number = self.UTILS.general.get_config_variable(
"sms_platform_numbers", "common").split(',')
self.data_layer.delete_all_sms()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
self.UTILS.messages.create_incoming_sms(self.contact["tel"]["value"],
self.test_msg)
self.UTILS.statusbar.wait_for_notification_toaster_detail(
self.test_msg, timeout=120)
title = self.UTILS.statusbar.wait_for_notification_toaster_with_titles(
self.cp_incoming_number, timeout=5)
self.UTILS.statusbar.click_on_notification_title(
title, DOM.Messages.frame_locator)
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"Send SMS button")
smsBTN.tap()
time.sleep(2)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.check_last_message_contents(self.test_msg)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Get details of our test contacts.
self.contact = MockContact(tel=[{
'type': 'Mobile',
'value': '11111111'
}, {
'type': 'Mobile',
'value': '222222222'
}])
"""
We're not testing adding a contact, so just stick one
into the database.
"""
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the 2nd sms button (index=1) in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(
("id", DOM.Contacts.sms_button_specific_id.format(0)),
"1st send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
time.sleep(2)
"""
test: this automatically opens the 'send SMS' screen, so
check the correct name is in the header of this sms.
"""
self.UTILS.element.headerCheck("1 recipient")
# Check this is the right number.
self.messages.checkIsInToField(self.contact["name"])
self.messages.checkNumberIsInToField(self.contact["tel"][0]["value"])
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
self.Contact_1 = MockContact()
self.num = self.UTILS.general.get_config_variable(
"phone_number", "custom")
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Enter a number in the dialer.
self.dialer.launch()
self.dialer.enterNumber(self.num)
# Press the add to contacts button, then select 'add to existing contact'.
x = self.UTILS.element.getElement(DOM.Dialer.add_to_contacts_button,
"Add to contacts button")
x.tap()
x = self.UTILS.element.getElement(DOM.Dialer.create_new_contact_btn,
"Create new contact button")
x.tap()
# Enter the details of the new contact.
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
contFields = self.contacts.get_contact_fields()
self.contacts.replace_str(contFields['givenName'],
self.Contact_1["givenName"])
self.contacts.replace_str(contFields['familyName'],
self.Contact_1["familyName"])
done_button = self.UTILS.element.getElement(DOM.Contacts.done_button,
"'Done' button")
done_button.tap()
# Verify that the contacts app is closed and we are returned to the call log.
self.marionette.switch_to_frame()
self.UTILS.element.waitForNotElements(("xpath", "//iframe[contains(@{}, '{}')]".\
format(DOM.Contacts.frame_locator[0], DOM.Contacts.frame_locator[1])),
"Contacts frame")
self.UTILS.iframe.switchToFrame(*DOM.Dialer.frame_locator)
# Verify that this contact has been created in contacts.
self.apps.kill_all()
self.contacts.launch()
self.contacts.view_contact(self.Contact_1["name"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info",
"Final screenshot and html dump:", x)
class test_main(GaiaTestCase):
test_msg = "Test."
def __init__(self, *args, **kwargs):
kwargs['restart'] = True
super(test_main, self).__init__(*args, **kwargs)
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
tlf = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact(tel={'type': 'Mobile', 'value': tlf})
self.UTILS.reporting.logComment("Using target telephone number " +
self.contact["tel"]["value"])
# Add this contact (quick'n'dirty method - we're just testing sms, no adding a contact).
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(2)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
# Create SMS.
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "frame", x)
self.messages.enterSMSMsg(self.test_msg)
# Click send.
self.messages.sendSMS()
class test_main(GaiaTestCase):
test_msg = "Test message."
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch messages app.
self.messages.launch()
# Create and send a new test message.
self.messages.create_and_send_sms([self.phone_number], "Test message.")
self.messages.wait_for_message()
# Tap the header to create a contact.
self.messages.header_addToContact()
# Select our contact.
self.contacts.view_contact(self.contact["givenName"], False)
# Check the phone number.
second_phone = self.UTILS.element.getElement(("id", "number_1"), "2nd phone number.")
self.UTILS.test.test(second_phone.get_attribute("value") == self.phone_number,
"Contact now has a 2nd number which is '{}' (it was '{}').".format(self.phone_number, second_phone.get_attribute("value")))
# Press the Done button.
done_btn = self.UTILS.element.getElement(DOM.Contacts.edit_update_button, "Update button")
done_btn.tap()
# Wait for contacts app to close and return to sms app.
self.marionette.switch_to_frame()
self.UTILS.element.waitForNotElements(("xpath", "//iframe[contains(@src, '{}')]".format(DOM.Contacts.frame_locator[1])),
"Contacts iframe")
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
# Verify the header is now the name,
header = self.UTILS.element.getElement(DOM.Messages.message_header, "Message header")
self.UTILS.test.test(header.text == self.contact["name"],
"Message header has been changed to match the contact (it was '{}').".format(header.text))
# Go back to the threads view and check the message name there too.
self.messages.go_back()
self.messages.openThread(self.contact["name"])
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Get details of our test contacts.
self.contact = MockContact(tel=[{'type': 'Mobile', 'value': '11111111'},
{'type': 'Mobile', 'value': '222222222'}])
"""
We're not testing adding a contact, so just stick one
into the database.
"""
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Select our contact.
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the 2nd sms button (index=1) in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(("id", DOM.Contacts.sms_button_specific_id.format(1)),
"2nd send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
time.sleep(3)
"""
test: this automatically opens the 'send SMS' screen, so
check the correct name is in the header of this sms.
"""
self.UTILS.element.headerCheck("1 recipient")
# Check this is the right number.
self.messages.checkIsInToField(self.contact["name"])
self.messages.checkNumberIsInToField(self.contact["tel"][1]["value"])
class test_main(GaiaTestCase):
add_fav_str = "Add as Favorite"
remove_fav_str = "Remove as Favorite"
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
# View the details of our contact and make him a favourite.
self.UTILS.reporting.logResult("info", "<b>Setting up a contact in favourites ...</b>")
self.contacts.view_contact(self.contact['name'])
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (before tap)")
self.UTILS.test.test(fav_btn.text == self.add_fav_str, "Toggle favourite button text is '{}'.".
format(self.add_fav_str))
fav_btn.tap()
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (after tap)")
self.UTILS.test.test(fav_btn.text == self.remove_fav_str, "Toggle favourite button text is '{}'.".
format(self.remove_fav_str))
self.contacts.go_back_from_contact_details()
string = self.contact['givenName'] + self.contact['familyName']
favs = ("xpath", DOM.Contacts.favourites_list_xpath.format(string.upper()))
self.UTILS.element.waitForElements(favs, "'" + self.contact['name'] + "' in the favourites list")
screenshot = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", screenshot)
self.UTILS.reporting.logResult("info", "<b>removing contact from favourites ...</b>")
self.contacts.view_contact(self.contact['name'])
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (before tap)")
self.UTILS.test.test(fav_btn.text == self.remove_fav_str, "Toggle favourite button text is '{}'.".
format(self.remove_fav_str))
fav_btn.tap()
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (after tap)")
self.UTILS.test.test(fav_btn.text == self.add_fav_str, "Toggle favourite button text is '{}'.".
format(self.add_fav_str))
self.contacts.go_back_from_contact_details()
time.sleep(1)
string = self.contact['givenName'] + " " + self.contact['familyName']
favs = ("xpath", DOM.Contacts.favourites_list_xpath.format(string.upper()))
self.UTILS.element.waitForNotElements(favs, "'" + self.contact['name'] + "' in the favourites list")
class test_main(GaiaTestCase):
test_msg = "Test."
def __init__(self, *args, **kwargs):
kwargs['restart'] = True
super(test_main, self).__init__(*args, **kwargs)
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
tlf = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact(tel={'type': 'Mobile', 'value': tlf})
self.UTILS.reporting.logComment("Using target telephone number " + self.contact["tel"]["value"])
# Add this contact (quick'n'dirty method - we're just testing sms, no adding a contact).
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button, "Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(2)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
# Create SMS.
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "frame", x)
self.messages.enterSMSMsg(self.test_msg)
# Click send.
self.messages.sendSMS()
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
# View the contact details.
self.contacts.view_contact(self.contact['name'])
# Press the favourites button.
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Favourite toggle button")
fav_btn.tap()
# Go back to view all contacts and check this contact is listed in the
# 'favourites' section.
self.contacts.go_back_from_contact_details()
# Check our test contact is listed in the group favourites.
string = self.contact['givenName'] + self.contact['familyName']
favs = ("xpath", DOM.Contacts.favourites_list_xpath.format(string.upper()))
self.UTILS.element.waitForElements(favs, "'" + self.contact['name'] + "' in the favourites list")
# View the contact.
self.UTILS.reporting.logResult("info", "*** Removing contact as a favourite ... ***")
self.contacts.view_contact(self.contact['name'])
# Press the favourites button.
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Favourite toggle button")
self.UTILS.test.test(fav_btn.text == "Remove as Favorite",
"Favourite toggle button says 'Remove as Favorite' before contact is removed as a favorite.")
fav_btn.tap()
time.sleep(2)
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Favourite toggle button")
self.UTILS.test.test(fav_btn.text == "Add as Favorite",
"Favourite toggle button says 'Add as Favorite' after contact is removed as a favorite.")
# Go back to view all contacts and check this contact is listed in the
# 'favourites' section.
self.contacts.go_back_from_contact_details()
# Check our test contact is no longer listed in the group favourites.
string = self.contact['givenName'] + self.contact['familyName']
favs = ("xpath", DOM.Contacts.favourites_list_xpath.format(string.upper()))
self.UTILS.element.waitForNotElements(favs, "'" + self.contact['name'] + "' in the favourites list")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Get details of our test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
self.data_layer.connect_to_wifi()
result = self.loop.initial_test_checks()
if result:
self.loop.phone_login()
self.loop.allow_permission_phone_login()
self.UTILS.element.waitForElements(DOM.Loop.app_header, "Loop main view")
self.apps.kill_all()
time.sleep(2)
_ = setup_translations(self)
self.expected_message = _("No problem! Just share the following link and they can call you back from"\
" any browser.")
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
self.wait_for_element_displayed(*DOM.Loop.not_a_user_explanation, timeout=10)
not_a_user_explanation = self.marionette.find_element(*DOM.Loop.not_a_user_explanation)
self.UTILS.test.test(not_a_user_explanation.text == self.expected_message, "Message found: {} (Expected: {}".\
format(not_a_user_explanation.text, self.expected_message))
share_options = self.UTILS.element.getElements(DOM.Loop.share_link_options, "Sharing options")
self.UTILS.test.test(len(share_options) == 3, "There are {} sharing options (Expected: 3)".\
format(len(share_options)))
share_by_sms = self.UTILS.element.getElement(DOM.Loop.share_panel_sms_share, "Share by SMS")
share_by_sms.tap()
self.UTILS.iframe.switch_to_frame(*DOM.Messages.frame_locator)
self.UTILS.element.getElement(DOM.Messages.target_numbers, "Message recipients")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.loop = Loop(self)
# Get details of our test contacts.
self.contact = MockContact()
curr_time = repr(time.time()).replace('.', '')
self.contact['email'] = [self.contact['email']]
self.contact['tel'] = [self.contact['tel']]
self.contact['email'].append({
'type': 'Job',
'value': '{}@testmail.net'.format(curr_time)})
self.contact['tel'].append({
'type': 'Landline',
'value': '91{}'.format(curr_time)})
self.UTILS.general.insertContact(self.contact)
self.data_layer.connect_to_wifi()
self.loop.initial_test_checks()
result = self.loop.wizard_or_login()
if result:
self.loop.phone_login()
self.loop.allow_permission_phone_login()
self.UTILS.element.waitForElements(DOM.Loop.app_header, "Loop main view")
self.apps.kill_all()
time.sleep(2)
_ = setup_translations(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.view_contact(self.contact['name'])
video_btn = self.marionette.find_element(DOM.Contacts.view_contact_hello_option[0],
DOM.Contacts.view_contact_hello_option[1].format("video"))
video_btn.tap()
self.loop.share_micro_and_camera()
not_user_str = _("Not a Firefox Hello user yet")
not_user_dom = (DOM.Loop.not_a_hello_user_msg[0], DOM.Loop.not_a_hello_user_msg[1].format(not_user_str))
self.wait_for_element_displayed(*not_user_dom, timeout=10)
not_a_user_msg = self.marionette.find_element(*not_user_dom)
self.UTILS.test.test(not_a_user_msg.text == not_user_str, "Message found: {} (Expected: {}".\
format(not_a_user_msg.text, not_user_str))
class test_main(GaiaTestCase):
test_msg = "Test message."
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.email_address = self.UTILS.general.get_config_variable("gmail_1_email", "common")
self.test_contact = MockContact(email=[{"type": "Personal", "value": "*****@*****.**"},
{"type": "Personal", "value": "*****@*****.**"},
{"type": "Personal", "value": "*****@*****.**"}])
self.UTILS.general.insertContact(self.test_contact)
self.UTILS.general.add_file_to_device('./tests/_resources/contact_face.jpg')
self.data_layer.delete_all_sms()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
self.messages.create_and_send_sms([self.phone_number], "Hello {} old bean.".format(self.email_address))
send_time = self.messages.last_sent_message_timestamp()
msg = self.messages.wait_for_message(send_time=send_time)
# Press the email link.
link = msg.find_element("tag name", "a")
link.tap()
add_btn = self.UTILS.element.getElement(DOM.Messages.header_add_to_contact_btn, "Add to an existing contact button")
add_btn.tap()
# Verify that the email is in the email field.
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.test_contact["givenName"], False)
self.UTILS.element.waitForElements(("xpath",
"//input[@type='email' and @value='{}']".format(self.email_address)),
"New email address")
self.contacts.add_gallery_image_to_contact(0)
done_button = self.UTILS.element.getElement(DOM.Contacts.edit_update_button, "'Update' button")
done_button.tap()
# Check that the contacts iframe is now gone.
self.marionette.switch_to_frame()
self.UTILS.element.waitForNotElements(("xpath", "//iframe[contains(@src,'contacts')]"),
"Contact app iframe")
class test_main(GaiaTestCase):
test_msg = "Test."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
# Put the phone into airplane mode.
self.data_layer.set_setting('airplaneMode.enabled', True)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.contact = MockContact(tel={
'type': '',
'value': self.phone_number
})
self.UTILS.general.insertContact(self.contact)
self.UTILS.reporting.logComment("Using target telephone number " +
self.contact["tel"]["value"])
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open sms app and delete every thread to start a new one
self.contacts.launch()
self.contacts.view_contact(self.contact["name"])
x = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"SMS button")
x.tap()
time.sleep(2)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
# Create SMS.
self.messages.enterSMSMsg(self.test_msg)
# Click send.
self.messages.sendSMS()
time.sleep(3)
# Check that popup appears.
self.messages.checkAirplaneModeWarning()
class test_main(GaiaTestCase):
test_msg = "Test."
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
self.target_mms_number = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.contact_1 = MockContact(tel={
'type': 'Mobile',
'value': self.target_mms_number
})
self.UTILS.reporting.logComment("Using target telephone number " +
self.contact_1["tel"]["value"])
self.UTILS.general.insertContact(self.contact_1)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
self.contacts.view_contact(self.contact_1['name'])
# Tap the sms button in the view details screen to go to the sms page.
sms_button = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"Send SMS button")
sms_button.tap()
self.apps.switch_to_displayed_app()
time.sleep(10)
self.wait_for_condition(
lambda m: m.find_element(*DOM.Messages.target_numbers
).text == self.contact_1['name'],
timeout=10,
message="To field is already prepulated with our contact info")
# Create SMS.
self.messages.enterSMSMsg(self.test_msg)
self.messages.sendSMS()
# Wait for the last message in this thread to be a 'received' one.
self.UTILS.statusbar.wait_for_notification_toaster_detail(
self.test_msg, timeout=120)
self.UTILS.statusbar.click_on_notification_detail(
self.test_msg, DOM.Messages.frame_locator)
self.messages.check_last_message_contents(self.test_msg)
class test_main(GaiaTestCase):
def __init__(self, *args, **kwargs):
kwargs['restart'] = True
super(test_main, self).__init__(*args, **kwargs)
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.facebook = Facebook(self)
self.fb_user = self.UTILS.general.get_config_variable("gmail_1_email", "common")
self.fb_pass = self.UTILS.general.get_config_variable("gmail_1_pass", "common")
self.fb_email = self.UTILS.general.get_config_variable("gmail_2_email", "common")
self.test_contact = MockContact()
self.UTILS.general.insertContact(self.test_contact)
self.connect_to_network()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
self.contacts.tapSettingsButton()
self.contacts.enable_FB_import()
self.facebook.login(self.fb_user, self.fb_pass)
# Import all
self.contacts.switch_to_facebook()
self.facebook.importAll()
# Go back to "All contacts" screen
back_btn = self.UTILS.element.getElement(DOM.Contacts.settings_done_button, "Details 'done' button")
back_btn.tap()
# View the contact details.
self.contacts.view_contact(self.test_contact['givenName'])
# Press the link button.
self.contacts.tapLinkContact()
# Select the contact to link.
self.facebook.link_contact(self.fb_email)
# Check we're back at our contact.
self.UTILS.element.headerCheck(self.test_contact['name'])
# Verify that we're now linked.
self.contacts.verify_linked(self.test_contact['givenName'], self.fb_email)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Prepare the contacts.
self.contact_list = [MockContact() for i in range(3)]
map(self.UTILS.general.insertContact, self.contact_list)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
# View the details of our contact and make him a favourite.
self.UTILS.reporting.logResult("info", "<b>Setting up a contact in favourites ...</b>")
self.contacts.view_contact(self.contact_list[0]['name'])
# Mark contact as favourite
fav_btn = self.UTILS.element.getElement(DOM.Contacts.favourite_button, "Toggle favourite button (before tap)")
fav_btn.tap()
# Go back to all contacts list
self.contacts.go_back_from_contact_details()
# Check the contact is in the favourite list
string = self.contact_list[0]['givenName'] + self.contact_list[0]['familyName']
favs = ("xpath", DOM.Contacts.favourites_list_xpath.format(string.upper()))
self.UTILS.element.waitForElements(favs, "'" + self.contact_list[0]['name'] + "' in the favourites list")
# Now check the favourites list appears first.
fav_list = self.UTILS.element.getElements(("tag name", "ol"), "Contact lists")
fav_id = "contacts-list-favorites"
normal_ids = "contacts-list-"
foundFav = False
foundNormal = False
for i in fav_list:
if fav_id in i.get_attribute("id"):
foundFav = True
if normal_ids in i.get_attribute("id"):
foundNormal = True
break
self.UTILS.test.test(foundNormal, "Found the non-favourite lists.")
self.UTILS.test.test(foundFav, "Found the favourite lists before the non-favourite lists.")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
self.Contact_1 = MockContact()
self.num = self.UTILS.general.get_config_variable("phone_number", "custom")
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Enter a number in the dialer.
self.dialer.launch()
self.dialer.enterNumber(self.num)
# Press the add to contacts button, then select 'add to existing contact'.
x = self.UTILS.element.getElement(DOM.Dialer.add_to_contacts_button, "Add to contacts button")
x.tap()
x = self.UTILS.element.getElement(DOM.Dialer.create_new_contact_btn, "Create new contact button")
x.tap()
# Enter the details of the new contact.
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
contFields = self.contacts.get_contact_fields()
self.contacts.replace_str(contFields['givenName'], self.Contact_1["givenName"])
self.contacts.replace_str(contFields['familyName'], self.Contact_1["familyName"])
done_button = self.UTILS.element.getElement(DOM.Contacts.done_button, "'Done' button")
done_button.tap()
# Verify that the contacts app is closed and we are returned to the call log.
self.marionette.switch_to_frame()
self.UTILS.element.waitForNotElements(("xpath", "//iframe[contains(@{}, '{}')]".\
format(DOM.Contacts.frame_locator[0], DOM.Contacts.frame_locator[1])),
"Contacts frame")
self.UTILS.iframe.switchToFrame(*DOM.Dialer.frame_locator)
# Verify that this contact has been created in contacts.
self.apps.kill_all()
self.contacts.launch()
self.contacts.view_contact(self.Contact_1["name"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Final screenshot and html dump:", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
self.Dialer = Dialer(self)
phone_number = self.UTILS.general.get_config_variable(
"phone_number", "custom")
prefix = "0034"
self.num1 = prefix + phone_number if not phone_number.startswith(
"+34") else prefix + phone_number[3:]
self.num2 = phone_number[3:] if phone_number.startswith(
"+34") else phone_number
self.contact = MockContact(tel={'type': 'Mobile', 'value': self.num1})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
# Create and send a new test message to this contact.
self.messages.startNewSMS()
self.messages.selectAddContactButton()
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.contact["givenName"], False)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.checkIsInToField(self.contact["name"], True)
self.messages.enterSMSMsg("Test message.")
self.messages.sendSMS()
self.messages.wait_for_message()
# Tap the header to call.
self.messages.header_call()
# Dialler is started with the number already filled in.
phone_field = self.UTILS.element.getElement(DOM.Dialer.phone_number,
"Phone number")
self.UTILS.test.test(
self.num2 in phone_field.get_attribute("value"),
"The phone number contains '{}' (it was '{}').".format(
self.num1, phone_field.get_attribute("value")))
class test_main(GaiaTestCase):
test_msg = "Test."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact(givenName='AAAAAAAAAAAAAAAALEX',
familyName='SMITHXXXXXXXX',
name='AAAAAAAAAAAAAAAALEX SMITHXXXXXXXX',
tel={'type': 'Mobile', 'value': self.phone_number})
self.UTILS.general.insertContact(self.contact)
self.cp_incoming_number = self.UTILS.general.get_config_variable("sms_platform_numbers", "common").split(',')
self.data_layer.delete_all_sms()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
self.UTILS.messages.create_incoming_sms(self.contact["tel"]["value"], self.test_msg)
self.UTILS.statusbar.wait_for_notification_toaster_detail(self.test_msg, timeout=120)
title = self.UTILS.statusbar.wait_for_notification_toaster_with_titles(self.cp_incoming_number, timeout=5)
self.UTILS.statusbar.click_on_notification_title(title, DOM.Messages.frame_locator)
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button, "Send SMS button")
smsBTN.tap()
time.sleep(2)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.check_last_message_contents(self.test_msg)
class test_main(GaiaTestCase):
def __init__(self, *args, **kwargs):
kwargs['restart'] = True
super(test_main, self).__init__(*args, **kwargs)
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.test_contacts = [MockContact() for i in range(2)]
map(self.UTILS.general.insertContact, self.test_contacts)
self.contact_name = self.test_contacts[0]["givenName"]
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Go to the view details screen for this contact.
self.contacts.view_contact(self.contact_name, header_check=False)
# Tap the Send an email button.
sendEmail = self.UTILS.element.getElement(DOM.Contacts.view_contact_email_field, "Send email button")
sendEmail.tap()
self.UTILS.iframe.switchToFrame(*DOM.Email.frame_locator)
time.sleep(3)
# Verify a dialog appears indicating that we do not have any mail accounts configured.
x = self.UTILS.element.getElement(DOM.Email.confirm_msg,
"Dialog confirmation message", True, 10, False)
msg = "You are not set up to send or receive email. Would you like to do that now?"
self.UTILS.test.test(msg == x.text, "Verifying confirmation msg")
# Tap Ok button for confirmation.
x = self.UTILS.element.getElement(DOM.Email.confirm_ok, "OK button", True, 5, False)
x.tap()
class test_main(GaiaTestCase):
test_msg = "Test text - please ignore."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.contact = MockContact(tel={
'type': 'Mobile',
'value': self.phone_number
})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(5)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.UTILS.element.headerCheck("1 recipient")
self.messages.checkIsInToField(self.contact['name'])
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
_ = setup_translations(self)
self.contact_1 = MockContact()
self.phone_number = "0034" + self.UTILS.general.get_config_variable("target_call_number", "common")
# Generate an entry in the call log
self.dialer.launch()
self.dialer.callLog_clearAll()
self.dialer.createMultipleCallLogEntries(self.phone_number, 1)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the call log and create a contact for our number.
self.dialer.callLog_createContact(self.phone_number)
contFields = self.contacts.get_contact_fields()
self.contacts.replace_str(contFields['givenName'], self.contact_1["givenName"])
self.contacts.replace_str(contFields['familyName'], self.contact_1["familyName"])
done_button = self.UTILS.element.getElement(DOM.Contacts.done_button, "'Done' button")
done_button.tap()
# Verify that the contacts app is closed and we are returned to the call log.
self.marionette.switch_to_frame()
self.UTILS.element.waitForNotElements(("xpath", "//iframe[contains(@{}, '{}')]".
format(DOM.Contacts.frame_locator[0], DOM.Contacts.frame_locator[1])),
"Contacts frame")
self.UTILS.iframe.switchToFrame(*DOM.Dialer.frame_locator)
header = ('xpath', DOM.GLOBAL.app_head_specific.format(_("Call log")))
self.UTILS.element.waitForElements(header, "Call log header")
# Verify that this contact has been created in contacts.
self.apps.kill_all()
self.contacts.launch()
self.contacts.view_contact(self.contact_1["name"])
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Prepare the contact.
self.contact = MockContact()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.start_create_new_contact()
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
x = self.UTILS.element.getElement(DOM.Contacts.done_button,
"Done button")
self.UTILS.test.test(not x.is_enabled(), "Done button is not enabled")
contFields = self.contacts.get_contact_fields()
"""
Put the contact details into each of the fields (this method
clears each field first).
"""
self.contacts.replace_str(contFields['givenName'],
self.contact["givenName"])
self.contacts.replace_str(contFields['familyName'],
self.contact["familyName"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
x = self.UTILS.element.getElement(DOM.Contacts.done_button,
"Done button")
self.UTILS.test.test(x.is_enabled(), "Done button is not enabled")
x.tap()
self.contacts.view_contact(self.contact["name"])
class test_main(GaiaTestCase):
test_msg = "Test message."
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
self.Dialer = Dialer(self)
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom").split("+34")[-1]
self.contact = MockContact(tel={'type': 'Mobile', 'value': self.phone_number})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
# Create and send a new test message.
self.messages.startNewSMS()
self.messages.selectAddContactButton()
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.contact["givenName"], False)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.checkIsInToField(self.contact["name"], True)
self.messages.enterSMSMsg("Test message.")
self.messages.sendSMS()
send_time = self.messages.last_sent_message_timestamp()
self.messages.wait_for_message(send_time=send_time)
# Tap the header to call.
self.messages.header_call()
# Dialer is started with the number already filled in.
time.sleep(2)
phone_field = self.UTILS.element.getElement(DOM.Dialer.phone_number, "Phone number field", False)
dialer_num = phone_field.get_attribute("value")
self.UTILS.test.test(self.phone_number == dialer_num,
"The phone is '{}' (expected '{}').".\
format(dialer_num, self.phone_number))
class test_main(GaiaTestCase):
test_msg = "Test."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
# Put the phone into airplane mode.
self.data_layer.set_setting('airplaneMode.enabled', True)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact(tel={'type': '', 'value': self.phone_number})
self.UTILS.general.insertContact(self.contact)
self.UTILS.reporting.logComment("Using target telephone number " + self.contact["tel"]["value"])
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open sms app and delete every thread to start a new one
self.contacts.launch()
self.contacts.view_contact(self.contact["name"])
x = self.UTILS.element.getElement(DOM.Contacts.sms_button, "SMS button")
x.tap()
time.sleep(2)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
# Create SMS.
self.messages.enterSMSMsg(self.test_msg)
# Click send.
self.messages.sendSMS()
time.sleep(3)
# Check that popup appears.
self.messages.checkAirplaneModeWarning()
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.messages = Messages(self)
self.contacts = Contacts(self)
self.Dialer = Dialer(self)
phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
prefix = "0034"
self.num1 = prefix + phone_number if not phone_number.startswith("+34") else prefix + phone_number[3:]
self.num2 = phone_number[3:] if phone_number.startswith("+34") else phone_number
self.contact = MockContact(tel={'type': 'Mobile', 'value': self.num1})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.messages.launch()
# Create and send a new test message to this contact.
self.messages.startNewSMS()
self.messages.selectAddContactButton()
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.contact["givenName"], False)
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.messages.checkIsInToField(self.contact["name"], True)
self.messages.enterSMSMsg("Test message.")
self.messages.sendSMS()
self.messages.wait_for_message()
# Tap the header to call.
self.messages.header_call()
# Dialler is started with the number already filled in.
phone_field = self.UTILS.element.getElement(DOM.Dialer.phone_number, "Phone number")
self.UTILS.test.test(self.num2 in phone_field.get_attribute("value"),
"The phone number contains '{}' (it was '{}').".format(self.num1, phone_field.get_attribute("value")))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Get details of our test contacts.
self.contact = MockContact(tel=[{
'type': 'Mobile',
'value': '555555555'
}, {
'type': 'Mobile',
'value': '666666666'
}])
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Search for our new contact.
self.contacts.view_contact(self.contact["name"])
tel_counter = len(self.contact["tel"])
for i in range(tel_counter):
x = self.UTILS.element.getElement(("xpath", DOM.Contacts.view_contact_tels_xpath.\
format(self.contact["tel"][i]["value"])),
"Telephone number button for {}".format(self.contact["tel"][i]["value"]))
self.UTILS.test.test(self.contact["tel"][i]["value"] in x.text,
"Phone number '{}' matches the expacted value ('{}')".\
format(x.text, self.contact["tel"][i]["value"]))
self.UTILS.element.waitForElements(
("id", DOM.Contacts.sms_button_specific_id.format(i)),
"Send SMS button for {}".format(
self.contact["tel"][i]["value"]))
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot of contact:", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Prepare the contact.
self.contact = MockContact()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
self.contacts.start_create_new_contact()
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
x = self.UTILS.element.getElement(DOM.Contacts.done_button, "Done button")
self.UTILS.test.test(not x.is_enabled(), "Done button is not enabled")
contFields = self.contacts.get_contact_fields()
"""
Put the contact details into each of the fields (this method
clears each field first).
"""
self.contacts.replace_str(contFields['givenName'], self.contact["givenName"])
self.contacts.replace_str(contFields['familyName'], self.contact["familyName"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
x = self.UTILS.element.getElement(DOM.Contacts.done_button, "Done button")
self.UTILS.test.test(x.is_enabled(), "Done button is not enabled")
x.tap()
self.contacts.view_contact(self.contact["name"])
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.test_contact = MockContact()
self.UTILS.general.insertContact(self.test_contact)
self.email_1 = "*****@*****.**"
self.email_2 = "*****@*****.**"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.contacts.launch()
self.contacts.view_contact(self.test_contact['name'])
self.contacts.press_edit_contact_button()
# Count the current email addresses.
orig_count = self.contacts.count_email_addresses_while_editing()
# Add a few email addresses.
self.contacts.add_another_email_address(self.email_1)
self.contacts.add_another_email_address(self.email_2)
# Get the new count and check it's been updated
new_count = self.contacts.count_email_addresses_while_editing()
self.UTILS.test.test(new_count == orig_count + 2,
"After adding two email, there are three")
update_btn = self.UTILS.element.getElement(DOM.Contacts.edit_update_button, "Update button")
update_btn.tap()
self.contacts.go_back_from_contact_details()
self.contacts.view_contact(self.test_contact['name'])
# Count the email fields.
emails_elements = self.UTILS.element.getElements(DOM.Contacts.email_address_list, "Email addresses")
emails = [elem.find_element(*('css selector', 'button b')).text for elem in emails_elements]
self.UTILS.test.test(self.email_1 in emails, "Email 1 has been saved")
self.UTILS.test.test(self.email_2 in emails, "Email 2 has been saved")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.dialer = Dialer(self)
# Get details of our test contacts.
self.contact = MockContact(tel={
'type': 'Mobile',
'value': '+345555555555'
})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Search for our new contact.
self.contacts.view_contact(self.contact["name"])
# Tap the phone number.
x = self.UTILS.element.getElement(DOM.Contacts.view_contact_tel_field,
"Telephone number")
x.tap()
# Switch to dialer.
self.UTILS.iframe.switchToFrame(*DOM.Dialer.frame_locator_calling)
self.UTILS.element.waitForElements(
("xpath",
DOM.Dialer.outgoing_call_numberXP.format(self.contact["name"])),
"Outgoing call found with number matching {}".format(
self.contact["name"]))
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot of contact:", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Prepare the contact.
self.contact = MockContact()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# Create the contact.
self.contacts.start_create_new_contact()
contFields = self.contacts.get_contact_fields()
self.contacts.replace_str(contFields['givenName'],
self.contact["givenName"])
self.contacts.replace_str(contFields['familyName'],
self.contact["familyName"])
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
x = self.UTILS.element.getElement(DOM.Contacts.done_button,
"Done button")
x.tap()
self.contacts.view_contact(self.contact["name"])
time.sleep(1)
self.UTILS.element.waitForNotElements(("xpath", "//h2[text()='Home']"),
"'Home' section.")
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Screenshot at this point", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button, "Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(2)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
"""
test: this automatically opens the 'send SMS' screen, so
check the correct name is in the 'to' field of this sms.
"""
self.messages.checkIsInToField(self.contact['name'])
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button,
"Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(2)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
"""
test: this automatically opens the 'send SMS' screen, so
check the correct name is in the 'to' field of this sms.
"""
self.messages.checkIsInToField(self.contact['name'])
class test_main(GaiaTestCase):
test_msg = "Test text - please ignore."
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.messages = Messages(self)
# Prepare the contact we're going to insert.
self.phone_number = self.UTILS.general.get_config_variable("phone_number", "custom")
self.contact = MockContact(tel={'type': 'Mobile', 'value': self.phone_number})
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View the details of our contact.
self.contacts.view_contact(self.contact['name'])
# Tap the sms button in the view details screen to go to the sms page.
smsBTN = self.UTILS.element.getElement(DOM.Contacts.sms_button, "Send SMS button")
smsBTN.tap()
"""
Switch to the 'Messages' app frame (or marionette will still be watching the
'Contacts' app!).
"""
time.sleep(5)
self.marionette.switch_to_frame()
self.UTILS.iframe.switchToFrame(*DOM.Messages.frame_locator)
self.UTILS.element.headerCheck("1 recipient")
self.messages.checkIsInToField(self.contact['name'])
class test_main(GaiaTestCase):
_testNum = "123456789"
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.dialer = Dialer(self)
self.contacts = Contacts(self)
self.test_contact = MockContact(tel={'type': 'Mobile', 'value': '111111111'})
self.UTILS.general.insertContact(self.test_contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.dialer.launch()
self.dialer.enterNumber(self._testNum)
# Press the add to contacts button, then select 'add to existing contact'.
x = self.UTILS.element.getElement(DOM.Dialer.add_to_contacts_button, "Add to contacts button")
x.tap()
x = self.UTILS.element.getElement(DOM.Dialer.add_to_existing_contact_btn, "Add to existing contact button")
x.tap()
self.UTILS.iframe.switchToFrame(*DOM.Contacts.frame_locator)
self.contacts.view_contact(self.test_contact["givenName"], header_check=False)
x = self.UTILS.element.getElement(("name", "tel[0][value]"), "Phone number 1")
self.UTILS.test.test(x.get_attribute("value") == self.test_contact["tel"]["value"],
"1st number is {} (it was {}).".format(self.test_contact["tel"]["value"],
x.get_attribute("value")))
x = self.UTILS.element.getElement(("name", "tel[1][value]"), "Phone number 2")
self.UTILS.test.test(x.get_attribute("value") == self._testNum,
"2nd number is {} (it was {}).".format(self._testNum, x.get_attribute("value")))
x = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Final screenshot:", x)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
self.dialer = Dialer(self)
# Get details of our test contacts.
self.Contact_1 = MockContact()
self.UTILS.general.insertContact(self.Contact_1)
_ = setup_translations(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.toggleViaStatusBar("airplane")
# Launch contacts app.
self.contacts.launch()
# Search for our new contact.
self.contacts.view_contact(self.Contact_1["name"])
# Tap the phone number.
phone_field = self.UTILS.element.getElement(DOM.Contacts.view_contact_tel_field, "Telephone number")
phone_field.tap()
# Switch to dialer.
warning_header = (DOM.GLOBAL.confirmation_msg_header[0],
DOM.GLOBAL.confirmation_msg_header[1].format(_("Airplane mode activated")))
self.UTILS.element.getElement(warning_header, "Airplane mode warning [header]")
ok_btn = self.UTILS.element.getElement(DOM.GLOBAL.confirmation_msg_ok_btn, "OK button")
ok_btn.tap()
self.UTILS.element.waitForElements(DOM.Contacts.view_details_title, "Contact details")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.contacts = Contacts(self)
# Create test contacts.
self.contact = MockContact()
self.UTILS.general.insertContact(self.contact)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Launch contacts app.
self.contacts.launch()
# View our contact.
self.contacts.view_contact(self.contact['name'])
# Edit our contact.
self.contacts.press_edit_contact_button()
# Delete our contact.
self.contacts.press_delete_contact_button()
# Cancel deletion.
cancel_deletion = self.UTILS.element.getElement(
DOM.Contacts.cancel_delete_btn, "Cancel button")
cancel_deletion.tap()
# Cancel contact edition
self.contacts.press_cancel_edit_button()
# Go back to contacts start page
self.contacts.go_back_from_contact_details()
# Now actually delete our contact.
self.contacts.delete_contact(self.contact['name'])
