2024-05-21 18:24:39 +00:00
const { MultimediaViewer } = require ( 'mmv' ) ;
2023-05-20 08:30:52 +00:00
const { getMultimediaViewer } = require ( './mmv.testhelpers.js' ) ;
const { MultimediaViewerBootstrap } = require ( 'mmv.bootstrap' ) ;
2018-11-12 16:33:24 +00:00
( function ( ) {
2023-10-06 02:58:23 +00:00
QUnit . module ( 'mmv' , QUnit . newMwEnvironment ( {
beforeEach : function ( ) {
// prevent a real "back" navigation from taking place
this . sandbox . stub ( require ( 'mediawiki.router' ) , 'back' ) ;
}
} ) ) ;
2013-11-27 21:57:45 +00:00
2019-05-18 16:19:44 +00:00
QUnit . test ( 'eachPreloadableLightboxIndex()' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
let expectedIndices ;
let i ;
2014-02-13 09:52:40 +00:00
viewer . preloadDistance = 3 ;
2014-02-17 15:09:23 +00:00
viewer . thumbs = [ ] ;
// 0..10
for ( i = 0 ; i < 11 ; i ++ ) {
2015-01-23 12:48:27 +00:00
viewer . thumbs . push ( { image : false } ) ;
2014-02-17 15:09:23 +00:00
}
2014-02-13 09:52:40 +00:00
2014-03-05 02:24:18 +00:00
viewer . currentIndex = 2 ;
2014-02-13 09:52:40 +00:00
i = 0 ;
2016-07-18 13:49:27 +00:00
expectedIndices = [ 2 , 3 , 1 , 4 , 0 , 5 ] ;
2019-05-18 16:19:44 +00:00
viewer . eachPreloadableLightboxIndex ( function ( index ) {
2016-07-18 13:49:27 +00:00
assert . strictEqual ( index , expectedIndices [ i ++ ] , 'preload on left edge' ) ;
2014-02-13 09:52:40 +00:00
} ) ;
2014-03-05 02:24:18 +00:00
viewer . currentIndex = 9 ;
2014-02-13 09:52:40 +00:00
i = 0 ;
2016-07-18 13:49:27 +00:00
expectedIndices = [ 9 , 10 , 8 , 7 , 6 ] ;
2019-05-18 16:19:44 +00:00
viewer . eachPreloadableLightboxIndex ( function ( index ) {
2016-07-18 13:49:27 +00:00
assert . strictEqual ( index , expectedIndices [ i ++ ] , 'preload on right edge' ) ;
2014-02-13 09:52:40 +00:00
} ) ;
} ) ;
2014-02-21 11:16:30 +00:00
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Progress' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const imageDeferred = $ . Deferred ( ) ;
const viewer = getMultimediaViewer ( ) ;
const fakeImage = {
2024-05-15 18:59:58 +00:00
filePageTitle : new mw . Title ( 'File:Stuff.jpg' )
2023-10-24 09:53:23 +00:00
} ;
// custom clock ensures progress handlers execute in correct sequence
const clock = this . sandbox . useFakeTimers ( ) ;
2014-02-25 13:43:22 +00:00
viewer . thumbs = [ ] ;
2019-02-05 23:59:52 +00:00
viewer . displayPlaceholderThumbnail = function ( ) { } ;
viewer . setImage = function ( ) { } ;
viewer . scroll = function ( ) { } ;
viewer . preloadFullscreenThumbnail = function ( ) { } ;
2023-06-27 20:33:13 +00:00
viewer . fetchSizeIndependentLightboxInfo = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
2014-03-05 02:24:18 +00:00
viewer . ui = {
2019-02-05 23:59:52 +00:00
setFileReuseData : function ( ) { } ,
setupForLoad : function ( ) { } ,
canvas : { set : function ( ) { } ,
unblurWithAnimation : function ( ) { } ,
unblur : function ( ) { } ,
2024-02-13 00:44:51 +00:00
getCurrentImageWidths : function ( ) {
return { real : 0 } ;
} ,
getDimensions : function ( ) {
return { } ;
}
2014-09-26 18:37:53 +00:00
} ,
2014-09-12 18:05:13 +00:00
panel : {
2019-02-05 23:59:52 +00:00
setImageInfo : function ( ) { } ,
2014-05-05 21:44:27 +00:00
scroller : {
2019-02-05 23:59:52 +00:00
animateMetadataOnce : function ( ) { }
2014-05-05 21:44:27 +00:00
} ,
2014-04-21 21:48:40 +00:00
progressBar : {
2023-04-25 08:49:10 +00:00
hide : this . sandbox . stub ( ) ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
animateTo : this . sandbox . stub ( ) ,
jumpTo : this . sandbox . stub ( )
2014-03-05 02:24:18 +00:00
}
} ,
2019-02-05 23:59:52 +00:00
open : function ( ) { } } ;
2014-02-25 13:43:22 +00:00
2023-06-27 20:33:13 +00:00
viewer . imageProvider . get = ( ) => imageDeferred . promise ( ) ;
viewer . imageInfoProvider . get = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
viewer . thumbnailInfoProvider . get = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
2014-02-25 13:43:22 +00:00
2017-05-11 15:03:52 +00:00
// loadImage will call setupProgressBar, which will attach done, fail &
// progress handlers
2024-05-21 18:24:39 +00:00
viewer . loadImage ( fakeImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . jumpTo . lastCall . calledWith ( 0 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly reset by loadImage' ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . firstCall . calledWith ( 5 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly animated to 5 by loadImage' ) ;
2014-02-25 13:43:22 +00:00
imageDeferred . notify ( 'response' , 45 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . secondCall . calledWith ( 45 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly funneled to panel UI' ) ;
2014-12-30 05:10:27 +00:00
imageDeferred . resolve ( { } , { } ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . thirdCall . calledWith ( 100 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly funneled to panel UI' ) ;
2017-05-11 15:03:52 +00:00
clock . restore ( ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . close ( ) ;
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Progress when switching images' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const firstImageDeferred = $ . Deferred ( ) ;
const secondImageDeferred = $ . Deferred ( ) ;
const firstImage = {
index : 1 ,
2024-05-15 18:59:58 +00:00
filePageTitle : new mw . Title ( 'File:First.jpg' )
2023-10-24 09:53:23 +00:00
} ;
const secondImage = {
index : 2 ,
2024-05-15 18:59:58 +00:00
filePageTitle : new mw . Title ( 'File:Second.jpg' )
2023-10-24 09:53:23 +00:00
} ;
const viewer = getMultimediaViewer ( ) ;
// custom clock ensures progress handlers execute in correct sequence
const clock = this . sandbox . useFakeTimers ( ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
2015-06-24 18:54:22 +00:00
// animation would keep running, conflict with other tests
this . sandbox . stub ( $ . fn , 'animate' ) . returnsThis ( ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . thumbs = [ ] ;
2019-02-05 23:59:52 +00:00
viewer . displayPlaceholderThumbnail = function ( ) { } ;
viewer . setImage = function ( ) { } ;
viewer . scroll = function ( ) { } ;
viewer . preloadFullscreenThumbnail = function ( ) { } ;
viewer . preloadImagesMetadata = function ( ) { } ;
viewer . preloadThumbnails = function ( ) { } ;
2023-06-27 20:33:13 +00:00
viewer . fetchSizeIndependentLightboxInfo = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . ui = {
2019-02-05 23:59:52 +00:00
setFileReuseData : function ( ) { } ,
setupForLoad : function ( ) { } ,
canvas : { set : function ( ) { } ,
unblurWithAnimation : function ( ) { } ,
unblur : function ( ) { } ,
2024-02-13 00:44:51 +00:00
getCurrentImageWidths : function ( ) {
return { real : 0 } ;
} ,
getDimensions : function ( ) {
return { } ;
}
2014-09-26 18:37:53 +00:00
} ,
2015-01-23 12:48:27 +00:00
panel : {
2019-02-05 23:59:52 +00:00
setImageInfo : function ( ) { } ,
2014-05-05 21:44:27 +00:00
scroller : {
2019-02-05 23:59:52 +00:00
animateMetadataOnce : function ( ) { }
2014-05-05 21:44:27 +00:00
} ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
progressBar : {
hide : this . sandbox . stub ( ) ,
animateTo : this . sandbox . stub ( ) ,
jumpTo : this . sandbox . stub ( )
}
} ,
2019-02-05 23:59:52 +00:00
open : function ( ) { } ,
empty : function ( ) { } } ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
2023-06-27 20:33:13 +00:00
viewer . imageInfoProvider . get = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
viewer . thumbnailInfoProvider . get = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
// load some image
viewer . imageProvider . get = this . sandbox . stub ( ) . returns ( firstImageDeferred ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( firstImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . jumpTo . getCall ( 0 ) . calledWith ( 0 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly reset for new first image' ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . getCall ( 0 ) . calledWith ( 5 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly animated to 5 for first new image' ) ;
2017-05-11 15:03:52 +00:00
// progress on active image
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
firstImageDeferred . notify ( 'response' , 20 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . getCall ( 1 ) . calledWith ( 20 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly animated when active image is loading' ) ;
// change to another image
viewer . imageProvider . get = this . sandbox . stub ( ) . returns ( secondImageDeferred ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( secondImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . jumpTo . getCall ( 1 ) . calledWith ( 0 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly reset for second new image' ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . getCall ( 2 ) . calledWith ( 5 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly animated to 5 for second new image' ) ;
2017-05-11 15:03:52 +00:00
// progress on active image
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
secondImageDeferred . notify ( 'response' , 30 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . getCall ( 3 ) . calledWith ( 30 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage correctly animated when active image is loading' ) ;
2017-05-11 15:03:52 +00:00
// progress on inactive image
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
firstImageDeferred . notify ( 'response' , 40 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 17:23:16 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . callCount , 4 ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage not animated when inactive image is loading' ) ;
2017-05-11 15:03:52 +00:00
// progress on active image
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
secondImageDeferred . notify ( 'response' , 50 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . getCall ( 4 ) . calledWith ( 50 ) , true ,
2017-05-11 15:03:52 +00:00
'Percentage correctly ignored inactive image & only animated when active image is loading' ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
// change back to first image
2017-05-11 15:03:52 +00:00
viewer . imageProvider . get = this . sandbox . stub ( ) . returns ( firstImageDeferred ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( firstImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . jumpTo . getCall ( 2 ) . calledWith ( 40 ) , true ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Percentage jumps to right value when changing images' ) ;
2014-12-30 05:10:27 +00:00
secondImageDeferred . resolve ( { } , { } ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . hide . called , false ,
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
'Progress bar not hidden when something finishes in the background' ) ;
2017-05-11 15:03:52 +00:00
// change back to second image, which has finished loading
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . imageProvider . get = this . sandbox . stub ( ) . returns ( secondImageDeferred ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( secondImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . hide . called , true ,
2017-05-11 15:03:52 +00:00
'Progress bar hidden when switching to finished image' ) ;
clock . restore ( ) ;
2014-02-25 13:43:22 +00:00
viewer . close ( ) ;
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'resetBlurredThumbnailStates' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
2014-02-25 13:43:22 +00:00
2015-06-24 18:54:22 +00:00
// animation would keep running, conflict with other tests
this . sandbox . stub ( $ . fn , 'animate' ) . returnsThis ( ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , false , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , false , 'Placeholder state is correct' ) ;
2014-02-25 13:43:22 +00:00
viewer . realThumbnailShown = true ;
viewer . blurredThumbnailShown = true ;
viewer . resetBlurredThumbnailStates ( ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , false , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , false , 'Placeholder state is correct' ) ;
2014-02-25 13:43:22 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Placeholder first, then real thumbnail' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
2014-02-25 13:43:22 +00:00
2019-02-05 23:59:52 +00:00
viewer . setImage = function ( ) { } ;
2015-01-23 12:48:27 +00:00
viewer . ui = { canvas : {
2019-02-05 23:59:52 +00:00
unblurWithAnimation : function ( ) { } ,
unblur : function ( ) { } ,
2024-02-13 00:44:51 +00:00
maybeDisplayPlaceholder : function ( ) {
return true ;
}
2014-03-05 02:24:18 +00:00
} } ;
2014-04-24 01:03:24 +00:00
viewer . imageInfoProvider . get = this . sandbox . stub ( ) ;
2014-02-25 13:43:22 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayPlaceholderThumbnail ( { originalWidth : 100 , originalHeight : 100 } , undefined , undefined ) ;
2014-04-24 01:03:24 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . blurredThumbnailShown , true , 'Placeholder state is correct' ) ;
assert . strictEqual ( viewer . realThumbnailShown , false , 'Real thumbnail state is correct' ) ;
2014-04-24 01:03:24 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayRealThumbnail ( { url : undefined } ) ;
2014-04-24 01:03:24 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , true , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , true , 'Placeholder state is correct' ) ;
2014-04-24 01:03:24 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Placeholder first, then real thumbnail - missing size' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
2014-04-24 01:03:24 +00:00
viewer . currentIndex = 1 ;
2019-02-05 23:59:52 +00:00
viewer . setImage = function ( ) { } ;
2015-01-23 12:48:27 +00:00
viewer . ui = { canvas : {
2019-02-05 23:59:52 +00:00
unblurWithAnimation : function ( ) { } ,
unblur : function ( ) { } ,
2024-02-13 00:44:51 +00:00
maybeDisplayPlaceholder : function ( ) {
return true ;
}
2014-04-24 01:03:24 +00:00
} } ;
2015-01-23 12:48:27 +00:00
viewer . imageInfoProvider . get = this . sandbox . stub ( ) . returns ( $ . Deferred ( ) . resolve ( { width : 100 , height : 100 } ) ) ;
2014-04-24 01:03:24 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayPlaceholderThumbnail ( { index : 1 } , undefined , undefined ) ;
2014-02-25 13:43:22 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . blurredThumbnailShown , true , 'Placeholder state is correct' ) ;
assert . strictEqual ( viewer . realThumbnailShown , false , 'Real thumbnail state is correct' ) ;
2014-02-25 13:43:22 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayRealThumbnail ( { url : undefined } ) ;
2014-02-25 13:43:22 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , true , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , true , 'Placeholder state is correct' ) ;
2014-02-25 13:43:22 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Real thumbnail first, then placeholder' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
2014-02-25 13:43:22 +00:00
2019-02-05 23:59:52 +00:00
viewer . setImage = function ( ) { } ;
2014-03-05 02:24:18 +00:00
viewer . ui = {
2019-02-05 23:59:52 +00:00
showImage : function ( ) { } ,
2015-01-23 12:48:27 +00:00
canvas : {
2019-02-05 23:59:52 +00:00
unblurWithAnimation : function ( ) { } ,
unblur : function ( ) { }
2016-07-18 13:49:27 +00:00
} } ;
2014-02-25 13:43:22 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayRealThumbnail ( { url : undefined } ) ;
2014-02-25 13:43:22 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , true , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , false , 'Placeholder state is correct' ) ;
2014-02-25 13:43:22 +00:00
2015-01-23 12:48:27 +00:00
viewer . displayPlaceholderThumbnail ( { } , undefined , undefined ) ;
2014-02-25 13:43:22 +00:00
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . realThumbnailShown , true , 'Real thumbnail state is correct' ) ;
assert . strictEqual ( viewer . blurredThumbnailShown , false , 'Placeholder state is correct' ) ;
2014-02-25 13:43:22 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'displayRealThumbnail' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
2014-02-25 13:43:22 +00:00
2019-02-05 23:59:52 +00:00
viewer . setImage = function ( ) { } ;
2015-01-23 12:48:27 +00:00
viewer . ui = { canvas : {
unblurWithAnimation : this . sandbox . stub ( ) ,
2019-02-05 23:59:52 +00:00
unblur : function ( ) { }
2014-03-05 02:24:18 +00:00
} } ;
2014-02-25 13:43:22 +00:00
viewer . blurredThumbnailShown = true ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
// Should not result in an unblurWithAnimation animation (image cache from cache)
2015-01-23 12:48:27 +00:00
viewer . displayRealThumbnail ( { url : undefined } , undefined , undefined , 5 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . canvas . unblurWithAnimation . called , false , 'There should not be an unblurWithAnimation animation' ) ;
2014-02-25 13:43:22 +00:00
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
// Should result in an unblurWithAnimation (image didn't come from cache)
2015-01-23 12:48:27 +00:00
viewer . displayRealThumbnail ( { url : undefined } , undefined , undefined , 1000 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . canvas . unblurWithAnimation . called , true , 'There should be an unblurWithAnimation animation' ) ;
2014-02-25 13:43:22 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'New image loaded while another one is loading' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
const firstImageDeferred = $ . Deferred ( ) ;
const secondImageDeferred = $ . Deferred ( ) ;
const firstLigthboxInfoDeferred = $ . Deferred ( ) ;
const secondLigthboxInfoDeferred = $ . Deferred ( ) ;
const firstImage = {
filePageTitle : new mw . Title ( 'File:Foo.jpg' ) ,
2024-05-15 18:59:58 +00:00
index : 0
2023-10-24 09:53:23 +00:00
} ;
const secondImage = {
filePageTitle : new mw . Title ( 'File:Bar.jpg' ) ,
2024-05-15 18:59:58 +00:00
index : 1
2023-10-24 09:53:23 +00:00
} ;
// custom clock ensures progress handlers execute in correct sequence
const clock = this . sandbox . useFakeTimers ( ) ;
2014-02-27 00:40:39 +00:00
2019-02-05 23:59:52 +00:00
viewer . preloadFullscreenThumbnail = function ( ) { } ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . fetchSizeIndependentLightboxInfo = this . sandbox . stub ( ) ;
2014-03-05 02:24:18 +00:00
viewer . ui = {
2019-02-05 23:59:52 +00:00
setFileReuseData : function ( ) { } ,
setupForLoad : function ( ) { } ,
2015-01-23 12:48:27 +00:00
canvas : {
2019-02-05 23:59:52 +00:00
set : function ( ) { } ,
2024-02-13 00:44:51 +00:00
getCurrentImageWidths : function ( ) {
return { real : 0 } ;
} ,
getDimensions : function ( ) {
return { } ;
}
2014-09-26 18:37:53 +00:00
} ,
2015-01-23 12:48:27 +00:00
panel : {
setImageInfo : this . sandbox . stub ( ) ,
2014-05-05 21:44:27 +00:00
scroller : {
2019-02-05 23:59:52 +00:00
animateMetadataOnce : function ( ) { }
2014-05-05 21:44:27 +00:00
} ,
2014-04-21 21:48:40 +00:00
progressBar : {
2023-04-25 08:49:10 +00:00
hide : this . sandbox . stub ( ) ,
2015-01-23 12:48:27 +00:00
animateTo : this . sandbox . stub ( ) ,
jumpTo : this . sandbox . stub ( )
2014-03-05 02:24:18 +00:00
} ,
2019-02-05 23:59:52 +00:00
empty : function ( ) { }
2014-03-05 02:24:18 +00:00
} ,
2019-02-05 23:59:52 +00:00
open : function ( ) { } ,
empty : function ( ) { } } ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . displayRealThumbnail = this . sandbox . stub ( ) ;
2019-05-18 16:19:44 +00:00
viewer . eachPreloadableLightboxIndex = function ( ) { } ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . animateMetadataDivOnce = this . sandbox . stub ( ) . returns ( $ . Deferred ( ) . reject ( ) ) ;
viewer . imageProvider . get = this . sandbox . stub ( ) ;
2023-06-27 20:33:13 +00:00
viewer . imageInfoProvider . get = ( ) => $ . Deferred ( ) . reject ( { } ) ;
viewer . thumbnailInfoProvider . get = ( ) => $ . Deferred ( ) . resolve ( { } ) ;
2014-02-27 00:40:39 +00:00
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . imageProvider . get . returns ( firstImageDeferred . promise ( ) ) ;
viewer . fetchSizeIndependentLightboxInfo . returns ( firstLigthboxInfoDeferred . promise ( ) ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( firstImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . animateMetadataDivOnce . called , false , 'Metadata of the first image should not be animated' ) ;
assert . strictEqual ( viewer . ui . panel . setImageInfo . called , false , 'Metadata of the first image should not be shown' ) ;
2014-02-27 00:40:39 +00:00
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . imageProvider . get . returns ( secondImageDeferred . promise ( ) ) ;
viewer . fetchSizeIndependentLightboxInfo . returns ( secondLigthboxInfoDeferred . promise ( ) ) ;
2024-05-21 18:24:39 +00:00
viewer . loadImage ( secondImage ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2014-02-27 00:40:39 +00:00
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
viewer . ui . panel . progressBar . animateTo . reset ( ) ;
2014-02-27 00:40:39 +00:00
firstImageDeferred . notify ( undefined , 45 ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . ui . panel . progressBar . animateTo . reset . called , undefined , 'Progress of the first image should not be shown' ) ;
Refactor progressbar & blur handling
This tries to fix a number of related issues:
* the blurred thumbnail was visible for a split-second sometimes
when switching back to an already-loaded image. (Presumably when
JS was sluggish enough to take more than 10 ms to execute.) We
now check whether the promise is pending before showing a placeholder.
(More generally, a lot of unnecessary logic was executed when paging
through already loaded images, like displaying the placeholder, so
this might make the UI a bit more responsive.)
* the blur could get stuck sometimes - I have seen this a few times,
but have never been able to reproduce it, so I'm only guessing, but
maybe the timing was really unfortunate, and we switched back less
than 10 ms before loading finished. We now remove the blur on every
branch, just to be sure.
* adding a progress handler to a promise might not have any immediate
effect, so when switching to an image which was loading, the progress
bar reacted too late. We now store the progress state per thumbnail
so it is always available immediately.
* the progress would animate from 0 to its actual state whenever we
navigated to the image. The change on paging is now instant; the
progress bar only animates when we are looking at it.
* switching quickly back and forthe between a loaded and a loading
image resulted in the loading image becoming unblurred. This seems
fixed now, I'm not sure why. Maybe the "skip on non-pending promise"
logic affects it somehow.
Also removes some unused things / renames some things which were
confusing, and makes an unrelated fix in the image provider, which kept
amassing fail handlers.
Change-Id: I580becff246f197ec1bc65e82acd422620e35578
Mingle: https://wikimedia.mingle.thoughtworks.com/projects/multimedia/cards/489
2014-04-25 22:26:34 +00:00
2014-12-30 05:10:27 +00:00
firstImageDeferred . resolve ( { } , { } ) ;
2014-12-02 10:05:12 +00:00
firstLigthboxInfoDeferred . resolve ( { } ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . displayRealThumbnail . called , false , 'The first image being done loading should have no effect' ) ;
2014-02-27 00:40:39 +00:00
2023-06-27 20:33:13 +00:00
viewer . displayRealThumbnail = this . sandbox . spy ( ( ) => viewer . close ( ) ) ;
2014-12-30 05:10:27 +00:00
secondImageDeferred . resolve ( { } , { } ) ;
2014-12-02 10:05:12 +00:00
secondLigthboxInfoDeferred . resolve ( { } ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( viewer . displayRealThumbnail . called , true , 'The second image being done loading should result in the image being shown' ) ;
2017-05-11 15:03:52 +00:00
clock . restore ( ) ;
2014-02-27 00:40:39 +00:00
} ) ;
2014-03-03 11:20:52 +00:00
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Events are not trapped after the viewer is closed' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
const $document = $ ( document ) ;
const $qf = $ ( '#qunit-fixture' ) ;
const eventTypes = [ 'keydown' , 'keyup' , 'keypress' , 'click' , 'mousedown' , 'mouseup' ] ;
const modifiers = [ undefined , 'altKey' , 'ctrlKey' , 'shiftKey' , 'metaKey' ] ;
// Events are async, we need to wait for the last event to be caught before ending the test
const done = assert . async ( ) ;
const oldScrollTo = $ . scrollTo ;
2014-03-29 01:38:22 +00:00
2017-07-25 23:38:21 +00:00
assert . expect ( 0 ) ;
2015-06-24 18:54:22 +00:00
// animation would keep running, conflict with other tests
this . sandbox . stub ( $ . fn , 'animate' ) . returnsThis ( ) ;
2023-06-27 20:33:13 +00:00
$ . scrollTo = function ( ) {
return { scrollTop : ( ) => { } , on : ( ) => { } , off : ( ) => { } } ;
} ;
2014-03-03 11:20:52 +00:00
2014-03-04 11:53:53 +00:00
viewer . setupEventHandlers ( ) ;
2023-06-27 20:33:13 +00:00
viewer . imageProvider . get = ( ) => $ . Deferred ( ) . reject ( ) ;
viewer . imageInfoProvider . get = ( ) => $ . Deferred ( ) . reject ( ) ;
viewer . thumbnailInfoProvider . get = ( ) => $ . Deferred ( ) . reject ( ) ;
viewer . fileRepoInfoProvider . get = ( ) => $ . Deferred ( ) . reject ( ) ;
2014-03-03 11:20:52 +00:00
2019-02-05 23:59:52 +00:00
viewer . preloadFullscreenThumbnail = function ( ) { } ;
2014-03-03 11:20:52 +00:00
viewer . initWithThumbs ( [ ] ) ;
2017-10-31 17:49:29 +00:00
viewer . loadImage (
{
filePageTitle : new mw . Title ( 'File:Stuff.jpg' ) ,
2024-05-21 18:24:39 +00:00
thumbnail : new Image ( 10 , 10 )
2017-10-31 17:49:29 +00:00
} ,
new Image ( )
) ;
2014-03-03 11:20:52 +00:00
2018-04-24 14:47:41 +00:00
viewer . ui . $closeButton . trigger ( 'click' ) ;
2014-03-03 11:20:52 +00:00
2016-07-18 13:49:27 +00:00
function eventHandler ( e ) {
2014-03-03 11:20:52 +00:00
if ( e . isDefaultPrevented ( ) ) {
2022-05-20 00:18:43 +00:00
assert . true ( false , 'Event was incorrectly trapped: ' + e . which ) ;
2014-03-03 11:20:52 +00:00
}
e . preventDefault ( ) ;
// Wait for the last event
if ( e . which === 32 && e . type === 'mouseup' ) {
2014-03-04 11:53:53 +00:00
$document . off ( '.mmvtest' ) ;
viewer . cleanupEventHandlers ( ) ;
2014-03-29 01:38:22 +00:00
$ . scrollTo = oldScrollTo ;
2017-07-26 00:01:07 +00:00
done ( ) ;
2014-03-03 11:20:52 +00:00
}
}
2023-10-24 09:53:23 +00:00
for ( let j = 0 ; j < eventTypes . length ; j ++ ) {
2014-03-03 11:20:52 +00:00
$document . on ( eventTypes [ j ] + '.mmvtest' , eventHandler ) ;
2016-07-18 13:49:27 +00:00
eventloop :
2023-10-24 09:53:23 +00:00
for ( let i = 0 ; i < 256 ; i ++ ) {
2014-03-03 11:20:52 +00:00
// Save some time by not testing unlikely values for mouse events
if ( i > 32 ) {
switch ( eventTypes [ j ] ) {
case 'click' :
case 'mousedown' :
case 'mouseup' :
break eventloop ;
}
}
2023-10-24 09:53:23 +00:00
for ( let k = 0 ; k < modifiers . length ; k ++ ) {
const eventParameters = { which : i } ;
2014-03-03 11:20:52 +00:00
if ( modifiers [ k ] !== undefined ) {
eventParameters [ modifiers [ k ] ] = true ;
}
$qf . trigger ( $ . Event ( eventTypes [ j ] , eventParameters ) ) ;
}
}
}
} ) ;
2014-04-15 00:01:03 +00:00
2017-07-25 23:38:21 +00:00
QUnit . test ( 'Refuse to load too-big thumbnails' , function ( assert ) {
2023-10-24 09:53:23 +00:00
let expectedWidth ;
const reuestedWidth = 1000 ;
const originalWidth = 50 ;
const viewer = getMultimediaViewer ( ) ;
2014-04-15 00:01:03 +00:00
viewer . thumbnailInfoProvider . get = function ( fileTitle , width ) {
2018-11-22 15:17:40 +00:00
assert . strictEqual ( width , expectedWidth ) ;
2014-04-15 00:01:03 +00:00
return $ . Deferred ( ) . reject ( ) ;
} ;
2018-11-22 15:17:40 +00:00
// non-vector should be capped to original size
2023-10-24 09:53:23 +00:00
let title = mw . Title . newFromText ( 'File:Foobar.png' ) ;
2018-11-22 15:17:40 +00:00
expectedWidth = originalWidth ;
viewer . fetchThumbnail ( title , reuestedWidth , null , originalWidth , 60 ) ;
// vector images can be aritrarily large
title = mw . Title . newFromText ( 'File:Foobar.svg' ) ;
expectedWidth = reuestedWidth ;
viewer . fetchThumbnail ( title , reuestedWidth , null , originalWidth , 60 ) ;
2014-04-10 01:08:36 +00:00
} ) ;
2017-07-25 23:38:21 +00:00
QUnit . test ( 'fetchThumbnail()' , function ( assert ) {
2023-10-24 09:53:23 +00:00
let guessedThumbnailInfoStub ;
let thumbnailInfoStub ;
let imageStub ;
let promise ;
let useThumbnailGuessing ;
const viewer = new MultimediaViewer ( {
imageQueryParameter : function ( ) { } ,
language : function ( ) { } ,
recordVirtualViewBeaconURI : function ( ) { } ,
extensions : function ( ) {
return { jpg : 'default' } ;
} ,
useThumbnailGuessing : ( ) => useThumbnailGuessing
} ) ;
const sandbox = this . sandbox ;
const file = new mw . Title ( 'File:Copyleft.svg' ) ;
const sampleURL = 'http://upload.wikimedia.org/wikipedia/commons/thumb/8/8b/Copyleft.svg/300px-Copyleft.svg.png' ;
const width = 100 ;
const originalWidth = 1000 ;
const originalHeight = 1000 ;
const image = { } ;
// custom clock ensures progress handlers execute in correct sequence
const clock = this . sandbox . useFakeTimers ( ) ;
2014-04-10 01:08:36 +00:00
2014-04-17 03:00:42 +00:00
function setupStubs ( ) {
guessedThumbnailInfoStub = viewer . guessedThumbnailInfoProvider . get = sandbox . stub ( ) ;
thumbnailInfoStub = viewer . thumbnailInfoProvider . get = sandbox . stub ( ) ;
imageStub = viewer . imageProvider . get = sandbox . stub ( ) ;
}
2014-04-10 01:08:36 +00:00
2016-04-03 09:18:26 +00:00
useThumbnailGuessing = true ;
2014-04-10 01:08:36 +00:00
2014-04-17 03:00:42 +00:00
// When we lack sample URL and original dimensions, the classic provider should be used
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'guessedURL' } ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . returns ( $ . Deferred ( ) . resolve ( image ) ) ;
promise = viewer . fetchThumbnail ( file , width ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . called , false , 'When we lack sample URL and original dimensions, GuessedThumbnailInfoProvider is not called' ) ;
assert . strictEqual ( thumbnailInfoStub . calledOnce , true , 'When we lack sample URL and original dimensions, ThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( imageStub . calledOnce , true , 'When we lack sample URL and original dimensions, ImageProvider is called once' ) ;
assert . strictEqual ( imageStub . calledWith ( 'apiURL' ) , true , 'When we lack sample URL and original dimensions, ImageProvider is called with the API url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'resolved' , 'When we lack sample URL and original dimensions, fetchThumbnail resolves' ) ;
// When the guesser bails out, the classic provider should be used
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . reject ( ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . returns ( $ . Deferred ( ) . resolve ( image ) ) ;
promise = viewer . fetchThumbnail ( file , width , sampleURL , originalWidth , originalHeight ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . calledOnce , true , 'When the guesser bails out, GuessedThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( thumbnailInfoStub . calledOnce , true , 'When the guesser bails out, ThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( imageStub . calledOnce , true , 'When the guesser bails out, ImageProvider is called once' ) ;
assert . strictEqual ( imageStub . calledWith ( 'apiURL' ) , true , 'When the guesser bails out, ImageProvider is called with the API url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'resolved' , 'When the guesser bails out, fetchThumbnail resolves' ) ;
// When the guesser returns an URL, that should be used
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'guessedURL' } ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . returns ( $ . Deferred ( ) . resolve ( image ) ) ;
promise = viewer . fetchThumbnail ( file , width , sampleURL , originalWidth , originalHeight ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . calledOnce , true , 'When the guesser returns an URL, GuessedThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( thumbnailInfoStub . called , false , 'When the guesser returns an URL, ThumbnailInfoProvider is not called' ) ;
assert . strictEqual ( imageStub . calledOnce , true , 'When the guesser returns an URL, ImageProvider is called once' ) ;
assert . strictEqual ( imageStub . calledWith ( 'guessedURL' ) , true , 'When the guesser returns an URL, ImageProvider is called with the guessed url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'resolved' , 'When the guesser returns an URL, fetchThumbnail resolves' ) ;
// When the guesser returns an URL, but that returns 404, image loading should be retried with the classic provider
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'guessedURL' } ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . withArgs ( 'guessedURL' ) . returns ( $ . Deferred ( ) . reject ( ) ) ;
imageStub . withArgs ( 'apiURL' ) . returns ( $ . Deferred ( ) . resolve ( image ) ) ;
promise = viewer . fetchThumbnail ( file , width , sampleURL , originalWidth , originalHeight ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . calledOnce , true , 'When the guesser returns an URL, but that returns 404, GuessedThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( thumbnailInfoStub . calledOnce , true , 'When the guesser returns an URL, but that returns 404, ThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( imageStub . calledTwice , true , 'When the guesser returns an URL, but that returns 404, ImageProvider is called twice' ) ;
assert . strictEqual ( imageStub . getCall ( 0 ) . calledWith ( 'guessedURL' ) , true , 'When the guesser returns an URL, but that returns 404, ImageProvider is called first with the guessed url' ) ;
assert . strictEqual ( imageStub . getCall ( 1 ) . calledWith ( 'apiURL' ) , true , 'When the guesser returns an URL, but that returns 404, ImageProvider is called second with the guessed url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'resolved' , 'When the guesser returns an URL, but that returns 404, fetchThumbnail resolves' ) ;
// When even the retry fails, fetchThumbnail() should reject
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'guessedURL' } ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . withArgs ( 'guessedURL' ) . returns ( $ . Deferred ( ) . reject ( ) ) ;
imageStub . withArgs ( 'apiURL' ) . returns ( $ . Deferred ( ) . reject ( ) ) ;
promise = viewer . fetchThumbnail ( file , width , sampleURL , originalWidth , originalHeight ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . calledOnce , true , 'When even the retry fails, GuessedThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( thumbnailInfoStub . calledOnce , true , 'When even the retry fails, ThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( imageStub . calledTwice , true , 'When even the retry fails, ImageProvider is called twice' ) ;
assert . strictEqual ( imageStub . getCall ( 0 ) . calledWith ( 'guessedURL' ) , true , 'When even the retry fails, ImageProvider is called first with the guessed url' ) ;
assert . strictEqual ( imageStub . getCall ( 1 ) . calledWith ( 'apiURL' ) , true , 'When even the retry fails, ImageProvider is called second with the guessed url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'rejected' , 'When even the retry fails, fetchThumbnail rejects' ) ;
2014-04-10 01:08:36 +00:00
2016-04-03 09:18:26 +00:00
useThumbnailGuessing = false ;
2014-04-10 01:08:36 +00:00
2014-04-17 03:00:42 +00:00
// When guessing is disabled, the classic provider is used
setupStubs ( ) ;
guessedThumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'guessedURL' } ) ) ;
thumbnailInfoStub . returns ( $ . Deferred ( ) . resolve ( { url : 'apiURL' } ) ) ;
imageStub . returns ( $ . Deferred ( ) . resolve ( image ) ) ;
promise = viewer . fetchThumbnail ( file , width ) ;
2017-05-11 15:03:52 +00:00
clock . tick ( 10 ) ;
2018-06-06 18:23:25 +00:00
assert . strictEqual ( guessedThumbnailInfoStub . called , false , 'When guessing is disabled, GuessedThumbnailInfoProvider is not called' ) ;
assert . strictEqual ( thumbnailInfoStub . calledOnce , true , 'When guessing is disabled, ThumbnailInfoProvider is called once' ) ;
assert . strictEqual ( imageStub . calledOnce , true , 'When guessing is disabled, ImageProvider is called once' ) ;
assert . strictEqual ( imageStub . calledWith ( 'apiURL' ) , true , 'When guessing is disabled, ImageProvider is called with the API url' ) ;
2014-04-17 03:00:42 +00:00
assert . strictEqual ( promise . state ( ) , 'resolved' , 'When guessing is disabled, fetchThumbnail resolves' ) ;
2017-05-11 15:03:52 +00:00
clock . restore ( ) ;
2014-04-15 00:01:03 +00:00
} ) ;
2014-07-01 22:22:06 +00:00
2017-07-25 23:38:21 +00:00
QUnit . test ( 'document.title' , function ( assert ) {
2023-10-24 09:53:23 +00:00
const viewer = getMultimediaViewer ( ) ;
const bootstrap = new MultimediaViewerBootstrap ( ) ;
const title = new mw . Title ( 'File:This_should_show_up_in_document_title.png' ) ;
const oldDocumentTitle = document . title ;
2014-07-01 22:22:06 +00:00
2023-04-28 21:49:00 +00:00
this . sandbox . stub ( mw . loader , 'using' ) . returns ( $ . Deferred ( ) . resolve ( viewer ) ) ;
2014-07-01 22:22:06 +00:00
viewer . currentImageFileTitle = title ;
bootstrap . setupEventHandlers ( ) ;
2023-04-28 21:49:00 +00:00
viewer . setTitle ( ) ;
2014-07-01 22:22:06 +00:00
2022-05-20 00:18:43 +00:00
assert . notStrictEqual ( document . title . match ( title . getNameText ( ) ) , null , 'File name is visible in title' ) ;
2014-07-01 22:22:06 +00:00
viewer . close ( ) ;
bootstrap . cleanupEventHandlers ( ) ;
2015-01-23 12:48:27 +00:00
assert . strictEqual ( document . title , oldDocumentTitle , 'Original title restored after viewer is closed' ) ;
2014-07-01 22:22:06 +00:00
} ) ;
2018-11-12 16:33:24 +00:00
} ( ) ) ;
