def test_subscribe_all(subscribe_all): p_select = StatefulPublisher('a') p1 = StatefulPublisher(0) p2 = StatefulPublisher(1) dut = Switch({'a': p1, 'b': p2, 'c': 2}, subscribe_all=subscribe_all) assert not p_select.subscriptions assert not p1.subscriptions assert not p2.subscriptions assert not dut.subscriptions mock_cb = mock.Mock() disposable = p_select | dut | Sink(mock_cb) assert len(dut.subscriptions) == 1 assert len(p_select.subscriptions) == 1 assert len(p1.subscriptions) == 1 assert len(p2.subscriptions) == (1 if subscribe_all else 0) p_select.notify('b') assert len(dut.subscriptions) == 1 assert len(p_select.subscriptions) == 1 assert len(p1.subscriptions) == (1 if subscribe_all else 0) assert len(p2.subscriptions) == 1 disposable.dispose() assert not p_select.subscriptions assert not p1.subscriptions assert not p2.subscriptions assert not dut.subscriptions
def test_getattr_attribute(): p = StatefulPublisher() class Foo: a = None def __init__(self, a=5): self.a = a p.inherit_type(Foo) dut = p.a m = mock.Mock() dut | op.Sink(m) with pytest.raises(ValueError): dut.get() m.assert_not_called() p.notify(Foo(3)) assert dut.get() == 3 m.assert_called_once_with(3) with pytest.raises(ValueError): dut.emit_op(0, who=Publisher()) with pytest.raises(AttributeError): dut.assnign(5)
def test_stateful_publisher(): p = StatefulPublisher(1) future = p | OnEmitFuture(timeout=1, loop=asyncio.get_event_loop()) assert future.result() == 1 p.notify(2) assert future.result() == 1
def test_inherit_with_operators(): p = StatefulPublisher() p.inherit_type(str) dut = op.Len(('abc' + p + 'ghi').upper()) m = mock.Mock() dut | op.Sink(m) p.notify('def') m.assert_called_once_with(9)
def test_inherit_getattr(): p = StatefulPublisher() p.inherit_type(str) dut = p.lower().split(' ') m = mock.Mock() dut | op.Sink(m) p.notify('This is a TEST') m.assert_called_once_with(['this', 'is', 'a', 'test'])
def test_allow_stateless_extensive(): source1 = StatefulPublisher(0) source2 = Publisher() source3 = StatefulPublisher(0) source4 = Publisher() dut = CombineLatest(source1, source2, source3, source4, allow_stateless=True, emit_on=(source2, source3)) with pytest.raises(ValueError): dut | Sink() # source4 is stateless but not in emit_on list def reverse(s1, s2, s3, s4): return (s4, s3, s2, s1) dut = CombineLatest(source1, source2, source3, source4, map_=reverse, allow_stateless=True, emit_on=(source2, source3, source4)) with pytest.raises(ValueError): dut.get() collector = Collector() dut.subscribe(collector) with pytest.raises(ValueError): dut.get() assert collector.result_vector == () collector.reset() source1.notify(1) source2.notify(2) with pytest.raises(ValueError): dut.get() assert collector.result_vector == ((NONE, 0, 2, 1), ) collector.reset() source3.notify(3) source4.notify(4) with pytest.raises(ValueError): dut.get() assert collector.result_vector == ( (NONE, 3, NONE, 1), (4, 3, NONE, 1), )
def test_allow_stateless_with_stateful_publishers(): source1 = StatefulPublisher(0) source2 = StatefulPublisher(0) dut = CombineLatest(source1, source2, allow_stateless=True) collector = Collector() dut.subscribe(collector) source1.notify(1) source2.notify(1) assert collector.result_vector == ((0, 0), (1, 0), (1, 1))
def test_uninitialised_with_stateful(): source = StatefulPublisher(1) dut = source | Cache() cb = mock.Mock() dut | Sink(cb) cb.assert_called_once_with(1) source.notify(1) cb.assert_called_once_with(1) cb.reset_mock() source.notify(2) cb.assert_called_once_with(2)
def test_stateless_map(): source1 = StatefulPublisher(0) source2 = Publisher() dut = CombineLatest(source1, source2, map_=lambda a, b: a + (0 if b is NONE else b), allow_stateless=True) collector = Collector() dut.subscribe(collector) with pytest.raises(ValueError): dut.get() assert collector.result_vector == () collector.reset() source1.notify(1) assert collector.result_vector == (1, ) source1.notify(1) assert collector.result_vector == (1, ) source1.notify(1.0) assert collector.result_vector == (1, ) source2.notify(0) assert collector.result_vector == (1, 1) source2.notify(1) assert collector.result_vector == (1, 1, 2) source2.notify(1) assert collector.result_vector == (1, 1, 2, 2)
def test_getattr_method(): p = StatefulPublisher() p.inherit_type(str) dut1 = p.split() dut2 = p.split(',') dut3 = p.split(sep='!') mock1 = mock.Mock() mock2 = mock.Mock() mock3 = mock.Mock() dut1 | op.Sink(mock1) dut2 | op.Sink(mock2) dut3 | op.Sink(mock3) with pytest.raises(ValueError): dut1.get() with pytest.raises(ValueError): dut2.get() with pytest.raises(ValueError): dut3.get() mock1.assert_not_called() mock2.assert_not_called() mock3.assert_not_called() p.notify('This is just a test, honestly!') assert dut1.get() == ['This', 'is', 'just', 'a', 'test,', 'honestly!'] assert dut2.get() == ['This is just a test', ' honestly!'] assert dut3.get() == ['This is just a test, honestly', ''] mock1.assert_called_once_with( ['This', 'is', 'just', 'a', 'test,', 'honestly!']) mock2.assert_called_once_with(['This is just a test', ' honestly!']) mock3.assert_called_once_with(['This is just a test, honestly', ''])
def test_operator_concat(): DUT = OperatorConcat(Map(lambda v: v / 2), Reduce(lambda s, v: s + v, init=0)) mock_cb = mock.Mock() p = StatefulPublisher(0) p | DUT assert DUT.get() == 0 DUT | Sink(mock_cb) for v in range(5): p.notify(v) mock_cb.assert_has_calls([ mock.call(0), mock.call(0.5), mock.call(1.5), mock.call(3), mock.call(5) ]) assert DUT.get() == 5
def test_allow_stateless(): source1 = StatefulPublisher(0) source2 = Publisher() dut = CombineLatest(source1, source2, allow_stateless=True) with pytest.raises(ValueError): dut.get() collector = Collector() disposable = dut.subscribe(collector) with pytest.raises(ValueError): dut.get() assert collector.result_vector == () source1.notify(1) source2.notify(True) source1.notify(2) source2.notify(False) assert collector.result_vector == ((1, NONE), (1, True), (2, NONE), (2, False)) # combine latest should also emit when stateless publisher is emitting collector.reset() source2.notify(False) assert collector.result_vector == ((2, False), ) source2.notify(False) assert collector.result_vector == ((2, False), (2, False)) source1.notify(0) assert collector.result_vector == ((2, False), (2, False), (0, NONE)) disposable.dispose() assert len(dut.subscriptions) == 0 source3 = StatefulPublisher(0) dut2 = CombineLatest(dut, source3) with pytest.raises(ValueError): dut2.get()
def test_stateful_publisher(): p = StatefulPublisher() v = Value(0) with pytest.raises(ValueError): p.get() mock_sink = mock.Mock() disposable = p | v v | op.Sink(mock_sink) mock_sink.assert_called_once_with(0) mock_sink.reset_mock() p.notify(1) mock_sink.assert_called_once_with(1) assert p.get() == 1 mock_sink.reset_mock() p.notify(1) assert p.get() == 1 mock_sink.assert_not_called() p.notify(2) assert p.get() == 2 mock_sink.assert_called_once_with(2) p.reset_state() with pytest.raises(ValueError): p.get() p.reset_state(3) assert p.get() == 3