Adding tests.

Disabled Jasmine test due to flakiness on dev machine.
Added test for endTime in update().
Enabled updatePlayTime() tests. Will see on Jenkins.
Adding test for updatePlayTime() method.
Adding ProgressSlider notifyThroughHandleEnd() Jasmine tests.
Fixing Jasmine coverage problems.
Removed cover logs.
Fixing flaky test.
Removed code coverage logs.

BLD-488

common/lib/xmodule/xmodule/js/spec/video/video_focus_grabber_spec.js

@@ -72,7 +72,17 @@
             expect(state.focusGrabber.disableFocusGrabber).toHaveBeenCalled();
         });
 
-        it('after controls hide focus grabbers are enabled', function () {
+        // Disabled on 18.11.2013 due to flakiness on local dev machine.
+        //
+        //     Video FocusGrabber: after controls hide focus grabbers are
+        //     enabled [fail]
+        //         Expected spy enableFocusGrabber to have been called.
+        //
+        // Approximately 1 in 8 times this test fails.
+        //
+        // TODO: Most likely, focusGrabber will be disabled in the future. This
+        // test could become unneeded in the future.
+        xit('after controls hide focus grabbers are enabled', function () {
             runs(function () {
                 // Captions should not be "sticky" for the autohide mechanism
                 // to work.

common/lib/xmodule/xmodule/js/spec/video/video_player_spec.js

@@ -4,11 +4,26 @@
             videoProgressSlider, videoSpeedControl, videoVolumeControl,
             oldOTBD;
 
-        function initialize(fixture) {
-            if (typeof fixture === 'undefined') {
-                loadFixtures('video_all.html');
+        function initialize(config) {
+            if (config) {
+                if (config.fixture) {
+                    loadFixtures(config.fixture);
+                } else {
+                    loadFixtures('video_all.html');
+                }
+
+                if (config.startTime) {
+                    $('#example')
+                        .find('#video_id')
+                        .data('start', config.startTime);
+                }
+                if (config.endTime) {
+                    $('#example')
+                        .find('#video_id')
+                        .data('end', config.endTime);
+                }
             } else {
-                loadFixtures(fixture);
+                loadFixtures('video_all.html');
             }
 
             state = new Video('#example');
@@ -41,7 +56,7 @@
         }
 
         function initializeYouTube() {
-            initialize('video.html');
+            initialize({fixture: 'video.html'});
         }
 
         beforeEach(function () {
@@ -532,8 +547,54 @@
             });
         });
 
-        // Disabled 10/24/13 due to flakiness in master
-        xdescribe('updatePlayTime', function () {
+        describe('update with start & end time', function () {
+            var START_TIME = 2, END_TIME = 4;
+
+            beforeEach(function () {
+                initialize({startTime: START_TIME, endTime: END_TIME});
+
+                spyOn(videoPlayer, 'update').andCallThrough();
+                spyOn(videoPlayer, 'pause').andCallThrough();
+                spyOn(videoProgressSlider, 'notifyThroughHandleEnd')
+                    .andCallThrough();
+            });
+
+            it('video is paused on first endTime, start & end time are reset', function () {
+                var checkForStartEndTimeSet = true;
+
+                videoProgressSlider.notifyThroughHandleEnd.reset();
+                videoPlayer.pause.reset();
+                videoPlayer.play();
+
+                waitsFor(function () {
+                    if (
+                        !isFinite(videoPlayer.currentTime) ||
+                        videoPlayer.currentTime <= 0
+                    ) {
+                        return false;
+                    }
+
+                    if (checkForStartEndTimeSet) {
+                        checkForStartEndTimeSet = false;
+
+                        expect(videoPlayer.startTime).toBe(START_TIME);
+                        expect(videoPlayer.endTime).toBe(END_TIME);
+                    }
+
+                    return videoPlayer.pause.calls.length === 1
+                }, 5000, 'pause() has been called');
+
+                runs(function () {
+                    expect(videoPlayer.startTime).toBe(0);
+                    expect(videoPlayer.endTime).toBe(null);
+
+                    expect(videoProgressSlider.notifyThroughHandleEnd)
+                        .toHaveBeenCalledWith({end: true});
+                });
+            });
+        });
+
+        describe('updatePlayTime', function () {
             beforeEach(function () {
                 initialize();
 
@@ -548,7 +609,7 @@
                     duration = videoPlayer.duration();
 
                     if (duration > 0) {
-                    return true;
+                        return true;
                     }
 
                     return false;
@@ -612,6 +673,73 @@
             });
         });
 
+        describe('updatePlayTime with start & end times', function () {
+            beforeEach(function () {
+                initialize({startTime: 2, endTime: 4});
+
+                spyOn(videoPlayer, 'updatePlayTime').andCallThrough();
+                spyOn(videoPlayer.player, 'seekTo').andCallThrough();
+                spyOn(videoProgressSlider, 'updateStartEndTimeRegion')
+                    .andCallThrough();
+            });
+
+            it('when duration becomes available, updatePlayTime() is called', function () {
+                var duration;
+
+                expect(videoPlayer.initialSeekToStartTime).toBeTruthy();
+                expect(videoPlayer.seekToStartTimeOldSpeed).toBe('void');
+
+                videoPlayer.play();
+
+                waitsFor(function () {
+                    duration = videoPlayer.duration();
+
+                    return duration > 0 &&
+                        videoPlayer.initialSeekToStartTime === false;
+                }, 'duration becomes available', 1000);
+
+                runs(function () {
+                    expect(videoPlayer.startTime).toBe(2);
+                    expect(videoPlayer.endTime).toBe(4);
+
+                    expect(videoPlayer.player.seekTo).toHaveBeenCalledWith(2);
+
+                    expect(videoProgressSlider.updateStartEndTimeRegion)
+                        .toHaveBeenCalledWith({duration: duration});
+
+                    // videoProgressSlider.updateStartEndTimeRegion
+
+                    expect(videoPlayer.seekToStartTimeOldSpeed).toBe(state.speed);
+                });
+            });
+        });
+
+        describe('updatePlayTime with invalid endTime', function () {
+            beforeEach(function () {
+                initialize({endTime: 100000});
+
+                spyOn(videoPlayer, 'updatePlayTime').andCallThrough();
+            });
+
+            it('invalid endTime is reset to null', function () {
+                var duration;
+
+                videoPlayer.updatePlayTime.reset();
+                videoPlayer.play();
+
+                waitsFor(function () {
+                    duration = videoPlayer.duration();
+
+                    return duration > 0 &&
+                        videoPlayer.initialSeekToStartTime === false;
+                }, 'updatePlayTime was invoked and duration is set', 5000);
+
+                runs(function () {
+                    expect(videoPlayer.endTime).toBe(null);
+                });
+            });
+        });
+
         describe('toggleFullScreen', function () {
             describe('when the video player is not full screen', function () {
                 beforeEach(function () {

common/lib/xmodule/xmodule/js/spec/video/video_progress_slider_spec.js

@@ -285,6 +285,55 @@
                 expect(params).toEqual(expectedParams);
             });
         });
+
+        describe('notifyThroughHandleEnd', function () {
+            beforeEach(function () {
+                initialize();
+
+                spyOnEvent(videoProgressSlider.handle, 'focus');
+                spyOn(videoProgressSlider, 'notifyThroughHandleEnd')
+                    .andCallThrough();
+            });
+
+            it('params.end = true', function () {
+                videoProgressSlider.notifyThroughHandleEnd({end: true});
+
+                expect(videoProgressSlider.handle.attr('title'))
+                    .toBe('video ended');
+
+                expect('focus').toHaveBeenTriggeredOn(videoProgressSlider.handle);
+            });
+
+            it('params.end = false', function () {
+                videoProgressSlider.notifyThroughHandleEnd({end: false});
+
+                expect(videoProgressSlider.handle.attr('title'))
+                    .toBe('video position');
+
+                expect('focus').not.toHaveBeenTriggeredOn(videoProgressSlider.handle);
+            });
+
+            it('is called when video plays', function () {
+                videoPlayer.play();
+
+                waitsFor(function () {
+                    var duration = videoPlayer.duration(),
+                        currentTime = videoPlayer.currentTime;
+
+                    return (
+                        isFinite(duration) &&
+                        duration > 0 &&
+                        isFinite(currentTime) &&
+                        currentTime > 0
+                    );
+                }, 'duration is set, video is playing', 5000);
+
+                runs(function () {
+                    expect(videoProgressSlider.notifyThroughHandleEnd)
+                        .toHaveBeenCalledWith({end: false});
+                });
+            });
+        });
     });
 
 }).call(this);

common/lib/xmodule/xmodule/js/src/video/03_video_player.js

@@ -83,9 +83,9 @@ function (HTML5Video, Resizer) {
 
         state.videoPlayer.initialSeekToStartTime = true;
 
-        // The initial value of the variable `seekToStartTimeOldSpeed`
-        // should always differ from the value returned by the duration
-        // function.
+        // At the start, the initial value of the variable
+        // `seekToStartTimeOldSpeed` should always differ from the value
+        // returned by the duration function.
         state.videoPlayer.seekToStartTimeOldSpeed = 'void';
 
         state.videoPlayer.playerVars = {
@@ -616,20 +616,6 @@ function (HTML5Video, Resizer) {
                 }
             }
 
-            // If this is not a duration change (if it is, we continue playing
-            // from current time), then we need to seek the video to the start
-            // time.
-            //
-            // We seek only if start time differs from zero, and we haven't
-            // performed already such a seek.
-            if (
-                durationChange === false &&
-                this.videoPlayer.startTime > 0 &&
-                !(tempStartTime === 0 && tempEndTime === null)
-            ) {
-                this.videoPlayer.player.seekTo(this.videoPlayer.startTime);
-            }
-
             // Rebuild the slider start-end range (if it doesn't take up the
             // whole slider). Remember that endTime === null means the end time
             // is set to the end of video by default.
@@ -645,6 +631,20 @@ function (HTML5Video, Resizer) {
                 );
             }
 
+            // If this is not a duration change (if it is, we continue playing
+            // from current time), then we need to seek the video to the start
+            // time.
+            //
+            // We seek only if start time differs from zero, and we haven't
+            // performed already such a seek.
+            if (
+                durationChange === false &&
+                this.videoPlayer.startTime > 0 &&
+                !(tempStartTime === 0 && tempEndTime === null)
+            ) {
+                this.videoPlayer.player.seekTo(this.videoPlayer.startTime);
+            }
+
             // Reset back the actual startTime and endTime if they have been
             // already reset (a seek event happened, the video already ended
             // once, or endTime has already been reached once).