def __init__(self, marionette, url, **kwargs):
self.player = None
super(YouTubePuppeteer,
self).__init__(marionette,
url,
video_selector='.html5-video-player video',
**kwargs)
wait = Wait(self.marionette, timeout=30)
with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
verbose_until(
wait, self,
expected.element_present(By.CLASS_NAME, 'html5-video-player'))
self.player = self.marionette.find_element(By.CLASS_NAME,
'html5-video-player')
self.marionette.execute_script("log('.html5-video-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, autostart=True, **kwargs):
self.player = None
self._last_seen_player_state = None
super(YouTubePuppeteer,
self).__init__(marionette, url,
video_selector='.html5-video-player video',
autostart=False,
**kwargs)
wait = Wait(self.marionette, timeout=30)
with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
verbose_until(wait, self,
expected.element_present(By.CLASS_NAME,
'html5-video-player'))
self.player = self.marionette.find_element(By.CLASS_NAME,
'html5-video-player')
self.marionette.execute_script("log('.html5-video-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._last_seen_player_state.player_ad_inactive and
self._last_seen_video_state.duration and not
self._last_seen_player_state.player_buffering):
break
self._update_expected_duration()
if autostart:
self.start()
def __init__(self, marionette, url, video_selector='video', interval=1,
set_duration=0, stall_wait_time=0, timeout=60,
autostart=True):
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._first_seen_time = 0
self._first_seen_wall_time = 0
wait = Wait(self.marionette, timeout=self.timeout)
with self.marionette.using_context(Marionette.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');")
if autostart:
self.start()
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)
def start(self):
# 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 start(self):
# 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 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 start(self):
# To get an accurate expected_duration, playback must have started
wait = Wait(self, timeout=self.timeout)
verbose_until(wait, self, playback_started,
"Check if video has played some range")
self._first_seen_time = self.current_time
self._first_seen_wall_time = clock()
self.update_expected_duration()
def start(self):
# To get an accurate expected_duration, playback must have started
wait = Wait(self, timeout=self.timeout)
verbose_until(wait, self, playback_started,
"Check if video has played some range")
self._first_seen_time = self.current_time
self._first_seen_wall_time = clock()
self.update_expected_duration()
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 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 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 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 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)
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_playback_starts(self, video):
"""
Check to see if a given video will start. Raises if the video does not
start.
:param video: VideoPuppeteer instance to play.
"""
with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
self.logger.info(video.test_url)
try:
verbose_until(Wait(video, timeout=video.timeout), video, VideoPuppeteer.playback_started)
except TimeoutException as e:
raise self.failureException(e)
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 check_playback_starts(self, video):
"""
Check to see if a given video will start. Raises if the video does not
start.
:param video: VideoPuppeteer instance to play.
"""
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 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 run_playback(self, video):
"""
Play the video all of the way through, or for the requested duration,
whichever comes first. Raises if the video stalls for too long.
:param video: VideoPuppeteer instance to play.
"""
with self.marionette.using_context(Marionette.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, VideoPuppeteer.playback_done)
except VideoException 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 run_playback(self, video):
"""
Play the video all of the way through, or for the requested duration,
whichever comes first. Raises if the video stalls for too long.
:param video: VideoPuppeteer instance to play.
"""
with self.marionette.using_context(Marionette.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, VideoPuppeteer.playback_done)
except VideoException as e:
raise self.failureException(e)
def process_ad(self):
"""
Try to skip this ad. If not, wait for this ad to finish.
"""
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 for ad'.format(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 __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 process_ad(self):
"""
Wait for this ad to finish. Refreshes state.
"""
self._refresh_state()
if self._last_seen_player_state.player_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 for ad'.format(ad_timeout))
verbose_until(wait, self, YouTubePuppeteer._check_if_ad_ended,
"Check if ad ended")
except TimeoutException:
self.marionette.log('Waiting for ad to end timed out',
level='WARNING')
def __init__(self, marionette, url, autostart=True,
set_duration=10.0, **kwargs):
self.player = None
self._last_seen_player_state = None
super(TwitchPuppeteer,
self).__init__(marionette, url, set_duration=set_duration,
autostart=False, **kwargs)
wait = Wait(self.marionette, timeout=30)
with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
verbose_until(wait, self,
expected.element_present(By.CLASS_NAME,
'player'))
self.player = self.marionette.find_element(By.CLASS_NAME,
'player')
self.marionette.execute_script("log('.player "
"element obtained');")
if autostart:
self.start()
def __init__(self, marionette, url, autostart=True,
set_duration=10.0, **kwargs):
self.player = None
self._last_seen_player_state = None
super(TwitchPuppeteer,
self).__init__(marionette, url, set_duration=set_duration,
autostart=False, **kwargs)
wait = Wait(self.marionette, timeout=30)
with self.marionette.using_context(Marionette.CONTEXT_CONTENT):
verbose_until(wait, self,
expected.element_present(By.CLASS_NAME,
'player'))
self.player = self.marionette.find_element(By.CLASS_NAME,
'player')
self.marionette.execute_script("log('.player "
"element obtained');")
if autostart:
self.start()
def __init__(self,
marionette,
url,
video_selector='video',
interval=1,
set_duration=0,
stall_wait_time=0,
timeout=60,
autostart=True):
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._first_seen_time = 0
self._first_seen_wall_time = 0
self._fetch_state_script_string = None
self._last_seen_video_state = None
wait = Wait(self.marionette, timeout=self.timeout)
with self.marionette.using_context(Marionette.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');")
if autostart:
self.start()
def process_ad(self):
"""
Wait for this ad to finish. Refreshes state.
"""
self._refresh_state()
if self._last_seen_player_state.player_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 for ad'
.format(ad_timeout))
verbose_until(wait,
self,
YouTubePuppeteer._check_if_ad_ended,
"Check if ad ended")
except TimeoutException:
self.marionette.log('Waiting for ad to end timed out',
level='WARNING')
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 __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 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)
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)