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 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 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)
