async def test_get_chan():
class TestChannel(channels.Channel):
pass
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_send_producer_without_consumer():
class TestProducer(channel_producer.Producer):
async def send(self, data, **kwargs):
await super().send(data)
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def pause(self):
pass
async def resume(self):
pass
class TestConsumer(channel_consumer.Consumer):
async def consume(self):
while not self.should_stop:
await self.callback(**(await self.queue.get()))
class TestChannel(channels.Channel):
PRODUCER_CLASS = TestProducer
CONSUMER_CLASS = TestConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = TestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
await producer.send({})
async def test_create_all_subclasses_channel():
class TestChannelClass(channels.Channel):
pass
class Test1Channel(TestChannelClass):
pass
class Test2Channel(TestChannelClass):
pass
def clean_channels():
for channel in copy.deepcopy(
channels.ChannelInstances.instance().channels):
channels.del_chan(channel)
channels.del_chan(tests.TEST_CHANNEL)
await util.create_all_subclasses_channel(TestChannelClass,
channels.set_chan)
assert len(channels.ChannelInstances.instance().channels
) == 3 # (EmptyTestChannel, Test1Channel, Test2Channel)
clean_channels()
await util.create_all_subclasses_channel(TestChannelClass,
channels.set_chan,
is_synchronized=True)
assert all(
channels.get_chan(channel).is_synchronized
for channel in channels.ChannelInstances.instance().channels)
clean_channels()
async def test_set_chan():
class TestChannel(channels.Channel):
pass
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
with pytest.raises(ValueError):
channels.set_chan(TestChannel(), name=TestChannel.get_name())
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_get_internal_producer():
class TestChannel(channels.Channel):
pass
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
with pytest.raises(TypeError):
channels.get_chan(tests.TEST_CHANNEL).get_internal_producer()
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_create_synchronized_channel_instance():
class TestChannel(channels.Channel):
pass
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel,
channels.set_chan,
is_synchronized=True)
assert channels.get_chan(tests.TEST_CHANNEL).is_synchronized
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def init_consumer_test():
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
CONSUMER_CLASS = tests.EmptyTestConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
return await channels.get_chan(tests.TEST_CHANNEL
).new_consumer(tests.empty_test_callback)
async def test_producer_is_running():
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
assert not producer.is_running
await producer.run()
assert producer.is_running
await channels.get_chan(tests.TEST_CHANNEL).stop()
assert not producer.is_running
async def test_set_chan_using_default_name():
class TestChannel(channels.Channel):
pass
channels.del_chan(tests.TEST_CHANNEL)
channel = TestChannel()
returned_channel = channels.set_chan(channel, name=None)
assert returned_channel is channel
assert channel.get_name() is not None
assert channels.ChannelInstances.instance().channels[
channel.get_name()] == channel
with pytest.raises(ValueError):
channels.set_chan(TestChannel(), name=TestChannel.get_name())
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def internal_consumer():
class TestInternalConsumer(channel_consumer.InternalConsumer):
async def perform(self, kwargs):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
CONSUMER_CLASS = TestInternalConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
yield TestInternalConsumer()
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_producer_pause_resume():
class TestChannel(channels.Channel):
PRODUCER_CLASS = channel_producer.Producer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = channel_producer.Producer(channels.get_chan(tests.TEST_CHANNEL))
assert producer.channel.is_paused
await producer.pause()
assert producer.channel.is_paused
await producer.resume()
assert not producer.channel.is_paused
await producer.pause()
assert producer.channel.is_paused
await producer.resume()
assert not producer.channel.is_paused
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_pause_producer_without_consumers():
class TestProducer(channel_producer.Producer):
async def pause(self):
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def pause(self):
pass
async def resume(self):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = TestProducer
CONSUMER_CLASS = tests.EmptyTestConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
await TestProducer(channels.get_chan(tests.TEST_CHANNEL)).run()
async def test_send_internal_producer_without_consumer():
class TestProducer(channel_producer.Producer):
async def send(self, data, **kwargs):
await super().send(data)
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def pause(self):
pass
async def resume(self):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = TestProducer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
await channels.get_chan(tests.TEST_CHANNEL).get_internal_producer().send({})
async def test_resume_producer():
class TestSupervisedConsumer(channel_consumer.SupervisedConsumer):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
CONSUMER_CLASS = TestSupervisedConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
await channels.get_chan(tests.TEST_CHANNEL).new_consumer(tests.empty_test_callback)
await channels.get_chan(tests.TEST_CHANNEL).new_consumer(tests.empty_test_callback)
await channels.get_chan(tests.TEST_CHANNEL).new_consumer(tests.empty_test_callback)
await producer.send({"data": "test"})
await producer.wait_for_processing()
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def test_send_producer_with_consumer():
class TestConsumer(channel_consumer.Consumer):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
CONSUMER_CLASS = TestConsumer
async def callback(data):
assert data == "test"
await channels.get_chan(tests.TEST_CHANNEL).stop()
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
await channels.get_chan(tests.TEST_CHANNEL).new_consumer(callback)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
await producer.send({"data": "test"})
async def test_supervised_consumer():
class TestSupervisedConsumer(channel_consumer.SupervisedConsumer):
pass
class TestChannel(channels.Channel):
PRODUCER_CLASS = tests.EmptyTestProducer
CONSUMER_CLASS = TestSupervisedConsumer
channels.del_chan(tests.TEST_CHANNEL)
await util.create_channel_instance(TestChannel, channels.set_chan)
producer = tests.EmptyTestProducer(channels.get_chan(tests.TEST_CHANNEL))
await producer.run()
consumer = await channels.get_chan(tests.TEST_CHANNEL
).new_consumer(tests.empty_test_callback
)
await channels.get_chan(tests.TEST_CHANNEL
).get_internal_producer().send({})
await consumer.queue.join()
await channels.get_chan(tests.TEST_CHANNEL).stop()
async def delete_time_channel(self):
await self.time_channel.stop()
for consumer in self.time_channel.consumers:
await self.time_channel.remove_consumer(consumer)
self.time_channel.flush()
channels.del_chan(self.time_channel.get_name())
def clean_channels():
for channel in copy.deepcopy(
channels.ChannelInstances.instance().channels):
channels.del_chan(channel)
async def synchronized_channel():
yield await util.create_channel_instance(SynchronizedChannelTest, channels.set_chan, is_synchronized=True)
channels.del_chan(TEST_SYNCHRONIZED_CHANNEL)
async def test_channel():
channels.del_chan(tests.EMPTY_TEST_CHANNEL)
yield await util.create_channel_instance(tests.EmptyTestChannel,
channels.set_chan)
await channels.get_chan(tests.EMPTY_TEST_CHANNEL).stop()
