| # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging, time |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros import cros_ui_test, httpd |
| |
| WAIT_TIMEOUT_S = 5 |
| PLAYBACK_TEST_TIME_S = 10 |
| PLAYER_PLAYING_STATE = 'Playing' |
| PLAYER_PAUSE_STATE = 'Paused' |
| PLAYER_ENDED_STATE = 'Ended' |
| |
| class desktopui_YouTubeHTML5(cros_ui_test.UITest): |
| """This test verify the YouTube HTML5 video. |
| |
| - verify the video playback. |
| - verify the available video resolutions. |
| - verify the player functionalities. |
| """ |
| version = 1 |
| |
| def initialize(self): |
| super(desktopui_YouTubeHTML5, self).initialize() |
| self._driver = self.pyauto.NewWebDriver() |
| self._video_duration = 0 |
| self._testServer = httpd.HTTPListener(8000, docroot=self.bindir) |
| self._testServer.run() |
| |
| def cleanup(self): |
| if self._testServer: |
| self._testServer.stop() |
| super(desktopui_YouTubeHTML5, self).cleanup() |
| |
| def video_current_time(self): |
| """Returns video's current playback time. |
| |
| Returns: |
| returns the current playback location in seconds (int). |
| """ |
| return int(self._driver.execute_script( |
| 'return player.getCurrentTime()')) |
| |
| def get_player_status(self): |
| """Returns the player status.""" |
| js = 'return playerStatus.innerHTML' |
| return self._driver.execute_script(js) |
| |
| def get_video_duration(self): |
| """Returns the video duration.""" |
| return int(self._driver.execute_script( |
| 'return player.getDuration()')) |
| |
| def set_playback_quality(self, quality): |
| """Set the video quality to the quality passed in the arg.""" |
| self._driver.execute_script( |
| 'player.setPlaybackQuality("%s")' % quality) |
| |
| def get_playback_quality(self): |
| """Returns the playback quality.""" |
| return self._driver.execute_script( |
| 'return player.getPlaybackQuality()') |
| |
| def wait_for_player_state(self, expected_status): |
| """Wait till the player status changes to expected_status. |
| |
| If the status doesn't change for long, the test will time out after |
| WAIT_TIMEOUT_S and fails. |
| """ |
| wait_time = 0 # seconds |
| while self.get_player_status() != expected_status: |
| time.sleep(1) |
| if wait_time > WAIT_TIMEOUT_S: |
| player_status = self.get_player_status() |
| raise error.TestError( |
| 'Video failed to load. Player expected status: %s' |
| 'and current status: %s.' |
| % (expected_status, player_status)) |
| wait_time += 1 |
| |
| def verify_video_playback(self): |
| """Verify the video playback.""" |
| logging.info('Verifying the YouTube video playback') |
| playback = 0 # seconds |
| prev_playback = 0 |
| while (self.video_current_time() < self._video_duration |
| and playback < PLAYBACK_TEST_TIME_S): |
| time.sleep(1) |
| if self.video_current_time() <= prev_playback: |
| player_status = self.get_player_status() |
| raise error.TestError( |
| 'Video is not playing. Player status: %s.' % player_status) |
| prev_playback = self.video_current_time() |
| playback = playback + 1 |
| |
| def verify_video_resolutions(self): |
| """Verify available video resolutions like 360p, 480p, 720p and |
| 1080p. |
| """ |
| logging.info('Verifying the video resolutions.') |
| video_qualities = self._driver.execute_script( |
| 'return player.getAvailableQualityLevels()') |
| if not video_qualities: |
| raise error.TestError( |
| 'Player failed to return available video qualities.') |
| for quality in video_qualities: |
| logging.info('Playing video in %s quality.' % quality) |
| self.set_playback_quality(quality) |
| self.wait_for_player_state(PLAYER_PLAYING_STATE) |
| current_quality = self.get_playback_quality() |
| if quality != current_quality: |
| raise error.TestError( |
| 'Expected video quality: %s. Current video quality: %s' |
| % (quality, current_quality)) |
| |
| def verify_player_states(self): |
| """Verify the player states like play, pause, ended and seek.""" |
| logging.info('Verifying the player states.') |
| self._driver.execute_script('player.pauseVideo()') |
| self.wait_for_player_state(PLAYER_PAUSE_STATE) |
| self._driver.execute_script('player.playVideo()') |
| self.wait_for_player_state(PLAYER_PLAYING_STATE) |
| # We are seeking the player position to (video length - 2 seconds). |
| # Since the player waits for WAIT_TIMEOUT_S for the status change, |
| # the video should be ended before we hit the timeout. |
| video_end_test_duration = (self._video_duration - |
| self.video_current_time() - 2) |
| if video_end_test_duration >= WAIT_TIMEOUT_S: |
| self._driver.execute_script( |
| 'player.seekTo(%d, true)' % (self._video_duration - 2)) |
| self.wait_for_player_state(PLAYER_ENDED_STATE) |
| else: |
| raise error.TestError( |
| 'Test video is not long enough for the video end test.') |
| # Verifying seek back from the end position. |
| self._driver.execute_script('player.seekTo(%d, true)' |
| % (self._video_duration / 2)) |
| self.wait_for_player_state(PLAYER_PLAYING_STATE) |
| # So the playback doesn't stay at the mid. |
| time.sleep(1) |
| seek_position = self.video_current_time() |
| if not (seek_position > self._video_duration / 2 |
| and seek_position < self._video_duration): |
| raise error.TestError( |
| 'Seek location is wrong. Video length: %d, seek position: %d' % |
| (self._video_duration, seek_position)) |
| |
| def run_once(self): |
| self._driver.get('http://localhost:8000/youtube5.html') |
| |
| # Verify that we are not in the Flash YouTube mode. |
| child_processes = self.pyauto.GetBrowserInfo()['child_processes'] |
| flash_processes = [x for x in child_processes if |
| x['name'] == 'Shockwave Flash'] |
| if flash_processes: |
| raise error.TestFail('Running YouTube in Flash mode.') |
| |
| # Waiting for test video to load. |
| self.wait_for_player_state(PLAYER_PLAYING_STATE) |
| self._driver.execute_script('player.setVolume(0)') |
| self._video_duration = self.get_video_duration() |
| self.verify_video_playback() |
| self.verify_video_resolutions() |
| self.verify_player_states() |
