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 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()
async def test_create_channel_instance():
class TestChannel(Channel):
pass
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
await get_chan(TEST_CHANNEL).stop()
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 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_set_chan():
class TestChannel(Channel):
pass
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
with pytest.raises(ValueError):
set_chan(TestChannel(), name=TestChannel.get_name())
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 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 test_evaluator_channel_send():
del_chan(MATRIX_CHANNEL)
await create_matrix_channels()
await get_chan(MATRIX_CHANNEL).new_consumer(matrix_callback)
await get_chan(MATRIX_CHANNEL).get_internal_producer().send(evaluator_name="test",
evaluator_type="test2",
eval_note=1)
# following assert should be None because send() doesn't call set_tentacle_value
assert Matrix.instance().get_node_at_path(
get_tentacle_path(tentacle_name="test", tentacle_type="test2")) is None
await get_chan(MATRIX_CHANNEL).stop()
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_evaluator_channel_send_eval_note():
del_chan(MATRIX_CHANNEL)
await create_matrix_channels()
await get_chan(MATRIX_CHANNEL).new_consumer(matrix_callback)
await get_chan(MATRIX_CHANNEL).get_internal_producer().send_eval_note(evaluator_name="test",
evaluator_type="test2",
eval_note=1,
eval_note_type=int)
assert Matrix.instance().get_node_at_path(
get_tentacle_path(tentacle_name="test", tentacle_type="test2")).node_value == 1
await get_chan(MATRIX_CHANNEL).stop()
async def test_set_chan_using_default_name():
class TestChannel(Channel):
pass
del_chan(TEST_CHANNEL)
channel = TestChannel()
returned_channel = set_chan(channel, name=None)
assert returned_channel is channel
assert channel.get_name() is not None
assert ChannelInstances.instance().channels[channel.get_name()] == channel
with pytest.raises(ValueError):
set_chan(TestChannel(), name=TestChannel.get_name())
await get_chan(TEST_CHANNEL).stop()
async def test_create_all_subclasses_channel():
class TestChannelClass(Channel):
pass
class Test1Channel(TestChannelClass):
pass
class Test2Channel(TestChannelClass):
pass
del_chan(TEST_CHANNEL)
await create_all_subclasses_channel(TestChannelClass, set_chan)
assert len(ChannelInstances.instance().channels
) == 3 # (EmptyTestChannel, Test1Channel, Test2Channel)
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_send_internal_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 TestChannel(Channel):
PRODUCER_CLASS = TestProducer
del_chan(TEST_CHANNEL)
await create_channel_instance(TestChannel, set_chan)
await get_chan(TEST_CHANNEL).get_internal_producer().send({})
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_evaluator_channel_creation():
del_chan(MATRIX_CHANNEL)
await create_matrix_channels()
await get_chan(MATRIX_CHANNEL).new_consumer(matrix_callback)
await get_chan(MATRIX_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()
