it('should report lint error once', (done) => {
    host.writeMultipleFiles({'src/app/app.component.ts': 'const foo = "";\n' });
    const logger = new TestLogger('lint-error');

    runTargetSpec(host, tslintTargetSpec, undefined, DefaultTimeout, logger).pipe(
      tap((buildEvent) => expect(buildEvent.success).toBe(false)),
      tap(() => {
        // this is to make sure there are no duplicates
        expect(logger.includes(`" should be \'\nERROR`)).toBe(false);

        expect(logger.includes(`" should be '`)).toBe(true);
        expect(logger.includes(`Lint errors found in the listed files`)).toBe(true);
      }),
    ).toPromise().then(done, done.fail);
  }, 30000);

  it('works', (done) => {
    host.replaceInFile('src/app/app.module.ts', './app.component', '@root/app/app.component');
    host.replaceInFile('tsconfig.json', /"baseUrl": ".\/",/, `
      "baseUrl": "./",
      "paths": {
        "@root/*": [
          "./src/*"
        ]
      },
    `);

    runTargetSpec(host, browserTargetSpec).pipe(
      tap((buildEvent) => expect(buildEvent.success).toBe(true)),
    ).toPromise().then(done, done.fail);
  }, Timeout.Basic);

  it('does not map sourcemaps from external library when disabled', (done) => {
    const overrides = { sourceMap: true, vendorSourceMap: false };

    runTargetSpec(host, browserTargetSpec, overrides).pipe(
      tap((buildEvent) => expect(buildEvent.success).toBe(true)),
      tap(() => {
        const fileName = join(outputPath, 'vendor.js.map');
        expect(host.scopedSync().exists(fileName)).toBe(true);
        const content = virtualFs.fileBufferToString(host.scopedSync().read(normalize(fileName)));
        // this is due the fact that some vendors like `tslib` sourcemaps to js files
        const sourcePath = JSON.parse(content).sources[0];
        expect(path.extname(sourcePath)).toBe('.js', `${sourcePath} extention should be '.js'`);
      }),
    ).toPromise().then(done, done.fail);
  }, Timeout.Basic);

  it(`supports lazy bundle for dynamic import() calls`, (done) => {
    host.writeMultipleFiles({
      'src/lazy-module.ts': 'export const value = 42;',
      'src/main.ts': `
        const lazyFileName = 'module';
        import(/*webpackChunkName: '[request]'*/'./lazy-' + lazyFileName);
      `,
    });
    host.replaceInFile('src/tsconfig.app.json', `"module": "es2015"`, `"module": "esnext"`);

    runTargetSpec(host, browserTargetSpec).pipe(
      tap((buildEvent) => expect(buildEvent.success).toBe(true)),
      tap(() => expect(host.scopedSync().exists(join(outputPath, 'lazy-module.js'))).toBe(true)),
    ).toPromise().then(done, done.fail);
  }, Timeout.Basic);

  it('works', (done) => {
    const overrides: Partial<NormalizedKarmaBuilderSchema> = { codeCoverage: true };

    runTargetSpec(host, karmaTargetSpec, overrides).pipe(
      // It seems like the coverage files take a while being written to disk, so we wait 500ms here.
      debounceTime(500),
      tap(buildEvent => {
        expect(buildEvent.success).toBe(true);
        expect(host.scopedSync().exists(coverageFilePath)).toBe(true);
        const content = virtualFs.fileBufferToString(host.scopedSync().read(coverageFilePath));
        expect(content).toContain('polyfills.ts');
        expect(content).toContain('test.ts');
      }),
    ).toPromise().then(done, done.fail);
  }, 120000);

  it('deletes output path', (done) => {
    // Write a file to the output path to later verify it was deleted.
    host.scopedSync().write(join(outputPath, 'file.txt'), virtualFs.stringToFileBuffer('file'));
    // Delete an app file to force a failed compilation.
    // Failed compilations still delete files, but don't output any.
    host.delete(join(host.root(), 'src', 'app', 'app.component.ts')).subscribe({
      error: done.fail,
    });

    runTargetSpec(host, browserTargetSpec).pipe(
      tap((buildEvent) => {
        expect(buildEvent.success).toBe(false);
        expect(host.scopedSync().exists(outputPath)).toBe(false);
      }),
    ).toPromise().then(done, done.fail);
  }, Timeout.Basic);

  it('fails with non-source root input path', (done) => {
    const assets: { [path: string]: string } = {
      './node_modules/some-package/node_modules-asset.txt': 'node_modules-asset.txt',
    };
    host.writeMultipleFiles(assets);
    const overrides = {
      assets: ['not-source-root/file.txt'],
    };

    runTargetSpec(host, browserTargetSpec, overrides)
      .subscribe(undefined, () => done(), done.fail);

    // The node_modules folder must be deleted, otherwise code that tries to find the
    // node_modules folder will hit this one and can fail.
    host.scopedSync().delete(normalize('./node_modules'));
  });

  it('does not hash lazy styles', (done) => {
    const overrides = {
      outputHashing: 'all',
      extractCss: true,
      styles: [{ input: 'src/styles.css', lazy: true }],
    };

    runTargetSpec(host, browserTargetSpec, overrides, DefaultTimeout).pipe(
      tap(() => {
        expect(host.fileMatchExists('dist', /styles\.[0-9a-f]{20}\.js/)).toBeFalsy();
        expect(host.fileMatchExists('dist', /styles\.[0-9a-f]{20}\.js.map/)).toBeFalsy();
        expect(host.scopedSync().exists(normalize('dist/styles.css'))).toBe(true);
        expect(host.scopedSync().exists(normalize('dist/styles.css.map'))).toBe(true);
      }),
    ).toPromise().then(done, done.fail);
  });