def test_get_logger_different_log_file(self, getFileHandler, getQueueLogger): queueLogger = log.QueueLogger('virtwho') queueLogger.logger.handlers = [] mockQueueLogger = Mock(wraps=queueLogger) getQueueLogger.return_value = mockQueueLogger config = Mock() config.name = 'test' config.log_file = 'test.log' config.log_dir = '/test/' options = Mock() options.debug = False options.background = True options.log_per_config = True options.log_dir = '' options.log_file = '' log.init(options) test_logger = log.getLogger(name='test', config=config) self.assertTrue(test_logger.name == 'virtwho.test') self.assertTrue(len(test_logger.handlers) == 1) self.assertTrue(len(queueLogger.logger.handlers) == 1) getFileHandler.assert_called_with(name=test_logger.name, config=config)
def test_update_report_to_send(self, fromConfig, fromOptions, getLogger): options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") report = Mock() report.hash.return_value = "hash" config = Mock() report.config = config config.hash.return_value = "config_hash" config.name.return_value = "config_name" self.assertTrue(virtwho.update_report_to_send(report)) self.assertTrue(len(virtwho.configs_ready) == 1 and config in virtwho.configs_ready) self.assertTrue(virtwho.reports_to_send[config.hash].hash == report.hash) # Pretend we sent the report for that config virtwho.configs_ready = [] virtwho.reports[config.hash] = report.hash del virtwho.reports_to_send[config.hash] # if we receive the same report twice we should not send it self.assertFalse(virtwho.update_report_to_send(report)) self.assertFalse(virtwho.configs_ready) self.assertFalse(virtwho.reports_to_send)
def test_report_hash_added_after_send(self, fromConfig, fromOptions, getLogger): # Side effect for fromConfig def fake_virts(logger, config): new_fake_virt = Mock() new_fake_virt.config.name = config.name return new_fake_virt fromConfig.side_effect = fake_virts options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_file = '' options.log_dir = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") def send(report): report.state = AbstractVirtReport.STATE_FINISHED return True virtwho.send = Mock(side_effect=send) queue = Queue() virtwho.queue = queue virtwho.retry_after = 1 virtwho.configManager.addConfig(self.config) virtwho.configManager.addConfig(self.second_config) queue.put(self.fake_report) queue.put(self.fake_domain_list) virtwho.run() self.assertEquals(virtwho.send.call_count, 2) self.assertEqual(virtwho.last_reports_hash[self.config.name], self.fake_report.hash) self.assertEqual(virtwho.last_reports_hash[self.second_config.name], self.fake_domain_list.hash)
def test_same_report_filtering(self, fromConfig, fromOptions, getLogger): def fake_virts(logger, config): new_fake_virt = Mock() new_fake_virt.config.name = config.name return new_fake_virt fromConfig.side_effect = fake_virts options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = Executor(self.logger, options, config_dir="/nonexistant") queue = Queue() # Create another report with same hash report2 = HostGuestAssociationReport(self.config, self.fake_report.association) self.assertEqual(self.fake_report.hash, report2.hash) def send(report): report.state = AbstractVirtReport.STATE_FINISHED # Put second report when the first is done queue.put(report2) return True virtwho.send = Mock(side_effect=send) virtwho.queue = queue virtwho.retry_after = 1 virtwho.configManager.addConfig(self.config) queue.put(self.fake_report) virtwho.run() self.assertEquals(virtwho.send.call_count, 1)
def test_sending_guests(self, parseFile, fromOptions, fromConfig, getLogger): self.setUpParseFile(parseFile) options = Mock() options.oneshot = True options.interval = 0 options.print_ = False fake_virt = Mock() fake_virt.CONFIG_TYPE = 'esx' test_hypervisor = Hypervisor('test', guestIds=[Guest('guest1', fake_virt, 1)]) association = {'hypervisors': [test_hypervisor]} options.log_dir = '' options.log_file = '' getLogger.return_value = sentinel.logger fromConfig.return_value.config.name = 'test' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") config = Config("test", "esx", server="localhost", username="******", password="******", owner="owner", env="env") virtwho.configManager.addConfig(config) virtwho.queue = Queue() virtwho.queue.put(HostGuestAssociationReport(config, association)) virtwho.run() fromConfig.assert_called_with(sentinel.logger, config) self.assertTrue(fromConfig.return_value.start.called) fromOptions.assert_called_with(self.logger, options, ANY)
def test_update_report_to_send(self, fromConfig, fromOptions, getLogger): options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") report = Mock() report.hash.return_value = "hash" config = Mock() report.config = config config.hash.return_value = "config_hash" config.name.return_value = "config_name" self.assertTrue(virtwho.update_report_to_send(report)) self.assertTrue( len(virtwho.configs_ready) == 1 and config in virtwho.configs_ready) self.assertTrue( virtwho.reports_to_send[config.hash].hash == report.hash) # Pretend we sent the report for that config virtwho.configs_ready = [] virtwho.reports[config.hash] = report.hash del virtwho.reports_to_send[config.hash] # if we receive the same report twice we should not send it self.assertFalse(virtwho.update_report_to_send(report)) self.assertFalse(virtwho.configs_ready) self.assertFalse(virtwho.reports_to_send)
def test_same_report_filtering(self, fromConfig, fromOptions, getLogger): def fake_virts(logger, config): new_fake_virt = Mock() new_fake_virt.config.name = config.name return new_fake_virt fromConfig.side_effect = fake_virts options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") queue = Queue() # Create another report with same hash report2 = HostGuestAssociationReport(self.config, self.fake_report.association) self.assertEqual(self.fake_report.hash, report2.hash) def send(report): report.state = AbstractVirtReport.STATE_FINISHED # Put second report when the first is done queue.put(report2) return True virtwho.send = Mock(side_effect=send) virtwho.queue = queue virtwho.retry_after = 1 virtwho.configManager.addConfig(self.config) queue.put(self.fake_report) virtwho.run() self.assertEquals(virtwho.send.call_count, 1)
def test_send_current_report(self, fromConfig, fromOptions, getLogger, time): initial = 10 time.side_effect = [initial, initial] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") virtwho.oneshot_remaining = ['config_name'] config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.send = Mock() virtwho.send.return_value = True report = HostGuestAssociationReport(config, {'hypervisors': {}}) report.state = AbstractVirtReport.STATE_PROCESSING virtwho.queued_reports[config.name] = report virtwho.send_current_report() def check_report_state(report): report.state = AbstractVirtReport.STATE_FINISHED virtwho.check_report_state = Mock(side_effect=check_report_state) virtwho.check_reports_state() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + 60)
def test_report_hash_added_after_send(self, fromConfig, fromOptions, getLogger): # Side effect for fromConfig def fake_virts(logger, config): new_fake_virt = Mock() new_fake_virt.config.name = config.name return new_fake_virt fromConfig.side_effect = fake_virts options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_file = '' options.log_dir = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") virtwho.send = Mock(wraps=virtwho.send) queue = Queue() virtwho.queue = queue virtwho.configManager.addConfig(self.config) virtwho.configManager.addConfig(self.second_config) queue.put(self.fake_report) queue.put(self.fake_domain_list) virtwho.run() self.assertEquals(virtwho.send.call_count, 2) self.assertTrue( virtwho.reports[self.config.hash] == self.fake_report.hash) self.assertTrue(virtwho.reports[self.second_config.hash] == self.fake_domain_list.hash)
def test_sending_guests(self, fromOptions, fromConfig, getLogger): options = Mock() options.oneshot = True options.interval = 0 options.print_ = False fake_virt = Mock() fake_virt.CONFIG_TYPE = 'esx' test_hypervisor = Hypervisor('test', guestIds=[Guest('guest1', fake_virt, 1)]) association = {'hypervisors': [test_hypervisor]} options.log_dir = '' options.log_file = '' getLogger.return_value = sentinel.logger fromConfig.return_value.config.name = 'test' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") config = Config("test", "esx", server="localhost", username="******", password="******", owner="owner", env="env") virtwho.configManager.addConfig(config) virtwho.queue = Queue() virtwho.queue.put(HostGuestAssociationReport(config, association)) virtwho.run() fromConfig.assert_called_with(sentinel.logger, config) self.assertTrue(fromConfig.return_value.start.called) fromOptions.assert_called_with(self.logger, options)
def test_send_current_report(self, fromConfig, fromOptions, getLogger, time): initial = 10 time.side_effect = [initial, initial] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = Executor(Mock(), options, config_dir="/nonexistant") virtwho.oneshot_remaining = ['config_name'] config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.send = Mock() virtwho.send.return_value = True report = HostGuestAssociationReport(config, {'hypervisors': {}}) report.state = AbstractVirtReport.STATE_PROCESSING virtwho.queued_reports[config.name] = report virtwho.send_current_report() def check_report_state(report): report.state = AbstractVirtReport.STATE_FINISHED virtwho.check_report_state = Mock(side_effect=check_report_state) virtwho.check_reports_state() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + 60)
def setupVirtWho(self, oneshot=True): options = Mock() options.oneshot = oneshot options.interval = 0 options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(self.logger, options, config_dir="/nonexistant") config = Config("test", "esx", server="localhost", username="******", password="******", owner="owner", env="env") virtwho.configManager.addConfig(config) return virtwho
def test_get_file_handler(self, open, isdir): open.return_value = None # Ensure we don't actually try to open a file # Ensure we don't try to make a directory isdir.return_value = True options = Mock() filtername = 'test' options.log_file = 'test.log' options.log_dir = '/nonexistant/' log.Logger.initialize(options) fileHandler = log.Logger.get_file_handler(filtername) self.assertEquals(fileHandler.baseFilename, options.log_dir + options.log_file)
def test_get_logger_different_log_file(self, getFileHandler, getDefaultQueueLogger): queueLogger = log.QueueLogger('virtwho') queueLogger.logger.handlers = [] mockQueueLogger = Mock(wraps=queueLogger) getDefaultQueueLogger.return_value = mockQueueLogger config = Mock() config.name = 'test' config.log_file = 'test.log' config.log_dir = '/test/' options = Mock() options.debug = False options.background = True options.log_per_config = True options.log_dir = '' options.log_file = '' test_logger = log.getLogger(options, config) self.assertTrue(test_logger.name == 'virtwho.test') self.assertTrue(len(test_logger.handlers) == 1) self.assertTrue(len(queueLogger.logger.handlers) == 1) getFileHandler.assert_called_with(test_logger.name, config.log_file, config.log_dir)
def test_send_current_report_with_429(self, fromConfig, fromOptions, getLogger, time): initial = 10 retry_after = 2 time.return_value = initial fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = Executor(Mock(), options, config_dir="/nonexistant") config = Mock() config.hash = "config_hash" config.name = "config_name" report = HostGuestAssociationReport(config, {'hypervisors': []}) report.state = AbstractVirtReport.STATE_PROCESSING virtwho.queued_reports[config.name] = report virtwho.send = Mock() virtwho.send.return_value = False virtwho.send.side_effect = ManagerThrottleError(retry_after) virtwho.send_current_report() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + 60) self.assertEquals(len(virtwho.queued_reports), 1) retry_after = 120 virtwho.send.side_effect = ManagerThrottleError(retry_after) virtwho.send_current_report() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + retry_after * 2) self.assertEquals(len(virtwho.queued_reports), 1) def finish(x): report.state = AbstractVirtReport.STATE_FINISHED return True virtwho.send.side_effect = finish virtwho.send_current_report() retry_after = 60 self.assertEquals(virtwho.retry_after, retry_after) self.assertEquals(virtwho.send_after, initial + retry_after) self.assertEquals(len(virtwho.queued_reports), 0)
def test_send_current_report_with_429(self, fromConfig, fromOptions, getLogger, time): initial = 10 retry_after = 2 time.return_value = initial fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") config = Mock() config.hash = "config_hash" config.name = "config_name" report = HostGuestAssociationReport(config, {'hypervisors': []}) report.state = AbstractVirtReport.STATE_PROCESSING virtwho.queued_reports[config.name] = report virtwho.send = Mock() virtwho.send.return_value = False virtwho.send.side_effect = ManagerThrottleError(retry_after) virtwho.send_current_report() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + 60) self.assertEquals(len(virtwho.queued_reports), 1) retry_after = 120 virtwho.send.side_effect = ManagerThrottleError(retry_after) virtwho.send_current_report() virtwho.send.assert_called_with(report) self.assertEquals(virtwho.send_after, initial + retry_after * 2) self.assertEquals(len(virtwho.queued_reports), 1) def finish(x): report.state = AbstractVirtReport.STATE_FINISHED return True virtwho.send.side_effect = finish virtwho.send_current_report() retry_after = 60 self.assertEquals(virtwho.retry_after, retry_after) self.assertEquals(virtwho.send_after, initial + retry_after) self.assertEquals(len(virtwho.queued_reports), 0)
def test_send_current_report_with_429(self, fromConfig, fromOptions, getLogger, time): initial = 0 start_time = 0 end_time = 2 send_after_start_time = 0 retry_after = 2 expected_429_count = 1 time.side_effect = [ initial, initial, start_time, send_after_start_time ] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") expected_queue_timeout = retry_after**expected_429_count expected_send_after = expected_queue_timeout + send_after_start_time config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.configs_ready.append(config) virtwho.reports_to_send[config.hash] = sentinel.report virtwho.send = Mock() virtwho.send.return_value = False virtwho.send.side_effect = RestlibException( "429", "429", {"Retry-After": retry_after}) result_config, result_report = virtwho.send_current_report() self.assertEquals(expected_queue_timeout, virtwho.queue_timeout) self.assertEquals(expected_send_after, virtwho.send_after) self.assertEquals(result_config, config) self.assertEquals(None, result_report) self.assertEquals(len(virtwho.reports_to_send), 1) self.assertTrue(config in virtwho.configs_ready)
def test_get_logger_no_config(self, open, getDefaultQueueLogger, isdir): open.return_value = None isdir.return_value = True queueLogger = log.QueueLogger('virtwho') queueLogger.logger.handlers = [] mockQueueLogger = Mock(wraps=queueLogger) getDefaultQueueLogger.return_value = mockQueueLogger options = Mock() options.debug = False options.background = True options.log_file = log.DEFAULT_LOG_FILE options.log_dir = log.DEFAULT_LOG_DIR options.log_per_config = False main_logger = log.getLogger(options) self.assertTrue(main_logger.name == 'virtwho.main') self.assertTrue(len(main_logger.handlers) == 1) self.assertTrue(isinstance(main_logger.handlers[0], log.QueueHandler)) mockQueueLogger.getHandler.assert_called_with(logging.INFO) queue_handlers = queueLogger.logger.handlers self.assertTrue(len(queue_handlers) == 1) self.assertEquals(queue_handlers[0].baseFilename, '%s/%s' % (log.DEFAULT_LOG_DIR, log.DEFAULT_LOG_FILE))
def test_get_logger_no_config(self, open, getQueueLogger, isdir): open.return_value = None isdir.return_value = True queueLogger = log.QueueLogger('virtwho') queueLogger.logger.handlers = [] mockQueueLogger = Mock(wraps=queueLogger) getQueueLogger.return_value = mockQueueLogger options = Mock() options.debug = False options.background = True options.log_file = log.DEFAULT_LOG_FILE options.log_dir = log.DEFAULT_LOG_DIR options.log_per_config = False log.init(options) main_logger = log.getLogger(name='main') self.assertTrue(main_logger.name == 'virtwho.main') self.assertTrue(len(main_logger.handlers) == 1) self.assertTrue(isinstance(main_logger.handlers[0], log.QueueHandler)) queue_handlers = queueLogger.logger.handlers self.assertTrue(len(queue_handlers) == 1) self.assertEquals(queue_handlers[0].baseFilename, '%s/%s' % (log.DEFAULT_LOG_DIR, log.DEFAULT_LOG_FILE))
def test_send_current_report(self, fromConfig, fromOptions, getLogger, time): initial = 0 start_time = 0 end_time = 2 send_after_start_time = 0 expected_delta = end_time - start_time time.side_effect = [ initial, start_time, end_time, send_after_start_time ] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") expected_queue_timeout = max(0, options.interval - expected_delta) expected_send_after = expected_queue_timeout + send_after_start_time config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.send = Mock() virtwho.send.return_value = True virtwho.reports_to_send[config.hash] = sentinel.report virtwho.configs_ready.append(config) result_config, result_report = virtwho.send_current_report() self.assertEquals(expected_queue_timeout, virtwho.queue_timeout) self.assertEquals(expected_send_after, virtwho.send_after) self.assertEquals(config, result_config) self.assertEquals(sentinel.report, result_report) self.assertTrue(not virtwho.reports_to_send)
def test_send_current_report_with_429(self, fromConfig, fromOptions, getLogger, time): initial = 0 start_time = 0 end_time = 2 send_after_start_time = 0 retry_after = 2 expected_429_count = 1 time.side_effect = [initial, initial, start_time, send_after_start_time] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") expected_queue_timeout = retry_after ** expected_429_count expected_send_after = expected_queue_timeout + send_after_start_time config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.configs_ready.append(config) virtwho.reports_to_send[config.hash] = sentinel.report virtwho.send = Mock() virtwho.send.return_value = False virtwho.send.side_effect = RestlibException("429", "429", {"Retry-After": retry_after}) result_config, result_report = virtwho.send_current_report() self.assertEquals(expected_queue_timeout, virtwho.queue_timeout) self.assertEquals(expected_send_after, virtwho.send_after) self.assertEquals(result_config, config) self.assertEquals(None, result_report) self.assertEquals(len(virtwho.reports_to_send), 1) self.assertTrue(config in virtwho.configs_ready)
def test_report_hash_added_after_send(self, fromConfig, fromOptions, getLogger): # Side effect for fromConfig def fake_virts(logger, config): new_fake_virt = Mock() new_fake_virt.config.name = config.name return new_fake_virt fromConfig.side_effect = fake_virts options = Mock() options.interval = 0 options.oneshot = True options.print_ = False options.log_file = '' options.log_dir = '' virtwho = Executor(self.logger, options, config_dir="/nonexistant") def send(report): report.state = AbstractVirtReport.STATE_FINISHED return True virtwho.send = Mock(side_effect=send) queue = Queue() virtwho.queue = queue virtwho.retry_after = 1 virtwho.configManager.addConfig(self.config) virtwho.configManager.addConfig(self.second_config) queue.put(self.fake_report) queue.put(self.fake_domain_list) virtwho.run() self.assertEquals(virtwho.send.call_count, 2) self.assertEqual(virtwho.last_reports_hash[self.config.name], self.fake_report.hash) self.assertEqual(virtwho.last_reports_hash[self.second_config.name], self.fake_domain_list.hash)
def test_send_current_report(self, fromConfig, fromOptions, getLogger, time): initial = 0 start_time = 0 end_time = 2 send_after_start_time = 0 expected_delta = end_time - start_time time.side_effect = [initial, start_time, end_time, send_after_start_time] fromOptions.return_value = Mock() options = Mock() options.interval = 6 options.oneshot = True options.print_ = False options.log_dir = '' options.log_file = '' virtwho = VirtWho(Mock(), options, config_dir="/nonexistant") expected_queue_timeout = max(0, options.interval - expected_delta) expected_send_after = expected_queue_timeout + send_after_start_time config = Mock() config.hash = "config_hash" config.name = "config_name" virtwho.send = Mock() virtwho.send.return_value = True virtwho.reports_to_send[config.hash] = sentinel.report virtwho.configs_ready.append(config) result_config, result_report = virtwho.send_current_report() self.assertEquals(expected_queue_timeout, virtwho.queue_timeout) self.assertEquals(expected_send_after, virtwho.send_after) self.assertEquals(config, result_config) self.assertEquals(sentinel.report, result_report) self.assertTrue(not virtwho.reports_to_send)