TypeScript ObservableWrapper.callNext方法代码示例

    it("should keep channels independent", inject([AsyncTestCompleter], (async) => {
         const CHANNEL_ONE = "CHANNEL 1";
         const CHANNEL_TWO = "CHANNEL 2";
         const MESSAGE_ONE = "This is a message on CHANNEL 1";
         const MESSAGE_TWO = "This is a message on CHANNEL 2";
         var callCount = 0;
         bus.initChannel(CHANNEL_ONE, false);
         bus.initChannel(CHANNEL_TWO, false);

         var firstFromEmitter = bus.from(CHANNEL_ONE);
         ObservableWrapper.subscribe(firstFromEmitter, (message) => {
           expect(message).toEqual(MESSAGE_ONE);
           callCount++;
           if (callCount == 2) {
             async.done();
           }
         });
         var secondFromEmitter = bus.from(CHANNEL_TWO);
         ObservableWrapper.subscribe(secondFromEmitter, (message) => {
           expect(message).toEqual(MESSAGE_TWO);
           callCount++;
           if (callCount == 2) {
             async.done();
           }
         });

         var firstToEmitter = bus.to(CHANNEL_ONE);
         ObservableWrapper.callNext(firstToEmitter, MESSAGE_ONE);

         var secondToEmitter = bus.to(CHANNEL_TWO);
         ObservableWrapper.callNext(secondToEmitter, MESSAGE_TWO);
       }));

    it("should dispatch events", inject([Serializer, AsyncTestCompleter], (serializer, async) => {
         var messageBuses = createPairedMessageBuses();
         var webWorkerEventDispatcher =
             new WebWorkerEventDispatcher(messageBuses.worker, serializer);

         var elementIndex = 15;
         var eventName = 'click';

         var eventDispatcher = new SpyEventDispatcher((elementIndex, eventName, locals) => {
           expect(elementIndex).toEqual(elementIndex);
           expect(eventName).toEqual(eventName);
           async.done();
         });

         var viewRef = new WebWorkerRenderViewRef(0);
         serializer.allocateRenderViews(0);  // serialize the ref so it's in the store
         viewRef =
             serializer.deserialize(serializer.serialize(viewRef, RenderViewRef), RenderViewRef);
         webWorkerEventDispatcher.registerEventDispatcher(viewRef, eventDispatcher);

         ObservableWrapper.callNext(messageBuses.ui.to(EVENT_CHANNEL), {
           'viewRef': viewRef.serialize(),
           'elementIndex': elementIndex,
           'eventName': eventName,
           'locals': {'$event': {'target': {value: null}}}
         });
       }));

 PromiseWrapper.scheduleMicrotask(() => {
   ObservableWrapper.callNext(emitter, res);
   // this is required because of a bug in ObservableWrapper
   // where callComplete can fire before callNext
   // remove this one the bug is fixed
   TimerWrapper.setTimeout(() => { ObservableWrapper.callComplete(emitter); }, 0);
 });

    it("should subscribe to the wrapper asynchronously", () => {
      var called = false;
      ObservableWrapper.subscribe(emitter, (value) => { called = true; });

      ObservableWrapper.callNext(emitter, 99);
      expect(called).toBe(false);
    });

 it("should call the next callback", inject([AsyncTestCompleter], (async) => {
   ObservableWrapper.subscribe(obs, (value) => {
     expect(value).toEqual(99);
     async.done();
   });
   ObservableWrapper.callNext(controller, 99);
 }));

 /**
  * Sends a mock response to the connection. This response is the value that is emitted to the
  * {@link EventEmitter} returned by {@link Http}.
  *
  * #Example
  *
  * ```
  * var connection;
  * backend.connections.subscribe(c => connection = c);
  * http.request('data.json').subscribe(res => console.log(res.text()));
  * connection.mockRespond(new Response('fake response')); //logs 'fake response'
  * ```
  *
  */
 mockRespond(res: Response) {
   if (this.readyState === ReadyStates.DONE || this.readyState === ReadyStates.CANCELLED) {
     throw new BaseException('Connection has already been resolved');
   }
   this.readyState = ReadyStates.DONE;
   ObservableWrapper.callNext(this.response, res);
   ObservableWrapper.callReturn(this.response);
 }

 /**
  * Creates a new {@link MockConnection}. This is equivalent to calling `new
  * MockConnection()`, except that it also will emit the new `Connection` to the `connections`
  * emitter of this `MockBackend` instance. This method will usually only be used by tests
  * against the framework itself, not by end-users.
  */
 createConnection(req: Request): Connection {
   if (!isPresent(req) || !(req instanceof Request)) {
     throw new BaseException(`createConnection requires an instance of Request, got ${req}`);
   }
   let connection = new MockConnection(req);
   ObservableWrapper.callNext(this.connections, connection);
   return connection;
 }

  _updateValue() {
    this._setValueErrorsStatus();
    this._pristine = false;

    ObservableWrapper.callNext(this._valueChanges, this._value);

    this._updateParent();
  }

         inject([AsyncTestCompleter], (async) => {
           pipe.transform(emitter);
           ObservableWrapper.callNext(emitter, message);

           TimerWrapper.setTimeout(() => {
             expect(ref.spy('requestCheck')).toHaveBeenCalled();
             async.done();
           }, 0)
         }));