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