def test_eos_events(self):
"""Test receiving various eos events: on source eos, on source group eos and on player eos.
"""
on_eos_mock = mock.MagicMock(return_value=None)
self.player.event('on_eos')(on_eos_mock)
on_source_group_eos_mock = mock.MagicMock(return_value=None)
self.player.event('on_source_group_eos')(on_source_group_eos_mock)
on_player_eos_mock = mock.MagicMock(return_value=None)
self.player.event('on_player_eos')(on_player_eos_mock)
def reset_eos_mocks():
on_eos_mock.reset_mock()
on_source_group_eos_mock.reset_mock()
on_player_eos_mock.reset_mock()
def assert_eos_events_received(on_eos=False,
on_source_group_eos=False,
on_player_eos=False):
self.assertEqual(on_eos_mock.called, on_eos)
self.assertEqual(on_source_group_eos_mock.called,
on_source_group_eos)
self.assertEqual(on_player_eos_mock.called, on_player_eos)
mock_source1 = self.create_mock_source(self.audio_format_1, None)
mock_source2 = self.create_mock_source(self.audio_format_1, None)
mock_source3 = self.create_mock_source(self.audio_format_2, None)
self.player.queue(mock_source1)
self.player.queue(mock_source2)
self.player.queue(mock_source3)
self.assert_not_playing_yet(mock_source1)
self.player.play()
self.assert_driver_player_created_for(mock_source1, mock_source2)
self.reset_mocks()
reset_eos_mocks()
# Pretend the current source in the group was eos and next source started
self.current_playing_source_group.next_source()
self.player.dispatch_event('on_eos')
self.assert_driver_player_not_destroyed()
assert_eos_events_received(on_eos=True)
self.reset_mocks()
reset_eos_mocks()
# Pretend current source group is eos, triggers player to play next source group on a new
# player
self.player.dispatch_event('on_source_group_eos')
self.assert_driver_player_destroyed()
self.assert_driver_player_created_for(mock_source3)
assert_eos_events_received(on_source_group_eos=True)
self.reset_mocks()
reset_eos_mocks()
# Pretend current source group is eos. Should be no more source groups to play.
self.player.dispatch_event('on_source_group_eos')
self.assert_driver_player_destroyed()
self.assert_not_playing(None)
assert_eos_events_received(on_source_group_eos=True,
on_player_eos=True)
def test_operate_event_moddone(self):
id = 'bogus_id'
event = attrs['MODULE_EVENT_MODDONE']
qstate = mock.MagicMock()
qdata = mock.MagicMock()
self.assertTrue(self.srv.operate(id, event, qstate, qdata))
qstate.ext_state.__setitem__.assert_called_with(id, attrs['MODULE_FINISHED'])
def create_response_object(url, status_code, content=None):
"""
The function generates a mock object that is properly formatted for the RegistryException and validates the input
:param url: url to pass through for the mock request object
:param status_code: status code to append to the response object
:param content: **required** if not provided, this attribute will be blocked
:return: Parent Mock: request.Reponse Child Mock: request - requests.PreparedRequest
"""
if not isinstance(url, six.string_types):
raise (TypeError("incorrect type provided for url"))
if not isinstance(status_code, six.integer_types):
raise (TypeError("incorrect type provided for http status code"))
mock_object_request = mock.MagicMock(spec=requests.PreparedRequest,
url=url)
mock_object_response = mock.MagicMock(spec=requests.Response,
request=mock_object_request)
mock_object_response.status_code = status_code
if content:
mock_object_response.content = content
else:
# this blocks the content attribute from being present
del mock_object_response.content
return mock_object_response
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 test_handle_forward(self):
id = 'bogus_id'
event = attrs['MODULE_EVENT_NEW']
qstate = mock.MagicMock()
qstate.qinfo.qtype = attrs['RR_TYPE_A']
qstate.qinfo.qname_str = 'bogus-name%s.' % self.zone
qdata = mock.MagicMock()
server.DNSMessage = mock.MagicMock()
self.assertTrue(self.srv.operate(id, event, qstate, qdata))
def test_operate_forward(self):
id = 'bogus_id'
event = attrs['MODULE_EVENT_NEW']
qstate = mock.MagicMock()
qstate.qinfo.qtype = attrs['RR_TYPE_A']
qstate.qinfo.qname_str = 'bogus-name%s.' % self.zone
qdata = mock.MagicMock()
self.assertEqual(self.srv.operate(id, event, qstate, qdata), TestServer.HANDLE_FORWARD_RESULT)
qstate.qinfo.qtype = attrs['RR_TYPE_ANY']
self.assertEqual(self.srv.operate(id, event, qstate, qdata), TestServer.HANDLE_FORWARD_RESULT)
def test_events():
enter_mock = mock.MagicMock()
exit_mock = mock.MagicMock()
event_loop.push_handlers(on_enter=enter_mock, on_exit=exit_mock)
try:
event_loop.clock.schedule_once(lambda dt: event_loop.exit(), .1)
event_loop.run()
enter_mock.assert_called_once_with()
exit_mock.assert_called_once_with()
finally:
event_loop.pop_handlers()
def test_create_instance(self):
settings = mock.MagicMock()
crawler = mock.MagicMock(spec_set=['settings'])
args = (True, 100.)
kwargs = {'key': 'val'}
def _test_with_settings(mock, settings):
create_instance(mock, settings, None, *args, **kwargs)
if hasattr(mock, 'from_crawler'):
self.assertEqual(mock.from_crawler.call_count, 0)
if hasattr(mock, 'from_settings'):
mock.from_settings.assert_called_once_with(
settings, *args, **kwargs)
self.assertEqual(mock.call_count, 0)
else:
mock.assert_called_once_with(*args, **kwargs)
def _test_with_crawler(mock, settings, crawler):
create_instance(mock, settings, crawler, *args, **kwargs)
if hasattr(mock, 'from_crawler'):
mock.from_crawler.assert_called_once_with(
crawler, *args, **kwargs)
if hasattr(mock, 'from_settings'):
self.assertEqual(mock.from_settings.call_count, 0)
self.assertEqual(mock.call_count, 0)
elif hasattr(mock, 'from_settings'):
mock.from_settings.assert_called_once_with(
settings, *args, **kwargs)
self.assertEqual(mock.call_count, 0)
else:
mock.assert_called_once_with(*args, **kwargs)
# Check usage of correct constructor using four mocks:
# 1. with no alternative constructors
# 2. with from_settings() constructor
# 3. with from_crawler() constructor
# 4. with from_settings() and from_crawler() constructor
spec_sets = ([], ['from_settings'], ['from_crawler'],
['from_settings', 'from_crawler'])
for specs in spec_sets:
m = mock.MagicMock(spec_set=specs)
_test_with_settings(m, settings)
m.reset_mock()
_test_with_crawler(m, settings, crawler)
# Check adoption of crawler settings
m = mock.MagicMock(spec_set=['from_settings'])
create_instance(m, None, crawler, *args, **kwargs)
m.from_settings.assert_called_once_with(crawler.settings, *args,
**kwargs)
with self.assertRaises(ValueError):
create_instance(m, None, None)
def test_etc_ceph(self, _check, _get_connection, cephadm_module):
_get_connection.return_value = mock.Mock(), mock.Mock()
_check.return_value = '{}', '', 0
assert cephadm_module.manage_etc_ceph_ceph_conf is False
with with_host(cephadm_module, 'test'):
assert not cephadm_module.cache.host_needs_new_etc_ceph_ceph_conf('test')
with with_host(cephadm_module, 'test'):
cephadm_module.set_module_option('manage_etc_ceph_ceph_conf', True)
cephadm_module.config_notify()
assert cephadm_module.manage_etc_ceph_ceph_conf == True
cephadm_module._refresh_hosts_and_daemons()
_check.assert_called_with(ANY, ['dd', 'of=/etc/ceph/ceph.conf'], stdin=b'')
assert not cephadm_module.cache.host_needs_new_etc_ceph_ceph_conf('test')
cephadm_module.cache.last_etc_ceph_ceph_conf = {}
cephadm_module.cache.load()
assert not cephadm_module.cache.host_needs_new_etc_ceph_ceph_conf('test')
# Make sure, _check_daemons does a redeploy due to monmap change:
cephadm_module.mock_store_set('_ceph_get', 'mon_map', {
'modified': datetime.datetime.utcnow().strftime(CEPH_DATEFMT),
'fsid': 'foobar',
})
cephadm_module.notify('mon_map', mock.MagicMock())
assert cephadm_module.cache.host_needs_new_etc_ceph_ceph_conf('test')
cephadm_module.cache.last_etc_ceph_ceph_conf = {}
cephadm_module.cache.load()
assert cephadm_module.cache.host_needs_new_etc_ceph_ceph_conf('test')
def test_not_started_yet(self):
mock_player = mock.MagicMock()
mock_source_group = MockSourceGroup(1.)
silent_player = SilentAudioPlayerPacketConsumer(
mock_source_group.mock, mock_player)
# Do initial buffering even when not playing yet
self.set_time(1000.)
silent_player._buffer_data()
self.assertAlmostEqual(.4,
mock_source_group.seconds_buffered,
delta=.01)
self.assertAlmostEqual(0., silent_player.get_time(), delta=.01)
# Increase of timestamp does not change anything
self.set_time(1001.)
self.assertAlmostEqual(0., silent_player.get_time(), delta=.01)
# No data is consumed
silent_player._consume_data()
self.assertAlmostEqual(0., silent_player.get_time(), delta=.01)
# No new data is buffered
silent_player._buffer_data()
self.assertAlmostEqual(.4,
mock_source_group.seconds_buffered,
delta=.01)
self.assertAlmostEqual(0., silent_player.get_time(), delta=.01)
def test_playing(self):
mock_player = mock.MagicMock()
mock_source_group = MockSourceGroup(1.)
silent_player = SilentAudioPlayerPacketConsumer(
mock_source_group.mock, mock_player)
# Buffer initial data
self.set_time(1000.)
silent_player._buffer_data()
self.assertAlmostEqual(.4,
mock_source_group.seconds_buffered,
delta=.01)
# Start playing
silent_player.play()
self.assertAlmostEqual(0., silent_player.get_time(), delta=.01)
# Check timestamp increases even when not consuming new data
self.set_time(1000.2)
self.assertAlmostEqual(.2, silent_player.get_time(), delta=.01)
# Timestamp sill correct after consuming data
silent_player._consume_data()
self.assertAlmostEqual(.2, silent_player.get_time(), delta=.01)
# Consuming data means we need to buffer more
silent_player._buffer_data()
self.assertAlmostEqual(.6,
mock_source_group.seconds_buffered,
delta=.01)
self.assertAlmostEqual(.2, silent_player.get_time(), delta=.01)
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 cephadm_module():
with mock.patch("cephadm.module.CephadmOrchestrator.get_ceph_option", get_ceph_option),\
mock.patch("cephadm.module.CephadmOrchestrator._configure_logging", lambda *args: None),\
mock.patch("cephadm.module.CephadmOrchestrator.remote"),\
mock.patch("cephadm.module.CephadmOrchestrator.set_store", set_store), \
mock.patch("cephadm.module.CephadmOrchestrator.get_store", get_store),\
mock.patch("cephadm.module.CephadmOrchestrator._run_cephadm", _run_cephadm('[]')), \
mock.patch("cephadm.module.HostCache.save_host"), \
mock.patch("cephadm.module.HostCache.rm_host"), \
mock.patch("cephadm.module.CephadmOrchestrator.send_command"), \
mock.patch("cephadm.module.CephadmOrchestrator.mon_command", mon_command), \
mock.patch("cephadm.module.CephadmOrchestrator.get_store_prefix", get_store_prefix):
CephadmOrchestrator._register_commands('')
CephadmOrchestrator._register_options('')
m = CephadmOrchestrator.__new__(CephadmOrchestrator)
m._root_logger = mock.MagicMock()
m._store = {
'ssh_config': '',
'ssh_identity_key': '',
'ssh_identity_pub': '',
'inventory': {},
'upgrade_state': None,
}
m.__init__('cephadm', 0, 0)
m._cluster_fsid = "fsid"
yield m
class OutputWizardProcessPlaybookResult(unittest.TestCase):
"""Test ProcessPlaybookResult Output Wizard
"""
# Input to process
INVENTORY_EVENTS = {1: "first event", 2: "second event"}
EVENT_INFORMATION = "event information\n"
# Mocked response
mocked_response = mock.Mock()
mocked_response.text = EVENT_INFORMATION
# The Ansible Runner Service client
ar_client = mock.Mock()
ar_client.http_get = mock.MagicMock(return_value=mocked_response)
test_wizard = ProcessPlaybookResult(ar_client)
def test_process(self):
"""Test a normal call
"""
operation_id = 24
result = self.test_wizard.process(operation_id, self.INVENTORY_EVENTS)
# Check http request are correct and compose expected result
expected_result = ""
for key, dummy_data in self.INVENTORY_EVENTS.items():
http_request = EVENT_DATA_URL % (operation_id, key)
self.ar_client.http_get.assert_any_call(http_request)
expected_result += self.EVENT_INFORMATION
#Check result
self.assertEqual(result, expected_result)
def test_progress():
c = some_complex_completion()
mgr = mock.MagicMock()
mgr.process = lambda cs: [c.finalize(None) for c in cs]
progress_val = 0.75
c._last_promise().then(
on_complete=ProgressReference(message='hello world',
mgr=mgr,
completion=lambda: Completion(
on_complete=lambda _: progress_val))
)
mgr.remote.assert_called_with('progress', 'update', c.progress_reference.progress_id, 'hello world', 0.0, [('origin', 'orchestrator')])
c.finalize()
mgr.remote.assert_called_with('progress', 'complete', c.progress_reference.progress_id)
c.progress_reference.update()
mgr.remote.assert_called_with('progress', 'update', c.progress_reference.progress_id, 'hello world', progress_val, [('origin', 'orchestrator')])
assert not c.progress_reference.effective
progress_val = 1
c.progress_reference.update()
assert c.progress_reference.effective
mgr.remote.assert_called_with('progress', 'complete', c.progress_reference.progress_id)
def test_handle_forward(self):
server.storeQueryInCache = mock.Mock()
server.DNSMessage = mock.MagicMock()
instances_mock = mock.MagicMock()
instances_mock.tags = {'Address': 'bogus_ip_address'}
self.lookup_mock.lookup.return_value = [instances_mock]
id = 'bogus_id'
event = attrs['MODULE_EVENT_NEW']
qstate = mock.MagicMock()
qstate.qinfo.qtype = attrs['RR_TYPE_A']
qstate.qinfo.qname_str = 'bogus-name%s.' % self.zone
qdata = mock.MagicMock()
self.assertTrue(self.srv.operate(id, event, qstate, qdata))
qstate.ext_state.__setitem__.assert_called_with(id, attrs['MODULE_FINISHED'])
self.assertEqual(qstate.return_msg.rep.security, 2)
server.DNSMessage.return_value.answer.append.assert_called_with(
'%s %d IN A %s' % (qstate.qinfo.qname_str, self.ttl, 'bogus_ip_address'))
def setUp(self):
server.log_info = mock.Mock()
lookup_mock = mock.MagicMock()
self.zone = '.bogus.tld'
self.reverse_zone = '127.in-addr.arpa'
self.ttl = 'bogus_ttl'
self.ip_order = 'bogus_ip_order'
self.srv = server.Authoritative(self.zone, self.reverse_zone, self.ttl, lookup_mock, self.ip_order)
def setUp(self):
server.log_info = mock.Mock()
self.lookup_mock = mock.MagicMock()
self.zone = '.bogus.tld'
self.reverse_zone = '127.in-addr.arpa'
self.ttl = 88888881
self.ip_order = 'bogus_ip_order'
self.srv = server.Caching(self.zone, self.reverse_zone, self.ttl, self.lookup_mock, self.ip_order)
def setUp(self):
# Patch sys.stdout for stream
self.patch_utils_stdout = mock.patch(
"freight_forwarder.utils.utils.stdout", name="utils_sys")
self.mock_utils_stdout = self.patch_utils_stdout.start()
# Patch normalized_values
self.patch_utils_normalize_keys = mock.patch(
"freight_forwarder.utils.utils.normalize_keys",
name="utils_normalize_keys")
self.mock_utils_normalize_keys = self.patch_utils_normalize_keys.start(
)
# Patch Display Error
self.patch_display_error = mock.patch(
"freight_forwarder.utils.utils._display_error",
name="mock_display_error")
self.mock_display_error = self.patch_display_error.start()
# Patch Display Progress
self.patch_display_progress = mock.patch(
"freight_forwarder.utils.utils._display_progress",
name="mock_display_error")
self.mock_display_progress = self.patch_display_progress.start()
# Patch Display Status
self.patch_display_status = mock.patch(
"freight_forwarder.utils.utils._display_status",
name="mock_display_status")
self.mock_display_status = self.patch_display_status.start()
# Patch Display Stream
self.patch_display_stream = mock.patch(
"freight_forwarder.utils.utils._display_stream",
name="mock_display_stream")
self.mock_display_stream = self.patch_display_stream.start()
# Mock Response Object
self.mock_object_request = mock.MagicMock(
spec=requests.PreparedRequest,
url="https://docker-host.test.io:2376")
self.mock_object_response = mock.MagicMock(
spec=requests.Response, request=self.mock_object_request)
self.mock_object_response.status_code = 404
def setUp(self):
super().setUp()
# Mock Decompiler so that when it is instantiated, it returns our
# decompiler that can be used in the tests.
self.decompiler = mock.MagicMock(spec_set=Decompiler)
self.DecompilerMock = mock.Mock()
self.DecompilerMock.return_value = self.decompiler
self.patch('retdec.tools.decompiler.Decompiler', self.DecompilerMock)
def test_invalidate_notcached(self):
invalidator.invalidateQueryInCache = mock.MagicMock()
qstate = mock.MagicMock()
self.server_mock.cached_requests = {
'id-2.bogus.tld': {
'time': 'bogus_time',
'qstate': qstate
}
}
self.server_mock.lookup.resolve.side_effect = [
lookup_resolve([1, 3]),
lookup_resolve([4, 6])
]
self.invalidator.invalidate()
self.server_mock.lookup.invalidate.assert_called_with()
self.assertTrue(invalidator.invalidateQueryInCache.mock_calls)
invalidator.invalidateQueryInCache.assert_called_with(
qstate, qstate.qinfo)
def test_invalidate_cached(self):
invalidator.invalidateQueryInCache = mock.MagicMock()
self.server_mock.lookup.resolve.side_effect = [
lookup_resolve([1, 3]),
lookup_resolve([1, 3])
]
self.invalidator.invalidate()
self.server_mock.lookup.invalidate.assert_called_with()
self.assertFalse(invalidator.invalidateQueryInCache.mock_calls)
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
class TestServer(server.Server):
HANDLE_FORWARD_RESULT = 'dummy_handle_forward'
DNSMSG = mock.MagicMock()
def handle_request(self, _id, event, qstate, qdata, request_type):
return self.HANDLE_FORWARD_RESULT
def new_dns_msg(self, qname):
return self.DNSMSG
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 _get_crawler(self):
crawler = mock.MagicMock()
crawler.settings = Settings()
crawler.settings.set('USER_AGENT', 'CustomAgent')
self.assertRaises(NotConfigured, RobotsTxtMiddleware, crawler)
crawler.settings.set('ROBOTSTXT_OBEY', True)
crawler.engine.download = mock.MagicMock()
ROBOTS = re.sub(r'^\s+(?m)', '', '''
User-Agent: *
Disallow: /admin/
Disallow: /static/
''')
response = Response('http://site.local/robots.txt', body=ROBOTS)
def return_response(request, spider):
deferred = Deferred()
reactor.callFromThread(deferred.callback, response)
return deferred
crawler.engine.download.side_effect = return_response
return crawler
def test_robotstxt_error(self):
crawler = mock.MagicMock()
crawler.settings = Settings()
crawler.settings.set('ROBOTSTXT_OBEY', True)
crawler.engine.download = mock.MagicMock()
err = error.DNSLookupError('Robotstxt address not found')
def return_failure(request, spider):
deferred = Deferred()
reactor.callFromThread(deferred.errback, failure.Failure(err))
return deferred
crawler.engine.download.side_effect = return_failure
middleware = RobotsTxtMiddleware(crawler)
middleware._logerror = mock.MagicMock()
middleware.process_request(Request('http://site.local'), None)
deferred = Deferred()
deferred.addErrback(lambda _: self.assertIsNone(middleware._logerror.assert_any_call()))
reactor.callFromThread(deferred.callback, None)
return deferred
def setUp(self):
# Mock APIConnection so that when it is instantiated, it returns our
# connection that can be used in the tests.
self.conn = mock.MagicMock(spec_set=APIConnection)
self.APIConnectionMock = mock.Mock()
self.APIConnectionMock.return_value = self.conn
self.patch(
'retdec.service.APIConnection',
self.APIConnectionMock
)
def mock_ec2():
reservation = namedtuple('Reservation', ('instances'))
instance = namedtuple('Instance', ('id', 'tags'))
ec2 = mock.Mock()
ec2.get_all_reservations = mock.MagicMock(return_value=[reservation(
[instance("id-%s" % i, {
"Name": "name-%s" % i,
"Address": "192.168.1.%s" % i}
) for i in xrange(RESERVATION_COUNT)])])
return ec2
