| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 import re | |
| 7 import time | |
| 8 | |
| 9 import pyauto_functional | |
| 10 import pyauto | |
| 11 import pyauto_errors | |
| 12 import test_utils | |
| 13 | |
| 14 | |
| 15 class YoutubeTestHelper(): | |
| 16 """Helper functions for Youtube tests. | |
| 17 | |
| 18 For sample usage, look at class YoutubeTest. | |
| 19 """ | |
| 20 | |
| 21 # YouTube player states | |
| 22 is_unstarted = '-1' | |
| 23 is_playing = '1' | |
| 24 is_paused = '2' | |
| 25 has_ended = '0' | |
| 26 _pyauto = None | |
| 27 | |
| 28 def __init__(self, pyauto): | |
| 29 self._pyauto = pyauto | |
| 30 | |
| 31 def IsFlashPluginEnabled(self): | |
| 32 """Verify flash plugin availability and its state.""" | |
| 33 return [x for x in self._pyauto.GetPluginsInfo().Plugins() \ | |
| 34 if x['name'] == 'Shockwave Flash' and x['enabled']] | |
| 35 | |
| 36 def AssertPlayerState(self, state, msg): | |
| 37 expected_regex = '^%s$' % state | |
| 38 self.WaitForDomNode('id("playerState")', expected_value=expected_regex, | |
| 39 msg=msg) | |
| 40 | |
| 41 def WaitUntilPlayerReady(self): | |
| 42 """Verify that player is ready.""" | |
| 43 self.AssertPlayerState(state=self.is_unstarted, | |
| 44 msg='Failed to load youtube player.') | |
| 45 | |
| 46 def GetPlayerState(self): | |
| 47 """Returns a player state.""" | |
| 48 js = """ | |
| 49 var val = ytplayer.getPlayerState(); | |
| 50 window.domAutomationController.send(val + ''); | |
| 51 """ | |
| 52 return self._pyauto.ExecuteJavascript(js) | |
| 53 | |
| 54 def GetVideoInfo(self): | |
| 55 """Returns Youtube video info.""" | |
| 56 youtube_apis = self._pyauto.GetPrivateInfo()['youtube_api'] | |
| 57 youtube_debug_text = youtube_apis['GetDebugText'] | |
| 58 return self._pyauto.ExecuteJavascript( | |
| 59 'window.domAutomationController.send(%s);' % youtube_debug_text) | |
| 60 | |
| 61 def GetVideoDroppedFrames(self): | |
| 62 """Returns total Youtube video dropped frames. | |
| 63 | |
| 64 Returns: | |
| 65 -1 if failed to get video frames from the video data | |
| 66 """ | |
| 67 video_data = self._pyauto.GetVideoInfo() | |
| 68 matched = re.search('droppedFrames=([\d\.]+)', video_data) | |
| 69 if matched: | |
| 70 return int(matched.group(1)) | |
| 71 else: | |
| 72 return -1 | |
| 73 | |
| 74 def GetVideoFrames(self): | |
| 75 """Returns Youtube video frames/second. | |
| 76 | |
| 77 Returns: | |
| 78 -1 if failed to get droppd frames from the video data. | |
| 79 """ | |
| 80 video_data = self._pyauto.GetVideoInfo() | |
| 81 matched = re.search('videoFps=([\d\.]+)', video_data) | |
| 82 if matched: | |
| 83 return int(matched.group(1)) | |
| 84 else: | |
| 85 return -1 | |
| 86 | |
| 87 def GetVideoTotalBytes(self): | |
| 88 """Returns video total size in bytes. | |
| 89 | |
| 90 To call this function, video must be in the paying state, | |
| 91 or this returns 0. | |
| 92 """ | |
| 93 total_bytes = 0 | |
| 94 total_bytes = self._pyauto.ExecuteJavascript(""" | |
| 95 bytesTotal = document.getElementById("bytesTotal"); | |
| 96 window.domAutomationController.send(bytesTotal.innerHTML); | |
| 97 """) | |
| 98 return int(total_bytes) | |
| 99 | |
| 100 def GetVideoLoadedBytes(self): | |
| 101 """Returns video size in bytes.""" | |
| 102 loaded_bytes = 0 | |
| 103 loaded_bytes = self.ExecuteJavascript(""" | |
| 104 bytesLoaded = document.getElementById("bytesLoaded"); | |
| 105 window.domAutomationController.send(bytesLoaded.innerHTML); | |
| 106 """) | |
| 107 return int(loaded_bytes) | |
| 108 | |
| 109 def GetCurrentVideoTime(self): | |
| 110 """Returns the current time of the video in seconds.""" | |
| 111 current_time = 0 | |
| 112 current_time = self.ExecuteJavascript(""" | |
| 113 videoCurrentTime = document.getElementById("videoCurrentTime"); | |
| 114 window.domAutomationController.send(videoCurrentTime.innerHTML); | |
| 115 """) | |
| 116 return int(current_time) | |
| 117 | |
| 118 def PlayVideo(self): | |
| 119 """Plays the loaded video.""" | |
| 120 self._pyauto.ExecuteJavascript(""" | |
| 121 ytplayer.playVideo(); | |
| 122 window.domAutomationController.send(''); | |
| 123 """) | |
| 124 | |
| 125 def StopVideo(self): | |
| 126 """Stops the video and cancels loading.""" | |
| 127 self._pyauto.ExecuteJavascript(""" | |
| 128 ytplayer.stopVideo(); | |
| 129 window.domAutomationController.send(''); | |
| 130 """) | |
| 131 | |
| 132 def PauseVideo(self): | |
| 133 """Pause the video.""" | |
| 134 self.ExecuteJavascript(""" | |
| 135 ytplayer.pauseVideo(); | |
| 136 window.domAutomationController.send(''); | |
| 137 """) | |
| 138 | |
| 139 def PlayVideoAndAssert(self, youtube_video='zuzaxlddWbk', | |
| 140 ignore_assert=False): | |
| 141 """Start video and assert the playing state. | |
| 142 | |
| 143 By default test uses http://www.youtube.com/watch?v=zuzaxlddWbki. | |
| 144 | |
| 145 Args: | |
| 146 youtube_video: The string ID of the youtube video to play. | |
| 147 ignore_assert: flag to ignore the assertion and continue the test. | |
| 148 """ | |
| 149 self._pyauto.assertTrue(self._pyauto.IsFlashPluginEnabled(), | |
| 150 msg='From here Flash plugin is disabled or not available.') | |
| 151 url = self._pyauto.GetHttpURLForDataPath( | |
| 152 'media', 'youtube.html?video=' + youtube_video) | |
| 153 self._pyauto.NavigateToURL(url) | |
| 154 self.WaitUntilPlayerReady() | |
| 155 i = 0 | |
| 156 # The YouTube player will get in a state where it does not return the | |
| 157 # number of loaded bytes. When this happens we need to reload the page | |
| 158 # before starting the test. | |
| 159 while self.GetVideoLoadedBytes() == 1 and i < 30: | |
| 160 self._pyauto.NavigateToURL(url) | |
| 161 self.WaitUntilPlayerReady() | |
| 162 i = i + 1 | |
| 163 self.PlayVideo() | |
| 164 if ignore_assert: | |
| 165 return self.is_playing | |
| 166 self.AssertPlayerState(state=self.is_playing, | |
| 167 msg='Player did not enter the playing state.') | |
| 168 | |
| 169 def VideoBytesLoadingAndAssert(self): | |
| 170 """Assert the video loading.""" | |
| 171 total_bytes = self.GetVideoTotalBytes() | |
| 172 prev_loaded_bytes = 0 | |
| 173 loaded_bytes = 0 | |
| 174 count = 0 | |
| 175 while loaded_bytes < total_bytes: | |
| 176 # We want to test bytes loading only twice | |
| 177 count = count + 1 | |
| 178 if count == 2: | |
| 179 break | |
| 180 loaded_bytes = self.GetVideoLoadedBytes() | |
| 181 self.assertTrue(prev_loaded_bytes <= loaded_bytes) | |
| 182 prev_loaded_bytes = loaded_bytes | |
| 183 # Give some time to load a video | |
| 184 time.sleep(1) | |
| 185 | |
| 186 def PlayFAVideo(self): | |
| 187 """Play and assert FA video playing. | |
| 188 | |
| 189 We are using multiple test videos in case any FA video playback fails | |
| 190 becuase other tests are palying the same video and the test gets the | |
| 191 simultaneous playback error. | |
| 192 """ | |
| 193 fa_videos = ('APRpcscmbY0', 'yQqvrED-np0', 'KJuFw6hQdNY', | |
| 194 'BeFQbgxr_9g', 'L6JwlOudqA4') | |
| 195 credentials = self.GetPrivateInfo()['test_fa_account'] | |
| 196 test_utils.GoogleAccountsLogin(self, | |
| 197 credentials['username'], credentials['password']) | |
| 198 for video in fa_videos: | |
| 199 result = self.PlayVideoAndAssert(video, ignore_assert=True) | |
| 200 if result is self.is_playing: | |
| 201 return | |
| 202 self.assertTrue(False, msg='Player did not enter the playing state.') | |
| 203 | |
| 204 | |
| 205 class YoutubeTest(pyauto.PyUITest, YoutubeTestHelper): | |
| 206 """Test case for Youtube videos.""" | |
| 207 | |
| 208 def __init__(self, methodName='runTest', **kwargs): | |
| 209 pyauto.PyUITest.__init__(self, methodName, **kwargs) | |
| 210 YoutubeTestHelper.__init__(self, self) | |
| 211 | |
| 212 def testPlayerStatus(self): | |
| 213 """Test that YouTube loads a player and changes player states. | |
| 214 | |
| 215 Test verifies various player states like unstarted, playing, paused | |
| 216 and ended. | |
| 217 """ | |
| 218 # Navigating to Youtube video. This video is 122 seconds long. | |
| 219 # During tests, we are not goinig to play this video full. | |
| 220 self.PlayVideoAndAssert() | |
| 221 self.PauseVideo() | |
| 222 self.AssertPlayerState(state=self.is_paused, | |
| 223 msg='Player did not enter the paused state.') | |
| 224 # Seek to the end of video | |
| 225 self.ExecuteJavascript(""" | |
| 226 val = ytplayer.getDuration(); | |
| 227 ytplayer.seekTo(val, true); | |
| 228 window.domAutomationController.send(''); | |
| 229 """) | |
| 230 self.PlayVideo() | |
| 231 # We've seeked to almost the end of the video but not quite. | |
| 232 # Wait until the end. | |
| 233 self.AssertPlayerState(state=self.has_ended, | |
| 234 msg='Player did not reach the stopped state.') | |
| 235 | |
| 236 def testPlayerResolution(self): | |
| 237 """Test various video resolutions.""" | |
| 238 self.PlayVideoAndAssert() | |
| 239 resolutions = self.ExecuteJavascript(""" | |
| 240 res = ytplayer.getAvailableQualityLevels(); | |
| 241 window.domAutomationController.send(res.toString()); | |
| 242 """) | |
| 243 resolutions = resolutions.split(',') | |
| 244 for res in resolutions: | |
| 245 self.ExecuteJavascript(""" | |
| 246 ytplayer.setPlaybackQuality('%s'); | |
| 247 window.domAutomationController.send(''); | |
| 248 """ % res) | |
| 249 curr_res = self.ExecuteJavascript(""" | |
| 250 res = ytplayer.getPlaybackQuality(); | |
| 251 window.domAutomationController.send(res + ''); | |
| 252 """) | |
| 253 self.assertEqual(res, curr_res, msg='Resolution is not set to %s.' % res) | |
| 254 | |
| 255 def testPlayerBytes(self): | |
| 256 """Test that player downloads video bytes.""" | |
| 257 self.PlayVideoAndAssert() | |
| 258 self.VideoBytesLoadingAndAssert() | |
| 259 | |
| 260 def testFAVideo(self): | |
| 261 """Test that FlashAccess/DRM video plays.""" | |
| 262 self.PlayFAVideo() | |
| 263 self.StopVideo() | |
| 264 | |
| 265 def testFAVideoBytes(self): | |
| 266 """Test FlashAccess/DRM video bytes loading.""" | |
| 267 self.PlayFAVideo() | |
| 268 self.VideoBytesLoadingAndAssert() | |
| 269 self.StopVideo() | |
| 270 | |
| 271 | |
| 272 if __name__ == '__main__': | |
| 273 pyauto_functional.Main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
