TypeScript testing.fixmeIvy函数代码示例

    describe('typescript support', () => {

      fixmeIvy('FW-738: ngtsc doesn\'t generate flat index files') &&
          it('should have an index d.ts file',
             () => { expect(shx.cat('core.d.ts')).toContain(`export *`); });

      it('should not have amd module names',
         () => { expect(shx.cat('public_api.d.ts')).not.toContain('<amd-module name'); });
    });

describe('upgrade/static (full)', () => {
  beforeEach(loadPage);
  afterEach(verifyNoBrowserErrors);

  it('should render the `ng2-heroes` component', () => {
    expect(element(by.css('h1')).getText()).toEqual('Heroes');
    expect(element.all(by.css('p')).get(0).getText()).toEqual('There are 3 heroes.');
  });

  it('should render 3 ng1-hero components', () => {
    const heroComponents = element.all(by.css('ng1-hero'));
    expect(heroComponents.count()).toEqual(3);
  });

  fixmeIvy('unknown; <ng1Hero> component does not seem to render name & description')
      .it('should add a new hero when the "Add Hero" button is pressed', () => {
        const addHeroButton = element.all(by.css('button')).last();
        expect(addHeroButton.getText()).toEqual('Add Hero');
        addHeroButton.click();
        const heroComponents = element.all(by.css('ng1-hero'));
        expect(heroComponents.last().element(by.css('h2')).getText()).toEqual('Kamala Khan');
      });

  fixmeIvy('unknown; <ng1Hero> component does not seem to render name & description')
      .it('should remove a hero when the "Remove" button is pressed', () => {
        let firstHero = element.all(by.css('ng1-hero')).get(0);
        expect(firstHero.element(by.css('h2')).getText()).toEqual('Superman');

        const removeHeroButton = firstHero.element(by.css('button'));
        expect(removeHeroButton.getText()).toEqual('Remove');
        removeHeroButton.click();

        const heroComponents = element.all(by.css('ng1-hero'));
        expect(heroComponents.count()).toEqual(2);

        firstHero = element.all(by.css('ng1-hero')).get(0);
        expect(firstHero.element(by.css('h2')).getText()).toEqual('Wonder Woman');
      });
});

  describe('ng-if-then-else', () => {
    let comp = 'ng-if-then-else';

    fixmeIvy('unknown. Run "yarn bazel run packages/examples/common:devserver" to debug')
        .it('should hide/show content', () => {
          browser.get(URL);
          waitForElement(comp);
          expect(element.all(by.css(comp)).get(0).getText())
              .toEqual('hideSwitch Primary show = true\nPrimary text to show');
          element.all(by.css(comp + ' button')).get(1).click();
          expect(element.all(by.css(comp)).get(0).getText())
              .toEqual('hideSwitch Primary show = true\nSecondary text to show');
          element.all(by.css(comp + ' button')).get(0).click();
          expect(element.all(by.css(comp)).get(0).getText())
              .toEqual(
                  'showSwitch Primary show = false\nAlternate text while primary text is hidden');
        });
  });

describe('ngc_wrapped', () => {

  // fixmeIvy placeholder to prevent jasmine from erroring out because there are no specs
  it('should be removed once the fixmeIvy below is resolved', () => {});

  fixmeIvy('FW-741: ngtsc breaks tsc module resolution') && it('should work', () => {
    const {read, write, runOneBuild, writeConfig, shouldExist, basePath} = setup();

    write('some_project/index.ts', `
      import {Component} from '@angular/core';
      import {a} from 'ambient_module';
      console.log('works: ', Component);
    `);

    const tsconfig = writeConfig({
      srcTargetPath: 'some_project',
    });
    const typesFile = path.resolve(
        tsconfig.compilerOptions.rootDir, tsconfig.compilerOptions.typeRoots[0], 'thing',
        'index.d.ts');

    write(typesFile, `
      declare module "ambient_module" {
        declare const a = 1;
      }
    `);

    // expect no error
    expect(runOneBuild()).toBe(true);

    shouldExist('bazel-bin/some_project/index.js');

    expect(read('bazel-bin/some_project/index.js'))
        .toContain(`console.log('works: ', core_1.Component);`);
  });
});

  describe('examples', () => {

    beforeEach(() => destroyPlatform());
    afterEach(() => destroyPlatform());

    it('should have AngularJS loaded', () => expect(angular.version.major).toBe(1));

    fixmeIvy('FW-714: ng1 projected content is not being rendered') &&
        it('should verify UpgradeAdapter example', async(() => {

             // This is wrapping (upgrading) an AngularJS component to be used in an Angular
             // component
             @Directive({selector: 'ng1'})
             class Ng1Component extends UpgradeComponent {
               // TODO(issue/24571): remove '!'.
               @Input() title !: string;

               constructor(elementRef: ElementRef, injector: Injector) {
                 super('ng1', elementRef, injector);
               }
             }

             // This is an Angular component that will be downgraded
             @Component({
               selector: 'ng2',
               template: 'ng2[<ng1 [title]="nameProp">transclude</ng1>](<ng-content></ng-content>)'
             })
             class Ng2Component {
               // TODO(issue/24571): remove '!'.
               @Input('name') nameProp !: string;
             }

             // This module represents the Angular pieces of the application
             @NgModule({
               declarations: [Ng1Component, Ng2Component],
               entryComponents: [Ng2Component],
               imports: [BrowserModule, UpgradeModule]
             })
             class Ng2Module {
               ngDoBootstrap() { /* this is a placeholder to stop the bootstrapper from
                                    complaining */
               }
             }

             // This module represents the AngularJS pieces of the application
             const ng1Module =
                 angular
                     .module('myExample', [])
                     // This is an AngularJS component that will be upgraded
                     .directive(
                         'ng1',
                         () => {
                           return {
                             scope: {title: '='},
                             transclude: true,
                             template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
                           };
                         })
                     // This is wrapping (downgrading) an Angular component to be used in
                     // AngularJS
                     .directive('ng2', downgradeComponent({component: Ng2Component}));

             // This is the (AngularJS) application bootstrap element
             // Notice that it is actually a downgraded Angular component
             const element = html('<ng2 name="World">project</ng2>');

             // Let's use a helper function to make this simpler
             bootstrap(platformBrowserDynamic(), Ng2Module, element, ng1Module).then(upgrade => {
               expect(multiTrim(element.textContent))
                   .toBe('ng2[ng1[Hello World!](transclude)](project)');
             });
           }));
  });

describe('ngtools_api (deprecated)', () => {
  let testSupport: TestSupport;

  beforeEach(() => { testSupport = setup(); });

  function createProgram(rootNames: string[]) {
    const options = testSupport.createCompilerOptions();
    const host = ts.createCompilerHost(options, true);
    const program =
        ts.createProgram(rootNames.map(p => path.resolve(testSupport.basePath, p)), options, host);
    return {program, host, options};
  }

  function writeSomeRoutes() {
    testSupport.writeFiles({
      'src/main.ts': `
        import {NgModule, Component} from '@angular/core';
        import {RouterModule} from '@angular/router';

        // Component with metadata errors.
        @Component(() => {if (1==1) return null as any;})
        export class ErrorComp2 {}

        @NgModule({
          declarations: [ErrorComp2, NonExistentComp],
          imports: [RouterModule.forRoot([{loadChildren: './child#ChildModule'}])]
        })
        export class MainModule {}
      `,
      'src/child.ts': `
        import {NgModule} from '@angular/core';
        import {RouterModule} from '@angular/router';

        @NgModule({
          imports: [RouterModule.forChild([{loadChildren: './child2#ChildModule2'}])]
        })
        export class ChildModule {}
      `,
      'src/child2.ts': `
        import {NgModule} from '@angular/core';

        @NgModule()
        export class ChildModule2 {}
      `,
    });
  }

  fixmeIvy('FW-629: ngtsc lists lazy routes').it('should list lazy routes recursively', () => {
    writeSomeRoutes();
    const {program, host, options} = createProgram(['src/main.ts']);
    const routes = NgTools_InternalApi_NG_2.listLazyRoutes({
      program,
      host,
      angularCompilerOptions: options,
      entryModule: 'src/main#MainModule',
    });
    expect(routes).toEqual({
      './child#ChildModule': path.resolve(testSupport.basePath, 'src/child.ts'),
      './child2#ChildModule2': path.resolve(testSupport.basePath, 'src/child2.ts'),
    });
  });

  it('should allow to emit the program after analyzing routes', () => {
    writeSomeRoutes();
    const {program, host, options} = createProgram(['src/main.ts']);
    NgTools_InternalApi_NG_2.listLazyRoutes({
      program,
      host,
      angularCompilerOptions: options,
      entryModule: 'src/main#MainModule',
    });
    program.emit();
    testSupport.shouldExist('built/src/main.js');
  });
});

describe('setUpLocationSync', () => {
  let upgradeModule: UpgradeModule;
  let RouterMock: any;
  let LocationMock: any;

  beforeEach(() => {
    RouterMock = jasmine.createSpyObj('Router', ['navigateByUrl']);
    LocationMock = jasmine.createSpyObj('Location', ['normalize']);

    TestBed.configureTestingModule({
      providers: [
        UpgradeModule, {provide: Router, useValue: RouterMock},
        {provide: Location, useValue: LocationMock}
      ],
    });

    upgradeModule = TestBed.get(UpgradeModule);
    upgradeModule.$injector = {
      get: jasmine.createSpy('$injector.get').and.returnValue({'$on': () => undefined})
    };
  });

  it('should throw an error if the UpgradeModule.bootstrap has not been called', () => {
    upgradeModule.$injector = null;

    expect(() => setUpLocationSync(upgradeModule)).toThrowError(`
        RouterUpgradeInitializer can be used only after UpgradeModule.bootstrap has been called.
        Remove RouterUpgradeInitializer and call setUpLocationSync after UpgradeModule.bootstrap.
      `);
  });

  fixmeIvy('FW-777: R3Injector doesn\'t support injectors as a provider') &&
      it('should get the $rootScope from AngularJS and set an $on watch on $locationChangeStart',
         () => {
           const $rootScope = jasmine.createSpyObj('$rootScope', ['$on']);

           upgradeModule.$injector.get.and.callFake(
               (name: string) => (name === '$rootScope') && $rootScope);

           setUpLocationSync(upgradeModule);

           expect($rootScope.$on).toHaveBeenCalledTimes(1);
           expect($rootScope.$on)
               .toHaveBeenCalledWith('$locationChangeStart', jasmine.any(Function));
         });

  fixmeIvy('FW-777: R3Injector doesn\'t support injectors as a provider') &&
      it('should navigate by url every time $locationChangeStart is broadcasted', () => {
        const url = 'https://google.com';
        const pathname = '/custom/route';
        const normalizedPathname = 'foo';
        const query = '?query=1&query2=3';
        const hash = '#new/hash';
        const $rootScope = jasmine.createSpyObj('$rootScope', ['$on']);

        upgradeModule.$injector.get.and.returnValue($rootScope);
        LocationMock.normalize.and.returnValue(normalizedPathname);

        setUpLocationSync(upgradeModule);

        const callback = $rootScope.$on.calls.argsFor(0)[1];
        callback({}, url + pathname + query + hash, '');

        expect(LocationMock.normalize).toHaveBeenCalledTimes(1);
        expect(LocationMock.normalize).toHaveBeenCalledWith(pathname);

        expect(RouterMock.navigateByUrl).toHaveBeenCalledTimes(1);
        expect(RouterMock.navigateByUrl).toHaveBeenCalledWith(normalizedPathname + query + hash);
      });

  fixmeIvy('FW-777: R3Injector doesn\'t support injectors as a provider') &&
      it('should work correctly on browsers that do not start pathname with `/`', () => {
        const anchorProto = HTMLAnchorElement.prototype;
        const originalDescriptor = Object.getOwnPropertyDescriptor(anchorProto, 'pathname');
        Object.defineProperty(anchorProto, 'pathname', {get: () => 'foo/bar'});

        try {
          const $rootScope = jasmine.createSpyObj('$rootScope', ['$on']);
          upgradeModule.$injector.get.and.returnValue($rootScope);

          setUpLocationSync(upgradeModule);

          const callback = $rootScope.$on.calls.argsFor(0)[1];
          callback({}, '', '');

          expect(LocationMock.normalize).toHaveBeenCalledWith('/foo/bar');
        } finally {
          Object.defineProperty(anchorProto, 'pathname', originalDescriptor !);
        }
      });
});

//.........这里部分代码省略.........
        providers: [SomeService]
      })];

      SomePublicComponent.annotations = [new Component({templateUrl: 'somePublicUrl.html'})];
      resourceLoader.expect('somePublicUrl.html', `Hello public world!`);

      SomePrivateComponent.annotations = [new Component({templateUrl: 'somePrivateUrl.html'})];
      resourceLoader.expect('somePrivateUrl.html', `Hello private world!`);

      SomeDirective.annotations = [new Directive({selector: '[someDir]'})];

      SomePipe.annotations = [new Pipe({name: 'somePipe'})];

      SomeService.annotations = [new Injectable()];
    }

    function clearMetadata() {
      Base.parameters = [];
      SomeModule.annotations = [];
      SomePublicComponent.annotations = [];
      SomePrivateComponent.annotations = [];
      SomeDirective.annotations = [];
      SomePipe.annotations = [];
      SomeService.annotations = [];
    }

    beforeEach(async(() => {
      instances = new Map<any, any>();
      createSummaries().then(s => summaries = s);
    }));

    afterEach(() => { resetTestEnvironmentWithSummaries(); });

    fixmeIvy('FW-514: ngSummary shims not generated by ngtsc') &&
        it('should use directive metadata from summaries', () => {
          resetTestEnvironmentWithSummaries(summaries);

          @Component({template: '<div someDir></div>'})
          class TestComp {
          }

          TestBed
              .configureTestingModule(
                  {providers: [SomeDep], declarations: [TestComp, SomeDirective]})
              .createComponent(TestComp);
          expectInstanceCreated(SomeDirective);
        });

    fixmeIvy('FW-514: ngSummary shims not generated by ngtsc') &&
        it('should use pipe metadata from summaries', () => {
          resetTestEnvironmentWithSummaries(summaries);

          @Component({template: '{{1 | somePipe}}'})
          class TestComp {
          }

          TestBed.configureTestingModule({providers: [SomeDep], declarations: [TestComp, SomePipe]})
              .createComponent(TestComp);
          expectInstanceCreated(SomePipe);
        });

    fixmeIvy('FW-514: ngSummary shims not generated by ngtsc') &&
        it('should use Service metadata from summaries', () => {
          resetTestEnvironmentWithSummaries(summaries);

          TestBed.configureTestingModule({

  describe('NoopAnimationsModule', () => {
    beforeEach(() => { TestBed.configureTestingModule({imports: [NoopAnimationsModule]}); });

    it('should be removed once FW-800 is fixed', () => { expect(true).toBeTruthy(); });

    // TODO: remove the dummy test above ^ once the bug FW-800 has been fixed
    fixmeIvy(`FW-800: Animation listeners are not invoked`)
        .it('should flush and fire callbacks when the zone becomes stable', (async) => {
          @Component({
            selector: 'my-cmp',
            template:
                '<div [@myAnimation]="exp" (@myAnimation.start)="onStart($event)" (@myAnimation.done)="onDone($event)"></div>',
            animations: [trigger(
                'myAnimation',
                [transition(
                    '* => state',
                    [style({'opacity': '0'}), animate(500, style({'opacity': '1'}))])])],
          })
          class Cmp {
            exp: any;
            startEvent: any;
            doneEvent: any;
            onStart(event: any) { this.startEvent = event; }
            onDone(event: any) { this.doneEvent = event; }
          }

          TestBed.configureTestingModule({declarations: [Cmp]});

          const fixture = TestBed.createComponent(Cmp);
          const cmp = fixture.componentInstance;
          cmp.exp = 'state';
          fixture.detectChanges();
          fixture.whenStable().then(() => {
            expect(cmp.startEvent.triggerName).toEqual('myAnimation');
            expect(cmp.startEvent.phaseName).toEqual('start');
            expect(cmp.doneEvent.triggerName).toEqual('myAnimation');
            expect(cmp.doneEvent.phaseName).toEqual('done');
            async();
          });
        });

    fixmeIvy(`FW-800: Animation listeners are not invoked`)
        .it('should handle leave animation callbacks even if the element is destroyed in the process',
            (async) => {
              @Component({
                selector: 'my-cmp',
                template:
                    '<div *ngIf="exp" @myAnimation (@myAnimation.start)="onStart($event)" (@myAnimation.done)="onDone($event)"></div>',
                animations: [trigger(
                    'myAnimation',
                    [transition(
                        ':leave',
                        [style({'opacity': '0'}), animate(500, style({'opacity': '1'}))])])],
              })
              class Cmp {
                exp: any;
                startEvent: any;
                doneEvent: any;
                onStart(event: any) { this.startEvent = event; }
                onDone(event: any) { this.doneEvent = event; }
              }

              TestBed.configureTestingModule({declarations: [Cmp]});
              const engine = TestBed.get(ÉľAnimationEngine);
              const fixture = TestBed.createComponent(Cmp);
              const cmp = fixture.componentInstance;

              cmp.exp = true;
              fixture.detectChanges();
              fixture.whenStable().then(() => {
                cmp.startEvent = null;
                cmp.doneEvent = null;

                cmp.exp = false;
                fixture.detectChanges();
                fixture.whenStable().then(() => {
                  expect(cmp.startEvent.triggerName).toEqual('myAnimation');
                  expect(cmp.startEvent.phaseName).toEqual('start');
                  expect(cmp.startEvent.toState).toEqual('void');
                  expect(cmp.doneEvent.triggerName).toEqual('myAnimation');
                  expect(cmp.doneEvent.phaseName).toEqual('done');
                  expect(cmp.doneEvent.toState).toEqual('void');
                  async();
                });
              });
            });
  });

  describe('JIT', () => {
    @Injectable({providedIn: null})
    class Service {
    }

    @NgModule({
      providers: [Service],
    })
    class JitModule {
    }

    @NgModule({
      imports: [JitModule],
    })
    class JitAppModule {
    }

    it('works', () => { createInjector(JitAppModule); });

    fixmeIvy('FW-645: jit doesn\'t support forwardRefs') &&
        it('throws an error on circular module dependencies', () => {
          @NgModule({
            imports: [forwardRef(() => BModule)],
          })
          class AModule {
          }

          @NgModule({
            imports: [AModule],
          })
          class BModule {
          }

          expect(() => createInjector(AModule))
              .toThrowError(
                  'Circular dependency in DI detected for type AModule. Dependency path: AModule > BModule > AModule.');
        });

    it('merges imports and exports', () => {
      const TOKEN = new InjectionToken<string>('TOKEN');
      @NgModule({
        providers: [{provide: TOKEN, useValue: 'provided from A'}],
      })
      class AModule {
      }
      @NgModule({
        providers: [{provide: TOKEN, useValue: 'provided from B'}],
      })
      class BModule {
      }

      @NgModule({
        imports: [AModule],
        exports: [BModule],
      })
      class CModule {
      }

      const injector = createInjector(CModule);
      expect(injector.get(TOKEN)).toEqual('provided from B');
    });
  });