Example #1
0
    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)
Example #2
0
    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)
Example #3
0
    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)
Example #4
0
    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)
Example #5
0
    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)
Example #6
0
    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)
Example #7
0
    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)
Example #8
0
    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)
Example #9
0
    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)
Example #10
0
    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)
Example #11
0
    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)
Example #12
0
 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
Example #13
0
    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)
Example #14
0
    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)
Example #15
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 = 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)
Example #16
0
    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)
Example #17
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)
Example #18
0
 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
Example #19
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)
Example #20
0
 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))
Example #21
0
 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))
Example #22
0
    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)
Example #23
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)
Example #24
0
    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)
Example #25
0
    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)