Python Gallery.wait_for_files_to_load方法代码示例

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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'])

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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()

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
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)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    def test_gallery_view(self):
        """ Test return to tiles view
        Load gallery.
        Tap the image and wait for it to load.
        Tap the tile view toolbar icon.
        Assert that the app returns to the main/tile view screen.
        """
        gallery = Gallery(self.marionette)
        gallery.launch()
        gallery.wait_for_files_to_load(1)

        image = gallery.tap_first_gallery_item()
        self.assertTrue(image.is_photo_toolbar_displayed)

        gallery = image.tap_tile_view_button()
        self.assertTrue(gallery.are_gallery_items_displayed)

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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')

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    def test_gallery_delete_image(self):
        gallery = Gallery(self.marionette)
        gallery.launch()
        gallery.wait_for_files_to_load(1)

        # Tap first image to open full screen view.
        image = gallery.tap_first_gallery_item()

        # Tap the delete button from the fullscreen toolbar.
        image.tap_delete_button()

        # Tap the confirm delete button.
        image.tap_confirm_deletion_button()
        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')

# 需要导入模块: from gaiatest.apps.gallery.app import Gallery [as 别名]
# 或者: from gaiatest.apps.gallery.app.Gallery import wait_for_files_to_load [as 别名]
    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')