Пример #1
0
export function useInjector() {
  var injector:ReflectiveInjector;

//#enddocregion injector
/*
//#docregion injector-no-new
  // Cannot 'new' an ReflectiveInjector like this!
  var injector = new ReflectiveInjector([Car, Engine, Tires, Logger]);
//#enddocregion injector-no-new
*/

//#docregion injector
  //#docregion injector-create-and-call
  injector = ReflectiveInjector.resolveAndCreate([Car, Engine, Tires, Logger]);
  //#docregion injector-call
  var car = injector.get(Car);
 //#enddocregion injector-call
 //#enddocregion injector-create-and-call
  car.description = 'Injector';

  var logger = injector.get(Logger);
  logger.log('Injector car.drive() said: '+car.drive());

  return car;
}
Пример #2
0
    beforeEach(() => {

      injector = ReflectiveInjector.resolveAndCreate([
        StoreModule.provideStore({ todos, todoCount }).providers
      ]);

      store = injector.get(Store);
      dispatcher = injector.get(Dispatcher);
    });
    beforeEach(() => {
      locationService = injector.get(LocationService);

      navService = injector.get(NavigationService);
      navService.currentNode.subscribe(selected => currentNode = selected);

      const backend = injector.get(ConnectionBackend);
      backend.connectionsArray[0].mockRespond(createResponse(navJson));
    });
    beforeEach(() => {
      navService = injector.get(NavigationService);
      navService.versionInfo.subscribe(info => versionInfo = info);

      const backend = injector.get(ConnectionBackend);
      backend.connectionsArray[0].mockRespond(createResponse({
        __versionInfo: { raw: '4.0.0' }
      }));
    });
Пример #5
0
    beforeEach(() => {
      location = injector.get(LocationService);

      service = injector.get(NavigationService);
      service.selectedNodes.subscribe(nodes => currentNodes = nodes);

      const backend = injector.get(ConnectionBackend);
      backend.connectionsArray[0].mockRespond(createResponse({ nav: nodeTree }));
    });
Пример #6
0
  beforeEach(() => {
    spyOn(Reducer, 'reduce').and.callThrough();

    injector = ReflectiveInjector.resolveAndCreate([
      StoreModule.provideStore(Reducer.reduce, initialState).providers
    ]);

    state = injector.get(State);
    dispatcher = injector.get(Dispatcher);
  });
Пример #7
0
  beforeEach(() => {
    injector = ReflectiveInjector.resolveAndCreate([
      ResourceService,
      { provide: ConnectionBackend, useClass: MockBackend },
      { provide: RequestOptions, useClass: BaseRequestOptions },
      Http
    ]);

    backend = injector.get(ConnectionBackend);
    resourceService = injector.get(ResourceService);
  });
    beforeEach(() => {
        const injector: ReflectiveInjector = DOTTestBed.resolveAndCreate([
            DotContainerContentletService
        ]);

        dotContainerContentletService = injector.get(DotContainerContentletService);
        backend = injector.get(ConnectionBackend);
        backend.connections.subscribe(
            (connection: MockConnection) => (lastConnection = connection)
        );
    });
 beforeEach(() => {
     injector = ReflectiveInjector.resolveAndCreate([
         AlfrescoSearchService,
         AlfrescoSettingsService,
         AlfrescoApiService,
         AlfrescoAuthenticationService,
         StorageService
     ]);
     service = injector.get(AlfrescoSearchService);
     apiService = injector.get(AlfrescoApiService);
     spyOn(apiService, 'getInstance').and.returnValue(fakeApi);
 });
  beforeEach(() => {
    injector = ReflectiveInjector.resolveAndCreate([
        ContributorService,
        { provide: ConnectionBackend, useClass: MockBackend },
        { provide: RequestOptions, useClass: BaseRequestOptions },
        Http,
        Logger
    ]);

    backend = injector.get(ConnectionBackend);
    contribService = injector.get(ContributorService);
  });