def prepare_app(self):
picture_count = 100
self.device.b2gpopulate.populate_pictures(picture_count)
# launch the gallery app and wait for the thumbnails to be displayed,
# the first launch after populating the data takes a long time.
gallery = Gallery(self.device.marionette)
gallery.app = self.device.gaiaApps.launch('Gallery')
time.sleep(5)
timeout = 200
starttime = time.time()
while (time.time() - starttime) < timeout:
try:
items = self.device.marionette.find_elements(
*gallery._gallery_items_locator)
progress = self.device.marionette.find_element(
*gallery._progress_bar_locator)
if len(items) == picture_count and not progress.is_displayed():
break
except (NoSuchElementException, StaleElementException):
pass
time.sleep(0.5)
else:
raise TimeoutException('Gallery items not displayed')
self.device.gaiaApps.kill(gallery.app)
def tap_confirm_deletion_button(self):
self.marionette.find_element(*self._confirm_delete_locator).tap()
self.wait_for_element_not_displayed(*self._confirm_delete_locator)
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
gallery.launch()
return gallery
class TestCardsViewTwoApps(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.cards_view = CardsView(self.marionette)
self.clock = Clock(self.marionette)
self.clock.launch()
self.gallery = Gallery(self.marionette)
self.gallery.launch(empty=True)
def test_kill_app_from_cards_view(self):
"""https://moztrap.mozilla.org/manage/case/1917/"""
# Pull up the cards view
self.device.hold_home_button()
self.cards_view.wait_for_cards_view()
# Wait for first app ready
self.cards_view.cards[1].wait_for_centered()
self.assertIn(self.cards_view.cards[1].manifest_url, self.gallery.manifest_url)
# Close the current apps from the cards view
self.cards_view.cards[1].close()
self.cards_view.cards[0].close()
# If successfully killed, the apps should no longer appear in the cards view and the "No recent apps" message should be displayed
self.assertEqual(len(self.cards_view.cards), 0, 'Should have no cards to display')
def test_gallery_crop_photo(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
image = gallery.tap_first_gallery_item()
initial_scale = image.current_scale
# Tap on Edit button.
edit_image = image.tap_edit_button()
edit_image.tap_edit_crop_button()
edit_image.tap_portrait_crop()
gallery = edit_image.tap_edit_save_button()
gallery.wait_for_files_to_load(2)
# Verify new Photo is created
self.assertEqual(2, gallery.gallery_items_number)
image1 = gallery.tap_first_gallery_item()
# The logic is: scale is inversely proportional with the size(witdh*height) of the image
# if initial_scale < image1.current_scale then image > image1
self.assertLess(initial_scale, image1.current_scale)
def tap_gallery(self):
self.marionette.find_element(*self._gallery_button_locator).tap()
self.wait_for_element_not_displayed(*self._actions_menu_locator)
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
gallery.switch_to_gallery_frame()
return gallery
def tap_gallery(self):
self.marionette.find_element(*self._gallery_button_locator).tap()
self.wait_for_element_not_displayed(*self._actions_menu_locator)
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
gallery.switch_to_gallery_frame()
return gallery
def tap_confirm_deletion_button(self):
self.marionette.find_element(*self._confirm_delete_locator).tap()
self.wait_for_element_not_displayed(*self._confirm_delete_locator)
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
gallery.launch()
return gallery
def tap_switch_to_gallery(self):
switch_to_gallery_button = self.marionette.find_element(*self._gallery_button_locator)
switch_to_gallery_button.tap()
from gaiatest.apps.gallery.app import Gallery
gallery_app = Gallery(self.marionette)
gallery_app.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
return gallery_app
def setUp(self):
GaiaTestCase.setUp(self)
self.cards_view = CardsView(self.marionette)
self.clock = Clock(self.marionette)
self.clock.launch()
self.gallery = Gallery(self.marionette)
self.gallery.launch(empty=True)
class TestEnduranceGalleryFlick(GaiaEnduranceTestCase):
images = 'IMG_0001.jpg'
image_count = 10
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Add photos to storage.
self.push_resource(self.images, count=self.image_count)
# Start gallery app
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(self.image_count)
self.assertTrue(self.gallery.gallery_items_number >= self.image_count)
# Tap first image to open full screen view.
self.image = self.gallery.tap_first_gallery_item()
def test_endurance_gallery_flick(self):
self.drive(test=self.gallery_flick, app='gallery')
def gallery_flick(self):
# Flick through images in gallery, and back again
# Original code taken from existing webqa test (test_gallery_flick.py, thanks!)
previous_image_source = None
# Check the next flicks.
for i in range(self.gallery.gallery_items_number):
self.assertIsNotNone(self.image.current_image_source)
self.assertNotEqual(self.image.current_image_source,
previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
previous_image_source = self.image.current_image_source
self.image.flick_to_next_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertEqual(self.image.current_image_source,
previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
# Check the prev flick.
for i in range(self.gallery.gallery_items_number - 1):
self.image.flick_to_previous_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertNotEqual(self.image.current_image_source,
previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
previous_image_source = self.image.current_image_source
# Try to flick prev image (No image should be available)
self.image.flick_to_previous_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertEqual(self.image.current_image_source,
previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
def tap_switch_to_gallery(self):
switch_to_gallery_button = self.marionette.find_element(
*self._gallery_button_locator)
switch_to_gallery_button.tap()
from gaiatest.apps.gallery.app import Gallery
gallery_app = Gallery(self.marionette)
gallery_app.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
return gallery_app
def tap_switch_to_gallery(self):
self.tap_options()
self.marionette.find_element(*self._gallery_button_locator).tap()
from gaiatest.apps.gallery.app import Gallery
gallery_app = Gallery(self.marionette)
gallery_app.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
Wait(self.marionette).until(expected.element_displayed(*self._thumbnail_list_view_locator))
return gallery_app
def test_gallery_edit_photo(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
self.assertTrue(gallery.gallery_items_number > 0)
image = gallery.tap_first_gallery_item()
# Tap on Edit button.
edit_image = image.tap_edit_button()
# Tap on Effects button.
edit_image.tap_edit_effects_button()
# Change effects.
[effect.tap() for effect in edit_image.effects]
# TBD. Verify the photo is changed.
gallery = edit_image.tap_edit_save_button()
gallery.wait_for_files_to_load(2)
# Verify new Photo is created
self.assertEqual(2, gallery.gallery_items_number)
def test_gallery_crop_photo(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
initial_image_size = gallery.thumbnails[0].absolute_image_size
image = gallery.tap_first_gallery_item()
# Tap on Edit button.
edit_image = image.tap_edit_button()
edit_image.tap_edit_crop_button()
# portrait crop is 2:3 and will retain the image's height
edit_image.tap_portrait_crop()
gallery = edit_image.tap_edit_save_button()
gallery.wait_for_files_to_load(2)
# get the absolute image for the new first image
cropped_image_size = gallery.thumbnails[0].absolute_image_size
# As we have chosen portrait crop, height will remain the same, width should change
self.assertEqual(cropped_image_size['height'],
initial_image_size['height'])
self.assertLess(cropped_image_size['width'],
initial_image_size['width'])
def test_empty_gallery(self):
"""https://moztrap.mozilla.org/manage/case/4003/"""
# Requires there to be no photos on SDCard which is the default
gallery = Gallery(self.marionette)
gallery.launch(True)
self.wait_for_condition(lambda m: gallery.empty_gallery_text == 'Use the Camera app to get started.')
# Verify empty gallery title
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
def tap_switch_to_gallery(self):
self.tap_options()
self.marionette.find_element(*self._gallery_button_locator).tap()
from gaiatest.apps.gallery.app import Gallery
gallery_app = Gallery(self.marionette)
gallery_app.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
Wait(self.marionette).until(
expected.element_displayed(*self._thumbnail_list_view_locator))
return gallery_app
def test_empty_gallery(self):
"""https://moztrap.mozilla.org/manage/case/4003/"""
# Requires there to be no photos on SDCard which is the default
gallery = Gallery(self.marionette)
gallery.launch()
self.wait_for_condition(lambda m: gallery.empty_gallery_text == 'Use the Camera app to get started.')
# Verify empty gallery title
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
def test_gallery_handle_load_corrupt_file(self, filename):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch(True)
self.assertTrue(len(self.data_layer.picture_files) == 1)
# image will not display in the gallery app
Wait(self.marionette).until(lambda m: gallery.empty_gallery_text == 'Use the Camera app to get started.')
self.assertTrue(gallery.gallery_items_number == 0)
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
def test_gallery_handle_load_corrupt_file(self, filename):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch(True)
self.assertTrue(len(self.data_layer.picture_files) == 1)
# image will not display in the gallery app
Wait(self.marionette).until(lambda m: gallery.empty_gallery_text ==
'Use the Camera app to get started.')
self.assertTrue(gallery.gallery_items_number == 0)
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
def setUp(self):
GaiaImageCompareTestCase.setUp(self)
self.cards_view = CardsView(self.marionette)
self.contacts = Contacts(self.marionette)
self.contacts.launch()
self.gallery = Gallery(self.marionette)
self.gallery.launch(empty=True)
# 10 seconds for the actual user using the app a bit, and going back to homescreen
time.sleep(10)
self.device.touch_home_button()
class TestEnduranceGalleryFlick(GaiaEnduranceTestCase):
images = 'IMG_0001.jpg'
image_count = 10
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Add photos to storage.
self.push_resource(self.images, count=self.image_count)
# Start gallery app
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(self.image_count)
self.assertTrue(self.gallery.gallery_items_number >= self.image_count)
# Tap first image to open full screen view.
self.image = self.gallery.tap_first_gallery_item()
def test_endurance_gallery_flick(self):
self.drive(test=self.gallery_flick, app='gallery')
def gallery_flick(self):
# Flick through images in gallery, and back again
# Original code taken from existing webqa test (test_gallery_flick.py, thanks!)
previous_image_source = None
# Check the next flicks.
for i in range(self.gallery.gallery_items_number):
self.assertIsNotNone(self.image.current_image_source)
self.assertNotEqual(self.image.current_image_source, previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
previous_image_source = self.image.current_image_source
self.image.flick_to_next_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertEqual(self.image.current_image_source, previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
# Check the prev flick.
for i in range(self.gallery.gallery_items_number - 1):
self.image.flick_to_previous_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertNotEqual(self.image.current_image_source, previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
previous_image_source = self.image.current_image_source
# Try to flick prev image (No image should be available)
self.image.flick_to_previous_image()
self.assertIsNotNone(self.image.current_image_source)
self.assertEqual(self.image.current_image_source, previous_image_source)
self.assertTrue(self.image.is_photo_toolbar_displayed)
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Turn off geolocation prompt
self.apps.set_permission('Camera', 'geolocation', 'deny')
# add photo to storage
self.push_resource('IMG_0001.jpg')
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(1)
def test_empty_gallery(self):
# https://moztrap.mozilla.org/manage/case/4003/
# Requires there to be no photos on SDCard which is the default
gallery = Gallery(self.marionette)
gallery.launch()
# Verify empty gallery title
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
# Verify empty gallery text
self.assertEqual(gallery.empty_gallery_text, 'Use the Camera app to get started.')
def tap_gallery(self):
actions_menu = Wait(self.marionette).until(
expected.element_present(*self._actions_menu_locator))
Wait(self.marionette).until(
expected.element_displayed(actions_menu))
self.marionette.find_element(*self._gallery_button_locator).tap()
Wait(self.marionette).until(
expected.element_not_displayed(actions_menu))
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
gallery.wait_to_be_displayed()
self.apps.switch_to_displayed_app()
return gallery
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Add photos to storage.
self.push_resource(self.images, count=self.image_count)
# Start gallery app
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(self.image_count)
self.assertTrue(self.gallery.gallery_items_number >= self.image_count)
# Tap first image to open full screen view.
self.image = self.gallery.tap_first_gallery_item()
def test_gallery_crop_photo(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
initial_image_size = gallery.thumbnails[0].absolute_image_size
image = gallery.tap_first_gallery_item()
# Tap on Edit button.
edit_image = image.tap_edit_button()
edit_image.tap_edit_crop_button()
# portrait crop is 2:3 and will retain the image's height
edit_image.tap_portrait_crop()
edit_image.tap_edit_tool_apply_button()
image = edit_image.tap_edit_save_button()
gallery = image.go_back()
gallery.wait_for_files_to_load(2)
# get the absolute image for the new first image
cropped_image_size = gallery.thumbnails[0].absolute_image_size
# As we have chosen portrait crop, height will remain the same, width should change
self.assertEqual(cropped_image_size['height'], initial_image_size['height'])
self.assertLess(cropped_image_size['width'], initial_image_size['width'])
def tap_tile_view_button(self):
fullscreen = self.marionette.find_element(
*self._fullscreen_view_locator)
self.marionette.find_element(*self._tile_view_locator).tap()
Wait(self.marionette).until(expected.element_not_displayed(fullscreen))
from gaiatest.apps.gallery.app import Gallery
return Gallery(self.marionette)
def tap_switch_to_gallery(self):
switch_to_gallery_button = self.marionette.find_element(*self._gallery_button_locator)
switch_to_gallery_button.tap()
from gaiatest.apps.gallery.app import Gallery
gallery_app = Gallery(self.marionette)
self.wait_for_condition(lambda m: self.apps.displayed_app.name == gallery_app.name)
self.apps.switch_to_displayed_app()
return gallery_app
def tap_confirm_deletion_button(self):
self.marionette.find_element(*self._confirm_delete_locator).tap()
self.wait_for_element_not_displayed(*self._confirm_delete_locator)
from gaiatest.apps.gallery.app import Gallery
gallery = Gallery(self.marionette)
self.wait_for_condition(lambda m: self.apps.displayed_app.name == gallery.name)
self.marionette.switch_to_frame(self.apps.displayed_app.frame)
return gallery
def test_gallery_full_screen_image_flicks(self):
"""https://moztrap.mozilla.org/manage/case/1326/"""
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(self.image_count)
self.assertEqual(gallery.gallery_items_number, self.image_count)
# Tap first image to open full screen view.
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
# Check the next flicks.
for i in range(1, gallery.gallery_items_number):
image.flick_to_next_image()
self.assertIsNotNone(image.current_image_source)
self.assertNotEqual(image.current_image_source, previous_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
# Check the prev flick.
for i in range(gallery.gallery_items_number, 1, -1):
image.flick_to_previous_image()
self.assertIsNotNone(image.current_image_source)
self.assertNotEqual(image.current_image_source, previous_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
def test_gallery_view(self):
# https://moztrap.mozilla.org/manage/case/1326/
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
# Verify that the screen orientation is in portrait mode
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('portrait-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
# Change the screen orientation to landscape mode and verify that the screen is in landscape mode
self.change_orientation('landscape-primary')
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('landscape-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
# Unlock the screen so that it can be changed back to portrait mode
self.marionette.execute_script('window.screen.mozUnlockRotation')
# Change the screen orientation back to portrait-primary and verify the screen is in portrait mode
self.change_orientation('portrait-primary')
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('portrait-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
def test_gallery_open_valid_image_file(self, filename, width, height):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1) # all and only valid files are showing previews
self.assertTrue(gallery.gallery_items_number == 1)
# make sure the file opens
image = gallery.tap_first_gallery_item()
# verify the blob is displayed
self.assertTrue("blob:app://gallery.gaiamobile.org/" in image.current_image_source)
# collect the initial image view dimension for comparison later
initial_width = image.current_image_size_width
initial_height = image.current_image_size_height
image.double_tap_image() # displays the image in its original resolution
# for big images exceeding the phone resolution, the gallery app only doubles the view size
# from the initial view; it does not render the entire image fully
if width <= (2 * initial_width) and height <= (2 * initial_height):
Wait(self.marionette).until(lambda m: image.current_image_size_width == width)
Wait(self.marionette).until(lambda m: image.current_image_size_height == height)
else:
Wait(self.marionette).until(lambda m: image.current_image_size_width == 2 * initial_width)
Wait(self.marionette).until(lambda m: image.current_image_size_height == 2 * initial_height)
def test_gallery_frame_visibility(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(self.image_count)
self.assertEqual(gallery.gallery_items_number, self.image_count)
# Tap first image to open full screen view.
image = gallery.tap_first_gallery_item()
previous_frame = image.current_image_frame
# Check that initial image is visible.
self.assertTrue(self.accessibility.is_visible(previous_frame))
# Check the next flicks.
for i in range(1, gallery.gallery_items_number):
image.flick_to_next_image()
# Check that current image is visible.
self.assertTrue(
self.accessibility.is_visible(image.current_image_frame))
# Check that previous image is hidden.
self.assertTrue(self.accessibility.is_hidden(previous_frame))
previous_frame = image.current_image_frame
# Check the prev flick.
for i in range(gallery.gallery_items_number, 1, -1):
image.flick_to_previous_image()
# Check that current image is visible.
self.assertTrue(
self.accessibility.is_visible(image.current_image_frame))
# Check that previous image is hidden.
self.assertTrue(self.accessibility.is_hidden(previous_frame))
previous_frame = image.current_image_frame
class TestEnduranceGalleryCamera(GaiaEnduranceTestCase):
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Turn off geolocation prompt
self.apps.set_permission('Camera', 'geolocation', 'deny')
# add photo to storage
self.push_resource('IMG_0001.jpg')
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(1)
def test_endurance_gallery_camera(self):
self.drive(test=self.gallery_camera, app='gallery')
def gallery_camera(self):
# Test requested per bug 851626:
# 1. open the Gallery app
# 2. when the UI/Camera button appears, tap it to switch to the camera
# 3. when the UI/Gallery button appears, tap it to switch back to the gallery
# 4. repeat steps 2 and 3 until *crash*
time.sleep(3)
# From gallery app, switch to camera app
self.camera = self.gallery.switch_to_camera()
time.sleep(3)
# From camera app, switch back to gallery again
self.gallery = self.camera.tap_switch_to_gallery()
self.gallery.wait_for_files_to_load(1)
self.assertTrue(self.gallery.are_gallery_items_displayed)
def test_gallery_handle_load_corrupt_file(self, filename):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch(filename != "image_formats/x07.jpg")
self.assertTrue(len(self.data_layer.picture_files) == 1)
# loaded image will not display in the gallery app, except in case of corrupt_jpg
if filename == "image_formats/x07.jpg":
self.assertTrue(gallery.gallery_items_number == 1)
# make sure the file opens without crash
image = gallery.tap_first_gallery_item()
self.assertTrue("blob:app://gallery.gaiamobile.org/" in image.current_image_source)
else:
Wait(self.marionette).until(lambda m: gallery.empty_gallery_text == 'Use the Camera app to get started.')
self.assertTrue(gallery.gallery_items_number == 0)
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
def wait_for_content_ready(self):
app = Gallery(self.device.marionette)
Wait(self.device.marionette, timeout=240).until(
lambda m: len(m.find_elements(By.CSS_SELECTOR, '.thumbnail')
) == self.picture_count)
Wait(self.device.marionette, timeout=60).until(
expected.element_not_displayed(
self.device.marionette.find_element(
*app._progress_bar_locator)))
def __init__(self, marionette):
Base.__init__(self, marionette)
from gaiatest.apps.gallery.app import Gallery
Gallery(self.marionette).wait_to_be_displayed()
self.apps.switch_to_displayed_app()
Wait(self.marionette).until(
expected.element_displayed(
Wait(self.marionette).until(
expected.element_present(*self._image_locator))))
def tap_edit_save_button(self):
element = Wait(self.marionette).until(
expected.element_present(*self._edit_save_locator))
Wait(self.marionette).until(expected.element_displayed(element))
element.tap()
progress = self.marionette.find_element(*self._save_progress_bar_locator)
Wait(self.marionette).until(expected.element_not_displayed(progress))
from gaiatest.apps.gallery.app import Gallery
return Gallery(self.marionette)
def test_gallery_click_share_button(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_thumbnails_to_load()
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
# click on share button and check the element is correct
actions_list = image.tap_share_button()
self.assertGreater(actions_list.options_count, 1)
actions_list.tap_cancel()
gallery = image.tap_tile_view_button()
gallery.wait_for_thumbnails_to_load()
image = gallery.tap_first_gallery_item()
self.assertTrue(image.is_image_displayed)
class TestCardsViewTwoApps(GaiaImageCompareTestCase):
def setUp(self):
GaiaImageCompareTestCase.setUp(self)
self.cards_view = CardsView(self.marionette)
self.contacts = Contacts(self.marionette)
self.contacts.launch()
self.gallery = Gallery(self.marionette)
self.gallery.launch(empty=True)
# 10 seconds for the actual user using the app a bit, and going back to homescreen
time.sleep(10)
self.device.touch_home_button()
def test_cards_view_kill_apps_with_two_apps(self):
"""https://moztrap.mozilla.org/manage/case/1917/"""
# Pull up the cards view
self.device.hold_home_button()
self.cards_view.wait_for_cards_view()
# Wait for first app ready
self.cards_view.cards[1].wait_for_centered()
self.take_screenshot(top_frame=True)
# Close the current apps from the cards view
self.cards_view.cards[1].close()
self.cards_view.cards[0].wait_for_centered()
self.take_screenshot(top_frame=True)
self.cards_view.cards[0].close()
self.cards_view.wait_for_cards_view_not_displayed()
self.take_screenshot(top_frame=True)
# If successfully killed, the apps should no longer appear in the cards view
# and the "No recent apps" message should be displayed
self.device.hold_home_button()
self.cards_view.wait_for_no_card_displayed()
self.take_screenshot(top_frame=True)
self.assertEqual(len(self.cards_view.cards), 0)
self.assertTrue(self.cards_view.is_no_card_displayed)
def test_gallery_handle_load_corrupt_file(self, filename):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch(filename != "image_formats/x07.jpg")
self.assertTrue(len(self.data_layer.picture_files) == 1)
# loaded image will not display in the gallery app, except in case of corrupt_jpg
if filename == "image_formats/x07.jpg":
self.assertTrue(gallery.gallery_items_number == 1)
# make sure the file opens without crash
image = gallery.tap_first_gallery_item()
self.assertTrue("blob:app://gallery.gaiamobile.org/" in
image.current_image_source)
else:
Wait(self.marionette).until(lambda m: gallery.empty_gallery_text ==
'Use the Camera app to get started.')
self.assertTrue(gallery.gallery_items_number == 0)
self.assertEqual(gallery.empty_gallery_title,
'No photos or videos')
def test_gallery_view(self):
# https://moztrap.mozilla.org/manage/case/1326/
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
# Verify that the screen orientation is in portrait mode
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('portrait-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
# Change the screen orientation to landscape mode and verify that the screen is in landscape mode
self.change_orientation('landscape-primary')
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('landscape-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
# Unlock the screen so that it can be changed back to portrait mode
self.marionette.execute_script('window.screen.mozUnlockRotation')
# Change the screen orientation back to portrait-primary and verify the screen is in portrait mode
self.change_orientation('portrait-primary')
self.assertTrue(image.is_photo_toolbar_displayed)
self.assertEqual('portrait-primary', self.screen_orientation)
self.assertEqual(self.screen_width, image.photo_toolbar_width)
def test_gallery_frame_visibility(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(self.image_count)
self.assertEqual(gallery.gallery_items_number, self.image_count)
# Tap first image to open full screen view.
image = gallery.tap_first_gallery_item()
previous_frame = image.current_image_frame
# Check that initial image is visible.
self.assertTrue(self.accessibility.is_visible(previous_frame))
# Check the next flicks.
for i in range(1, gallery.gallery_items_number):
image.flick_to_next_image()
# Check that current image is visible.
self.assertTrue(self.accessibility.is_visible(image.current_image_frame))
# Check that previous image is hidden.
self.assertTrue(self.accessibility.is_hidden(previous_frame))
previous_frame = image.current_image_frame
# Check the prev flick.
for i in range(gallery.gallery_items_number, 1, -1):
image.flick_to_previous_image()
# Check that current image is visible.
self.assertTrue(self.accessibility.is_visible(image.current_image_frame))
# Check that previous image is hidden.
self.assertTrue(self.accessibility.is_hidden(previous_frame))
previous_frame = image.current_image_frame
def test_gallery_open_valid_image_file(self, filename, width, height):
self.push_resource(filename)
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1) # all and only valid files are showing previews
self.assertTrue(gallery.gallery_items_number == 1)
# make sure the file opens
image = gallery.tap_first_gallery_item()
# verify the blob is displayed
self.assertTrue("blob:app://gallery.gaiamobile.org/" in image.current_image_source)
# collect the initial image view dimension for comparison later
initial_width = image.current_image_size_width
initial_height = image.current_image_size_height
image.double_tap_image() # displays the image in its original resolution
# for big images exceeding the phone resolution, the gallery app only doubles the view size
# from the initial view; it does not render the entire image fully
if width <= (2 * initial_width) and height <= (2 * initial_height):
Wait(self.marionette).until(lambda m: image.current_image_size_width == width)
Wait(self.marionette).until(lambda m: image.current_image_size_height == height)
else:
Wait(self.marionette).until(lambda m: image.current_image_size_width == 2 * initial_width)
Wait(self.marionette).until(lambda m: image.current_image_size_height == 2 * initial_height)
def test_gallery_full_screen_image_flicks(self):
"""https://moztrap.mozilla.org/manage/case/1326/"""
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(self.image_count)
self.assertEqual(gallery.gallery_items_number, self.image_count)
# Tap first image to open full screen view.
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
# Check the next flicks.
for i in range(1, gallery.gallery_items_number):
image.flick_to_next_image()
self.assertIsNotNone(image.current_image_source)
self.assertNotEqual(image.current_image_source, previous_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
# Check the prev flick.
for i in range(gallery.gallery_items_number, 1, -1):
image.flick_to_previous_image()
self.assertIsNotNone(image.current_image_source)
self.assertNotEqual(image.current_image_source, previous_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
previous_image_source = image.current_image_source
def orientation_zoom_check(self):
self.push_resource(self.images, count=self.image_count)
self.take_screenshot()
# flick image, change orientation, pinch zoom, change orientation
# launch gallery, load image.
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(self.image_count)
self.assertEqual(gallery.gallery_items_number, self.image_count)
# Tap first image to open full screen view.
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
# scroll back and forth in different display mode
self.change_orientation('landscape-primary')
self.take_screenshot()
GaiaImageCompareTestCase.scroll(self.marionette, 'right',
400, locator=image._current_image_locator)
self.change_orientation('portrait-primary')
self.take_screenshot()
GaiaImageCompareTestCase.scroll(self.marionette, 'left',
400, locator=image._current_image_locator)
# flip A LOT
for x in range(0, 4):
self.change_orientation('landscape-primary')
self.change_orientation('portrait-primary')
self.take_screenshot()
# do pinch zoom while flipping the phone
GaiaImageCompareTestCase.pinch(self.marionette, image._current_frame_locator, 'in', 20)
self.take_screenshot()
GaiaImageCompareTestCase.scroll(self.marionette, 'right',
300, locator=image._current_image_locator)
self.take_screenshot()
self.change_orientation('landscape-primary')
GaiaImageCompareTestCase.pinch(self.marionette, image._current_frame_locator, 'out', 50)
self.take_screenshot()
self.change_orientation('portrait-primary')
image.double_tap_image()
self.take_screenshot(prewait=3) #takes time for zoom-in action to complete
# go back and forth with flicking then exit gallery app
GaiaImageCompareTestCase.scroll(self.marionette, 'right',
150, locator=image._current_frame_locator)
self.take_screenshot()
GaiaImageCompareTestCase.scroll(self.marionette, 'left',
150, locator=image._current_frame_locator)
self.take_screenshot()
def setUp(self):
GaiaEnduranceTestCase.setUp(self)
# Add photos to storage.
self.push_resource(self.images, count=self.image_count)
# Start gallery app
self.gallery = Gallery(self.marionette)
self.gallery.launch()
self.gallery.wait_for_files_to_load(self.image_count)
self.assertTrue(self.gallery.gallery_items_number >= self.image_count)
# Tap first image to open full screen view.
self.image = self.gallery.tap_first_gallery_item()
def test_gallery_delete_image(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(3)
gallery_multi_view = gallery.switch_to_multiple_selection_view()
gallery_multi_view.select_nth_picture(0)
gallery_multi_view.select_nth_picture(1)
gallery_multi_view.select_nth_picture(2)
# Tap the delete button and confirm by default
gallery_multi_view.tap_delete_button()
gallery.wait_for_thumbnail_view_to_load()
# Verify empty gallery title.
Wait(self.marionette).until(lambda m: gallery.empty_gallery_title == 'No photos or videos')
def test_gallery_click_share_button(self):
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_thumbnails_to_load()
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
# click on share button and check the element is correct
activities_list = image.tap_share_button()
self.assertGreater(activities_list.options_count, 1)
activities_list.tap_cancel()
gallery = image.tap_tile_view_button()
gallery.wait_for_thumbnails_to_load()
image = gallery.tap_first_gallery_item()
self.assertTrue(image.is_image_displayed)
def setUp(self):
GaiaImageCompareTestCase.setUp(self)
self.push_resource(self.images, count=self.image_count)
self.take_screenshot(top_frame=True)
self.contacts = Contacts(self.marionette)
self.contacts.launch()
# 10 seconds for the actual user using the app a bit, and going back to homescreen
time.sleep(10)
self.device.touch_home_button()
self.gallery = Gallery(self.marionette)
self.gallery.launch()
# 10 seconds for the actual user using the app a bit, and going back to homescreen
time.sleep(10)
self.device.touch_home_button()
def test_gallery_view(self):
# https://moztrap.mozilla.org/manage/case/1326/
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
self.assertTrue(image.is_photo_toolbar_displayed)
def test_gallery_switch_to_camera(self):
"""
https://moztrap.mozilla.org/manage/case/3620/
"""
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(1)
# Enter the single photo view
image = gallery.tap_first_gallery_item()
self.assertIsNotNone(image.current_image_source)
# Check that there are 5 options displayed beneath the picture
self.assertEqual(len(image.photo_toolbar_options), 5)
# Tap on the Camera button to go to the Camera app
self.previous_number_of_pictures = len(self.data_layer.picture_files)
self.camera = image.tap_switch_to_camera()
# Take a picture and verify the picture is taken
self.camera.take_photo()
# Check that picture saved to SD card
Wait(self.marionette).until(
lambda m: len(self.data_layer.picture_files) == self.previous_number_of_pictures + 1
)
# Open Preview, tap the option icon and select Gallery app
self.camera.tap_thumbnail()
self.preview = ImagePreview(self.marionette)
self.preview.tap_switch_to_gallery()
# Verify the Gallery app is now open, with one more file
gallery.wait_for_files_to_load(2)
new_image = gallery.tap_first_gallery_item()
# verify the new first image is not same as the previous (and only) first image,
# meaning that the new image is shown on the top of the gallery app grid
self.assertFalse(new_image.current_image_source is image.current_image_source)
def test_gallery_delete_image(self):
"""
https://moztrap.mozilla.org/manage/case/1533/
"""
gallery = Gallery(self.marionette)
gallery.launch()
gallery.wait_for_files_to_load(3)
gallery_multi_view = gallery.switch_to_multiple_selection_view()
gallery_multi_view.select_nth_picture(0)
gallery_multi_view.select_nth_picture(1)
gallery_multi_view.select_nth_picture(2)
# Tap the delete button and confirm by default
gallery_multi_view.tap_delete_button()
gallery.wait_for_overlay_to_show()
self.assertEqual(gallery.empty_gallery_title, 'No photos or videos')
