glances/unitest.py

400 lines
15 KiB
Python
Raw Normal View History

2014-05-21 15:48:07 +04:00
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Glances - An eye on your system
#
2021-08-25 14:07:44 +03:00
# Copyright (C) 2021 Nicolargo <nicolas@nicolargo.com>
2014-05-21 15:48:07 +04:00
#
# Glances is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Glances is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""Glances unitary tests suite."""
2014-05-21 15:48:07 +04:00
2014-06-13 22:06:13 +04:00
import time
2014-05-21 15:48:07 +04:00
import unittest
2021-09-04 17:46:20 +03:00
import sys
# Check Python version
if sys.version_info < (3, 4):
print('Glances requires at least Python 3.4 to run.')
sys.exit(1)
2014-05-21 15:48:07 +04:00
from glances.main import GlancesMain
from glances.stats import GlancesStats
from glances import __version__
2021-08-28 11:56:04 +03:00
from glances.globals import WINDOWS, LINUX, subsample
from glances.outputs.glances_bars import Bar
2017-04-17 16:47:33 +03:00
from glances.thresholds import GlancesThresholdOk
from glances.thresholds import GlancesThresholdCareful
from glances.thresholds import GlancesThresholdWarning
from glances.thresholds import GlancesThresholdCritical
2017-04-17 20:24:00 +03:00
from glances.thresholds import GlancesThresholds
2021-09-04 10:39:17 +03:00
from glances.plugins.plugin import GlancesPlugin
2021-04-24 17:14:35 +03:00
from glances.secure import secure_popen
2014-05-21 15:48:07 +04:00
# Global variables
# =================
2014-05-21 15:48:07 +04:00
# Init Glances core
core = GlancesMain()
# Init Glances stats
stats = GlancesStats(config=core.get_config(),
args=core.get_args())
2014-05-21 15:48:07 +04:00
# Unitest class
# ==============
print('Unitary tests for Glances %s' % __version__)
2014-06-13 22:06:13 +04:00
class TestGlances(unittest.TestCase):
"""Test Glances class."""
2014-05-21 15:48:07 +04:00
def setUp(self):
"""The function is called *every time* before test_*."""
2014-06-13 22:06:13 +04:00
print('\n' + '=' * 78)
2014-05-21 15:48:07 +04:00
def test_000_update(self):
"""Update stats (mandatory step for all the stats).
2014-05-21 15:48:07 +04:00
The update is made twice (for rate computation).
"""
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_000] Test the stats update function')
try:
stats.update()
except Exception as e:
2015-09-21 17:51:20 +03:00
print('ERROR: Stats update failed: %s' % e)
2014-05-21 15:48:07 +04:00
self.assertTrue(False)
time.sleep(1)
try:
stats.update()
except Exception as e:
2015-09-21 17:51:20 +03:00
print('ERROR: Stats update failed: %s' % e)
2014-05-21 15:48:07 +04:00
self.assertTrue(False)
2014-05-21 15:48:07 +04:00
self.assertTrue(True)
def test_001_plugins(self):
"""Check mandatory plugins."""
plugins_to_check = ['system', 'cpu', 'load', 'mem', 'memswap', 'network', 'diskio', 'fs']
2014-06-13 22:06:13 +04:00
print('INFO: [TEST_001] Check the mandatory plugins list: %s' % ', '.join(plugins_to_check))
plugins_list = stats.getPluginsList()
2014-06-13 22:06:13 +04:00
for plugin in plugins_to_check:
self.assertTrue(plugin in plugins_list)
2014-05-21 15:48:07 +04:00
2016-10-23 22:39:53 +03:00
def test_002_system(self):
"""Check SYSTEM plugin."""
2014-06-13 22:06:13 +04:00
stats_to_check = ['hostname', 'os_name']
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_002] Check SYSTEM stats: %s' % ', '.join(stats_to_check))
stats_grab = stats.get_plugin('system').get_raw()
2014-06-13 22:06:13 +04:00
for stat in stats_to_check:
2014-05-21 15:48:07 +04:00
# Check that the key exist
2014-06-13 22:06:13 +04:00
self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
2014-05-21 15:48:07 +04:00
print('INFO: SYSTEM stats: %s' % stats_grab)
def test_003_cpu(self):
"""Check CPU plugin."""
2014-06-13 22:06:13 +04:00
stats_to_check = ['system', 'user', 'idle']
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_003] Check mandatory CPU stats: %s' % ', '.join(stats_to_check))
stats_grab = stats.get_plugin('cpu').get_raw()
2014-06-13 22:06:13 +04:00
for stat in stats_to_check:
2014-05-21 15:48:07 +04:00
# Check that the key exist
2014-06-13 22:06:13 +04:00
self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
2014-05-21 15:48:07 +04:00
# Check that % is > 0 and < 100
2014-06-13 22:06:13 +04:00
self.assertGreaterEqual(stats_grab[stat], 0)
self.assertLessEqual(stats_grab[stat], 100)
2014-05-21 15:48:07 +04:00
print('INFO: CPU stats: %s' % stats_grab)
2015-11-29 22:50:53 +03:00
@unittest.skipIf(WINDOWS, "Load average not available on Windows")
2014-05-21 15:48:07 +04:00
def test_004_load(self):
"""Check LOAD plugin."""
2014-06-13 22:06:13 +04:00
stats_to_check = ['cpucore', 'min1', 'min5', 'min15']
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_004] Check LOAD stats: %s' % ', '.join(stats_to_check))
stats_grab = stats.get_plugin('load').get_raw()
2014-06-13 22:06:13 +04:00
for stat in stats_to_check:
2014-05-21 15:48:07 +04:00
# Check that the key exist
2014-06-13 22:06:13 +04:00
self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
2014-05-21 15:48:07 +04:00
# Check that % is > 0
2014-06-13 22:06:13 +04:00
self.assertGreaterEqual(stats_grab[stat], 0)
2014-05-21 15:48:07 +04:00
print('INFO: LOAD stats: %s' % stats_grab)
def test_005_mem(self):
"""Check MEM plugin."""
2014-06-13 22:06:13 +04:00
stats_to_check = ['available', 'used', 'free', 'total']
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_005] Check MEM stats: %s' % ', '.join(stats_to_check))
stats_grab = stats.get_plugin('mem').get_raw()
2014-06-13 22:06:13 +04:00
for stat in stats_to_check:
2014-05-21 15:48:07 +04:00
# Check that the key exist
2014-06-13 22:06:13 +04:00
self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
2014-05-21 15:48:07 +04:00
# Check that % is > 0
2014-06-13 22:06:13 +04:00
self.assertGreaterEqual(stats_grab[stat], 0)
2014-05-21 15:48:07 +04:00
print('INFO: MEM stats: %s' % stats_grab)
def test_006_swap(self):
"""Check MEMSWAP plugin."""
2014-06-13 22:06:13 +04:00
stats_to_check = ['used', 'free', 'total']
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_006] Check SWAP stats: %s' % ', '.join(stats_to_check))
stats_grab = stats.get_plugin('memswap').get_raw()
2014-06-13 22:06:13 +04:00
for stat in stats_to_check:
2014-05-21 15:48:07 +04:00
# Check that the key exist
2014-06-13 22:06:13 +04:00
self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
2014-05-21 15:48:07 +04:00
# Check that % is > 0
2014-06-13 22:06:13 +04:00
self.assertGreaterEqual(stats_grab[stat], 0)
2014-05-21 15:48:07 +04:00
print('INFO: SWAP stats: %s' % stats_grab)
def test_007_network(self):
"""Check NETWORK plugin."""
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_007] Check NETWORK stats')
stats_grab = stats.get_plugin('network').get_raw()
self.assertTrue(type(stats_grab) is list, msg='Network stats is not a list')
print('INFO: NETWORK stats: %s' % stats_grab)
def test_008_diskio(self):
"""Check DISKIO plugin."""
print('INFO: [TEST_008] Check DISKIO stats')
2014-05-21 15:48:07 +04:00
stats_grab = stats.get_plugin('diskio').get_raw()
self.assertTrue(type(stats_grab) is list, msg='DiskIO stats is not a list')
print('INFO: diskio stats: %s' % stats_grab)
def test_009_fs(self):
"""Check File System plugin."""
2014-06-13 22:06:13 +04:00
# stats_to_check = [ ]
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_009] Check FS stats')
stats_grab = stats.get_plugin('fs').get_raw()
self.assertTrue(type(stats_grab) is list, msg='FileSystem stats is not a list')
print('INFO: FS stats: %s' % stats_grab)
def test_010_processes(self):
"""Check Process plugin."""
2014-06-13 22:06:13 +04:00
# stats_to_check = [ ]
2014-05-21 15:48:07 +04:00
print('INFO: [TEST_010] Check PROCESS stats')
stats_grab = stats.get_plugin('processcount').get_raw()
2014-06-13 22:06:13 +04:00
# total = stats_grab['total']
2014-05-21 15:48:07 +04:00
self.assertTrue(type(stats_grab) is dict, msg='Process count stats is not a dict')
print('INFO: PROCESS count stats: %s' % stats_grab)
stats_grab = stats.get_plugin('processlist').get_raw()
self.assertTrue(type(stats_grab) is list, msg='Process count stats is not a list')
print('INFO: PROCESS list stats: %s items in the list' % len(stats_grab))
# Check if number of processes in the list equal counter
# self.assertEqual(total, len(stats_grab))
2014-05-21 15:48:07 +04:00
def test_011_folders(self):
"""Check File System plugin."""
# stats_to_check = [ ]
print('INFO: [TEST_011] Check FOLDER stats')
stats_grab = stats.get_plugin('folders').get_raw()
self.assertTrue(type(stats_grab) is list, msg='Folders stats is not a list')
print('INFO: Folders stats: %s' % stats_grab)
def test_012_ip(self):
"""Check IP plugin."""
print('INFO: [TEST_012] Check IP stats')
stats_grab = stats.get_plugin('ip').get_raw()
self.assertTrue(type(stats_grab) is dict, msg='IP stats is not a dict')
print('INFO: IP stats: %s' % stats_grab)
2016-08-20 19:51:48 +03:00
@unittest.skipIf(not LINUX, "IRQs available only on Linux")
2016-08-19 20:26:23 +03:00
def test_013_irq(self):
"""Check IRQ plugin."""
print('INFO: [TEST_013] Check IRQ stats')
stats_grab = stats.get_plugin('irq').get_raw()
self.assertTrue(type(stats_grab) is list, msg='IRQ stats is not a list')
print('INFO: IRQ stats: %s' % stats_grab)
2017-01-28 20:54:27 +03:00
@unittest.skipIf(not LINUX, "GPU available only on Linux")
def test_013_gpu(self):
"""Check GPU plugin."""
print('INFO: [TEST_014] Check GPU stats')
stats_grab = stats.get_plugin('gpu').get_raw()
self.assertTrue(type(stats_grab) is list, msg='GPU stats is not a list')
print('INFO: GPU stats: %s' % stats_grab)
def test_014_sorted_stats(self):
"""Check sorted stats method."""
print('INFO: [TEST_015] Check sorted stats method')
aliases = {
"key2": "alias11",
"key5": "alias2",
}
unsorted_stats = [
{"key": "key4"},
{"key": "key2"},
{"key": "key5"},
{"key": "key21"},
{"key": "key3"},
]
gp = GlancesPlugin()
gp.get_key = lambda: "key"
gp.has_alias = aliases.get
gp.stats = unsorted_stats
sorted_stats = gp.sorted_stats()
self.assertEqual(len(sorted_stats), 5)
self.assertEqual(sorted_stats[0]["key"], "key5")
self.assertEqual(sorted_stats[1]["key"], "key2")
self.assertEqual(sorted_stats[2]["key"], "key3")
self.assertEqual(sorted_stats[3]["key"], "key4")
self.assertEqual(sorted_stats[4]["key"], "key21")
2018-04-02 14:23:06 +03:00
def test_015_subsample(self):
"""Test subsampling function."""
print('INFO: [TEST_015] Subsampling')
2021-04-20 19:52:02 +03:00
for l_test in [([1, 2, 3], 4),
([1, 2, 3, 4], 4),
([1, 2, 3, 4, 5, 6, 7], 4),
([1, 2, 3, 4, 5, 6, 7, 8], 4),
(list(range(1, 800)), 4),
(list(range(1, 8000)), 800)]:
l_subsample = subsample(l_test[0], l_test[1])
self.assertLessEqual(len(l_subsample), l_test[1])
2018-04-02 14:23:06 +03:00
def test_016_hddsmart(self):
"""Check hard disk SMART data plugin."""
2018-08-25 10:55:23 +03:00
try:
2021-08-28 11:56:04 +03:00
from glances.globals import is_admin
2018-08-25 10:55:23 +03:00
except ImportError:
print("INFO: [TEST_016] pySMART not found, not running SMART plugin test")
return
stat = 'DeviceName'
print('INFO: [TEST_016] Check SMART stats: {}'.format(stat))
stats_grab = stats.get_plugin('smart').get_raw()
if not is_admin():
print("INFO: Not admin, SMART list should be empty")
assert len(stats_grab) == 0
2019-08-12 10:57:28 +03:00
elif stats_grab == {}:
print("INFO: Admin but SMART list is empty")
assert len(stats_grab) == 0
else:
2019-08-12 10:57:28 +03:00
print(stats_grab)
self.assertTrue(stat in stats_grab[0].keys(), msg='Cannot find key: %s' % stat)
print('INFO: SMART stats: %s' % stats_grab)
2017-04-17 16:47:33 +03:00
def test_094_thresholds(self):
"""Test thresholds classes"""
2017-04-17 20:24:00 +03:00
print('INFO: [TEST_094] Thresholds')
2017-04-17 16:47:33 +03:00
ok = GlancesThresholdOk()
careful = GlancesThresholdCareful()
warning = GlancesThresholdWarning()
critical = GlancesThresholdCritical()
self.assertTrue(ok < careful)
self.assertTrue(careful < warning)
self.assertTrue(warning < critical)
self.assertFalse(ok > careful)
self.assertEqual(ok, ok)
self.assertEqual(str(ok), 'OK')
2017-04-17 20:24:00 +03:00
thresholds = GlancesThresholds()
thresholds.add('cpu_percent', 'OK')
self.assertEqual(thresholds.get(stat_name='cpu_percent').description(), 'OK')
2017-04-17 16:47:33 +03:00
2017-01-28 20:54:27 +03:00
def test_095_methods(self):
"""Test mandatories methods"""
print('INFO: [TEST_095] Mandatories methods')
mandatories_methods = ['reset', 'update']
plugins_list = stats.getPluginsList()
2017-01-28 20:54:27 +03:00
for plugin in plugins_list:
for method in mandatories_methods:
self.assertTrue(hasattr(stats.get_plugin(plugin), method),
msg='{} has no method {}()'.format(plugin, method))
2016-10-23 22:39:53 +03:00
def test_096_views(self):
"""Test get_views method"""
print('INFO: [TEST_096] Test views')
plugins_list = stats.getPluginsList()
2016-10-23 22:39:53 +03:00
for plugin in plugins_list:
2021-04-20 19:52:02 +03:00
stats.get_plugin(plugin).get_raw()
2016-10-23 22:39:53 +03:00
views_grab = stats.get_plugin(plugin).get_views()
self.assertTrue(type(views_grab) is dict,
msg='{} view is not a dict'.format(plugin))
2016-05-29 20:40:39 +03:00
def test_097_attribute(self):
"""Test GlancesAttribute classe"""
print('INFO: [TEST_097] Test attribute')
# GlancesAttribute
from glances.attribute import GlancesAttribute
a = GlancesAttribute('a', description='ad', history_max_size=3)
self.assertEqual(a.name, 'a')
self.assertEqual(a.description, 'ad')
a.description = 'adn'
self.assertEqual(a.description, 'adn')
a.value = 1
a.value = 2
self.assertEqual(len(a.history), 2)
a.value = 3
self.assertEqual(len(a.history), 3)
a.value = 4
# Check if history_max_size=3 is OK
self.assertEqual(len(a.history), 3)
self.assertEqual(a.history_size(), 3)
self.assertEqual(a.history_len(), 3)
self.assertEqual(a.history_value()[1], 4)
self.assertEqual(a.history_mean(nb=3), 4.5)
def test_098_history(self):
"""Test GlancesHistory classe"""
print('INFO: [TEST_098] Test history')
# GlancesHistory
from glances.history import GlancesHistory
h = GlancesHistory()
h.add('a', 1, history_max_size=100)
h.add('a', 2, history_max_size=100)
h.add('a', 3, history_max_size=100)
h.add('b', 10, history_max_size=100)
h.add('b', 20, history_max_size=100)
h.add('b', 30, history_max_size=100)
2016-05-29 20:40:39 +03:00
self.assertEqual(len(h.get()), 2)
self.assertEqual(len(h.get()['a']), 3)
h.reset()
self.assertEqual(len(h.get()), 2)
self.assertEqual(len(h.get()['a']), 0)
def test_099_output_bars_must_be_between_0_and_100_percent(self):
"""Test quick look plugin.
> bar.min_value
0
> bar.max_value
100
> bar.percent = -1
> bar.percent
0
> bar.percent = 101
> bar.percent
100
"""
2016-05-29 20:40:39 +03:00
print('INFO: [TEST_099] Test progress bar')
bar = Bar(size=1)
bar.percent = -1
self.assertLessEqual(bar.percent, bar.min_value)
bar.percent = 101
self.assertGreaterEqual(bar.percent, bar.max_value)
2021-04-24 17:14:35 +03:00
def test_100_secure(self):
"""Test secure functions"""
print('INFO: [TEST_100] Secure functions')
self.assertEqual(secure_popen('echo -n TEST'), 'TEST')
self.assertEqual(secure_popen('echo FOO | grep FOO'), 'FOO\n')
self.assertEqual(secure_popen('echo -n TEST1 && echo -n TEST2'), 'TEST1TEST2')
2021-04-24 17:14:35 +03:00
2016-05-29 20:40:39 +03:00
def test_999_the_end(self):
"""Free all the stats"""
print('INFO: [TEST_999] Free the stats')
stats.end()
self.assertTrue(True)
2017-04-17 20:24:00 +03:00
2014-05-21 15:48:07 +04:00
if __name__ == '__main__':
unittest.main()