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