def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
class BaseCollector(diamond.collector.Collector):
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
def get_default_config_help(self):
config_help = super(BaseCollector, self).get_default_config_help()
config_help.update({
'simple': 'run simple mode on of its sub collectors',
})
return config_help
def get_default_config(self):
config = super(BaseCollector, self).get_default_config()
return config
def collect(self):
self.cpu_collector.collect()
self.memory_collector.collect()
self.loadavg_collector.collect()
self.network_collector.collect()
self.diskusage_collector.collect()
self.diskspace_collector.collect()
self.vmstat_collector.collect()
return True
class BaseCollector(diamond.collector.Collector):
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(
config=self.config,
configfile=self.configfile,
handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config,
configfile=self.configfile,
handlers=self.handlers)
def get_default_config_help(self):
config_help = super(BaseCollector, self).get_default_config_help()
config_help.update({
'simple':
'run simple mode on of its sub collectors',
})
return config_help
def get_default_config(self):
config = super(BaseCollector, self).get_default_config()
return config
def collect(self):
self.cpu_collector.collect()
self.memory_collector.collect()
self.loadavg_collector.collect()
self.network_collector.collect()
self.diskusage_collector.collect()
self.diskspace_collector.collect()
self.vmstat_collector.collect()
return True
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval' : 10,
'byte_unit' : 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
def __init__(self, config=None, handlers=[], name=None, configfile=None):
super(BaseCollector, self).__init__(config, handlers, name, configfile)
self.cpu_collector = CPUCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.memory_collector = MemoryCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.loadavg_collector = LoadAverageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.network_collector = NetworkCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskusage_collector = DiskUsageCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.diskspace_collector = DiskSpaceCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
self.vmstat_collector = VMStatCollector(config=self.config, configfile=self.configfile, handlers=self.handlers)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'sector_size': '512',
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
def test_config(self):
self.assertFalse(self.collector.config['send_zero'])
def test_import(self):
self.assertTrue(DiskUsageCollector)
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self):
patch_open = patch('__builtin__.open',
Mock(return_value=self.getFixture('diskstats')))
open_mock = patch_open.start()
result = self.collector.get_disk_statistics()
patch_open.stop()
open_mock.assert_called_once_with('/proc/diskstats')
self.assertEqual(sorted(result.keys()), [(8, 0), (8, 1), (8, 16),
(8, 17), (8, 32), (8, 33),
(8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_should_work_with_real_data.pkl')
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_vda_and_xvdb(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults(
'test_verify_supporting_vda_and_xvdb.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_md_dm(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1_md_dm')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2_md_dm')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_md_dm.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_disk(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1_disk')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2_disk')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_disk.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_service_Time(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_1_service_time')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_2_service_time')))
patch_time = patch('time.time', Mock(return_value=70))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_service_Time.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_cciss(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1_cciss')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2_cciss')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_cciss.pkl')
self.assertPublishedMany(publish_mock, metrics)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
@patch('__builtin__.open')
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self, open_mock):
result = None
open_mock.return_value = StringIO("""
1 0 ram0 0 0 0 0 0 0 0 0 0 0 0
1 1 ram1 0 0 0 0 0 0 0 0 0 0 0
1 2 ram2 0 0 0 0 0 0 0 0 0 0 0
1 3 ram3 0 0 0 0 0 0 0 0 0 0 0
1 4 ram4 0 0 0 0 0 0 0 0 0 0 0
1 5 ram5 0 0 0 0 0 0 0 0 0 0 0
1 6 ram6 0 0 0 0 0 0 0 0 0 0 0
1 7 ram7 0 0 0 0 0 0 0 0 0 0 0
1 8 ram8 0 0 0 0 0 0 0 0 0 0 0
1 9 ram9 0 0 0 0 0 0 0 0 0 0 0
1 10 ram10 0 0 0 0 0 0 0 0 0 0 0
1 11 ram11 0 0 0 0 0 0 0 0 0 0 0
1 12 ram12 0 0 0 0 0 0 0 0 0 0 0
1 13 ram13 0 0 0 0 0 0 0 0 0 0 0
1 14 ram14 0 0 0 0 0 0 0 0 0 0 0
1 15 ram15 0 0 0 0 0 0 0 0 0 0 0
7 0 loop0 0 0 0 0 0 0 0 0 0 0 0
7 1 loop1 0 0 0 0 0 0 0 0 0 0 0
7 2 loop2 0 0 0 0 0 0 0 0 0 0 0
7 3 loop3 0 0 0 0 0 0 0 0 0 0 0
7 4 loop4 0 0 0 0 0 0 0 0 0 0 0
7 5 loop5 0 0 0 0 0 0 0 0 0 0 0
7 6 loop6 0 0 0 0 0 0 0 0 0 0 0
7 7 loop7 0 0 0 0 0 0 0 0 0 0 0
8 0 sda 11296323 127761523 1114247280 165221020 9292767 32155242 333252048 208563560 0 19035310 374755270
8 1 sda1 11296296 127761523 1114247064 165220780 9292767 32155242 333252048 208563560 0 19035230 374755030
8 16 sdb 11334585 127760303 1114502518 162448600 9287483 32167260 333227008 189022120 0 18792930 352418270
8 17 sdb1 11334558 127760303 1114502302 162448420 9287483 32167260 333227008 189022120 0 18792870 352418090
8 32 sdc 11357096 128084136 1117263302 175647900 9071409 31921768 329475344 181140140 0 19509790 357693530
8 33 sdc1 11357069 128084136 1117263086 175647670 9071409 31921768 329475344 181140140 0 19509740 357693300
8 48 sdd 11350168 128344871 1119269534 168467240 9130464 31774918 328709208 167823720 0 18473250 337157280
8 49 sdd1 11350141 128344871 1119269318 168467050 9130464 31774918 328709208 167823720 0 18473200 337157090
9 0 md0 150707 0 2818762 0 111152210 0 889217680 0 0 0 0
""".strip())
result = self.collector.get_disk_statistics()
open_mock.assert_called_once_with('/proc/diskstats')
self.assertEqual(sorted(result.keys()), [(8, 0), (8, 1), (8, 16),
(8, 17), (8, 32), (8, 33),
(8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
with nested(
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1'))),
patch('time.time', Mock(return_value=10))):
self.collector.collect()
self.assertPublishedMany(publish_mock, {})
with nested(
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2'))),
patch('time.time', Mock(return_value=20))):
self.collector.collect()
self.assertPublishedMany(
publish_mock, {
'sda.average_queue_length': 0.0,
'sda.average_request_size_kilobyte': 10.7,
'sda.await': 0.0,
'sda.concurrent_io': 0.0,
'sda.io': 0.3,
'sda.io_in_progress': 0.0,
'sda.io_milliseconds': 0.0,
'sda.io_milliseconds_weighted': 0.0,
'sda.iops': 0.03,
'sda.read_kilobyte_per_second': 0.0,
'sda.read_requests_merged_per_second': 0.0,
'sda.reads': 0.0,
'sda.reads_kilobyte': 0.0,
'sda.reads_merged': 0.0,
'sda.reads_milliseconds': 0.0,
'sda.reads_per_second': 0.0,
'sda.service_time': 0.0,
'sda.util_percentage': 0.0,
'sda.write_kilobyte_per_second': 0.32,
'sda.write_requests_merged_per_second': 0.05,
'sda.writes': 0.3,
'sda.writes_kilobyte': 3.2,
'sda.writes_merged': 0.5,
'sda.writes_milliseconds': 0.0,
'sda.writes_per_second': 0.03,
'sdb.average_queue_length': 49570.0,
'sdb.average_request_size_kilobyte': 6.3,
'sdb.await': 0.8,
'sdb.concurrent_io': 0.05,
'sdb.io': 921.4,
'sdb.io_in_progress': 0,
'sdb.io_milliseconds': 495.7,
'sdb.io_milliseconds_weighted': 749.2,
'sdb.iops': 92.14,
'sdb.read_kilobyte_per_second': 186.24,
'sdb.read_requests_merged_per_second': 0.0,
'sdb.reads': 116.4,
'sdb.reads_kilobyte': 1862.4,
'sdb.reads_merged': 0.0,
'sdb.reads_milliseconds': 716.3,
'sdb.reads_per_second': 11.64,
'sdb.service_time': 0.5,
'sdb.util_percentage': 49.57,
'sdb.write_kilobyte_per_second': 391.43,
'sdb.write_requests_merged_per_second': 20.17,
'sdb.writes': 805.0,
'sdb.writes_kilobyte': 3914.3,
'sdb.writes_merged': 201.7,
'sdb.writes_milliseconds': 33.7,
'sdb.writes_per_second': 80.5,
})
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'sector_size': '512',
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self):
with nested(
patch('__builtin__.open', Mock(
return_value=self.getFixture('diskstats')))):
result = self.collector.get_disk_statistics()
open.assert_called_once_with('/proc/diskstats')
self.assertEqual(
sorted(result.keys()),
[(8, 0), (8, 1), (8, 16), (8, 17), (8, 32),
(8, 33), (8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
with nested(
patch('__builtin__.open', Mock(
return_value=self.getFixture('proc_diskstats_1'))),
patch('time.time', Mock(return_value=10))):
self.collector.collect()
self.assertPublishedMany(publish_mock, {})
with nested(
patch('__builtin__.open', Mock(
return_value=self.getFixture('proc_diskstats_2'))),
patch('time.time', Mock(return_value=20))):
self.collector.collect()
metrics = {
'sda.average_queue_length': 0.0,
'sda.average_request_size_kilobyte': 10.6,
'sda.await': 0.0,
'sda.concurrent_io': 0.0,
'sda.io': 3.0,
'sda.io_in_progress': 0.0,
'sda.io_milliseconds': 0.0,
'sda.io_milliseconds_weighted': 0.0,
'sda.iops': 0.3,
'sda.read_kilobyte_per_second': 0.0,
'sda.read_requests_merged_per_second': 0.0,
'sda.reads': 0.0,
'sda.reads_kilobyte': 0.0,
'sda.reads_merged': 0.0,
'sda.reads_milliseconds': 0.0,
'sda.reads_per_second': 0.0,
'sda.service_time': 0.0,
'sda.util_percentage': 0.0,
'sda.write_kilobyte_per_second': 3.2,
'sda.write_requests_merged_per_second': 0.5,
'sda.writes': 3.0,
'sda.writes_kilobyte': 32.0,
'sda.writes_merged': 5.0,
'sda.writes_milliseconds': 0.0,
'sda.writes_per_second': 0.3,
'sdb.average_queue_length': 495700.0,
'sdb.average_request_size_kilobyte': 6.3,
'sdb.await': 0.8,
'sdb.concurrent_io': 0.5,
'sdb.io': 9214.0,
'sdb.io_in_progress': 0.0,
'sdb.io_milliseconds': 4957.0,
'sdb.io_milliseconds_weighted': 7492.0,
'sdb.iops': 921.4,
'sdb.read_kilobyte_per_second': 1862.4,
'sdb.read_requests_merged_per_second': 0.0,
'sdb.reads': 1164.0,
'sdb.reads_kilobyte': 18624.0,
'sdb.reads_merged': 0.0,
'sdb.reads_milliseconds': 7163.0,
'sdb.reads_per_second': 116.4,
'sdb.service_time': 0.5,
'sdb.util_percentage': 495.7,
'sdb.write_kilobyte_per_second': 3914.3,
'sdb.write_requests_merged_per_second': 201.7,
'sdb.writes': 8050.0,
'sdb.writes_kilobyte': 39143.0,
'sdb.writes_merged': 2017.0,
'sdb.writes_milliseconds': 337.0,
'sdb.writes_per_second': 805.0,
}
self.setDocExample(self.collector.__class__.__name__, metrics)
self.assertPublishedMany(publish_mock, metrics)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'sector_size': '512',
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self):
with nested(
patch('__builtin__.open',
Mock(return_value=self.getFixture('diskstats')))):
result = self.collector.get_disk_statistics()
open.assert_called_once_with('/proc/diskstats')
self.assertEqual(sorted(result.keys()), [(8, 0), (8, 1), (8, 16),
(8, 17), (8, 32), (8, 33),
(8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
with nested(
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_1'))),
patch('time.time', Mock(return_value=10))):
self.collector.collect()
self.assertPublishedMany(publish_mock, {})
with nested(
patch('__builtin__.open',
Mock(return_value=self.getFixture('proc_diskstats_2'))),
patch('time.time', Mock(return_value=20))):
self.collector.collect()
metrics = {
'sda.average_queue_length': 0.0,
'sda.average_request_size_kilobyte': 10.6,
'sda.await': 0.0,
'sda.concurrent_io': 0.0,
'sda.io': 3.0,
'sda.io_in_progress': 0.0,
'sda.io_milliseconds': 0.0,
'sda.io_milliseconds_weighted': 0.0,
'sda.iops': 0.3,
'sda.read_kilobyte_per_second': 0.0,
'sda.read_requests_merged_per_second': 0.0,
'sda.reads': 0.0,
'sda.reads_kilobyte': 0.0,
'sda.reads_merged': 0.0,
'sda.reads_milliseconds': 0.0,
'sda.reads_per_second': 0.0,
'sda.service_time': 0.0,
'sda.util_percentage': 0.0,
'sda.write_kilobyte_per_second': 3.2,
'sda.write_requests_merged_per_second': 0.5,
'sda.writes': 3.0,
'sda.writes_kilobyte': 32.0,
'sda.writes_merged': 5.0,
'sda.writes_milliseconds': 0.0,
'sda.writes_per_second': 0.3,
'sdb.average_queue_length': 495700.0,
'sdb.average_request_size_kilobyte': 6.3,
'sdb.await': 0.8,
'sdb.concurrent_io': 0.5,
'sdb.io': 9214.0,
'sdb.io_in_progress': 0.0,
'sdb.io_milliseconds': 4957.0,
'sdb.io_milliseconds_weighted': 7492.0,
'sdb.iops': 921.4,
'sdb.read_kilobyte_per_second': 1862.4,
'sdb.read_requests_merged_per_second': 0.0,
'sdb.reads': 1164.0,
'sdb.reads_kilobyte': 18624.0,
'sdb.reads_merged': 0.0,
'sdb.reads_milliseconds': 7163.0,
'sdb.reads_per_second': 116.4,
'sdb.service_time': 0.5,
'sdb.util_percentage': 495.7,
'sdb.write_kilobyte_per_second': 3914.3,
'sdb.write_requests_merged_per_second': 201.7,
'sdb.writes': 8050.0,
'sdb.writes_kilobyte': 39143.0,
'sdb.writes_merged': 2017.0,
'sdb.writes_milliseconds': 337.0,
'sdb.writes_per_second': 805.0,
}
self.setDocExample(self.collector.__class__.__name__, metrics)
self.assertPublishedMany(publish_mock, metrics)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'sector_size': '512',
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
def test_config(self):
self.assertFalse(self.collector.config['send_zero'])
def test_import(self):
self.assertTrue(DiskUsageCollector)
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self):
patch_open = patch(
'__builtin__.open',
Mock(return_value=self.getFixture('diskstats')))
open_mock = patch_open.start()
result = self.collector.get_disk_statistics()
patch_open.stop()
open_mock.assert_called_once_with('/proc/diskstats')
self.assertEqual(
sorted(result.keys()),
[(8, 0), (8, 1), (8, 16), (8, 17), (8, 32),
(8, 33), (8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_1')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_2')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_should_work_with_real_data.pkl')
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_vda_and_xvdb(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults(
'test_verify_supporting_vda_and_xvdb.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_md_dm(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_md_dm')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_md_dm')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_md_dm.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_disk(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_disk')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_disk')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_disk.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_service_Time(self, publish_mock):
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_service_time')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch(
'__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_service_time')))
patch_time = patch('time.time', Mock(return_value=70))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_service_Time.pkl')
self.assertPublishedMany(publish_mock, metrics)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval' : 10,
'byte_unit' : 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
@patch('__builtin__.open')
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self, open_mock):
result = None
open_mock.return_value = StringIO("""
1 0 ram0 0 0 0 0 0 0 0 0 0 0 0
1 1 ram1 0 0 0 0 0 0 0 0 0 0 0
1 2 ram2 0 0 0 0 0 0 0 0 0 0 0
1 3 ram3 0 0 0 0 0 0 0 0 0 0 0
1 4 ram4 0 0 0 0 0 0 0 0 0 0 0
1 5 ram5 0 0 0 0 0 0 0 0 0 0 0
1 6 ram6 0 0 0 0 0 0 0 0 0 0 0
1 7 ram7 0 0 0 0 0 0 0 0 0 0 0
1 8 ram8 0 0 0 0 0 0 0 0 0 0 0
1 9 ram9 0 0 0 0 0 0 0 0 0 0 0
1 10 ram10 0 0 0 0 0 0 0 0 0 0 0
1 11 ram11 0 0 0 0 0 0 0 0 0 0 0
1 12 ram12 0 0 0 0 0 0 0 0 0 0 0
1 13 ram13 0 0 0 0 0 0 0 0 0 0 0
1 14 ram14 0 0 0 0 0 0 0 0 0 0 0
1 15 ram15 0 0 0 0 0 0 0 0 0 0 0
7 0 loop0 0 0 0 0 0 0 0 0 0 0 0
7 1 loop1 0 0 0 0 0 0 0 0 0 0 0
7 2 loop2 0 0 0 0 0 0 0 0 0 0 0
7 3 loop3 0 0 0 0 0 0 0 0 0 0 0
7 4 loop4 0 0 0 0 0 0 0 0 0 0 0
7 5 loop5 0 0 0 0 0 0 0 0 0 0 0
7 6 loop6 0 0 0 0 0 0 0 0 0 0 0
7 7 loop7 0 0 0 0 0 0 0 0 0 0 0
8 0 sda 11296323 127761523 1114247280 165221020 9292767 32155242 333252048 208563560 0 19035310 374755270
8 1 sda1 11296296 127761523 1114247064 165220780 9292767 32155242 333252048 208563560 0 19035230 374755030
8 16 sdb 11334585 127760303 1114502518 162448600 9287483 32167260 333227008 189022120 0 18792930 352418270
8 17 sdb1 11334558 127760303 1114502302 162448420 9287483 32167260 333227008 189022120 0 18792870 352418090
8 32 sdc 11357096 128084136 1117263302 175647900 9071409 31921768 329475344 181140140 0 19509790 357693530
8 33 sdc1 11357069 128084136 1117263086 175647670 9071409 31921768 329475344 181140140 0 19509740 357693300
8 48 sdd 11350168 128344871 1119269534 168467240 9130464 31774918 328709208 167823720 0 18473250 337157280
8 49 sdd1 11350141 128344871 1119269318 168467050 9130464 31774918 328709208 167823720 0 18473200 337157090
9 0 md0 150707 0 2818762 0 111152210 0 889217680 0 0 0 0
""".strip())
result = self.collector.get_disk_statistics()
open_mock.assert_called_once_with('/proc/diskstats')
self.assertEqual(
sorted(result.keys()),
[ (8, 0), (8, 1), (8, 16), (8, 17), (8, 32), (8, 33), (8, 48), (8, 49), (9, 0) ]
)
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
with nested(
patch('__builtin__.open', Mock(return_value = self.getFixture('proc_diskstats_1'))),
patch('time.time', Mock(return_value = 10))
):
self.collector.collect()
self.assertPublishedMany(publish_mock, {})
with nested(
patch('__builtin__.open', Mock(return_value = self.getFixture('proc_diskstats_2'))),
patch('time.time', Mock(return_value = 20))
):
self.collector.collect()
metrics = {
'sda.average_queue_length': 0.0,
'sda.average_request_size_kilobyte': 10.7,
'sda.await': 0.0,
'sda.concurrent_io': 0.0,
'sda.io': 0.3,
'sda.io_in_progress': 0.0,
'sda.io_milliseconds': 0.0,
'sda.io_milliseconds_weighted': 0.0,
'sda.iops': 0.03,
'sda.read_kilobyte_per_second': 0.0,
'sda.read_requests_merged_per_second': 0.0,
'sda.reads': 0.0,
'sda.reads_kilobyte': 0.0,
'sda.reads_merged': 0.0,
'sda.reads_milliseconds': 0.0,
'sda.reads_per_second': 0.0,
'sda.service_time': 0.0,
'sda.util_percentage': 0.0,
'sda.write_kilobyte_per_second': 0.32,
'sda.write_requests_merged_per_second': 0.05,
'sda.writes': 0.3,
'sda.writes_kilobyte': 3.2,
'sda.writes_merged': 0.5,
'sda.writes_milliseconds': 0.0,
'sda.writes_per_second': 0.03,
'sdb.average_queue_length': 49570.0,
'sdb.average_request_size_kilobyte': 6.3,
'sdb.await': 0.8,
'sdb.concurrent_io': 0.05,
'sdb.io': 921.4,
'sdb.io_in_progress': 0,
'sdb.io_milliseconds': 495.7,
'sdb.io_milliseconds_weighted': 749.2,
'sdb.iops': 92.14,
'sdb.read_kilobyte_per_second': 186.24,
'sdb.read_requests_merged_per_second': 0.0,
'sdb.reads': 116.4,
'sdb.reads_kilobyte': 1862.4,
'sdb.reads_merged': 0.0,
'sdb.reads_milliseconds': 716.3,
'sdb.reads_per_second': 11.64,
'sdb.service_time': 0.5,
'sdb.util_percentage': 49.57,
'sdb.write_kilobyte_per_second': 391.43,
'sdb.write_requests_merged_per_second': 20.17,
'sdb.writes': 805.0,
'sdb.writes_kilobyte': 3914.3,
'sdb.writes_merged': 201.7,
'sdb.writes_milliseconds': 33.7,
'sdb.writes_per_second': 80.5,
}
self.setDocExample(self.collector.__class__.__name__, metrics)
self.assertPublishedMany(publish_mock, metrics)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config('DiskUsageCollector', {
'interval': 10,
'sector_size': '512',
'byte_unit': 'kilobyte'
})
self.collector = DiskUsageCollector(config, None)
def test_import(self):
self.assertTrue(DiskUsageCollector)
@patch('os.access', Mock(return_value=True))
def test_get_disk_statistics(self):
patch_open = patch('__builtin__.open',
Mock(return_value=self.getFixture('diskstats')))
open_mock = patch_open.start()
result = self.collector.get_disk_statistics()
patch_open.stop()
open_mock.assert_called_once_with('/proc/diskstats')
self.assertEqual(
sorted(result.keys()),
[(8, 0), (8, 1), (8, 16), (8, 17), (8, 32),
(8, 33), (8, 48), (8, 49), (9, 0)])
return result
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_should_work_with_real_data(self, publish_mock):
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_1')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture('proc_diskstats_2')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_should_work_with_real_data.pkl')
self.setDocExample(collector=self.collector.__class__.__name__,
metrics=metrics,
defaultpath=self.collector.config['path'])
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_vda_and_xvdb(self, publish_mock):
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_vda_xvdb')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults(
'test_verify_supporting_vda_and_xvdb.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_md_dm(self, publish_mock):
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_md_dm')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_md_dm')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_md_dm.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_verify_supporting_disk(self, publish_mock):
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_disk')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_disk')))
patch_time = patch('time.time', Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults('test_verify_supporting_disk.pkl')
self.assertPublishedMany(publish_mock, metrics)
@patch('os.access', Mock(return_value=True))
@patch.object(Collector, 'publish')
def test_service_Time(self, publish_mock):
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_1_service_time')))
patch_time = patch('time.time', Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch('__builtin__.open',
Mock(
return_value=self.getFixture(
'proc_diskstats_2_service_time')))
patch_time = patch('time.time', Mock(return_value=70))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = {
'sda.write_requests_merged_per_second': 18.1666666667,
'sda.read_requests_merged_per_second': 0.0,
'sda.reads': 38.0,
'sda.iops': 4.36666666667,
'sda.io': 262.0,
'sda.io_milliseconds_weighted': 396.0,
'sda.read_await': 7.15789473684,
'sda.writes': 224.0,
'sda.service_time': 0.732824427481,
'sda.average_request_size_kilobyte': 21.6030534351,
'sda.io_milliseconds': 192.0,
'sda.write_await': 0.553571428571,
'sda.writes_milliseconds': 124.0,
'sda.await': 1.51145038168,
'sda.util_percentage': 19.2,
'sda.reads_kilobyte': 696.0,
'sda.read_kilobyte_per_second': 11.6,
'sda.writes_per_second': 3.73333333333,
'sda.io_in_progress': 0.0,
'sda.reads_per_second': 0.633333333333,
'sda.concurrent_io': 0.0032,
'sda.writes_kilobyte': 4964.0,
'sda.write_kilobyte_per_second': 82.7333333333,
'sda.writes_merged': 1090.0,
'sda.reads_merged': 0.0,
'sda.average_queue_length': 3200.0,
'sda.reads_milliseconds': 272.0,
'sda5.write_requests_merged_per_second': 18.1666666667,
'sda5.read_requests_merged_per_second': 0.0,
'sda5.reads': 38.0,
'sda5.iops': 3.15,
'sda5.io': 189.0,
'sda5.io_milliseconds_weighted': 396.0,
'sda5.read_await': 7.15789473684,
'sda5.writes': 151.0,
'sda5.service_time': 1.01587301587,
'sda5.average_request_size_kilobyte': 29.9470899471,
'sda5.io_milliseconds': 192.0,
'sda5.write_await': 0.82119205298,
'sda5.writes_milliseconds': 124.0,
'sda5.await': 2.09523809524,
'sda5.util_percentage': 19.2,
'sda5.reads_kilobyte': 696.0,
'sda5.read_kilobyte_per_second': 11.6,
'sda5.writes_per_second': 2.51666666667,
'sda5.io_in_progress': 0.0,
'sda5.reads_per_second': 0.633333333333,
'sda5.concurrent_io': 0.0032,
'sda5.writes_kilobyte': 4964.0,
'sda5.write_kilobyte_per_second': 82.7333333333,
'sda5.writes_merged': 1090.0,
'sda5.reads_merged': 0.0,
'sda5.average_queue_length': 3200.0,
'sda5.reads_milliseconds': 272.0,
'dm-0.write_requests_merged_per_second': 0.0,
'dm-0.read_requests_merged_per_second': 0.0,
'dm-0.reads': 38.0,
'dm-0.iops': 22.2333333333,
'dm-0.io': 1334.0,
'dm-0.io_milliseconds_weighted': 1172.0,
'dm-0.read_await': 7.15789473684,
'dm-0.writes': 1296.0,
'dm-0.service_time': 0.143928035982,
'dm-0.average_request_size_kilobyte': 4.24287856072,
'dm-0.io_milliseconds': 192.0,
'dm-0.write_await': 0.694444444444,
'dm-0.writes_milliseconds': 900.0,
'dm-0.await': 0.87856071964,
'dm-0.util_percentage': 19.2,
'dm-0.reads_kilobyte': 696.0,
'dm-0.read_kilobyte_per_second': 11.6,
'dm-0.writes_per_second': 21.6,
'dm-0.io_in_progress': 0.0,
'dm-0.reads_per_second': 0.633333333333,
'dm-0.concurrent_io': 0.0032,
'dm-0.writes_kilobyte': 4964.0,
'dm-0.write_kilobyte_per_second': 82.7333333333,
'dm-0.writes_merged': 0.0,
'dm-0.reads_merged': 0.0,
'dm-0.average_queue_length': 3200.0,
'dm-0.reads_milliseconds': 272.0
}
self.assertPublishedMany(publish_mock, metrics)
def setUp(self):
config = get_collector_config(
"DiskUsageCollector", {"interval": 10, "sector_size": "512", "byte_unit": "kilobyte"}
)
self.collector = DiskUsageCollector(config, None)
class TestDiskUsageCollector(CollectorTestCase):
def setUp(self):
config = get_collector_config(
"DiskUsageCollector", {"interval": 10, "sector_size": "512", "byte_unit": "kilobyte"}
)
self.collector = DiskUsageCollector(config, None)
def test_import(self):
self.assertTrue(DiskUsageCollector)
@patch("os.access", Mock(return_value=True))
def test_get_disk_statistics(self):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("diskstats")))
open_mock = patch_open.start()
result = self.collector.get_disk_statistics()
patch_open.stop()
open_mock.assert_called_once_with("/proc/diskstats")
self.assertEqual(
sorted(result.keys()), [(8, 0), (8, 1), (8, 16), (8, 17), (8, 32), (8, 33), (8, 48), (8, 49), (9, 0)]
)
return result
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_should_work_with_real_data(self, publish_mock):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_1")))
patch_time = patch("time.time", Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_2")))
patch_time = patch("time.time", Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults("test_should_work_with_real_data.pkl")
self.setDocExample(
collector=self.collector.__class__.__name__, metrics=metrics, defaultpath=self.collector.config["path"]
)
self.assertPublishedMany(publish_mock, metrics)
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_verify_supporting_vda_and_xvdb(self, publish_mock):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_1_vda_xvdb")))
patch_time = patch("time.time", Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_2_vda_xvdb")))
patch_time = patch("time.time", Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults("test_verify_supporting_vda_and_xvdb.pkl")
self.assertPublishedMany(publish_mock, metrics)
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_verify_supporting_md_dm(self, publish_mock):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_1_md_dm")))
patch_time = patch("time.time", Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_2_md_dm")))
patch_time = patch("time.time", Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults("test_verify_supporting_md_dm.pkl")
self.assertPublishedMany(publish_mock, metrics)
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_verify_supporting_disk(self, publish_mock):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_1_disk")))
patch_time = patch("time.time", Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_2_disk")))
patch_time = patch("time.time", Mock(return_value=20))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults("test_verify_supporting_disk.pkl")
self.assertPublishedMany(publish_mock, metrics)
@patch("os.access", Mock(return_value=True))
@patch.object(Collector, "publish")
def test_service_Time(self, publish_mock):
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_1_service_time")))
patch_time = patch("time.time", Mock(return_value=10))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
self.assertPublishedMany(publish_mock, {})
patch_open = patch("__builtin__.open", Mock(return_value=self.getFixture("proc_diskstats_2_service_time")))
patch_time = patch("time.time", Mock(return_value=70))
patch_open.start()
patch_time.start()
self.collector.collect()
patch_open.stop()
patch_time.stop()
metrics = self.getPickledResults("test_service_Time.pkl")
self.assertPublishedMany(publish_mock, metrics)
