def check_playback_starts(self, video):
with self.marionette.using_context("content"):
self.logger.info(video.test_url)
try:
verbose_until(Wait(video, timeout=video.timeout), video, playback_started)
except TimeoutException as e:
raise self.failureException(e)
def process_ad(self):
if self.attempt_ad_skip() or self.ad_inactive:
return
ad_timeout = (self.search_ad_duration() or 30) + 5
wait = Wait(self, timeout=ad_timeout, interval=1)
try:
self.marionette.log('process_ad: waiting %s s for ad' % ad_timeout)
verbose_until(wait, self, lambda y: y.ad_ended, "Check if ad ended")
except TimeoutException:
self.marionette.log('Waiting for ad to end timed out',
level='WARNING')
def run_playback(self, video):
with self.marionette.using_context("content"):
self.logger.info(video.test_url)
try:
verbose_until(
Wait(video, interval=video.interval, timeout=video.expected_duration * 1.3 + video.stall_wait_time),
video,
playback_done,
)
except VideoException as e:
raise self.failureException(e)
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)
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)
def __init__(self, marionette, url, **kwargs):
self.player = None
super(YouTubePuppeteer,
self).__init__(marionette, url,
video_selector='#movie_player video',
**kwargs)
wait = Wait(self.marionette, timeout=30)
with self.marionette.using_context('content'):
verbose_until(wait, self,
expected.element_present(By.ID, 'movie_player'))
self.player = self.marionette.find_element(By.ID, 'movie_player')
self.marionette.execute_script("log('#movie_player "
"element obtained');")
# When an ad is playing, self.player_duration indicates the duration
# of the spliced-in ad stream, not the duration of the main video, so
# we attempt to skip the ad first.
for attempt in range(5):
sleep(1)
self.process_ad()
if (self.ad_inactive and self.duration and not
self.player_buffering):
break
self.update_expected_duration()
def __init__(
self, marionette, url, video_selector="video", interval=1, set_duration=0, stall_wait_time=0, timeout=60
):
self.marionette = marionette
self.test_url = url
self.interval = interval
self.stall_wait_time = stall_wait_time
self.timeout = timeout
self._set_duration = set_duration
self.video = None
self.expected_duration = 0
self._start_time = 0
self._start_wall_time = 0
wait = Wait(self.marionette, timeout=self.timeout)
with self.marionette.using_context("content"):
self.marionette.navigate(self.test_url)
self.marionette.execute_script(
"""
log('URL: {0}');""".format(
self.test_url
)
)
verbose_until(wait, self, expected.element_present(By.TAG_NAME, "video"))
videos_found = self.marionette.find_elements(By.CSS_SELECTOR, video_selector)
if len(videos_found) > 1:
self.marionette.log(type(self).__name__ + ": multiple video " "elements found. " "Using first.")
if len(videos_found) <= 0:
self.marionette.log(type(self).__name__ + ": no video " "elements found.")
return
self.video = videos_found[0]
self.marionette.execute_script("log('video element obtained');")
# To get an accurate expected_duration, playback must have started
wait = Wait(self, timeout=self.timeout)
verbose_until(wait, self, lambda v: v.current_time > 0, "Check if video current_time > 0")
self._start_time = self.current_time
self._start_wall_time = clock()
self.update_expected_duration()
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)
