2021-08-31 16:08:55 +00:00
const makeServiceWorkerEnv = require ( 'service-worker-mock' ) ;
global . fetch = require ( 'node-fetch' ) ;
jest . mock ( 'node-fetch' )
2022-01-25 00:28:41 +00:00
describe ( "service-worker" , ( ) => {
beforeEach ( ( ) => {
global . fetch . mockImplementation ( ( url , init ) => {
2021-09-01 21:01:01 +00:00
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
2021-08-31 16:08:55 +00:00
} ) ;
2022-01-25 00:28:41 +00:00
2021-08-31 16:08:55 +00:00
Object . assign ( global , makeServiceWorkerEnv ( ) ) ;
global . self = new ServiceWorkerGlobalScope ( )
jest . resetModules ( ) ;
self . LibResilientPlugins = new Array ( )
2021-09-18 23:35:22 +00:00
self . importScripts = jest . fn ( ( url ) => {
console . debug ( ` importScripts('../ ${ url } ') ` )
try {
require ( '../' + url ) ;
} catch ( e ) { }
} )
2021-09-19 10:04:19 +00:00
// TODO: pretty ugly, but necessary for some reason...
2021-09-18 23:35:22 +00:00
global . LibResilientPluginConstructors = new Map ( )
2021-09-19 10:04:19 +00:00
self . LibResilientPluginConstructors = global . LibResilientPluginConstructors
2021-09-01 21:01:01 +00:00
} )
2022-03-09 18:13:41 +00:00
test ( "reality-check: Promise.any() polyfill should work" , async ( ) => {
2021-09-04 00:41:08 +00:00
self . LibResilientPlugins = false
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ ] ,
2021-09-04 00:41:08 +00:00
loggedComponents : [
'service-worker'
]
}
expect . assertions ( 4 )
// we want to make sure to actually test the polyfill
Promise . any = undefined
expect ( typeof Promise . any ) . toEqual ( 'undefined' )
require ( "../service-worker.js" ) ;
expect ( typeof Promise . any ) . toEqual ( 'function' )
expect ( await Promise . any ( [
Promise . resolve ( 'test resolve 1' ) ,
Promise . reject ( 'test reject 2' )
] ) ) . toEqual ( 'test resolve 1' )
try {
await Promise . any ( [
Promise . reject ( 'test reject 1' ) ,
Promise . reject ( 'test reject 2' )
] )
} catch ( e ) {
expect ( e ) . toEqual ( [
"test reject 1" ,
"test reject 2"
] )
}
} )
2021-09-01 23:31:38 +00:00
2022-03-09 18:13:41 +00:00
test ( "basic set-up: LibResilientPlugins" , async ( ) => {
self . LibResilientPlugins = false
self . LibResilientConfig = {
plugins : [ ] ,
loggedComponents : [
'service-worker'
]
}
require ( "../service-worker.js" ) ;
expect ( self . LibResilientPlugins ) . toBeInstanceOf ( Array )
} )
2022-01-25 00:28:41 +00:00
test ( "basic set-up: use default LibResilientConfig values when config.json missing" , async ( ) => {
self . LibResilientConfig = null
global . fetch . mockImplementation ( ( url , init ) => {
2022-01-27 23:20:28 +00:00
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "fail" } ) ] ,
{ type : "application/json" }
) ,
{
status : 404 ,
statusText : "Not Found" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
2022-01-25 00:28:41 +00:00
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 10000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'fetch' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-25 00:28:41 +00:00
} )
test ( "basic set-up: use default LibResilientConfig values when config.json not valid JSON" , async ( ) => {
self . LibResilientConfig = null
2022-01-27 23:20:28 +00:00
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ "not a JSON" ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
2022-01-25 00:28:41 +00:00
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 10000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'fetch' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-25 00:28:41 +00:00
} )
test ( "basic set-up: use default LibResilientConfig values when no valid 'plugins' field in config.json" , async ( ) => {
2021-09-01 23:31:38 +00:00
self . LibResilientConfig = null
2022-01-25 00:28:41 +00:00
2022-01-27 23:20:28 +00:00
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { loggedComponents : [ 'service-worker' , 'fetch' ] , plugins : 'not a valid array' } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
2022-01-25 00:28:41 +00:00
2021-09-01 23:31:38 +00:00
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
2022-01-25 00:28:41 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
2021-09-01 23:31:38 +00:00
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 10000 )
2022-01-25 00:28:41 +00:00
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'fetch' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-25 00:28:41 +00:00
} )
test ( "basic set-up: use default LibResilientConfig values when no valid 'loggedComponents' field in config.json" , async ( ) => {
self . LibResilientConfig = null
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { loggedComponents : 'not a valid array' , plugins : [ { name : "fetch" } ] } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 10000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'fetch' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-25 00:28:41 +00:00
} )
test ( "basic set-up: use default LibResilientConfig values when 'defaultPluginTimeout' field in config.json contains an invalid value" , async ( ) => {
self . LibResilientConfig = null
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { loggedComponents : [ 'service-worker' , 'fetch' ] , plugins : [ { name : "fetch" } ] , defaultPluginTimeout : 'not an integer' } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 10000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'fetch' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-25 00:28:41 +00:00
} )
test ( "basic set-up: use config values from a valid config.json file" , async ( ) => {
self . LibResilientConfig = null
2022-01-26 02:02:25 +00:00
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { loggedComponents : [ 'service-worker' , 'cache' ] , plugins : [ { name : "cache" } ] , defaultPluginTimeout : 5000 } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
2022-01-25 00:28:41 +00:00
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-25 00:28:41 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 5000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2021-09-01 23:31:38 +00:00
} )
2022-03-09 18:13:41 +00:00
test ( "basic set-up: instantiate a complex tree of configured plugins" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'plugin-1' ,
uses : [ {
name : 'plugin-2' ,
uses : [ {
name : 'plugin-3'
} ]
} , {
name : 'plugin-3'
} ]
} , {
name : 'plugin-2' ,
uses : [ {
name : 'plugin-3'
} ]
} , {
name : 'plugin-3' ,
uses : [ {
name : 'plugin-1'
} , {
name : 'plugin-2' ,
uses : [ {
name : 'plugin-1' ,
uses : [ {
name : 'plugin-4'
} ]
} ]
} ]
} , {
name : 'plugin-4'
}
]
}
global . LibResilientPluginConstructors . set ( 'plugin-1' , ( LRPC , config ) => {
return {
name : 'plugin-1' ,
description : 'Plugin Type 1' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'plugin-2' , ( LRPC , config ) => {
return {
name : 'plugin-2' ,
description : 'Plugin Type 2' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'plugin-3' , ( LRPC , config ) => {
return {
name : 'plugin-3' ,
description : 'Plugin Type 3' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'plugin-4' , ( LRPC , config ) => {
return {
name : 'plugin-4' ,
description : 'Plugin Type 4' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
// basic stuff
expect ( self . LibResilientPlugins . length ) . toEqual ( 4 )
expect ( self . LibResilientPlugins [ 0 ] . name ) . toEqual ( 'plugin-1' )
expect ( self . LibResilientPlugins [ 1 ] . name ) . toEqual ( 'plugin-2' )
expect ( self . LibResilientPlugins [ 2 ] . name ) . toEqual ( 'plugin-3' )
expect ( self . LibResilientPlugins [ 3 ] . name ) . toEqual ( 'plugin-4' )
// first plugin dependencies
expect ( self . LibResilientPlugins [ 0 ] . uses . length ) . toEqual ( 2 )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-2' )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 0 ] . uses . length ) . toEqual ( 1 )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 0 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-3' )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 0 ] . uses [ 0 ] . uses . length ) . toEqual ( 0 )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 1 ] . name ) . toEqual ( 'plugin-3' )
expect ( self . LibResilientPlugins [ 0 ] . uses [ 1 ] . uses . length ) . toEqual ( 0 )
// second plugin dependencies
expect ( self . LibResilientPlugins [ 1 ] . uses . length ) . toEqual ( 1 )
expect ( self . LibResilientPlugins [ 1 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-3' )
expect ( self . LibResilientPlugins [ 1 ] . uses [ 0 ] . uses . length ) . toEqual ( 0 )
// third plugin dependencies
expect ( self . LibResilientPlugins [ 2 ] . uses . length ) . toEqual ( 2 )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-1' )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 0 ] . uses . length ) . toEqual ( 0 )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . name ) . toEqual ( 'plugin-2' )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . uses . length ) . toEqual ( 1 )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-1' )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . uses [ 0 ] . uses . length ) . toEqual ( 1 )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . uses [ 0 ] . uses [ 0 ] . name ) . toEqual ( 'plugin-4' )
expect ( self . LibResilientPlugins [ 2 ] . uses [ 1 ] . uses [ 0 ] . uses [ 0 ] . uses . length ) . toEqual ( 0 )
// fourth plugin dependencies
expect ( self . LibResilientPlugins [ 3 ] . uses . length ) . toEqual ( 0 )
} )
test ( "basic set-up: instantiate configured plugins; explicitly disabled plugins should not be instantiated" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'plugin-enabled'
} , {
name : 'plugin-disabled' ,
enabled : false
} , {
name : 'plugin-enabled' ,
enabled : true
} ]
}
global . LibResilientPluginConstructors . set ( 'plugin-enabled' , ( ) => {
return {
name : 'plugin-enabled' ,
description : 'Enabled plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true }
}
} )
global . LibResilientPluginConstructors . set ( 'plugin-disabled' , ( ) => {
return {
name : 'plugin-disabled' ,
description : 'Disabled plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true }
}
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientPlugins . length ) . toEqual ( 2 )
expect ( self . LibResilientPlugins [ 0 ] . name ) . toEqual ( 'plugin-enabled' )
expect ( self . LibResilientPlugins [ 1 ] . name ) . toEqual ( 'plugin-enabled' )
} )
test ( "basic set-up: instantiate configured plugins; explicitly disabled dependencies should not be instantiated" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'plugin-disabled' ,
enabled : false ,
uses : [ {
name : 'dependency-enabled'
} ]
} , {
name : 'plugin-enabled' ,
uses : [ {
name : 'dependency-disabled' ,
enabled : false
} ]
} , {
name : 'plugin-enabled' ,
uses : [ {
name : 'dependency-enabled' ,
enabled : true
} ]
} ] ,
loggedComponents : [ 'service-worker' ]
}
global . LibResilientPluginConstructors . set ( 'plugin-enabled' , ( LRPC , config ) => {
return {
name : 'plugin-enabled' ,
description : 'Enabled plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'plugin-disabled' , ( LRPC , config ) => {
return {
name : 'plugin-disabled' ,
description : 'Disabled plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'dependency-disabled' , ( LRPC , config ) => {
return {
name : 'dependency-disabled' ,
description : 'Disabled dependency plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
global . LibResilientPluginConstructors . set ( 'dependency-enabled' , ( LRPC , config ) => {
return {
name : 'dependency-enabled' ,
description : 'Enabled dependency plugin' ,
version : '0.0.1' ,
fetch : ( url ) => { return true } ,
uses : config . uses || [ ]
}
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientPlugins . length ) . toEqual ( 2 )
expect ( self . LibResilientPlugins [ 0 ] . name ) . toEqual ( 'plugin-enabled' )
expect ( self . LibResilientPlugins [ 0 ] . uses . length ) . toEqual ( 0 )
expect ( self . LibResilientPlugins [ 1 ] . name ) . toEqual ( 'plugin-enabled' )
expect ( self . LibResilientPlugins [ 1 ] . uses . length ) . toEqual ( 1 )
expect ( self . LibResilientPlugins [ 1 ] . uses [ 0 ] . name ) . toEqual ( 'dependency-enabled' )
expect ( self . LibResilientPlugins [ 1 ] . uses [ 0 ] . uses . length ) . toEqual ( 0 )
} )
2022-01-26 04:06:31 +00:00
test ( "basic set-up: a valid config.json file gets cached" , async ( ) => {
self . LibResilientConfig = null
var configData = { loggedComponents : [ 'service-worker' , 'cache' ] , plugins : [ { name : "cache" } ] , defaultPluginTimeout : 5000 }
global . fetch . mockImplementation ( ( url , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( configData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : url
} )
) ;
} ) ;
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-26 04:06:31 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 5000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'cache' ] )
2022-01-27 23:20:28 +00:00
expect ( fetch ) . toHaveBeenCalled ( ) ;
2022-01-26 04:06:31 +00:00
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . match ( self . location . origin + '/config.json' )
} ) . then ( ( response ) => {
return response . json ( )
} ) . then ( ( json ) => {
return json
} ) ) . toStrictEqual ( { loggedComponents : [ 'service-worker' , 'cache' ] , plugins : [ { name : "cache" } ] , defaultPluginTimeout : 5000 } )
} )
2022-01-27 23:20:28 +00:00
test ( "basic set-up: a cached valid config.json file gets used, no fetch happens" , async ( ) => {
self . LibResilientConfig = null
var configData = { loggedComponents : [ 'service-worker' , 'cache' ] , plugins : [ { name : "cache" } ] , defaultPluginTimeout : 5000 }
var configUrl = '/config.json'
var configResponse = new Response (
new Blob (
[ JSON . stringify ( configData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : configUrl
} )
await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . put ( configUrl , configResponse )
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-27 23:20:28 +00:00
await self . trigger ( 'activate' )
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 5000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'cache' ] )
expect ( fetch ) . not . toHaveBeenCalled ( ) ;
} )
2022-02-07 23:08:13 +00:00
test ( "basic set-up: a stale cached valid config.json file gets used, no fetch happens, fresh config.json is retrieved using the configured plugins and cached" , async ( ) => {
self . LibResilientConfig = null
2022-02-08 02:44:01 +00:00
var configData = { loggedComponents : [ 'service-worker' , 'cache' , 'fetch' ] , plugins : [ { name : "fetch" } , { name : "cache" } ] , defaultPluginTimeout : 5000 }
2022-02-07 23:08:13 +00:00
var configUrl = '/config.json'
var configResponse = new Response (
new Blob (
[ JSON . stringify ( configData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very stale date
'Date' : new Date ( 0 ) . toUTCString ( )
} ,
url : configUrl
} )
await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . put ( configUrl , configResponse )
} )
2022-02-08 02:44:01 +00:00
var newConfigData = { loggedComponents : [ 'service-worker' , 'fetch' ] , plugins : [ { name : "fetch" } ] , defaultPluginTimeout : 2000 }
2022-02-07 23:08:13 +00:00
let resolveConfigFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( newConfigData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very current date
'Date' : new Date ( ) . toUTCString ( )
} ,
url : configUrl
} )
)
} )
2022-02-08 02:44:01 +00:00
global . LibResilientPluginConstructors . set ( 'fetch' , ( ) => {
2022-02-07 23:08:13 +00:00
return {
2022-02-08 02:44:01 +00:00
name : 'fetch' ,
description : 'Resolve with config data (pretending to be fetch).' ,
2022-02-07 23:08:13 +00:00
version : '0.0.1' ,
fetch : resolveConfigFetch
}
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
await self . trigger ( 'activate' )
// verify current config (the one from the pre-cached stale `config.json`)
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 5000 )
2022-02-08 02:44:01 +00:00
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "fetch" } , { name : "cache" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'cache' , 'fetch' ] )
2022-02-07 23:08:13 +00:00
expect ( fetch ) . not . toHaveBeenCalled ( ) ;
expect ( resolveConfigFetch ) . toHaveBeenCalled ( ) ;
// verify that the *new* config got cached
cdata = await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . match ( configUrl )
} )
. then ( ( cresponse ) => {
return cresponse . json ( )
} )
expect ( cdata ) . toStrictEqual ( newConfigData )
} )
test ( "basic set-up: a stale cached valid config.json file gets used, no fetch happens; invalid config.json retrieved using the configured plugins is not cached" , async ( ) => {
self . LibResilientConfig = null
var configData = { loggedComponents : [ 'service-worker' , 'cache' , 'resolve-config' ] , plugins : [ { name : "cache" } , { name : "resolve-config" } ] , defaultPluginTimeout : 5000 }
var configUrl = '/config.json'
var configResponse = new Response (
new Blob (
[ JSON . stringify ( configData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very stale date
'Date' : new Date ( 0 ) . toUTCString ( )
} ,
url : configUrl
} )
await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . put ( configUrl , configResponse )
} )
var newConfigData = { loggedComponentsInvalid : [ 'service-worker' , 'resolve-config' ] , pluginsInvalid : [ { name : "resolve-config" } ] , defaultPluginTimeoutInvalid : 2000 }
let resolveConfigFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( newConfigData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very current date
'Date' : new Date ( ) . toUTCString ( )
} ,
url : configUrl
} )
)
} )
global . LibResilientPluginConstructors . set ( 'resolve-config' , ( ) => {
return {
name : 'resolve-config' ,
description : 'Resolve with config data.' ,
version : '0.0.1' ,
fetch : resolveConfigFetch
}
} )
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
await self . trigger ( 'install' )
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
await self . trigger ( 'activate' )
// verify current config (the one from the pre-cached stale `config.json`)
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( 5000 )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( [ { name : "cache" } , { name : "resolve-config" } ] )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( [ 'service-worker' , 'cache' , 'resolve-config' ] )
expect ( fetch ) . not . toHaveBeenCalled ( ) ;
expect ( resolveConfigFetch ) . toHaveBeenCalled ( ) ;
// verify that the *new* config got cached
cdata = await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . match ( configUrl )
} )
. then ( ( cresponse ) => {
return cresponse . json ( )
} )
expect ( cdata ) . toStrictEqual ( configData )
} )
2022-02-08 02:44:01 +00:00
test ( "basic set-up: a stale cached valid config.json file gets used, no fetch happens; valid config.json (configuring additional plugins) is retrieved using the configured plugins other than fetch, and is not cached" , async ( ) => {
self . LibResilientConfig = null
var configData = { loggedComponents : [ 'service-worker' , 'resolve-config' ] , plugins : [ { name : "resolve-config" } ] , defaultPluginTimeout : 5000 }
var configUrl = '/config.json'
var configResponse = new Response (
new Blob (
[ JSON . stringify ( configData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very stale date
'Date' : new Date ( 0 ) . toUTCString ( )
} ,
url : configUrl
} )
await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . put ( configUrl , configResponse )
} )
var newConfigData = { loggedComponents : [ 'service-worker' , 'resolve-config' , 'cache' ] , plugins : [ { name : "resolve-config" } , { name : "cache" } ] , defaultPluginTimeout : 2000 }
let resolveConfigFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( newConfigData ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader' ,
// very current date
'Date' : new Date ( ) . toUTCString ( )
} ,
url : configUrl
} )
)
} )
global . LibResilientPluginConstructors . set ( 'resolve-config' , ( ) => {
return {
name : 'resolve-config' ,
description : 'Resolve with config data.' ,
version : '0.0.1' ,
fetch : resolveConfigFetch
}
} )
2021-09-01 21:01:01 +00:00
2022-02-08 02:44:01 +00:00
try {
require ( "../service-worker.js" ) ;
} catch ( e ) { }
2021-09-01 21:01:01 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-09-01 21:01:01 +00:00
await self . trigger ( 'activate' )
2022-02-08 02:44:01 +00:00
// verify current config (the one from the pre-cached stale `config.json`)
expect ( typeof self . LibResilientConfig ) . toEqual ( 'object' )
expect ( self . LibResilientConfig . defaultPluginTimeout ) . toBe ( configData . defaultPluginTimeout )
expect ( self . LibResilientConfig . plugins ) . toStrictEqual ( configData . plugins )
expect ( self . LibResilientConfig . loggedComponents ) . toStrictEqual ( configData . loggedComponents )
expect ( fetch ) . not . toHaveBeenCalled ( ) ;
expect ( resolveConfigFetch ) . toHaveBeenCalled ( ) ;
// verify that the *new* config got cached
cdata = await caches
. open ( 'v1' )
. then ( ( cache ) => {
return cache . match ( configUrl )
} )
. then ( ( cresponse ) => {
return cresponse . json ( )
} )
expect ( cdata ) . toStrictEqual ( configData )
} )
2021-08-31 16:08:55 +00:00
2021-09-06 12:12:55 +00:00
test ( "failed fetch by first configured plugin should not affect a successful fetch by a second one" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'reject-all'
} , {
name : 'resolve-all'
} ] ,
2021-09-06 12:12:55 +00:00
loggedComponents : [
'service-worker'
]
}
let rejectingFetch = jest . fn ( ( request , init ) => { return Promise . reject ( request ) ; } )
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : rejectingFetch
}
2021-09-06 12:12:55 +00:00
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : resolvingFetch
}
2021-09-06 12:12:55 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-06 12:12:55 +00:00
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' ) )
expect ( rejectingFetch ) . toHaveBeenCalled ( ) ;
expect ( resolvingFetch ) . toHaveBeenCalled ( ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
} ) ;
2021-11-08 20:51:27 +00:00
test ( "plugins should receive the Request() init data" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'reject-all'
} , {
name : 'resolve-all'
} ] ,
loggedComponents : [
'service-worker'
]
}
let rejectingFetch = jest . fn ( ( request , init ) => { return Promise . reject ( request ) ; } )
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : rejectingFetch
}
} )
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : resolvingFetch
}
} )
var initTest = {
method : "GET" ,
2021-11-17 13:57:47 +00:00
// TODO: ref. https://gitlab.com/rysiekpl/libresilient/-/issues/23
//headers: new Headers({"x-stub": "STUB"}),
//mode: "mode-stub",
//credentials: "credentials-stub",
2021-11-08 20:51:27 +00:00
cache : "cache-stub" ,
referrer : "referrer-stub" ,
// these are not implemented by service-worker-mock
// https://github.com/zackargyle/service-workers/blob/master/packages/service-worker-mock/models/Request.js#L20
redirect : undefined ,
integrity : undefined ,
cache : undefined
}
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-11-08 20:51:27 +00:00
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' , initTest ) )
expect ( rejectingFetch ) . toHaveBeenCalled ( ) ;
expect ( resolvingFetch ) . toHaveBeenCalled ( ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
expect ( rejectingFetch ) . toHaveBeenCalledWith ( 'https://www.test.com/test.json' , initTest )
expect ( resolvingFetch ) . toHaveBeenCalledWith ( 'https://www.test.com/test.json' , initTest )
} ) ;
2021-09-06 12:12:55 +00:00
test ( "defaultPluginTimeout should be respected" , async ( ) => {
self . LibResilientConfig = {
2022-01-26 02:02:25 +00:00
defaultPluginTimeout : 100 ,
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'resolve-with-timeout'
} ] ,
2021-09-06 12:12:55 +00:00
loggedComponents : [
'service-worker' ,
]
}
let rwtCallback = jest . fn ( )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'resolve-with-timeout' , ( ) => {
return {
name : 'resolve-with-timeout' ,
description : 'Resolve all requests after a timeout.' ,
version : '0.0.1' ,
fetch : ( request , init ) => {
return new Promise ( ( resolve , reject ) => {
2022-01-26 02:02:25 +00:00
setTimeout ( rwtCallback , 300 )
2021-09-19 01:23:26 +00:00
} )
}
}
2021-09-06 12:12:55 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-06 12:12:55 +00:00
var response = self . trigger ( 'fetch' , new Request ( '/test.json' ) )
expect . assertions ( 2 )
try {
await response
} catch ( e ) {
2022-01-26 02:02:25 +00:00
expect ( e . toString ( ) ) . toBe ( "Error: LibResilient request using resolve-with-timeout timed out after 100ms." )
2021-09-06 12:12:55 +00:00
}
expect ( rwtCallback ) . not . toHaveBeenCalled ( )
} ) ;
2021-09-06 00:11:33 +00:00
test ( "making an external request should work and not go through the plugins" , async ( ) => {
global . fetch . mockImplementation ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
method : 'GET' ,
url : request . url
} )
) ;
} ) ;
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'reject-all'
} ] ,
2021-09-06 00:11:33 +00:00
loggedComponents : [
'service-worker'
]
}
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : ( request , init ) => { return Promise . reject ( request ) ; }
}
2021-09-06 00:11:33 +00:00
} )
require ( "../service-worker.js" ) ;
var response = await self . trigger ( 'fetch' , new Request ( 'https://example.com/test.json' ) )
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
} )
2021-09-04 18:33:33 +00:00
test ( "making a POST request should work and not go through the plugins" , async ( ) => {
global . fetch . mockImplementation ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
method : 'POST' ,
url : request . url
} )
) ;
} ) ;
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'reject-all'
} ] ,
2021-09-04 18:33:33 +00:00
loggedComponents : [
'service-worker'
]
}
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : ( request , init ) => { return Promise . reject ( request ) ; }
}
2021-09-04 18:33:33 +00:00
} )
require ( "../service-worker.js" ) ;
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' , { method : "POST" } ) )
expect ( response . method ) . toEqual ( 'POST' )
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
} )
2021-09-01 21:01:01 +00:00
test ( "stashing content after a successful fetch should work" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'fetch'
} , {
name : 'cache'
} ] ,
2021-09-01 21:01:01 +00:00
loggedComponents : [
'service-worker' , 'fetch' , 'cache'
]
}
2021-08-31 16:08:55 +00:00
require ( "../service-worker.js" ) ;
2021-09-01 21:01:01 +00:00
2021-08-31 16:08:55 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-08-31 16:08:55 +00:00
await self . trigger ( 'activate' )
2021-09-01 21:01:01 +00:00
2021-08-31 16:08:55 +00:00
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' ) )
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . keys ( )
} ) . then ( ( keys ) => {
return keys [ 0 ] . url
} ) ) . toEqual ( self . location . origin + '/test.json' )
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . match ( self . location . origin + '/test.json' )
} ) . then ( ( response ) => {
return response . json ( )
} ) . then ( ( json ) => {
return json
} ) ) . toEqual ( { test : "success" } )
} ) ;
2021-09-01 21:01:01 +00:00
2021-09-06 12:37:32 +00:00
test ( "stashing should be skipped if content was retrieved from a stashing plugin" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'stashing-test'
} , {
name : 'reject-all'
} ] ,
2021-09-06 12:37:32 +00:00
loggedComponents : [
'service-worker'
]
}
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
2021-09-06 13:10:51 +00:00
'X-LibResilient-Method' : 'resolve-all' ,
'X-LibResilient-ETag' : 'TestingETagHeader'
2021-09-06 12:37:32 +00:00
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let rejectingFetch = jest . fn ( ( request , init ) => { return Promise . reject ( request ) ; } )
let stashingStash = jest . fn ( )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'stashing-test' , ( ) => {
return {
name : 'stashing-test' ,
description : 'Mock stashing plugin.' ,
version : '0.0.1' ,
fetch : resolvingFetch ,
stash : stashingStash
}
2021-09-06 12:37:32 +00:00
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : rejectingFetch
}
2021-09-06 12:37:32 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-06 12:37:32 +00:00
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' ) )
expect ( resolvingFetch ) . toHaveBeenCalled ( ) ;
expect ( stashingStash ) . not . toHaveBeenCalled ( ) ;
expect ( rejectingFetch ) . toHaveBeenCalled ( ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
} ) ;
2021-09-06 13:10:51 +00:00
test ( "content should be stashed if it was retrieved from a job after retrieval from a stashing plugin, and it differs from the stashed version" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'stashing-test'
} , {
name : 'resolve-all'
} ] ,
2021-09-06 13:10:51 +00:00
loggedComponents : [
'service-worker'
]
}
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'X-LibResilient-Method' : 'resolve-all' ,
'X-LibResilient-ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let resolvingFetch2 = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success2" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'NewTestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let stashingStash = jest . fn ( async ( response , url ) => {
expect ( await response . json ( ) ) . toEqual ( { test : "success2" } )
expect ( response . headers . get ( 'ETag' ) ) . toEqual ( 'NewTestingETagHeader' )
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'stashing-test' , ( ) => {
return {
name : 'stashing-test' ,
description : 'Mock stashing plugin.' ,
version : '0.0.1' ,
fetch : resolvingFetch ,
stash : stashingStash
}
2021-09-06 13:10:51 +00:00
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : resolvingFetch2
}
2021-09-06 13:10:51 +00:00
} )
2021-09-06 18:14:19 +00:00
var testClient = new Client ( )
self . clients . clients . push ( testClient )
var fetchedDiffersFound = false
testClient . addEventListener ( 'message' , event => {
if ( event . data . fetchedDiffers ) {
fetchedDiffersFound = true
}
} )
2021-09-06 13:10:51 +00:00
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-06 18:14:19 +00:00
var response = await self . trigger ( 'fetch' , {
request : new Request ( '/test.json' ) ,
clientId : testClient . id
} )
2021-09-06 13:10:51 +00:00
expect ( resolvingFetch ) . toHaveBeenCalled ( ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
expect ( resolvingFetch2 ) . toHaveBeenCalled ( ) ;
expect ( stashingStash ) . toHaveBeenCalled ( ) ;
2021-09-06 18:14:19 +00:00
expect ( fetchedDiffersFound ) . toEqual ( true )
2021-09-06 13:10:51 +00:00
} ) ;
test ( "content should be stashed if it was retrieved from a job after retrieval from a stashing plugin, even it does not differ from the stashed version" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'stashing-test'
} , {
name : 'resolve-all'
} ] ,
2021-09-06 13:10:51 +00:00
loggedComponents : [
'service-worker'
]
}
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'X-LibResilient-Method' : 'resolve-all' ,
'X-LibResilient-ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let stashingStash = jest . fn ( )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'stashing-test' , ( ) => {
return {
name : 'stashing-test' ,
description : 'Mock stashing plugin.' ,
version : '0.0.1' ,
fetch : resolvingFetch ,
stash : stashingStash
}
2021-09-06 13:10:51 +00:00
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : resolvingFetch
}
2021-09-06 13:10:51 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-06 13:10:51 +00:00
var response = await self . trigger ( 'fetch' , new Request ( '/test.json' ) )
expect ( resolvingFetch ) . toHaveBeenCalledTimes ( 2 ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
expect ( stashingStash ) . toHaveBeenCalled ( ) ;
} ) ;
2021-09-01 21:01:01 +00:00
test ( "stashing content explicitly should work" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'cache'
} ] ,
2021-09-01 21:01:01 +00:00
loggedComponents : [
'service-worker' , 'cache'
]
}
require ( "../service-worker.js" ) ;
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-09-01 21:01:01 +00:00
await self . trigger ( 'activate' )
await self . trigger (
'message' ,
{
data : {
stash : [ new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
2021-09-06 13:10:51 +00:00
'ETag' : 'TestingETagHeader'
2021-09-01 21:01:01 +00:00
} ,
url : self . location . origin + '/test.json'
} ) ]
}
} )
2022-02-06 23:07:16 +00:00
// needed here also
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-09-01 21:01:01 +00:00
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . keys ( )
} ) . then ( ( keys ) => {
return keys [ 0 ] . url
} ) ) . toEqual ( self . location . origin + '/test.json' )
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . match ( self . location . origin + '/test.json' )
} ) . then ( ( response ) => {
return response . json ( )
} ) . then ( ( json ) => {
return json
} ) ) . toEqual ( { test : "success" } )
} ) ;
2021-09-04 18:33:33 +00:00
2021-11-08 20:51:27 +00:00
test ( "after a retrieval from a stashing plugin, background plugin should receive the Request() init data" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'stashing-test'
} , {
name : 'resolve-all'
} ] ,
loggedComponents : [
'service-worker'
]
}
let resolvingFetch = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'X-LibResilient-Method' : 'resolve-all' ,
'X-LibResilient-ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let resolvingFetch2 = jest . fn ( ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success2" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'NewTestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
} )
let stashingStash = jest . fn ( async ( response , url ) => {
expect ( await response . json ( ) ) . toEqual ( { test : "success2" } )
expect ( response . headers . get ( 'ETag' ) ) . toEqual ( 'NewTestingETagHeader' )
} )
global . LibResilientPluginConstructors . set ( 'stashing-test' , ( ) => {
return {
name : 'stashing-test' ,
description : 'Mock stashing plugin.' ,
version : '0.0.1' ,
fetch : resolvingFetch ,
stash : stashingStash
}
} )
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : resolvingFetch2
}
} )
var testClient = new Client ( )
self . clients . clients . push ( testClient )
var fetchedDiffersFound = false
testClient . addEventListener ( 'message' , event => {
if ( event . data . fetchedDiffers ) {
fetchedDiffersFound = true
}
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-11-08 20:51:27 +00:00
var initTest = {
method : "GET" ,
2021-11-17 13:57:47 +00:00
// TODO: ref. https://gitlab.com/rysiekpl/libresilient/-/issues/23
//headers: new Headers({"x-stub": "STUB"}),
//mode: "mode-stub",
//credentials: "credentials-stub",
2021-11-08 20:51:27 +00:00
cache : "cache-stub" ,
referrer : "referrer-stub" ,
// these are not implemented by service-worker-mock
// https://github.com/zackargyle/service-workers/blob/master/packages/service-worker-mock/models/Request.js#L20
redirect : undefined ,
integrity : undefined ,
cache : undefined
}
var response = await self . trigger ( 'fetch' , {
request : new Request ( '/test.json' , initTest ) ,
clientId : testClient . id
} )
expect ( resolvingFetch ) . toHaveBeenCalled ( ) ;
expect ( await response . json ( ) ) . toEqual ( { test : "success" } )
expect ( resolvingFetch ) . toHaveBeenCalledWith ( 'https://www.test.com/test.json' , initTest ) ;
expect ( resolvingFetch2 ) . toHaveBeenCalledWith ( 'https://www.test.com/test.json' , initTest ) ;
} ) ;
2021-09-04 18:33:33 +00:00
test ( "unstashing content explicitly should work" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'cache'
} ] ,
2021-09-04 18:33:33 +00:00
loggedComponents : [
'service-worker' , 'cache'
]
}
require ( "../service-worker.js" ) ;
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-09-04 18:33:33 +00:00
await self . trigger ( 'activate' )
await self . trigger (
'message' ,
{
data : {
stash : [ new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} ) ]
}
} )
2022-02-06 23:07:16 +00:00
// needed here also
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2021-09-04 18:33:33 +00:00
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . keys ( )
} ) . then ( ( keys ) => {
return keys [ 0 ] . url
} ) ) . toEqual ( self . location . origin + '/test.json' )
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . match ( self . location . origin + '/test.json' )
} ) . then ( ( response ) => {
return response . json ( )
} ) . then ( ( json ) => {
return json
} ) ) . toEqual ( { test : "success" } )
// now unstash
await self . trigger (
'message' ,
{
data : {
unstash : [ self . location . origin + '/test.json' ]
}
} )
expect ( await caches . open ( 'v1' ) . then ( ( cache ) => {
return cache . keys ( )
} ) ) . toEqual ( [ ] )
} ) ;
2021-09-04 19:09:06 +00:00
test ( "publishing content explicitly should work (stub)" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'publish-test'
} ] ,
2021-09-04 19:09:06 +00:00
loggedComponents : [
'service-worker'
]
}
var result = false
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'publish-test' , ( ) => {
return {
name : 'publish-test' ,
description : 'Publish plugin fixture.' ,
version : '0.0.1' ,
publish : ( request ) => {
result = 'publish-test success: ' + request . url
}
2021-09-04 19:09:06 +00:00
}
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-04 19:09:06 +00:00
await self . trigger (
'message' ,
{
data : {
publish : [ new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} ) ]
}
} )
expect ( result ) . toEqual ( 'publish-test success: ' + self . location . origin + '/test.json' )
} )
2021-09-04 19:55:07 +00:00
test ( "using plugins with dependencies should work" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'dependent-test' ,
uses : [ {
name : 'dependency1-test'
} , {
name : 'dependency2-test'
} ]
} ] ,
2021-09-04 19:55:07 +00:00
loggedComponents : [
'service-worker'
]
}
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'dependent-test' , ( ) => {
return {
name : 'dependent-test' ,
description : 'Dependent plugin fixture.' ,
version : '0.0.1' ,
uses : [ {
name : 'dependency1-test'
} , {
name : 'dependency2-test'
} ]
2021-09-04 19:55:07 +00:00
}
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'dependency1-test' , ( ) => {
return {
name : 'dependency1-test' ,
description : 'First dependency plugin fixture.' ,
version : '0.0.1'
}
2021-09-04 19:55:07 +00:00
} )
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'dependency2-test' , ( ) => {
return {
name : 'dependency2-test' ,
description : 'Second dependency plugin fixture.' ,
version : '0.0.1'
}
2021-09-04 19:55:07 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-19 01:23:26 +00:00
expect ( self . LibResilientPlugins . map ( p => p . name ) ) . toEqual ( [ 'dependent-test' ] )
expect ( self . LibResilientPlugins [ 0 ] . uses . map ( p => p . name ) ) . toEqual ( [ 'dependency1-test' , 'dependency2-test' ] )
} )
test ( "using multiple instances of the same plugin should work" , async ( ) => {
self . LibResilientConfig = {
plugins : [ {
name : 'plugin-test' ,
} , {
name : 'plugin-test' ,
} , {
name : 'plugin-test' ,
} ] ,
loggedComponents : [
'service-worker'
]
}
var pver = 0
global . LibResilientPluginConstructors . set ( 'plugin-test' , ( ) => {
pver += 1
return {
name : 'plugin-test' ,
description : 'Simple plugin stub.' ,
version : '0.0.' + pver
}
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-19 01:23:26 +00:00
expect ( self . LibResilientPlugins . map ( p => p . name ) ) . toEqual ( [ 'plugin-test' , 'plugin-test' , 'plugin-test' ] )
expect ( self . LibResilientPlugins . map ( p => p . version ) ) . toEqual ( [ '0.0.1' , '0.0.2' , '0.0.3' ] )
2021-09-04 19:55:07 +00:00
} )
2021-09-04 20:45:03 +00:00
test ( "should error out if all plugins fail" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'reject-all'
} ] ,
2021-09-04 20:45:03 +00:00
loggedComponents : [
'service-worker'
]
}
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'reject-all' , ( ) => {
return {
name : 'reject-all' ,
description : 'Reject all requests.' ,
version : '0.0.1' ,
fetch : ( request , init ) => { return Promise . reject ( request ) ; }
}
2021-09-04 20:45:03 +00:00
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-04 20:45:03 +00:00
expect . assertions ( 1 )
try {
await self . trigger ( 'fetch' , new Request ( '/test.json' , { method : "GET" } ) )
} catch ( e ) {
expect ( e ) . toEqual ( self . location . origin + '/test.json' )
}
} )
2021-09-05 23:59:44 +00:00
test ( "should send clientId back if event.resultingClientId is set" , async ( ) => {
self . LibResilientConfig = {
2021-09-18 23:35:22 +00:00
plugins : [ {
name : 'resolve-all'
} ] ,
2021-09-05 23:59:44 +00:00
loggedComponents : [
'service-worker'
]
}
2021-09-19 01:23:26 +00:00
global . LibResilientPluginConstructors . set ( 'resolve-all' , ( ) => {
return {
name : 'resolve-all' ,
description : 'Resolve all requests.' ,
version : '0.0.1' ,
fetch : ( request , init ) => {
return Promise . resolve (
new Response (
new Blob (
[ JSON . stringify ( { test : "success" } ) ] ,
{ type : "application/json" }
) ,
{
status : 200 ,
statusText : "OK" ,
headers : {
'ETag' : 'TestingETagHeader'
} ,
url : self . location . origin + '/test.json'
} )
)
}
2021-09-05 23:59:44 +00:00
}
} )
var testClient = new Client ( )
self . clients . clients . push ( testClient )
// monkey-patching addEventListener so that we can add
// the resultingClientId field to the event in a fetch callback
self . oldAddEventListener = self . addEventListener
self . addEventListener = ( eventName , callback ) => {
if ( eventName === 'fetch' ) {
return self . oldAddEventListener ( eventName , event => {
event . resultingClientId = testClient . id
return callback ( event )
} )
} else {
return self . oldAddEventListener ( eventName , callback )
}
}
expect . hasAssertions ( )
testClient . addEventListener ( 'message' , event => {
if ( event . data . clientId ) {
expect ( event . data . clientId ) . toEqual ( testClient . id )
}
} )
require ( "../service-worker.js" ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'install' )
2022-01-26 02:02:25 +00:00
// this is silly but works, and is necessary because
// event.waitUntil() in the install event handler is not handled correctly in NodeJS
2022-02-06 23:07:16 +00:00
await new Promise ( resolve => setTimeout ( resolve , 100 ) ) ;
2022-01-24 13:54:10 +00:00
await self . trigger ( 'activate' )
2021-09-05 23:59:44 +00:00
await self . trigger ( 'fetch' , new Request ( '/test.json' ) )
} )
2021-08-31 16:08:55 +00:00
} ) ;