def test_returns_list_of_strings(self): ensure_contains_only_formatted_lines(FILE_PATH, 'line') found_lines = lines_from_file(FILE_PATH) assert_is_instance(found_lines, list) for found_line in found_lines: assert_is_instance(found_line, string_types)
def test_net_interface_names_returns_set_of_strings(self): interface_names = self.linux.net_interface_names() assert_is_instance(interface_names, set) for interface_name in interface_names: assert_is_instance(interface_name, string_types) assert_in(PRESENT_INTERFACE, interface_names)
def test_returns_not_completely_shifted_stats_for_unfilled_history(self): self.collector._collect() stats, timestamp = self.collector.get_stats(DEVICE_NAME, self.shift, self.current_time) assert_less_equal(self.shift, self.current_time - timestamp) assert_is_instance(stats, DiskDeviceStats)
def test_net_interface_info_returns_NetworkInterfaceInfo(self): interface_names = self.linux.net_interface_names() interface_info = self.linux.net_interface_info(interface_names.pop()) assert_is_instance(interface_info, NetworkInterfaceInfo) for key, value in interface_info._asdict().items(): assert_is_instance(value, integer_types)
def test_disk_device_names_returns_set_of_strings(self): device_names = self.linux.disk_device_names() assert_is_instance(device_names, set) for device_name in device_names: assert_is_instance(device_name, string_types)
def test_returns_cpu_times_for_unfilled_history(self): self.collector._collect() cpu_count = self.host_os.cpu_count() for cpu_id in range(cpu_count): times = self.collector.get_times(cpu_id, self.shift) assert_is_instance(times, CpuTimes)
def test_disk_device_collector_collection(self): self.linux._disk_device_stats_collector._collect() devices = self.linux.disk_device_names() now = int(time.time()) (stats, timestamp) = self.linux.disk_device_stats_shifted(devices.pop(), 60, now) assert_is_instance(stats, DiskDeviceStats)
def test_send_value(self): self.protocol.send_value(self.client, 1) self.client.sendall.assert_called_with(ANY) assert_is_instance(self.client.sendall.call_args[0][0], bytes) self.protocol.send_value(self.client, "1") self.client.sendall.assert_called_with(ANY) assert_is_instance(self.client.sendall.call_args[0][0], bytes)
def test_returns_dict(self): ensure_contains_only_formatted_lines(FILE_PATH, 'key value') d = dict_from_file(FILE_PATH) assert_is_instance(d, dict) assert_less(0, len(d))
def test_cpu_times_collector_collection(self): self.linux._cpu_times_collector._collect() cpu_id = list(range(self.linux.cpu_count())).pop() times = self.linux._cpu_times_collector.get_times(cpu_id, 60) assert_is_instance(times, CpuTimes)
def test_disk_device_collector_collection(self): self.linux._disk_device_stats_collector._collect() devices = self.linux.disk_device_names() now = int(time.time()) (stats, timestamp) = self.linux.disk_device_stats_shifted( devices.pop(), 60, now) assert_is_instance(stats, DiskDeviceStats)
def test_returns_list_of_lists(self): ensure_contains_only_formatted_lines(FILE_PATH, '1 2') found_lists = lists_from_file(FILE_PATH) assert_is_instance(found_lists, list) for found_list in found_lists: assert_is_instance(found_list, list)
def test_disk_device_stats_returns_DiskDeviceStats(self): device_names = self.linux.disk_device_names() disk_device_stats = self.linux.disk_device_stats(device_names.pop()) assert_is_instance(disk_device_stats, DiskDeviceStats) for key, value in disk_device_stats._asdict().items(): assert_is_instance(value, integer_types)
def test_receive_key_zbxd(self): sent_key = KEY self.client.recv.side_effect = [ self.protocol.HEADER, struct.pack('q', len(sent_key)), b(sent_key) ] received_key = self.protocol.receive_value(self.client) assert_is_instance(received_key, string_types) assert_equal(u(sent_key), received_key)
def test_uid_returns_integer(self): uid = self.linux.uid('root') assert_is_instance(uid, integer_types)
def test_process_infos_returns_iterable_of_ProcessInfo(self): process_infos = list(self.linux.process_infos()) for process_info in process_infos: assert_is_instance(process_info, ProcessInfo)
def test_memory_returns_dict_of_numbers(self): d = self.linux.memory() assert_is_instance(d, dict) for key, value in d.items(): assert_is_instance(value, (integer_types, float))
def test_hostname(self): hostname = self.linux.hostname('host') assert_is_instance(hostname, string_types)
def test_cpu_times(self): cpu_id = list(range(self.linux.cpu_count())).pop() cpu_times = self.linux.cpu_times(cpu_id) assert_is_instance(cpu_times, CpuTimes)
def test_max_number_of_running_processes(self): maxproc = self.linux.max_number_of_running_processes() assert_is_instance(maxproc, integer_types)
def test_swap_info(self): swap_info = self.linux.swap_info() assert_is_instance(swap_info, SwapInfo)
def test_uname(self): uname = self.linux.uname() assert_is_instance(uname, collections.Iterable)
def test_convert_size_returns_integers_or_floats(): free, total = 50, 100 for conversion_mode in SIZE_CONVERSION_MODES: converted_size = convert_size(free, total, conversion_mode) assert_is_instance(converted_size, (float, integer_types))
def test_returns_integer(self): for mode in NET_MODES: value = self.function_under_test(INTERFACE_NAME, mode, self.host_os) assert_is_instance(value, integer_types)
def test_returns_float_less_than_hundred(self): for state in CPU_TIMES: percent = cpu.util('all', state=state, host_os=self.host_os) assert_is_instance(percent, float) assert_greater(100, percent)
def test_system_load(self): system_load = self.linux.system_load() assert_is_instance(system_load, SystemLoad)
def test_linux_is_detected_correctly(self): detected_os = detect_host_os() assert_is_instance(detected_os, self.linux.__class__)
def test_uptime(self): uptime = self.linux.uptime() assert_is_instance(uptime, integer_types)
def test_returns_zero_for_empty_history(self): self.host_os.cpu_times_shifted.return_value = None for state in CPU_TIMES: percent = cpu.util('all', state=state, host_os=self.host_os) assert_is_instance(percent, float) assert_equal(0, percent)
def test_pages_returns_integer(self): result = self.function_under_test(mode='pages', host_os=self.host_os) assert_is_instance(result, integer_types)
def test_disk_device_stat_types_returns_integer(self): for mode in SWAP_TO_DISK_DEVICE_STAT.keys(): result = self.function_under_test(mode=mode, host_os=self.host_os) assert_is_instance(result, integer_types)
def test_cpu_count_returns_integer(self): cpu_count = self.linux.cpu_count() assert_is_instance(cpu_count, integer_types)
def test_contains_listen_address(self): self.config_manager.update_config() host, port = self.config_manager.listen_address assert_is_instance(host, string_types) assert_is_instance(port, integer_types)
def test_returns_a_wrapper(self): wrapper = exception_guard(lambda: None) assert_is_instance(wrapper, FunctionType)