def test_duplicate_reports_are_ignored(self): """ Test that duplicate reports are filtered out when retrieving items from the data store """ source_keys = ['source1', 'source2'] interval = 1 terminate_event = Mock() options = Mock() options.print_ = False config1 = Config('source1', 'esx') virt1 = Mock() virt1.CONFIG_TYPE = 'esx' config = Mock() manager = Mock() guest1 = Guest('GUUID1', virt1, Guest.STATE_RUNNING) report1 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_1') report2 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_2') report3 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_3') datastore = { 'source1': report1, # Not changing, should be excluded later 'source2': report2, # Will change the report sent for source2 } data_to_send = { 'source1': report1, 'source2': report2, } logger = Mock() destination_thread = DestinationThread(logger, config, source_keys=source_keys, source=datastore, dest=manager, interval=interval, terminate_event=terminate_event, oneshot=False, options=options) destination_thread._send_data(data_to_send=data_to_send) expected_hashes = {} for source_key, report in data_to_send.iteritems(): expected_hashes[source_key] = report.hash self.assertEqual(destination_thread.last_report_for_source, expected_hashes) # Pretend there were updates to the datastore from elsewhere destination_thread.source['source2'] = report3 next_data_to_send = destination_thread._get_data() expected_next_data_to_send = {'source2': report3} self.assertEqual(next_data_to_send, expected_next_data_to_send)
def _get_report(self): if self.isHypervisor(): return HostGuestAssociationReport(self.config, self._getHostGuestMapping()) else: return DomainListReport(self.config, self._listDomains(), self._remote_host_id())
def setUp(self): self.config = Config('config', 'esx', server='localhost', username='******', password='******', owner='owner', env='env', log_dir='', log_file='') self.second_config = Config('second_config', 'esx', server='localhost', username='******', password='******', owner='owner', env='env', log_dir='', log_file='') fake_virt = Mock() fake_virt.CONFIG_TYPE = 'esx' guests = [Guest('guest1', fake_virt, 1)] test_hypervisor = Hypervisor('test', guestIds=[Guest('guest1', fake_virt, 1)]) assoc = {'hypervisors': [test_hypervisor]} self.fake_domain_list = DomainListReport(self.second_config, guests) self.fake_report = HostGuestAssociationReport(self.config, assoc)
def test_sendVirtGuests(self): config = VirtConfigSection.from_dict({'type': 'libvirt'}, 'test', None) report = DomainListReport(config, self.guestList, self.hypervisor_id) self.sm.sendVirtGuests(report) self.sm.connection.updateConsumer.assert_called_with( 123, guest_uuids=[g.toDict() for g in self.guestList], hypervisor_id=self.hypervisor_id)
def test_sendVirtGuests(self, rhsmconnection): config = Config('test', 'libvirt') report = DomainListReport(config, self.guestList, self.hypervisor_id) self.sm.sendVirtGuests(report) self.sm.connection.updateConsumer.assert_called_with( 123, guest_uuids=[g.toDict() for g in self.guestList], hypervisor_id=self.hypervisor_id)
def test_exit_after_unregister(self, fromConfig, getLogger): virtwho = self.mock_virtwho() report = DomainListReport(virtwho.configManager.configs[0], []) # Send two reports and then 'exit' virtwho.queue.get.side_effect = [report, Empty, report, Empty, 'exit'] # First report will be successful, second one will throw ManagerFatalError virtwho.send.side_effect = [True, ManagerFatalError] # _main should exit normally _main(virtwho) self.assertStartStop(fromConfig)
def _get_report(self): if self.status: # this will make the authentication happen # a failure will get picked up in the _run method self.statusConfirmConnection() return StatusReport(self.config) if self.isHypervisor(): return HostGuestAssociationReport(self.config, self._getHostGuestMapping()) else: return DomainListReport(self.config, self._listDomains(), self._remote_host_id())
def test_reload_after_unregister(self, fromConfig, getLogger): virtwho = self.mock_virtwho() report = DomainListReport(virtwho.configManager.configs[0], []) # Send two reports and then 'reload' virtwho.queue.get.side_effect = [ report, Empty, report, Empty, 'reload' ] # First report will be successful, second one will throw ManagerFatalError virtwho.send.side_effect = [True, ManagerFatalError] # _main should throw ReloadRequest self.assertRaises(ReloadRequest, _main, virtwho) self.assertStartStop(fromConfig)
def test_reload_after_register(self, fromConfig, getLogger): virtwho = self.mock_virtwho() report = DomainListReport(virtwho.configManager.configs[0], []) # Send report and then 'reload' virtwho.queue.get.side_effect = [report, Empty, 'reload'] # First report will be successful, second one will throw ManagerFatalError virtwho.send.side_effect = [ManagerFatalError, True] # _main should throw ReloadRequest self.assertRaises(ReloadRequest, _main, virtwho) self.assertEqual(virtwho.queue.get.call_count, 3) # It should wait blocking for the reload virtwho.queue.get.assert_has_calls([call(block=True)]) self.assertStartStop(fromConfig)
class TestManager(TestBase): """ Test of all available subscription managers. """ guest1 = Guest('9c927368-e888-43b4-9cdb-91b10431b258', xvirt, Guest.STATE_RUNNING) guest2 = Guest('d5ffceb5-f79d-41be-a4c1-204f836e144a', xvirt, Guest.STATE_SHUTOFF) guestInfo = [guest1] hypervisor_id = "HYPERVISOR_ID" config = Config('test', 'libvirt', owner='OWNER', env='ENV') host_guest_report = HostGuestAssociationReport(config, { 'hypervisors': [ Hypervisor('9c927368-e888-43b4-9cdb-91b10431b258', []), Hypervisor('ad58b739-5288-4cbc-a984-bd771612d670', [guest1, guest2]) ] }) domain_report = DomainListReport(config, [guest1], hypervisor_id)
def test_start_unregistered(self, fromConfig, getLogger): virtwho = self.mock_virtwho() virtwho.queue.get.side_effect = [ DomainListReport(virtwho.configManager.configs[0], []), Empty, 'reload' ] virtwho.send.side_effect = ManagerFatalError # When not registered, it should throw ReloadRequest self.assertRaises(ReloadRequest, _main, virtwho) # queue.get should be called 3 times: report, nonblocking reading # of remaining reports and after ManagerFatalError wait indefinately self.assertEqual(virtwho.queue.get.call_count, 3) # It should wait blocking for the reload virtwho.queue.get.assert_has_calls([call(block=True)]) self.assertStartStop(fromConfig)
def test_send_data_429_during_send_virt_guests(self): # Show that when a 429 is encountered during the sending of a # DomainListReport that we retry after waiting the appropriate # amount of time source_keys = ['source1'] config1 = Config('source1', 'esx') virt1 = Mock() virt1.CONFIG_TYPE = 'esx' guest1 = Guest('GUUID1', virt1, Guest.STATE_RUNNING) report1 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_1') datastore = {'source1': report1} data_to_send = {'source1': report1} config = Mock() config.polling_interval = 10 logger = Mock() error_to_throw = ManagerThrottleError(retry_after=21) manager = Mock() manager.sendVirtGuests = Mock(side_effect=[error_to_throw, report1]) terminate_event = Mock() interval = 10 options = Mock() options.print_ = False destination_thread = DestinationThread(logger, config, source_keys=source_keys, source=datastore, dest=manager, interval=interval, terminate_event=terminate_event, oneshot=True, options=options) destination_thread.wait = Mock() destination_thread._send_data(data_to_send) manager.sendVirtGuests.assert_has_calls([ call(report1, options=destination_thread.options), call(report1, options=destination_thread.options) ]) destination_thread.wait.assert_has_calls( [call(wait_time=error_to_throw.retry_after)])
def test_send_data_429_during_send_virt_guests(self): # Show that when a 429 is encountered during the sending of a # DomainListReport that we retry after waiting the appropriate # amount of time config, d = self.create_fake_config('test', **self.default_config_args) source_keys = ['source1'] virt1 = Mock() virt1.CONFIG_TYPE = 'esx' guest1 = Guest('GUUID1', virt1.CONFIG_TYPE, Guest.STATE_RUNNING) report1 = DomainListReport(config, [guest1], hypervisor_id='hypervisor_id_1') datastore = {'source1': report1} data_to_send = {'source1': report1} logger = Mock() error_to_throw = ManagerThrottleError(retry_after=62) manager = Mock() manager.sendVirtGuests = Mock(side_effect=[error_to_throw, report1]) terminate_event = Mock() interval = 10 options = Mock() options.print_ = False destination_thread = DestinationThread(logger, config, source_keys=source_keys, source=datastore, dest=manager, interval=interval, terminate_event=terminate_event, oneshot=False, options=self.options) destination_thread.wait = Mock() destination_thread.record_status = Mock() destination_thread.is_terminated = Mock(return_value=False) destination_thread._send_data(data_to_send) manager.sendVirtGuests.assert_has_calls( [call(report1, options=destination_thread.options)]) destination_thread.wait.assert_has_calls( [call(wait_time=error_to_throw.retry_after)])
def test_send_data_domain_list_reports(self): # Show that DomainListReports are sent using the sendVirtGuests # method of the destination source_keys = ['source1'] config1, d1 = self.create_fake_config('source1', **self.default_config_args) virt1 = Mock() virt1.CONFIG_TYPE = 'esx' guest1 = Guest('GUUID1', virt1.CONFIG_TYPE, Guest.STATE_RUNNING) report1 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_1') datastore = {'source1': report1} data_to_send = {'source1': report1} config, d = self.create_fake_config('test', **self.default_config_args) logger = Mock() manager = Mock() terminate_event = Mock() interval = 10 options = Mock() options.print_ = False destination_thread = DestinationThread(logger, config, source_keys=source_keys, source=datastore, dest=manager, interval=interval, terminate_event=terminate_event, oneshot=True, options=self.options) destination_thread.wait = Mock() destination_thread.is_terminated = Mock(return_value=False) destination_thread.record_status = Mock() destination_thread._send_data(data_to_send) manager.sendVirtGuests.assert_has_calls( [call(report1, options=destination_thread.options)])
def test_send_data_domain_list_reports(self): # Show that DomainListReports are sent using the sendVirtGuests # method of the destination source_keys = ['source1'] config1 = Config('source1', 'esx') virt1 = Mock() virt1.CONFIG_TYPE = 'esx' guest1 = Guest('GUUID1', virt1, Guest.STATE_RUNNING) report1 = DomainListReport(config1, [guest1], hypervisor_id='hypervisor_id_1') datastore = {'source1': report1} data_to_send = {'source1': report1} config = Mock() config.polling_interval = 10 logger = Mock() manager = Mock() terminate_event = Mock() interval = 10 options = Mock() options.print_ = False destination_thread = DestinationThread(logger, config, source_keys=source_keys, source=datastore, dest=manager, interval=interval, terminate_event=terminate_event, oneshot=True, options=options) destination_thread.wait = Mock() destination_thread._send_data(data_to_send) manager.sendVirtGuests.assert_has_calls( [call(report1, options=destination_thread.options)])