Esempio n. 1
0
    def test_video_playing_in_one_tab(self):
        with self.marionette.using_context('content'):
            for url in self.video_urls:
                self.logger.info(url)
                youtube = YouTubePuppeteer(self.marionette, url)
                self.logger.info('Expected duration: %s' %
                                 youtube.expected_duration)
                youtube.deactivate_autoplay()

                final_piece = 60
                try:
                    time_left = wait_for_almost_done(youtube,
                                                     final_piece=final_piece)
                except VideoException as e:
                    raise self.failureException(e)
                duration = abs(youtube.expected_duration) + 1
                if duration > 1:
                    self.logger.info('Almost done: %s - %s seconds left.' %
                                     (youtube.movie_id, time_left))
                    if time_left > final_piece:
                        self.marionette.log('time_left greater than '
                                            'final_piece - %s' % time_left,
                                            level='WARNING')
                        self.save_screenshot()
                else:
                    self.marionette.log('Duration close to 0 - %s' % youtube,
                                        level='WARNING')
                    self.save_screenshot()
                try:
                    verbose_until(
                        Wait(youtube,
                             timeout=max(100, time_left) * 1.3,
                             interval=1), youtube, playback_done)
                except TimeoutException as e:
                    raise self.failureException(e)
    def test_video_playing_in_one_tab(self):
        with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
            for url in self.video_urls:
                self.logger.info(url)
                youtube = YouTubePuppeteer(self.marionette, url)
                self.logger.info('Expected duration: {}'.format(
                    youtube.expected_duration))

                final_piece = 60
                try:
                    time_left = youtube.wait_for_almost_done(
                        final_piece=final_piece)
                except VideoException as e:
                    raise self.failureException(e)
                duration = abs(youtube.expected_duration) + 1
                if duration > 1:
                    self.logger.info(
                        'Almost done: {} - {} seconds left.'.format(
                            url, time_left))
                    if time_left > final_piece:
                        self.logger.warn('time_left greater than '
                                         'final_piece - {}'.format(time_left))
                        self.save_screenshot()
                else:
                    self.logger.warn(
                        'Duration close to 0 - {}'.format(youtube))
                    self.save_screenshot()
                try:
                    verbose_until(
                        Wait(youtube,
                             timeout=max(100, time_left) * 1.3,
                             interval=1), youtube,
                        YouTubePuppeteer.playback_done)
                except TimeoutException as e:
                    raise self.failureException(e)
Esempio n. 3
0
 def test_playback_starts(self):
     with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
         for url in self.video_urls:
             try:
                 YouTubePuppeteer(self.marionette, url, timeout=60)
             except TimeoutException as e:
                 raise self.failureException(e)
Esempio n. 4
0
    def check_src(self, src_type, url):
        # Why wait to check src until initial ad is done playing?
        # - src attribute in video element is sometimes null during ad playback
        # - many ads still don't use MSE even if main video does
        with self.marionette.using_context('content'):
            youtube = YouTubePuppeteer(self.marionette, url)
            youtube.attempt_ad_skip()
            wait = Wait(youtube,
                        timeout=min(self.max_timeout,
                                    youtube.player_duration * 1.3),
                        interval=1)

            def cond(y):
                return y.video_src.startswith(src_type)

            verbose_until(wait, youtube, cond)
Esempio n. 5
0
    def check_mse_src(self, mse_expected, url):
        with self.marionette.using_context('content'):
            youtube = YouTubePuppeteer(self.marionette, url)
            wait = Wait(youtube,
                        timeout=min(self.max_timeout,
                                    youtube.expected_duration * 1.3),
                        interval=1)

            def cond(y):
                return y.mse_enabled == mse_expected

            verbose_until(wait, youtube, cond)
Esempio n. 6
0
 def test_mse_is_enabled_by_default(self):
     with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
         youtube = YouTubePuppeteer(self.marionette, self.video_urls[0],
                                    timeout=60)
         wait = Wait(youtube,
                     timeout=min(300, youtube.expected_duration * 1.3),
                     interval=1)
         try:
             verbose_until(wait, youtube,
                           YouTubePuppeteer.mse_enabled,
                           "Failed to find 'blob' in video src url.")
         except TimeoutException as e:
             raise self.failureException(e)
    def test_video_playing_in_one_tab(self):
        with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
            for url in self.video_urls:
                self.logger.info(url)
                youtube = YouTubePuppeteer(self.marionette, url)
                self.logger.info('Expected duration: {}'
                                 .format(youtube.expected_duration))

                final_piece = 60
                try:
                    time_left = youtube.wait_for_almost_done(
                        final_piece=final_piece)
                except VideoException as e:
                    raise self.failureException(e)
                duration = abs(youtube.expected_duration) + 1
                if duration > 1:
                    self.logger.info('Almost done: {} - {} seconds left.'
                                     .format(url, time_left))
                    if time_left > final_piece:
                        self.marionette.log('time_left greater than '
                                            'final_piece - {}'
                                            .format(time_left),
                                            level='WARNING')
                        self.save_screenshot()
                else:
                    self.marionette.log('Duration close to 0 - {}'
                                        .format(youtube),
                                        level='WARNING')
                    self.save_screenshot()
                try:
                    verbose_until(Wait(youtube,
                                       timeout=max(100, time_left) * 1.3,
                                       interval=1),
                                  youtube,
                                  YouTubePuppeteer.playback_done)
                except TimeoutException as e:
                    raise self.failureException(e)
Esempio n. 8
0
    def test_video_playing_in_one_tab(self):
        with self.marionette.using_context('content'):
            for url in self.video_urls:
                self.logger.info(url)
                youtube = YouTubePuppeteer(self.marionette, url)
                self.logger.info('Expected duration: %s' %
                                 youtube.expected_duration)
                youtube.deactivate_autoplay()

                final_piece = 60
                try:
                    time_left = wait_for_almost_done(youtube,
                                                     final_piece=final_piece)
                except VideoException as e:
                    raise self.failureException(e)
                duration = abs(youtube.expected_duration) + 1
                if duration > 1:
                    self.logger.info('Almost done: %s - %s seconds left.' %
                                     (youtube.movie_id, time_left))
                    if time_left > final_piece:
                        self.marionette.log('time_left greater than '
                                            'final_piece - %s' % time_left,
                                            level='WARNING')
                        self.save_screenshot()
                else:
                    self.marionette.log('Duration close to 0 - %s' % youtube,
                                        level='WARNING')
                    self.save_screenshot()
                try:
                    verbose_until(Wait(youtube,
                                       timeout=max(100, time_left) * 1.3,
                                       interval=1),
                                  youtube,
                                  playback_done)
                except TimeoutException as e:
                    raise self.failureException(e)
Esempio n. 9
0
 def test_mse_is_enabled_by_default(self):
     with self.marionette.using_context('content'):
         youtube = YouTubePuppeteer(self.marionette,
                                    self.video_urls[0],
                                    timeout=60)
         wait = Wait(youtube,
                     timeout=min(300, youtube.expected_duration * 1.3),
                     interval=1)
         try:
             verbose_until(
                 wait, youtube,
                 lambda y: y.video_src.startswith('mediasource'),
                 "Failed to find 'mediasource' in video src url.")
         except TimeoutException as e:
             raise self.failureException(e)