angular-cn/packages/service-worker/worker/test/data_spec.ts

/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

import {CacheDatabase} from '../src/db-cache';
import {Driver} from '../src/driver';
import {Manifest} from '../src/manifest';
import {MockRequest} from '../testing/fetch';
import {MockFileSystemBuilder, MockServerStateBuilder, tmpHashTableForFs} from '../testing/mock';
import {SwTestHarness, SwTestHarnessBuilder} from '../testing/scope';

import {async_beforeEach, async_fit, async_it} from './async';

const dist = new MockFileSystemBuilder()
                 .addFile('/foo.txt', 'this is foo')
                 .addFile('/bar.txt', 'this is bar')
                 .addFile('/api/test', 'version 1')
                 .addFile('/api/a', 'version A')
                 .addFile('/api/b', 'version B')
                 .addFile('/api/c', 'version C')
                 .addFile('/api/d', 'version D')
                 .addFile('/api/e', 'version E')
                 .addFile('/fresh/data', 'this is fresh data')
                 .addFile('/refresh/data', 'this is some data')
                 .build();


const distUpdate = new MockFileSystemBuilder()
                       .addFile('/foo.txt', 'this is foo v2')
                       .addFile('/bar.txt', 'this is bar')
                       .addFile('/api/test', 'version 2')
                       .addFile('/fresh/data', 'this is fresher data')
                       .addFile('/refresh/data', 'this is refreshed data')
                       .build();

const manifest: Manifest = {
  configVersion: 1,
  index: '/index.html',
  assetGroups: [
    {
      name: 'assets',
      installMode: 'prefetch',
      updateMode: 'prefetch',
      urls: [
        '/foo.txt',
        '/bar.txt',
      ],
      patterns: [],
    },
  ],
  dataGroups: [
    {
      name: 'testPerf',
      maxSize: 3,
      strategy: 'performance',
      patterns: ['^/api/.*$'],
      timeoutMs: 1000,
      maxAge: 5000,
      version: 1,
    },
    {
      name: 'testRefresh',
      maxSize: 3,
      strategy: 'performance',
      patterns: ['^/refresh/.*$'],
      timeoutMs: 1000,
      refreshAheadMs: 1000,
      maxAge: 5000,
      version: 1,
    },
    {
      name: 'testFresh',
      maxSize: 3,
      strategy: 'freshness',
      patterns: ['^/fresh/.*$'],
      timeoutMs: 1000,
      maxAge: 5000,
      version: 1,
    },
  ],
  navigationUrls: [],
  hashTable: tmpHashTableForFs(dist),
};

const seqIncreasedManifest: Manifest = {
  ...manifest,
  dataGroups: [
    {
      ...manifest.dataGroups ![0],
      version: 2,
    },
    manifest.dataGroups ![1],
    manifest.dataGroups ![2],
  ],
};


const server = new MockServerStateBuilder().withStaticFiles(dist).withManifest(manifest).build();

const serverUpdate =
    new MockServerStateBuilder().withStaticFiles(distUpdate).withManifest(manifest).build();

const serverSeqUpdate = new MockServerStateBuilder()
                            .withStaticFiles(distUpdate)
                            .withManifest(seqIncreasedManifest)
                            .build();

const scope = new SwTestHarnessBuilder().withServerState(server).build();

function asyncWrap(fn: () => Promise<void>): (done: DoneFn) => void {
  return (done: DoneFn) => { fn().then(() => done(), err => done.fail(err)); };
}

(function() {
  // Skip environments that don't support the minimum APIs needed to run the SW tests.
  if (!SwTestHarness.envIsSupported()) {
    return;
  }
  describe('data cache', () => {
    let scope: SwTestHarness;
    let driver: Driver;
    async_beforeEach(async() => {
      server.clearRequests();
      scope = new SwTestHarnessBuilder().withServerState(server).build();
      driver = new Driver(scope, scope, new CacheDatabase(scope, scope));

      // Initialize.
      expect(await makeRequest(scope, '/foo.txt')).toEqual('this is foo');
      await driver.initialized;
      server.reset();
      serverUpdate.reset();
    });

    describe('in performance mode', () => {
      async_it('names the caches correctly', async() => {
        expect(await makeRequest(scope, '/api/test')).toEqual('version 1');
        const keys = await scope.caches.keys();
        expect(keys.every(key => key.startsWith('ngsw:'))).toEqual(true);
      });

      async_it('caches a basic request', async() => {
        expect(await makeRequest(scope, '/api/test')).toEqual('version 1');
        server.assertSawRequestFor('/api/test');
        scope.advance(1000);
        expect(await makeRequest(scope, '/api/test')).toEqual('version 1');
        server.assertNoOtherRequests();
      });

      async_it('refreshes after awhile', async() => {
        expect(await makeRequest(scope, '/api/test')).toEqual('version 1');
        server.clearRequests();
        scope.advance(10000);
        scope.updateServerState(serverUpdate);
        expect(await makeRequest(scope, '/api/test')).toEqual('version 2');
      });

      async_it('expires the least recently used entry', async() => {
        expect(await makeRequest(scope, '/api/a')).toEqual('version A');
        expect(await makeRequest(scope, '/api/b')).toEqual('version B');
        expect(await makeRequest(scope, '/api/c')).toEqual('version C');
        expect(await makeRequest(scope, '/api/d')).toEqual('version D');
        expect(await makeRequest(scope, '/api/e')).toEqual('version E');
        server.clearRequests();
        expect(await makeRequest(scope, '/api/c')).toEqual('version C');
        expect(await makeRequest(scope, '/api/d')).toEqual('version D');
        expect(await makeRequest(scope, '/api/e')).toEqual('version E');
        server.assertNoOtherRequests();
        expect(await makeRequest(scope, '/api/a')).toEqual('version A');
        expect(await makeRequest(scope, '/api/b')).toEqual('version B');
        server.assertSawRequestFor('/api/a');
        server.assertSawRequestFor('/api/b');
        server.assertNoOtherRequests();
      });

      async_it('does not carry over cache with new version', async() => {
        expect(await makeRequest(scope, '/api/test')).toEqual('version 1');
        scope.updateServerState(serverSeqUpdate);
        expect(await driver.checkForUpdate()).toEqual(true);
        await driver.updateClient(await scope.clients.get('default'));
        expect(await makeRequest(scope, '/api/test')).toEqual('version 2');
      });
    });

    describe('in freshness mode', () => {
      async_it('goes to the server first', async() => {
        expect(await makeRequest(scope, '/fresh/data')).toEqual('this is fresh data');
        server.assertSawRequestFor('/fresh/data');
        server.clearRequests();
        expect(await makeRequest(scope, '/fresh/data')).toEqual('this is fresh data');
        server.assertSawRequestFor('/fresh/data');
        server.assertNoOtherRequests();
        scope.updateServerState(serverUpdate);
        expect(await makeRequest(scope, '/fresh/data')).toEqual('this is fresher data');
        serverUpdate.assertSawRequestFor('/fresh/data');
        serverUpdate.assertNoOtherRequests();
      });

      async_it('falls back on the cache when server times out', async() => {
        expect(await makeRequest(scope, '/fresh/data')).toEqual('this is fresh data');
        server.assertSawRequestFor('/fresh/data');
        server.clearRequests();
        scope.updateServerState(serverUpdate);
        serverUpdate.pause();
        const [res, done] = makePendingRequest(scope, '/fresh/data');

        await serverUpdate.nextRequest;

        // Since the network request doesn't return within the timeout of 1,000ms,
        // this should return cached data.
        scope.advance(2000);

        expect(await res).toEqual('this is fresh data');

        // Unpausing allows the worker to continue with caching.
        serverUpdate.unpause();
        await done;

        serverUpdate.pause();
        const [res2, done2] = makePendingRequest(scope, '/fresh/data');
        await serverUpdate.nextRequest;
        scope.advance(2000);
        expect(await res2).toEqual('this is fresher data');
      });

      async_it('refreshes ahead', async() => {
        server.assertNoOtherRequests();
        serverUpdate.assertNoOtherRequests();
        expect(await makeRequest(scope, '/refresh/data')).toEqual('this is some data');
        server.assertSawRequestFor('/refresh/data');
        server.clearRequests();
        expect(await makeRequest(scope, '/refresh/data')).toEqual('this is some data');
        server.assertNoOtherRequests();
        scope.updateServerState(serverUpdate);
        scope.advance(1500);
        expect(await makeRequest(scope, '/refresh/data')).toEqual('this is some data');
        serverUpdate.assertSawRequestFor('/refresh/data');
        expect(await makeRequest(scope, '/refresh/data')).toEqual('this is refreshed data');
        serverUpdate.assertNoOtherRequests();
      });
    });
  });
})();

async function makeRequest(scope: SwTestHarness, url: string, clientId?: string):
    Promise<string|null> {
      const [resPromise, done] = scope.handleFetch(new MockRequest(url), clientId || 'default');
      await done;
      const res = await resPromise;
      if (res !== undefined) {
        return res.text();
      }
      return null;
    }

function makePendingRequest(scope: SwTestHarness, url: string, clientId?: string):
    [Promise<string|null>, Promise<void>] {
      const [resPromise, done] = scope.handleFetch(new MockRequest(url), clientId || 'default');
      return [
        (async() => {
          const res = await resPromise;
          if (res !== undefined) {
            return res.text();
          }
          return null;
        })(),
        done
      ];
    }