TypeScript testing.TestDispose类代码示例

 beforeEach(() => {
   mockRouteService = Mocks.listenable('RouteService');
   TestDispose.add(mockRouteService);
   const mockThemeService = jasmine.createSpyObj('ThemeService', ['applyTheme']);
   breadcrumb = new Breadcrumb(mockThemeService);
   TestDispose.add(breadcrumb);
 });

 beforeEach(() => {
   mockDocument = jasmine.createSpyObj('Document', ['createElement', 'querySelector']);
   mockTemplates = jasmine.createSpyObj('Templates', ['getTemplate']);
   mockWindow = jasmine.createSpyObj('Window', ['getComputedStyle']);
   service = new ThemeService(mockTemplates, mockWindow, mockDocument);
   TestDispose.add(service);
 });

 beforeEach(() => {
   const injector = Mocks.object('injector');
   mockThemeService = jasmine.createSpyObj('ThemeService', ['applyTheme', 'install']);
   mockRegistrar = jasmine.createSpyObj('Registrar', ['register']);
   main = new Main(injector, mockThemeService, mockRegistrar);
   TestDispose.add(main);
 });

    it('should set up correctly', () => {
      const ace = Mocks.object('ace');
      const routeFactoryServiceCtor = Mocks.object('routeFactoryServiceCtor');
      const templates = Mocks.object('templates');
      spyOn(Templates, 'newInstance').and.returnValue(templates);

      const mockThemeService = jasmine.createSpyObj('ThemeService', ['initialize', 'install']);
      const factories = Mocks.object('factories');
      const mockRouteFactoryService = jasmine.createSpyObj('RouteFactoryService', ['getFactories']);
      mockRouteFactoryService.getFactories.and.returnValue(factories);
      const mockInjector = jasmine.createSpyObj('Injector', ['bindProvider', 'getBoundValue']);
      Fakes.build(mockInjector.getBoundValue)
          .when('theming.ThemeService').return(mockThemeService)
          .when('x.gs_ui.routeFactoryService').return(mockRouteFactoryService);
      spyOn(Injector, 'newInstance').and.returnValue(mockInjector);

      const mockRegistrar = jasmine.createSpyObj('Registrar', ['register']);

      spyOn(ElementRegistrar, 'newInstance').and.returnValue(mockRegistrar);
      spyOn(Persona, 'registerAll');

      const main = Main.newInstance({
        ace: ace,
        routeFactoryServiceCtor: routeFactoryServiceCtor,
      });
      TestDispose.add(main);

      assert(main['injector_']).to.equal(mockInjector);
      assert(main['themeService_']).to.equal(mockThemeService);
      assert(main['registrar_']).to.equal(mockRegistrar);

      assert(mockThemeService.initialize).to.haveBeenCalledWith();
      assert(mockInjector.getBoundValue).to.haveBeenCalledWith('theming.ThemeService');
      assert(ElementRegistrar.newInstance).to.haveBeenCalledWith(mockInjector, templates);
      assert(TestInject.getBoundValue('x.dom.document')()).to.equal(document);
      assert(TestInject.getBoundValue('x.dom.window')()).to.equal(window);
      assert(TestInject.getBoundValue('x.gs_tools.templates')()).to.equal(templates);
      assert(TestInject.getBoundValue('x.gs_ui.routeFactoryService'))
          .to.equal(routeFactoryServiceCtor);
      assert(TestInject.getBoundValue('x.ace')()).to.equal(ace);

      assert(Templates.newInstance).to.haveBeenCalledWith();
      assert(Persona.registerAll).to.haveBeenCalledWith(mockInjector, templates);
    });

    it(`should do nothing if the target element cannot be found`, async () => {
      const triggeredBy = 'triggeredBy';
      spyOn(Persona, 'getValue').and.returnValue(triggeredBy);

      const origDisposable = DisposableFunction.of(() => undefined);
      Graph.createProvider($triggeredByRegistration, origDisposable);
      TestDispose.add(origDisposable);

      const mockRootNode = jasmine.createSpyObj('RootNode', ['querySelector']);
      Object.setPrototypeOf(mockRootNode, Element.prototype);
      mockRootNode.querySelector.and.returnValue(null);

      const mockElement = jasmine.createSpyObj('Element', ['getRootNode']);
      mockElement.getRootNode.and.returnValue(mockRootNode);
      Object.setPrototypeOf(mockElement, HTMLElement.prototype);
      await Graph.createProvider($.host.el.getId(), mockElement);

      await menu.onTriggeredByChanged_();
      assert(mockRootNode.querySelector).to.haveBeenCalledWith(triggeredBy);
      assert(origDisposable.isDisposed()).to.beFalse();
    });

  beforeEach(() => {
    mockRadioButtonService = jasmine.createSpyObj('RadioButtonService', ['setSelected']);

    button = new RadioButton(mockRadioButtonService, Mocks.object('ThemeService'));
    TestDispose.add(button);
  });

 beforeEach(() => {
   tab = new VerticalTab(Mocks.object('ThemeService'));
   TestDispose.add(tab);
 });

 assert(() => {
   TestDispose.add(Main.newInstance({}));
 }).toNot.throw();

 beforeEach(() => {
   mockFileService = jasmine.createSpyObj('FileService', ['addBundle', 'getBundle']);
   input = new FileInput(mockFileService, Mocks.object('ThemeService'));
   TestDispose.add(input);
 });

 beforeEach(() => {
   const mockThemeService = jasmine.createSpyObj('ThemeService', ['applyTheme']);
   input = new FloatInput(mockThemeService);
   TestDispose.add(input);
 });