async def _async_notify_consumers(self, data):
try:
# send notification only if is a notification channel is running
get_chan(self.FEED_CHANNEL.get_name())
await self.feed_send_coroutine(data)
except KeyError:
self.logger.error(
"Can't send notification data: no initialized channel found")
async def test_unregister_producer():
del_chan(EMPTY_TEST_CHANNEL)
await create_channel_instance(EmptyTestChannel, set_chan)
assert get_chan(EMPTY_TEST_CHANNEL).producers == []
producer = EmptyTestProducer(None)
await get_chan(EMPTY_TEST_CHANNEL).register_producer(producer)
assert get_chan(EMPTY_TEST_CHANNEL).producers == [producer]
await get_chan(EMPTY_TEST_CHANNEL).stop()
async def test_remove_consumer():
del_chan(EMPTY_TEST_CHANNEL)
await create_channel_instance(EmptyTestChannel, set_chan)
consumer = await get_chan(EMPTY_TEST_CHANNEL).new_consumer(empty_test_callback)
assert get_chan(EMPTY_TEST_CHANNEL).get_consumers() == [consumer]
await get_chan(EMPTY_TEST_CHANNEL).remove_consumer(consumer)
assert get_chan(EMPTY_TEST_CHANNEL).get_consumers() == []
await get_chan(EMPTY_TEST_CHANNEL).stop()
async def send_notification(notification: Notification) -> None:
try:
# send notification only if is a notification channel is running
get_chan(NotificationChannel.get_name())
await NotificationChannelProducer.instance().send(
{"notification": notification})
except KeyError:
if len(pending_notifications) < MAX_PENDING_NOTIFICATION:
pending_notifications.append(notification)
async def test_get_internal_producer():
class TestChannel(Channel):
pass
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
with pytest.raises(TypeError):
get_chan(TEST_CHANNEL).get_internal_producer()
await get_chan(TEST_CHANNEL).stop()
async def test_new_consumer_with_filters():
del_chan(EMPTY_TEST_CHANNEL)
await create_channel_instance(EmptyTestChannel, set_chan)
consumer = await get_chan(EMPTY_TEST_CHANNEL).new_consumer(empty_test_callback, {"test_key": 1})
assert get_chan(EMPTY_TEST_CHANNEL).get_consumers() == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({}) == [consumer] # returns all if empty
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 2}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 1, "test2": 2}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 1}) == [consumer]
await get_chan(EMPTY_TEST_CHANNEL).stop()
async def test_send_producer_without_consumer():
class TestProducer(Producer):
async def send(self, data, **kwargs):
await super().send(data)
await get_chan(TEST_CHANNEL).stop()
async def pause(self):
pass
async def resume(self):
pass
class TestConsumer(Consumer):
async def consume(self):
while not self.should_stop:
await self.callback(**(await self.queue.get()))
class TestChannel(Channel):
PRODUCER_CLASS = TestProducer
CONSUMER_CLASS = TestConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = TestProducer(get_chan(TEST_CHANNEL))
await producer.run()
await producer.send({})
async def _create_notification_channel_if_not_existing() -> Channel:
try:
return get_chan(NotificationChannel.get_name())
except KeyError:
channel = await create_channel_instance(NotificationChannel, set_chan)
await channel.register_producer(NotificationChannelProducer.instance(channel))
return channel
async def init_consumer_test():
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
CONSUMER_CLASS = EmptyTestConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
await producer.run()
return await get_chan(TEST_CHANNEL).new_consumer(empty_test_callback)
async def initialize(self):
try:
self.time_manager = TimeManager(self.config)
self.time_manager.initialize()
await create_channel_instance(TimeChannel, set_chan)
await TimeUpdater(get_chan(TIME_CHANNEL), self).run()
except Exception as e:
self.logger.error(f"Error when initializing backtesting : {e}.")
self.logger.exception(e)
async def test_producer_is_running():
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
assert not producer.is_running
await producer.run()
assert producer.is_running
await get_chan(TEST_CHANNEL).stop()
assert not producer.is_running
async def test_supervised_consumer():
class TestSupervisedConsumer(SupervisedConsumer):
pass
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
CONSUMER_CLASS = TestSupervisedConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
await producer.run()
consumer = await get_chan(TEST_CHANNEL).new_consumer(empty_test_callback)
await get_chan(TEST_CHANNEL).get_internal_producer().send({})
await consumer.queue.join()
await get_chan(TEST_CHANNEL).stop()
async def test_resume_producer():
class TestSupervisedConsumer(SupervisedConsumer):
pass
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
CONSUMER_CLASS = TestSupervisedConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
await producer.run()
await get_chan(TEST_CHANNEL).new_consumer(empty_test_callback)
await get_chan(TEST_CHANNEL).new_consumer(empty_test_callback)
await get_chan(TEST_CHANNEL).new_consumer(empty_test_callback)
await producer.send({"data": "test"})
await producer.wait_for_processing()
await get_chan(TEST_CHANNEL).stop()
async def test_pause_producer_without_consumers():
class TestProducer(Producer):
async def pause(self):
await get_chan(TEST_CHANNEL).stop()
async def pause(self):
pass
async def resume(self):
pass
class TestChannel(Channel):
PRODUCER_CLASS = TestProducer
CONSUMER_CLASS = EmptyTestConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
await TestProducer(get_chan(TEST_CHANNEL)).run()
async def test_send_producer_with_consumer():
class TestConsumer(Consumer):
pass
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
CONSUMER_CLASS = TestConsumer
async def callback(data):
assert data == "test"
await get_chan(TEST_CHANNEL).stop()
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
await get_chan(TEST_CHANNEL).new_consumer(callback)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
await producer.run()
await producer.send({"data": "test"})
async def test_internal_consumer():
class TestInternalConsumer(InternalConsumer):
async def perform(self, kwargs):
pass
class TestChannel(Channel):
PRODUCER_CLASS = EmptyTestProducer
CONSUMER_CLASS = TestInternalConsumer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
producer = EmptyTestProducer(get_chan(TEST_CHANNEL))
await producer.run()
consumer = TestInternalConsumer()
await get_chan(TEST_CHANNEL).new_consumer(internal_consumer=consumer)
with patch.object(consumer, 'perform',
new=AsyncMock()) as mocked_consume_ends:
await get_chan(TEST_CHANNEL).get_internal_producer().send({})
await mock_was_called_once(mocked_consume_ends)
await get_chan(TEST_CHANNEL).stop()
async def test_new_consumer_without_producer():
del_chan(EMPTY_TEST_CHANNEL)
await create_channel_instance(EmptyTestChannel, set_chan)
await get_chan(EMPTY_TEST_CHANNEL).new_consumer(empty_test_callback)
assert len(get_chan(EMPTY_TEST_CHANNEL).consumers) == 1
await get_chan(EMPTY_TEST_CHANNEL).stop()
async def _init_channel(self):
channel = get_chan(self.FEED_CHANNEL.get_name())
await channel.register_producer(self)
async def test_new_consumer_with_consumer_wildcard_filters():
del_chan(EMPTY_TEST_CHANNEL)
await create_channel_instance(EmptyTestChannel, set_chan)
consumer = await get_chan(EMPTY_TEST_CHANNEL).new_consumer(empty_test_callback, {"test_key": 1,
"test_key_2": "abc",
"test_key_3": CHANNEL_WILDCARD})
assert get_chan(EMPTY_TEST_CHANNEL).get_consumers() == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({}) == [consumer] # returns all if empty
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 1, "test_key_2": "abc"}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": 1, "test_key_2": "abc", "test_key_3": 45}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": 1, "test_key_2": "abc", "test_key_3": CHANNEL_WILDCARD}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 4, "test_key_2": "bc"}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 1, "test_key_2": CHANNEL_WILDCARD}) == [
consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 1}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key_2": CHANNEL_WILDCARD}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key_3": CHANNEL_WILDCARD}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key_3": "e"}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters({"test_key": 3, "test_key_2": CHANNEL_WILDCARD}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": CHANNEL_WILDCARD, "test_key_2": "abc"}) == [consumer]
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": CHANNEL_WILDCARD, "test_key_2": "a"}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": CHANNEL_WILDCARD, "test_key_2": "a", "test_key_3": CHANNEL_WILDCARD}) == []
assert get_chan(EMPTY_TEST_CHANNEL).get_consumer_from_filters(
{"test_key": CHANNEL_WILDCARD, "test_key_2": CHANNEL_WILDCARD}) == [consumer]
await get_chan(EMPTY_TEST_CHANNEL).stop()