def test_connectable_observable_connected(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_completed(250) ) subject = MySubject() conn = ConnectableObservable(xs, subject) disconnect = conn.connect() res = scheduler.start(lambda: conn) res.messages.assert_equal( on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_completed(250) )
def test_connectable_observable_creation(self): y = [0] s2 = Subject() co2 = ConnectableObservable(Observable.return_value(1), s2) def on_next(x): y[0] = x co2.subscribe(on_next=on_next) self.assertNotEqual(1, y[0]) co2.connect() self.assertEqual(1, y[0])
def test_connectable_observable_disconnect_future(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable(on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_completed(250)) subject = MySubject() conn = ConnectableObservable(xs, subject) subject.dispose_on(3, conn.connect()) res = scheduler.start(lambda: conn) res.messages.assert_equal(on_next(210, 1), on_next(220, 2), on_next(230, 3))
def test_ref_count_connects_on_first(self): scheduler = TestScheduler() xs = scheduler.create_hot_observable( on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_completed(250) ) subject = MySubject() conn = ConnectableObservable(xs, subject) def create(): return conn.ref_count() res = scheduler.start(create) res.messages.assert_equal( on_next(210, 1), on_next(220, 2), on_next(230, 3), on_next(240, 4), on_completed(250) ) assert(subject.disposed)
def test_ref_count_notconnected(self): disconnected = [False] count = [0] def factory(): count[0] += 1 def create(obs): def func(): disconnected[0] = True return func return Observable.create(create) xs = Observable.defer(factory) subject = MySubject() conn = ConnectableObservable(xs, subject) refd = conn.ref_count() dis1 = refd.subscribe() self.assertEqual(1, count[0]) self.assertEqual(1, subject.subscribe_count) assert (not disconnected[0]) dis2 = refd.subscribe() self.assertEqual(1, count[0]) self.assertEqual(2, subject.subscribe_count) assert (not disconnected[0]) dis1.dispose() assert (not disconnected[0]) dis2.dispose() assert (disconnected[0]) disconnected[0] = False dis3 = refd.subscribe() self.assertEqual(2, count[0]) self.assertEqual(3, subject.subscribe_count) assert (not disconnected[0]) dis3.dispose() assert (disconnected[0])
def test_ref_count_notconnected(self): disconnected = [False] count = [0] def factory(): count[0] += 1 def create(obs): def func(): disconnected[0] = True return func return Observable.create(create) xs = Observable.defer(factory) subject = MySubject() conn = ConnectableObservable(xs, subject) refd = conn.ref_count() dis1 = refd.subscribe() self.assertEqual(1, count[0]) self.assertEqual(1, subject.subscribe_count) assert(not disconnected[0]) dis2 = refd.subscribe() self.assertEqual(1, count[0]) self.assertEqual(2, subject.subscribe_count) assert(not disconnected[0]) dis1.dispose() assert(not disconnected[0]) dis2.dispose() assert(disconnected[0]) disconnected[0] = False dis3 = refd.subscribe() self.assertEqual(2, count[0]) self.assertEqual(3, subject.subscribe_count) assert(not disconnected[0]) dis3.dispose() assert(disconnected[0])
def multicast(self, subject=None, subject_selector=None, selector=None): """Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. Example: 1 - res = source.multicast(observable) 2 - res = source.multicast(subject_selector=lambda: Subject(), selector=lambda x: x) Keyword arguments: subject_selector -- {Function} Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. subject -- Subject {Subject} to push source elements into. selector -- {Function} [Optional] Optional selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. Specified only if subject_selector" is a factory function. Returns an observable {Observable} sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. """ source = self if subject_selector: def subscribe(observer): connectable = source.multicast(subject=subject_selector()) return CompositeDisposable(selector(connectable).subscribe(observer), connectable.connect()) return AnonymousObservable(subscribe) else: return ConnectableObservable(source, subject)