angular-cn/packages/platform-browser/test/browser/bootstrap_spec.ts

/**
 * @license
 * Copyright Google LLC 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 {DOCUMENT, isPlatformBrowser, ɵgetDOM as getDOM} from '@angular/common';
import {APP_INITIALIZER, Compiler, Component, createPlatformFactory, CUSTOM_ELEMENTS_SCHEMA, Directive, ErrorHandler, Inject, Injector, Input, LOCALE_ID, NgModule, OnDestroy, Pipe, PLATFORM_ID, PLATFORM_INITIALIZER, Provider, Sanitizer, StaticProvider, Type, VERSION} from '@angular/core';
import {ApplicationRef, destroyPlatform} from '@angular/core/src/application_ref';
import {Console} from '@angular/core/src/console';
import {ComponentRef} from '@angular/core/src/linker/component_factory';
import {Testability, TestabilityRegistry} from '@angular/core/src/testability/testability';
import {afterEach, AsyncTestCompleter, beforeEach, beforeEachProviders, describe, inject, it, Log} from '@angular/core/testing/src/testing_internal';
import {BrowserModule} from '@angular/platform-browser';
import {platformBrowserDynamic} from '@angular/platform-browser-dynamic';
import {expect} from '@angular/platform-browser/testing/src/matchers';
import {ivyEnabled, modifiedInIvy, onlyInIvy} from '@angular/private/testing';

@Component({selector: 'non-existent', template: ''})
class NonExistentComp {
}

@Component({selector: 'hello-app', template: '{{greeting}} world!'})
class HelloRootCmp {
  greeting: string;
  constructor() {
    this.greeting = 'hello';
  }
}

@Component({selector: 'hello-app', template: 'before: <ng-content></ng-content> after: done'})
class HelloRootCmpContent {
  constructor() {}
}

@Component({selector: 'hello-app-2', template: '{{greeting}} world, again!'})
class HelloRootCmp2 {
  greeting: string;
  constructor() {
    this.greeting = 'hello';
  }
}

@Component({selector: 'hello-app', template: ''})
class HelloRootCmp3 {
  appBinding: any /** TODO #9100 */;

  constructor(@Inject('appBinding') appBinding: any /** TODO #9100 */) {
    this.appBinding = appBinding;
  }
}

@Component({selector: 'hello-app', template: ''})
class HelloRootCmp4 {
  appRef: any /** TODO #9100 */;

  constructor(@Inject(ApplicationRef) appRef: ApplicationRef) {
    this.appRef = appRef;
  }
}

@Component({selector: 'hello-app'})
class HelloRootMissingTemplate {
}

@Directive({selector: 'hello-app'})
class HelloRootDirectiveIsNotCmp {
}

@Component({selector: 'hello-app', template: ''})
class HelloOnDestroyTickCmp implements OnDestroy {
  appRef: ApplicationRef;
  constructor(@Inject(ApplicationRef) appRef: ApplicationRef) {
    this.appRef = appRef;
  }

  ngOnDestroy(): void {
    this.appRef.tick();
  }
}

@Component({selector: 'hello-app', templateUrl: './sometemplate.html'})
class HelloUrlCmp {
  greeting = 'hello';
}

@Directive({selector: '[someDir]', host: {'[title]': 'someDir'}})
class SomeDirective {
  // TODO(issue/24571): remove '!'.
  @Input() someDir!: string;
}

@Pipe({name: 'somePipe'})
class SomePipe {
  transform(value: string): any {
    return `transformed ${value}`;
  }
}

@Component({selector: 'hello-app', template: `<div  [someDir]="'someValue' | somePipe"></div>`})
class HelloCmpUsingPlatformDirectiveAndPipe {
  show: boolean = false;
}

@Component({selector: 'hello-app', template: '<some-el [someProp]="true">hello world!</some-el>'})
class HelloCmpUsingCustomElement {
}

class MockConsole {
  res: any[][] = [];
  error(...s: any[]): void {
    this.res.push(s);
  }
}


class DummyConsole implements Console {
  public warnings: string[] = [];

  log(message: string) {}
  warn(message: string) {
    this.warnings.push(message);
  }
}


class TestModule {}
function bootstrap(
    cmpType: any, providers: Provider[] = [], platformProviders: StaticProvider[] = [],
    imports: Type<any>[] = []): Promise<any> {
  @NgModule({
    imports: [BrowserModule, ...imports],
    declarations: [cmpType],
    bootstrap: [cmpType],
    providers: providers,
    schemas: [CUSTOM_ELEMENTS_SCHEMA]
  })
  class TestModule {
  }
  return platformBrowserDynamic(platformProviders).bootstrapModule(TestModule);
}

{
  let el: any /** TODO #9100 */, el2: any /** TODO #9100 */, testProviders: Provider[],
      lightDom: any /** TODO #9100 */;

  describe('bootstrap factory method', () => {
    if (isNode) return;
    let compilerConsole: DummyConsole;

    beforeEachProviders(() => {
      return [Log];
    });

    beforeEach(inject([DOCUMENT], (doc: any) => {
      destroyPlatform();
      compilerConsole = new DummyConsole();
      testProviders = [{provide: Console, useValue: compilerConsole}];

      const oldRoots = doc.querySelectorAll('hello-app,hello-app-2,light-dom-el');
      for (let i = 0; i < oldRoots.length; i++) {
        getDOM().remove(oldRoots[i]);
      }

      el = getDOM().createElement('hello-app', doc);
      el2 = getDOM().createElement('hello-app-2', doc);
      lightDom = getDOM().createElement('light-dom-el', doc);
      doc.body.appendChild(el);
      doc.body.appendChild(el2);
      el.appendChild(lightDom);
      lightDom.textContent = 'loading';
    }));

    afterEach(destroyPlatform);

    // TODO(misko): can't use `modifiedInIvy.it` because the `it` is somehow special here.
    modifiedInIvy('bootstrapping non-Component throws in View Engine').isEnabled &&
        it('should throw if bootstrapped Directive is not a Component',
           inject([AsyncTestCompleter], (done: AsyncTestCompleter) => {
             const logger = new MockConsole();
             const errorHandler = new ErrorHandler();
             (errorHandler as any)._console = logger as any;
             expect(
                 () => bootstrap(
                     HelloRootDirectiveIsNotCmp, [{provide: ErrorHandler, useValue: errorHandler}]))
                 .toThrowError(`HelloRootDirectiveIsNotCmp cannot be used as an entry component.`);
             done.done();
           }));

    // TODO(misko): can't use `onlyInIvy.it` because the `it` is somehow special here.
    onlyInIvy('bootstrapping non-Component rejects Promise in Ivy').isEnabled &&
        it('should throw if bootstrapped Directive is not a Component',
           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
             const logger = new MockConsole();
             const errorHandler = new ErrorHandler();
             (errorHandler as any)._console = logger as any;
             bootstrap(HelloRootDirectiveIsNotCmp, [
               {provide: ErrorHandler, useValue: errorHandler}
             ]).catch((error: Error) => {
               expect(error).toEqual(
                   new Error(`HelloRootDirectiveIsNotCmp cannot be used as an entry component.`));
               async.done();
             });
           }));

    it('should retrieve sanitizer', inject([Injector], (injector: Injector) => {
         const sanitizer: Sanitizer|null = injector.get(Sanitizer, null);
         if (ivyEnabled) {
           // In Ivy we don't want to have sanitizer in DI. We use DI only to overwrite the
           // sanitizer, but not for default one. The default one is pulled in by the Ivy
           // instructions as needed.
           expect(sanitizer).toBe(null);
         } else {
           // In VE we always need to have Sanitizer available.
           expect(sanitizer).not.toBe(null);
         }
       }));

    it('should throw if no element is found',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const logger = new MockConsole();
         const errorHandler = new ErrorHandler();
         (errorHandler as any)._console = logger as any;
         bootstrap(NonExistentComp, [
           {provide: ErrorHandler, useValue: errorHandler}
         ]).then(null, (reason) => {
           expect(reason.message)
               .toContain('The selector "non-existent" did not match any elements');
           async.done();
           return null;
         });
       }));

    it('should throw if no provider', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const logger = new MockConsole();
         const errorHandler = new ErrorHandler();
         (errorHandler as any)._console = logger as any;

         class IDontExist {}

         @Component({selector: 'cmp', template: 'Cmp'})
         class CustomCmp {
           constructor(iDontExist: IDontExist) {}
         }

         @Component({
           selector: 'hello-app',
           template: '<cmp></cmp>',
         })
         class RootCmp {
         }

         @NgModule({declarations: [CustomCmp], exports: [CustomCmp]})
         class CustomModule {
         }

         bootstrap(RootCmp, [{provide: ErrorHandler, useValue: errorHandler}], [], [
           CustomModule
         ]).then(null, (e: Error) => {
           let errorMsg: string;
           if (ivyEnabled) {
             errorMsg = `R3InjectorError(TestModule)[IDontExist -> IDontExist -> IDontExist]: \n`;
           } else {
             errorMsg = `StaticInjectorError(TestModule)[CustomCmp -> IDontExist]: \n` +
                 '  StaticInjectorError(Platform: core)[CustomCmp -> IDontExist]: \n' +
                 '    NullInjectorError: No provider for IDontExist!';
           }
           expect(e.message).toContain(errorMsg);
           async.done();
           return null;
         });
       }));

    if (getDOM().supportsDOMEvents) {
      it('should forward the error to promise when bootstrap fails',
         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
           const logger = new MockConsole();
           const errorHandler = new ErrorHandler();
           (errorHandler as any)._console = logger as any;

           const refPromise =
               bootstrap(NonExistentComp, [{provide: ErrorHandler, useValue: errorHandler}]);
           refPromise.then(null, (reason: any) => {
             expect(reason.message)
                 .toContain('The selector "non-existent" did not match any elements');
             async.done();
           });
         }));

      it('should invoke the default exception handler when bootstrap fails',
         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
           const logger = new MockConsole();
           const errorHandler = new ErrorHandler();
           (errorHandler as any)._console = logger as any;

           const refPromise =
               bootstrap(NonExistentComp, [{provide: ErrorHandler, useValue: errorHandler}]);
           refPromise.then(null, (reason) => {
             expect(logger.res[0].join('#'))
                 .toContain('ERROR#Error: The selector "non-existent" did not match any elements');
             async.done();
             return null;
           });
         }));
    }

    it('should create an injector promise', () => {
      const refPromise = bootstrap(HelloRootCmp, testProviders);
      expect(refPromise).toEqual(jasmine.any(Promise));
    });

    it('should set platform name to browser',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise = bootstrap(HelloRootCmp, testProviders);
         refPromise.then((ref) => {
           expect(isPlatformBrowser(ref.injector.get(PLATFORM_ID))).toBe(true);
           async.done();
         });
       }));

    it('should display hello world', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise = bootstrap(HelloRootCmp, testProviders);
         refPromise.then((ref) => {
           expect(el).toHaveText('hello world!');
           expect(el.getAttribute('ng-version')).toEqual(VERSION.full);
           async.done();
         });
       }));

    it('should throw a descriptive error if BrowserModule is installed again via a lazily loaded module',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         @NgModule({imports: [BrowserModule]})
         class AsyncModule {
         }
         bootstrap(HelloRootCmp, testProviders)
             .then((ref: ComponentRef<HelloRootCmp>) => {
               const compiler: Compiler = ref.injector.get(Compiler);
               return compiler.compileModuleAsync(AsyncModule).then(factory => {
                 expect(() => factory.create(ref.injector))
                     .toThrowError(
                         `BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.`);
               });
             })
             .then(() => async.done(), err => async.fail(err));
       }));

    it('should support multiple calls to bootstrap',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise1 = bootstrap(HelloRootCmp, testProviders);
         const refPromise2 = bootstrap(HelloRootCmp2, testProviders);
         Promise.all([refPromise1, refPromise2]).then((refs) => {
           expect(el).toHaveText('hello world!');
           expect(el2).toHaveText('hello world, again!');
           async.done();
         });
       }));

    it('should not crash if change detection is invoked when the root component is disposed',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         bootstrap(HelloOnDestroyTickCmp, testProviders).then((ref) => {
           expect(() => ref.destroy()).not.toThrow();
           async.done();
         });
       }));

    it('should unregister change detectors when components are disposed',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         bootstrap(HelloRootCmp, testProviders).then((ref) => {
           const appRef = ref.injector.get(ApplicationRef);
           ref.destroy();
           expect(() => appRef.tick()).not.toThrow();
           async.done();
         });
       }));

    it('should make the provided bindings available to the application component',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise = bootstrap(
             HelloRootCmp3, [testProviders, {provide: 'appBinding', useValue: 'BoundValue'}]);

         refPromise.then((ref) => {
           expect(ref.injector.get('appBinding')).toEqual('BoundValue');
           async.done();
         });
       }));

    it('should not override locale provided during bootstrap',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise =
             bootstrap(HelloRootCmp, [testProviders], [{provide: LOCALE_ID, useValue: 'fr-FR'}]);

         refPromise.then(ref => {
           expect(ref.injector.get(LOCALE_ID)).toEqual('fr-FR');
           async.done();
         });
       }));

    it('should avoid cyclic dependencies when root component requires Lifecycle through DI',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise = bootstrap(HelloRootCmp4, testProviders);

         refPromise.then((ref) => {
           const appRef = ref.injector.get(ApplicationRef);
           expect(appRef).toBeDefined();
           async.done();
         });
       }));

    it('should run platform initializers',
       inject([Log, AsyncTestCompleter], (log: Log, async: AsyncTestCompleter) => {
         const p = createPlatformFactory(platformBrowserDynamic, 'someName', [
           {provide: PLATFORM_INITIALIZER, useValue: log.fn('platform_init1'), multi: true},
           {provide: PLATFORM_INITIALIZER, useValue: log.fn('platform_init2'), multi: true}
         ])();

         @NgModule({
           imports: [BrowserModule],
           providers: [
             {provide: APP_INITIALIZER, useValue: log.fn('app_init1'), multi: true},
             {provide: APP_INITIALIZER, useValue: log.fn('app_init2'), multi: true}
           ]
         })
         class SomeModule {
           ngDoBootstrap() {}
         }

         expect(log.result()).toEqual('platform_init1; platform_init2');
         log.clear();
         p.bootstrapModule(SomeModule).then(() => {
           expect(log.result()).toEqual('app_init1; app_init2');
           async.done();
         });
       }));

    it('should remove styles when transitioning from a server render',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         @Component({
           selector: 'root',
           template: 'root',
         })
         class RootCmp {
         }

         @NgModule({
           bootstrap: [RootCmp],
           declarations: [RootCmp],
           imports: [BrowserModule.withServerTransition({appId: 'my-app'})],
         })
         class TestModule {
         }

         // First, set up styles to be removed.
         const dom = getDOM();
         const platform = platformBrowserDynamic();
         const document = platform.injector.get(DOCUMENT);
         const style = dom.createElement('style', document);
         style.setAttribute('ng-transition', 'my-app');
         document.head.appendChild(style);

         const root = dom.createElement('root', document);
         document.body.appendChild(root);

         platform.bootstrapModule(TestModule).then(() => {
           const styles: HTMLElement[] =
               Array.prototype.slice.apply(document.getElementsByTagName('style') || []);
           styles.forEach(style => {
             expect(style.getAttribute('ng-transition')).not.toBe('my-app');
           });
           async.done();
         });
       }));

    it('should register each application with the testability registry',
       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         const refPromise1: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp, testProviders);
         const refPromise2: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp2, testProviders);

         Promise.all([refPromise1, refPromise2]).then((refs: ComponentRef<any>[]) => {
           const registry = refs[0].injector.get(TestabilityRegistry);
           const testabilities =
               [refs[0].injector.get(Testability), refs[1].injector.get(Testability)];
           Promise.all(testabilities).then((testabilities: Testability[]) => {
             expect(registry.findTestabilityInTree(el)).toEqual(testabilities[0]);
             expect(registry.findTestabilityInTree(el2)).toEqual(testabilities[1]);
             async.done();
           });
         });
       }));

    it('should allow to pass schemas', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
         bootstrap(HelloCmpUsingCustomElement, testProviders).then((compRef) => {
           expect(el).toHaveText('hello world!');
           async.done();
         });
       }));

    describe('change detection', () => {
      const log: string[] = [];
      @Component({
        selector: 'hello-app',
        template: '<div id="button-a" (click)="onClick()">{{title}}</div>',
      })
      class CompA {
        title: string = '';
        ngDoCheck() {
          log.push('CompA:ngDoCheck');
        }
        onClick() {
          this.title = 'CompA';
          log.push('CompA:onClick');
        }
      }

      @Component({
        selector: 'hello-app-2',
        template: '<div id="button-b" (click)="onClick()">{{title}}</div>',
      })
      class CompB {
        title: string = '';
        ngDoCheck() {
          log.push('CompB:ngDoCheck');
        }
        onClick() {
          this.title = 'CompB';
          log.push('CompB:onClick');
        }
      }

      it('should be triggered for all bootstrapped components in case change happens in one of them',
         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
           @NgModule({
             imports: [BrowserModule],
             declarations: [CompA, CompB],
             bootstrap: [CompA, CompB],
             schemas: [CUSTOM_ELEMENTS_SCHEMA]
           })
           class TestModuleA {
           }
           platformBrowserDynamic().bootstrapModule(TestModuleA).then((ref) => {
             log.length = 0;
             el.querySelectorAll('#button-a')[0].click();
             expect(log).toContain('CompA:onClick');
             expect(log).toContain('CompA:ngDoCheck');
             expect(log).toContain('CompB:ngDoCheck');

             log.length = 0;
             el2.querySelectorAll('#button-b')[0].click();
             expect(log).toContain('CompB:onClick');
             expect(log).toContain('CompA:ngDoCheck');
             expect(log).toContain('CompB:ngDoCheck');

             async.done();
           });
         }));


      it('should work in isolation for each component bootstrapped individually',
         inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
           const refPromise1 = bootstrap(CompA);
           const refPromise2 = bootstrap(CompB);
           Promise.all([refPromise1, refPromise2]).then((refs) => {
             log.length = 0;
             el.querySelectorAll('#button-a')[0].click();
             expect(log).toContain('CompA:onClick');
             expect(log).toContain('CompA:ngDoCheck');
             expect(log).not.toContain('CompB:ngDoCheck');

             log.length = 0;
             el2.querySelectorAll('#button-b')[0].click();
             expect(log).toContain('CompB:onClick');
             expect(log).toContain('CompB:ngDoCheck');
             expect(log).not.toContain('CompA:ngDoCheck');

             async.done();
           });
         }));
    });
  });
}