def create_valid_mock_source(self, bitrate=8, channels=1):
self.mock_source = mock.MagicMock()
self.mock_queue_source = self.mock_source._get_queue_source.return_value
byte_rate = bitrate >> 3
self.mock_data = [
b'a' * 22050 * byte_rate * channels,
b'b' * 22050 * byte_rate * channels,
b'c' * 11025 * byte_rate * channels
]
self.mock_data_length = sum(map(len, self.mock_data))
self.mock_audio_data = b''.join(self.mock_data)
def _get_audio_data(_):
if not self.mock_data:
return None
data = self.mock_data.pop(0)
return AudioData(data, len(data), 0.0, 1.0, ())
self.mock_queue_source.get_audio_data.side_effect = _get_audio_data
type(self.mock_queue_source).audio_format = mock.PropertyMock(
return_value=AudioFormat(channels, bitrate, 11025))
type(self.mock_queue_source).video_format = mock.PropertyMock(
return_value=None)
def test_worker_refill_multiple_players_refill_multiple():
worker = PlayerWorker()
worker.start()
try:
player1 = mock.MagicMock()
player1.get_write_size.return_value = 1024
type(player1).min_buffer_size = mock.PropertyMock(return_value=512)
worker.add(player1)
player2 = mock.MagicMock()
player2.get_write_size.return_value = 768
type(player2).min_buffer_size = mock.PropertyMock(return_value=512)
worker.add(player2)
for _ in range(10):
if player1.get_write_size.called and player2.get_write_size.called:
break
time.sleep(.1)
player1.refill.assert_called_with(1024)
player2.refill.assert_called_with(768)
finally:
worker.stop()
def create_mock_player(self, has_audio=True):
player = mock.MagicMock()
if has_audio:
audio_player = mock.PropertyMock(return_value=mock.MagicMock())
else:
audio_player = mock.PropertyMock(return_value=None)
type(player)._audio_player = audio_player
return player
def create_mock_source(self, audio_format, video_format):
mock_source = mock.MagicMock(spec=Source)
type(mock_source).audio_format = mock.PropertyMock(return_value=audio_format)
type(mock_source).video_format = mock.PropertyMock(return_value=video_format)
type(mock_source._get_queue_source.return_value).audio_format = mock.PropertyMock(return_value=audio_format)
type(mock_source._get_queue_source.return_value).video_format = mock.PropertyMock(return_value=video_format)
if video_format:
mock_source.video_format.frame_rate = 30
return mock_source
def create_mock_source(self, duration, audio_data=None, video_frame=None):
mock_source = mock.MagicMock()
m = mock_source._get_queue_source.return_value
type(m).audio_format = mock.PropertyMock(return_value=self.audio_format)
type(m).video_format = mock.PropertyMock(return_value=self.video_format)
type(m).duration = mock.PropertyMock(return_value=duration)
m.get_audio_data.return_value = self.create_audio_data(duration, audio_data)
m.get_next_video_timestamp.return_value=0.1
m.get_next_video_frame.return_value=video_frame
return mock_source
def create_mock_source(self, audio_format, video_format):
mock_source = mock.MagicMock()
type(mock_source).audio_format = mock.PropertyMock(
return_value=audio_format)
type(mock_source).video_format = mock.PropertyMock(
return_value=video_format)
type(mock_source._get_queue_source.return_value
).audio_format = mock.PropertyMock(return_value=audio_format)
type(mock_source._get_queue_source.return_value
).video_format = mock.PropertyMock(return_value=video_format)
return mock_source
def test_empty_source(self):
"""Test that wrapping an empty source does not cause trouble."""
self.mock_source = mock.MagicMock()
self.mock_queue_source = self.mock_source._get_queue_source.return_value
type(self.mock_queue_source).audio_format = mock.PropertyMock(return_value=None)
type(self.mock_queue_source).video_format = mock.PropertyMock(return_value=None)
static_source = StaticSource(self.mock_source)
self.assertEqual(static_source.duration, 0.)
self.assertIsNone(static_source._get_queue_source())
def test_video_not_supported(self):
self.create_valid_mock_source()
type(self.mock_queue_source).video_format = mock.PropertyMock(
return_value=VideoFormat(800, 600))
with self.assertRaises(NotImplementedError):
static_source = StaticSource(self.mock_source)
def test_worker_add_remove_players():
worker = PlayerWorker()
player1 = mock.MagicMock()
player1.get_write_size.return_value = 0
type(player1).min_buffer_size = mock.PropertyMock(return_value=512)
player2 = mock.MagicMock()
player2.get_write_size.return_value = 0
type(player2).min_buffer_size = mock.PropertyMock(return_value=512)
worker.start()
try:
worker.add(player1)
worker.add(player2)
worker.remove(player1)
worker.remove(player2)
worker.remove(player2)
finally:
worker.stop()
def __init__(self, duration, timestamp=0.):
self.mock = mock.MagicMock()
type(self.mock).audio_format = mock.PropertyMock(
return_value=self.audio_format)
self.mock.get_audio_data.side_effect = self._get_audio_data
self.timestamp = timestamp
self.duration = duration
self.seconds_buffered = 0.
self.bytes_buffered = 0
def test_data_uri(self, lib_mock):
lib_mock.sp_image_format.return_value = int(spotify.ImageFormat.JPEG)
sp_image = spotify.ffi.new('int *')
prop_mock = mock.PropertyMock()
with mock.patch.object(spotify.Image, 'data', prop_mock):
image = spotify.Image(sp_image=sp_image)
prop_mock.return_value = b'01234\x006789'
result = image.data_uri
self.assertEqual(result, 'data:image/jpeg;base64,MDEyMzQANjc4OQ==')
def test_data_uri(self, lib_mock):
lib_mock.sp_image_format.return_value = int(spotify.ImageFormat.JPEG)
lib_mock.sp_image_add_load_callback.return_value = int(
spotify.ErrorType.OK)
sp_image = spotify.ffi.cast('sp_image *', 42)
prop_mock = mock.PropertyMock()
with mock.patch.object(spotify.Image, 'data', prop_mock):
image = spotify.Image(self.session, sp_image=sp_image)
prop_mock.return_value = b'01234\x006789'
result = image.data_uri
self.assertEqual(result, 'data:image/jpeg;base64,MDEyMzQANjc4OQ==')
def test_worker_do_not_refill_player():
worker = PlayerWorker()
worker.start()
try:
player = mock.MagicMock()
player.get_write_size.return_value = 104
type(player).min_buffer_size = mock.PropertyMock(return_value=512)
worker.add(player)
for _ in range(10):
if player.get_write_size.called:
break
time.sleep(.1)
worker.remove(player)
assert not player.refill.called
finally:
worker.stop()
def test_is_draining(self, osd_obj, draining, empty, expected):
with mock.patch("cephadm.services.osd.OSD.is_empty", new_callable=mock.PropertyMock(return_value=empty)):
osd_obj.draining = draining
assert osd_obj.is_draining is expected
