unitest.TestGlances.test_006_swap() - Code Metrics - Inspection of "Merge branch 'master' into develop" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 05aaee...10b5c2 )

by Nicolas

created 2023-05-16 07:38 UTC

unitest.TestGlances.test_006_swap() A

↳ Parent: unitest

Complexity

Conditions

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	8
nop	1
dl	0
loc	11
rs	10
c	0
b	0
f	0

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Glances - An eye on your system
#
# SPDX-FileCopyrightText: 2022 Nicolas Hennion <[email protected]>
#
# SPDX-License-Identifier: LGPL-3.0-only
#

"""Glances unitary tests suite."""

#
# ./venv/bin/python unitest.py
#

import time
import unittest

from glances.main import GlancesMain
from glances.stats import GlancesStats
from glances import __version__
from glances.globals import WINDOWS, LINUX
from glances.outputs.glances_bars import Bar
from glances.thresholds import GlancesThresholdOk
from glances.thresholds import GlancesThresholdCareful
from glances.thresholds import GlancesThresholdWarning
from glances.thresholds import GlancesThresholdCritical
from glances.thresholds import GlancesThresholds
from glances.plugins.glances_plugin import GlancesPlugin
from glances.programs import processes_to_programs
from glances.compat import subsample, range, string_value_to_float
from glances.secure import secure_popen
from glances.compat import PY3

if PY3:
    pass

# Global variables
# =================

# Init Glances core
core = GlancesMain()
test_config = core.get_config()
test_args = core.get_args()

# Init Glances stats
stats = GlancesStats(config=test_config,
                     args=test_args)

# Unitest class
# ==============
print('Unitary tests for Glances %s' % __version__)


class TestGlances(unittest.TestCase):
    """Test Glances class."""

    def setUp(self):
        """The function is called *every time* before test_*."""
        print('\n' + '=' * 78)

    def test_000_update(self):
        """Update stats (mandatory step for all the stats).

        The update is made twice (for rate computation).
        """
        print('INFO: [TEST_000] Test the stats update function')
        try:
            stats.update()
        except Exception as e:
            print('ERROR: Stats update failed: %s' % e)
            self.assertTrue(False)
        time.sleep(1)
        try:
            stats.update()
        except Exception as e:
            print('ERROR: Stats update failed: %s' % e)
            self.assertTrue(False)

        self.assertTrue(True)

    def test_001_plugins(self):
        """Check mandatory plugins."""
        plugins_to_check = ['system', 'cpu', 'load', 'mem', 'memswap', 'network', 'diskio', 'fs']
        print('INFO: [TEST_001] Check the mandatory plugins list: %s' % ', '.join(plugins_to_check))
        plugins_list = stats.getPluginsList()
        for plugin in plugins_to_check:
            self.assertTrue(plugin in plugins_list)

    def test_002_system(self):
        """Check SYSTEM plugin."""
        stats_to_check = ['hostname', 'os_name']
        print('INFO: [TEST_002] Check SYSTEM stats: %s' % ', '.join(stats_to_check))
        stats_grab = stats.get_plugin('system').get_raw()
        for stat in stats_to_check:
            # Check that the key exist
            self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
        print('INFO: SYSTEM stats: %s' % stats_grab)

    def test_003_cpu(self):
        """Check CPU plugin."""
        stats_to_check = ['system', 'user', 'idle']
        print('INFO: [TEST_003] Check mandatory CPU stats: %s' % ', '.join(stats_to_check))
        stats_grab = stats.get_plugin('cpu').get_raw()
        for stat in stats_to_check:
            # Check that the key exist
            self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
            # Check that % is > 0 and < 100
            self.assertGreaterEqual(stats_grab[stat], 0)
            self.assertLessEqual(stats_grab[stat], 100)
        print('INFO: CPU stats: %s' % stats_grab)

    @unittest.skipIf(WINDOWS, "Load average not available on Windows")
    def test_004_load(self):
        """Check LOAD plugin."""
        stats_to_check = ['cpucore', 'min1', 'min5', 'min15']
        print('INFO: [TEST_004] Check LOAD stats: %s' % ', '.join(stats_to_check))
        stats_grab = stats.get_plugin('load').get_raw()
        for stat in stats_to_check:
            # Check that the key exist
            self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
            # Check that % is > 0
            self.assertGreaterEqual(stats_grab[stat], 0)
        print('INFO: LOAD stats: %s' % stats_grab)

    def test_005_mem(self):
        """Check MEM plugin."""
        stats_to_check = ['available', 'used', 'free', 'total']
        print('INFO: [TEST_005] Check MEM stats: %s' % ', '.join(stats_to_check))
        stats_grab = stats.get_plugin('mem').get_raw()
        for stat in stats_to_check:
            # Check that the key exist
            self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
            # Check that % is > 0
            self.assertGreaterEqual(stats_grab[stat], 0)
        print('INFO: MEM stats: %s' % stats_grab)

    def test_006_swap(self):
        """Check MEMSWAP plugin."""
        stats_to_check = ['used', 'free', 'total']
        print('INFO: [TEST_006] Check SWAP stats: %s' % ', '.join(stats_to_check))
        stats_grab = stats.get_plugin('memswap').get_raw()
        for stat in stats_to_check:
            # Check that the key exist
            self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
            # Check that % is > 0
            self.assertGreaterEqual(stats_grab[stat], 0)
        print('INFO: SWAP stats: %s' % stats_grab)

    def test_007_network(self):
        """Check NETWORK plugin."""
        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')
        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."""
        # stats_to_check = [ ]
        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."""
        # stats_to_check = [ ]
        print('INFO: [TEST_010] Check PROCESS stats')
        stats_grab = stats.get_plugin('processcount').get_raw()
        # total = stats_grab['total']
        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))

    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)

    @unittest.skipIf(not LINUX, "IRQs available only on Linux")
    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)

    @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")

    def test_015_subsample(self):
        """Test subsampling function."""
        print('INFO: [TEST_015] Subsampling')
        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])

    def test_016_hddsmart(self):
        """Check hard disk SMART data plugin."""
        try:
            from glances.compat import is_admin
        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
        elif stats_grab == {}:
            print("INFO: Admin but SMART list is empty")
            assert len(stats_grab) == 0
        else:
            print(stats_grab)
            self.assertTrue(stat in stats_grab[0].keys(), msg='Cannot find key: %s' % stat)

        print('INFO: SMART stats: %s' % stats_grab)

    def test_017_programs(self):
        """Check Programs function (it's not a plugin)."""
        # stats_to_check = [ ]
        print('INFO: [TEST_017] Check PROGRAM stats')
        stats_grab = processes_to_programs(stats.get_plugin('processlist').get_raw())
        self.assertTrue(type(stats_grab) is list, msg='Programs stats is not a list')
        print('INFO: PROGRAM 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))

    def test_018_string_value_to_float(self):
        """Check string_value_to_float function"""
        print('INFO: [TEST_018] Check string_value_to_float function')
        self.assertEqual(string_value_to_float('32kB'), 32000.0)
        self.assertEqual(string_value_to_float('32 KB'), 32000.0)
        self.assertEqual(string_value_to_float('15.5MB'), 15500000.0)
        self.assertEqual(string_value_to_float('25.9'), 25.9)
        self.assertEqual(string_value_to_float('12'), 12)
        self.assertEqual(string_value_to_float('--'), None)

    def test_094_thresholds(self):
        """Test thresholds classes"""
        print('INFO: [TEST_094] Thresholds')
        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')
        thresholds = GlancesThresholds()
        thresholds.add('cpu_percent', 'OK')
        self.assertEqual(thresholds.get(stat_name='cpu_percent').description(), 'OK')

    def test_095_methods(self):
        """Test mandatories methods"""
        print('INFO: [TEST_095] Mandatories methods')
        mandatories_methods = ['reset', 'update']
        plugins_list = stats.getPluginsList()
        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))

    def test_096_views(self):
        """Test get_views method"""
        print('INFO: [TEST_096] Test views')
        plugins_list = stats.getPluginsList()
        for plugin in plugins_list:
            stats.get_plugin(plugin).get_raw()
            views_grab = stats.get_plugin(plugin).get_views()
            self.assertTrue(type(views_grab) is dict,
                            msg='{} view is not a dict'.format(plugin))

    def test_097_attribute(self):
        """Test GlancesAttribute classes"""
        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 classes"""
        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)
        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
        """
        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)

    def test_100_secure(self):
        """Test secure functions"""
        print('INFO: [TEST_100] Secure functions')
        if WINDOWS:
            self.assertEqual(secure_popen('echo TEST'), 'TEST\r\n')
            self.assertEqual(secure_popen('echo TEST1 && echo TEST2'), 'TEST1\r\nTEST2\r\n')
        else:
            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')

    def test_200_memory_leak(self):
        """Memory leak check"""
        # Only available in PY3
        if not PY3:
            return
        import tracemalloc
        print('INFO: [TEST_200] Memory leak check')
        tracemalloc.start()
        # 3 iterations just to init the stats and fill the memory
        for _ in range(3):
            stats.update()

        # Start the memory leak check
        snapshot_begin = tracemalloc.take_snapshot()
        for _ in range(3):
            stats.update()
        snapshot_end = tracemalloc.take_snapshot()
        snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
        memory_leak = sum([s.size_diff for s in snapshot_diff])
        print('INFO: Memory leak: {} bytes'.format(memory_leak))

        # snapshot_begin = tracemalloc.take_snapshot()
        for _ in range(30):
            stats.update()
        snapshot_end = tracemalloc.take_snapshot()
        snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
        memory_leak = sum([s.size_diff for s in snapshot_diff])
        print('INFO: Memory leak: {} bytes'.format(memory_leak))

        # snapshot_begin = tracemalloc.take_snapshot()
        for _ in range(300):
            stats.update()
        snapshot_end = tracemalloc.take_snapshot()
        snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
        memory_leak = sum([s.size_diff for s in snapshot_diff])
        print('INFO: Memory leak: {} bytes'.format(memory_leak))
        snapshot_top = snapshot_end.compare_to(snapshot_begin, 'traceback')
        print("Memory consumption (top 5):")
        for stat in snapshot_top[:5]:
            print(stat)
            for line in stat.traceback.format():
                print(line)

    def test_999_the_end(self):
        """Free all the stats"""
        print('INFO: [TEST_999] Free the stats')
        stats.end()
        self.assertTrue(True)


if __name__ == '__main__':
    unittest.main()


1			#!/usr/bin/env python
2			# -- coding: utf-8 --
3			#
4			# Glances - An eye on your system
5			#
6			# SPDX-FileCopyrightText: 2022 Nicolas Hennion <[email protected]>
7			#
8			# SPDX-License-Identifier: LGPL-3.0-only
9			#
10
11			"""Glances unitary tests suite."""
12
13			#
14			# ./venv/bin/python unitest.py
15			#
16
17			import time
18			import unittest
19
20			from glances.main import GlancesMain
21			from glances.stats import GlancesStats
22			from glances import __version__
23			from glances.globals import WINDOWS, LINUX
24			from glances.outputs.glances_bars import Bar
25			from glances.thresholds import GlancesThresholdOk
26			from glances.thresholds import GlancesThresholdCareful
27			from glances.thresholds import GlancesThresholdWarning
28			from glances.thresholds import GlancesThresholdCritical
29			from glances.thresholds import GlancesThresholds
30			from glances.plugins.glances_plugin import GlancesPlugin
31			from glances.programs import processes_to_programs
32			from glances.compat import subsample, range, string_value_to_float
33			from glances.secure import secure_popen
34			from glances.compat import PY3
35
36			if PY3:
37			pass
38
39			# Global variables
40			# =================
41
42			# Init Glances core
43			core = GlancesMain()
44			test_config = core.get_config()
45			test_args = core.get_args()
46
47			# Init Glances stats
48			stats = GlancesStats(config=test_config,
49			args=test_args)
50
51			# Unitest class
52			# ==============
53			print('Unitary tests for Glances %s' % __version__)
54
55
56			class TestGlances(unittest.TestCase):
57			"""Test Glances class."""
58
59			def setUp(self):
60			"""The function is called every time before test_*."""
61			print('\n' + '=' * 78)
62
63			def test_000_update(self):
64			"""Update stats (mandatory step for all the stats).
65
66			The update is made twice (for rate computation).
67			"""
68			print('INFO: [TEST_000] Test the stats update function')
69			try:
70			stats.update()
71			except Exception as e:
72			print('ERROR: Stats update failed: %s' % e)
73			self.assertTrue(False)
74			time.sleep(1)
75			try:
76			stats.update()
77			except Exception as e:
78			print('ERROR: Stats update failed: %s' % e)
79			self.assertTrue(False)
80
81			self.assertTrue(True)
82
83			def test_001_plugins(self):
84			"""Check mandatory plugins."""
85			plugins_to_check = ['system', 'cpu', 'load', 'mem', 'memswap', 'network', 'diskio', 'fs']
86			print('INFO: [TEST_001] Check the mandatory plugins list: %s' % ', '.join(plugins_to_check))
87			plugins_list = stats.getPluginsList()
88			for plugin in plugins_to_check:
89			self.assertTrue(plugin in plugins_list)
90
91			def test_002_system(self):
92			"""Check SYSTEM plugin."""
93			stats_to_check = ['hostname', 'os_name']
94			print('INFO: [TEST_002] Check SYSTEM stats: %s' % ', '.join(stats_to_check))
95			stats_grab = stats.get_plugin('system').get_raw()
96			for stat in stats_to_check:
97			# Check that the key exist
98			self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
99			print('INFO: SYSTEM stats: %s' % stats_grab)
100
101			def test_003_cpu(self):
102			"""Check CPU plugin."""
103			stats_to_check = ['system', 'user', 'idle']
104			print('INFO: [TEST_003] Check mandatory CPU stats: %s' % ', '.join(stats_to_check))
105			stats_grab = stats.get_plugin('cpu').get_raw()
106			for stat in stats_to_check:
107			# Check that the key exist
108			self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
109			# Check that % is > 0 and < 100
110			self.assertGreaterEqual(stats_grab[stat], 0)
111			self.assertLessEqual(stats_grab[stat], 100)
112			print('INFO: CPU stats: %s' % stats_grab)
113
114			@unittest.skipIf(WINDOWS, "Load average not available on Windows")
115			def test_004_load(self):
116			"""Check LOAD plugin."""
117			stats_to_check = ['cpucore', 'min1', 'min5', 'min15']
118			print('INFO: [TEST_004] Check LOAD stats: %s' % ', '.join(stats_to_check))
119			stats_grab = stats.get_plugin('load').get_raw()
120			for stat in stats_to_check:
121			# Check that the key exist
122			self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
123			# Check that % is > 0
124			self.assertGreaterEqual(stats_grab[stat], 0)
125			print('INFO: LOAD stats: %s' % stats_grab)
126
127			def test_005_mem(self):
128			"""Check MEM plugin."""
129			stats_to_check = ['available', 'used', 'free', 'total']
130			print('INFO: [TEST_005] Check MEM stats: %s' % ', '.join(stats_to_check))
131			stats_grab = stats.get_plugin('mem').get_raw()
132			for stat in stats_to_check:
133			# Check that the key exist
134			self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
135			# Check that % is > 0
136			self.assertGreaterEqual(stats_grab[stat], 0)
137			print('INFO: MEM stats: %s' % stats_grab)
138
139			def test_006_swap(self):
140			"""Check MEMSWAP plugin."""
141			stats_to_check = ['used', 'free', 'total']
142			print('INFO: [TEST_006] Check SWAP stats: %s' % ', '.join(stats_to_check))
143			stats_grab = stats.get_plugin('memswap').get_raw()
144			for stat in stats_to_check:
145			# Check that the key exist
146			self.assertTrue(stat in stats_grab, msg='Cannot find key: %s' % stat)
147			# Check that % is > 0
148			self.assertGreaterEqual(stats_grab[stat], 0)
149			print('INFO: SWAP stats: %s' % stats_grab)
150
151			def test_007_network(self):
152			"""Check NETWORK plugin."""
153			print('INFO: [TEST_007] Check NETWORK stats')
154			stats_grab = stats.get_plugin('network').get_raw()
155			self.assertTrue(type(stats_grab) is list, msg='Network stats is not a list')
156			print('INFO: NETWORK stats: %s' % stats_grab)
157
158			def test_008_diskio(self):
159			"""Check DISKIO plugin."""
160			print('INFO: [TEST_008] Check DISKIO stats')
161			stats_grab = stats.get_plugin('diskio').get_raw()
162			self.assertTrue(type(stats_grab) is list, msg='DiskIO stats is not a list')
163			print('INFO: diskio stats: %s' % stats_grab)
164
165			def test_009_fs(self):
166			"""Check File System plugin."""
167			# stats_to_check = [ ]
168			print('INFO: [TEST_009] Check FS stats')
169			stats_grab = stats.get_plugin('fs').get_raw()
170			self.assertTrue(type(stats_grab) is list, msg='FileSystem stats is not a list')
171			print('INFO: FS stats: %s' % stats_grab)
172
173			def test_010_processes(self):
174			"""Check Process plugin."""
175			# stats_to_check = [ ]
176			print('INFO: [TEST_010] Check PROCESS stats')
177			stats_grab = stats.get_plugin('processcount').get_raw()
178			# total = stats_grab['total']
179			self.assertTrue(type(stats_grab) is dict, msg='Process count stats is not a dict')
180			print('INFO: PROCESS count stats: %s' % stats_grab)
181			stats_grab = stats.get_plugin('processlist').get_raw()
182			self.assertTrue(type(stats_grab) is list, msg='Process count stats is not a list')
183			print('INFO: PROCESS list stats: %s items in the list' % len(stats_grab))
184			# Check if number of processes in the list equal counter
185			# self.assertEqual(total, len(stats_grab))
186
187			def test_011_folders(self):
188			"""Check File System plugin."""
189			# stats_to_check = [ ]
190			print('INFO: [TEST_011] Check FOLDER stats')
191			stats_grab = stats.get_plugin('folders').get_raw()
192			self.assertTrue(type(stats_grab) is list, msg='Folders stats is not a list')
193			print('INFO: Folders stats: %s' % stats_grab)
194
195			def test_012_ip(self):
196			"""Check IP plugin."""
197			print('INFO: [TEST_012] Check IP stats')
198			stats_grab = stats.get_plugin('ip').get_raw()
199			self.assertTrue(type(stats_grab) is dict, msg='IP stats is not a dict')
200			print('INFO: IP stats: %s' % stats_grab)
201
202			@unittest.skipIf(not LINUX, "IRQs available only on Linux")
203			def test_013_irq(self):
204			"""Check IRQ plugin."""
205			print('INFO: [TEST_013] Check IRQ stats')
206			stats_grab = stats.get_plugin('irq').get_raw()
207			self.assertTrue(type(stats_grab) is list, msg='IRQ stats is not a list')
208			print('INFO: IRQ stats: %s' % stats_grab)
209
210			@unittest.skipIf(not LINUX, "GPU available only on Linux")
211			def test_013_gpu(self):
212			"""Check GPU plugin."""
213			print('INFO: [TEST_014] Check GPU stats')
214			stats_grab = stats.get_plugin('gpu').get_raw()
215			self.assertTrue(type(stats_grab) is list, msg='GPU stats is not a list')
216			print('INFO: GPU stats: %s' % stats_grab)
217
218			def test_014_sorted_stats(self):
219			"""Check sorted stats method."""
220			print('INFO: [TEST_015] Check sorted stats method')
221			aliases = {
222			"key2": "alias11",
223			"key5": "alias2",
224			}
225			unsorted_stats = [
226			{"key": "key4"},
227			{"key": "key2"},
228			{"key": "key5"},
229			{"key": "key21"},
230			{"key": "key3"},
231			]
232
233			gp = GlancesPlugin()
234			gp.get_key = lambda: "key"
235			gp.has_alias = aliases.get
236			gp.stats = unsorted_stats
237
238			sorted_stats = gp.sorted_stats()
239			self.assertEqual(len(sorted_stats), 5)
240			self.assertEqual(sorted_stats[0]["key"], "key5")
241			self.assertEqual(sorted_stats[1]["key"], "key2")
242			self.assertEqual(sorted_stats[2]["key"], "key3")
243			self.assertEqual(sorted_stats[3]["key"], "key4")
244			self.assertEqual(sorted_stats[4]["key"], "key21")
245
246			def test_015_subsample(self):
247			"""Test subsampling function."""
248			print('INFO: [TEST_015] Subsampling')
249			for l_test in [([1, 2, 3], 4),
250			([1, 2, 3, 4], 4),
251			([1, 2, 3, 4, 5, 6, 7], 4),
252			([1, 2, 3, 4, 5, 6, 7, 8], 4),
253			(list(range(1, 800)), 4),
254			(list(range(1, 8000)), 800)]:
255			l_subsample = subsample(l_test[0], l_test[1])
256			self.assertLessEqual(len(l_subsample), l_test[1])
257
258			def test_016_hddsmart(self):
259			"""Check hard disk SMART data plugin."""
260			try:
261			from glances.compat import is_admin
262			except ImportError:
263			print("INFO: [TEST_016] pySMART not found, not running SMART plugin test")
264			return
265
266			stat = 'DeviceName'
267			print('INFO: [TEST_016] Check SMART stats: {}'.format(stat))
268			stats_grab = stats.get_plugin('smart').get_raw()
269			if not is_admin():
270			print("INFO: Not admin, SMART list should be empty")
271			assert len(stats_grab) == 0
272			elif stats_grab == {}:
273			print("INFO: Admin but SMART list is empty")
274			assert len(stats_grab) == 0
275			else:
276			print(stats_grab)
277			self.assertTrue(stat in stats_grab[0].keys(), msg='Cannot find key: %s' % stat)
278
279			print('INFO: SMART stats: %s' % stats_grab)
280
281			def test_017_programs(self):
282			"""Check Programs function (it's not a plugin)."""
283			# stats_to_check = [ ]
284			print('INFO: [TEST_017] Check PROGRAM stats')
285			stats_grab = processes_to_programs(stats.get_plugin('processlist').get_raw())
286			self.assertTrue(type(stats_grab) is list, msg='Programs stats is not a list')
287			print('INFO: PROGRAM list stats: %s items in the list' % len(stats_grab))
288			# Check if number of processes in the list equal counter
289			# self.assertEqual(total, len(stats_grab))
290
291			def test_018_string_value_to_float(self):
292			"""Check string_value_to_float function"""
293			print('INFO: [TEST_018] Check string_value_to_float function')
294			self.assertEqual(string_value_to_float('32kB'), 32000.0)
295			self.assertEqual(string_value_to_float('32 KB'), 32000.0)
296			self.assertEqual(string_value_to_float('15.5MB'), 15500000.0)
297			self.assertEqual(string_value_to_float('25.9'), 25.9)
298			self.assertEqual(string_value_to_float('12'), 12)
299			self.assertEqual(string_value_to_float('--'), None)
300
301			def test_094_thresholds(self):
302			"""Test thresholds classes"""
303			print('INFO: [TEST_094] Thresholds')
304			ok = GlancesThresholdOk()
305			careful = GlancesThresholdCareful()
306			warning = GlancesThresholdWarning()
307			critical = GlancesThresholdCritical()
308			self.assertTrue(ok < careful)
309			self.assertTrue(careful < warning)
310			self.assertTrue(warning < critical)
311			self.assertFalse(ok > careful)
312			self.assertEqual(ok, ok)
313			self.assertEqual(str(ok), 'OK')
314			thresholds = GlancesThresholds()
315			thresholds.add('cpu_percent', 'OK')
316			self.assertEqual(thresholds.get(stat_name='cpu_percent').description(), 'OK')
317
318			def test_095_methods(self):
319			"""Test mandatories methods"""
320			print('INFO: [TEST_095] Mandatories methods')
321			mandatories_methods = ['reset', 'update']
322			plugins_list = stats.getPluginsList()
323			for plugin in plugins_list:
324			for method in mandatories_methods:
325			self.assertTrue(hasattr(stats.get_plugin(plugin), method),
326			msg='{} has no method {}()'.format(plugin, method))
327
328			def test_096_views(self):
329			"""Test get_views method"""
330			print('INFO: [TEST_096] Test views')
331			plugins_list = stats.getPluginsList()
332			for plugin in plugins_list:
333			stats.get_plugin(plugin).get_raw()
334			views_grab = stats.get_plugin(plugin).get_views()
335			self.assertTrue(type(views_grab) is dict,
336			msg='{} view is not a dict'.format(plugin))
337
338			def test_097_attribute(self):
339			"""Test GlancesAttribute classes"""
340			print('INFO: [TEST_097] Test attribute')
341			# GlancesAttribute
342			from glances.attribute import GlancesAttribute
343			a = GlancesAttribute('a', description='ad', history_max_size=3)
344			self.assertEqual(a.name, 'a')
345			self.assertEqual(a.description, 'ad')
346			a.description = 'adn'
347			self.assertEqual(a.description, 'adn')
348			a.value = 1
349			a.value = 2
350			self.assertEqual(len(a.history), 2)
351			a.value = 3
352			self.assertEqual(len(a.history), 3)
353			a.value = 4
354			# Check if history_max_size=3 is OK
355			self.assertEqual(len(a.history), 3)
356			self.assertEqual(a.history_size(), 3)
357			self.assertEqual(a.history_len(), 3)
358			self.assertEqual(a.history_value()[1], 4)
359			self.assertEqual(a.history_mean(nb=3), 4.5)
360
361			def test_098_history(self):
362			"""Test GlancesHistory classes"""
363			print('INFO: [TEST_098] Test history')
364			# GlancesHistory
365			from glances.history import GlancesHistory
366			h = GlancesHistory()
367			h.add('a', 1, history_max_size=100)
368			h.add('a', 2, history_max_size=100)
369			h.add('a', 3, history_max_size=100)
370			h.add('b', 10, history_max_size=100)
371			h.add('b', 20, history_max_size=100)
372			h.add('b', 30, history_max_size=100)
373			self.assertEqual(len(h.get()), 2)
374			self.assertEqual(len(h.get()['a']), 3)
375			h.reset()
376			self.assertEqual(len(h.get()), 2)
377			self.assertEqual(len(h.get()['a']), 0)
378
379			def test_099_output_bars_must_be_between_0_and_100_percent(self):
380			"""Test quick look plugin.
381
382			> bar.min_value
383			0
384			> bar.max_value
385			100
386			> bar.percent = -1
387			> bar.percent
388			0
389			> bar.percent = 101
390			> bar.percent
391			100
392			"""
393			print('INFO: [TEST_099] Test progress bar')
394			bar = Bar(size=1)
395			bar.percent = -1
396			self.assertLessEqual(bar.percent, bar.min_value)
397			bar.percent = 101
398			self.assertGreaterEqual(bar.percent, bar.max_value)
399
400			def test_100_secure(self):
401			"""Test secure functions"""
402			print('INFO: [TEST_100] Secure functions')
403			if WINDOWS:
404			self.assertEqual(secure_popen('echo TEST'), 'TEST\r\n')
405			self.assertEqual(secure_popen('echo TEST1 && echo TEST2'), 'TEST1\r\nTEST2\r\n')
406			else:
407			self.assertEqual(secure_popen('echo -n TEST'), 'TEST')
408			self.assertEqual(secure_popen('echo FOO \| grep FOO'), 'FOO\n')
409			self.assertEqual(secure_popen('echo -n TEST1 && echo -n TEST2'), 'TEST1TEST2')
410
411			def test_200_memory_leak(self):
412			"""Memory leak check"""
413			# Only available in PY3
414			if not PY3:
415			return
416			import tracemalloc
417			print('INFO: [TEST_200] Memory leak check')
418			tracemalloc.start()
419			# 3 iterations just to init the stats and fill the memory
420			for _ in range(3):
421			stats.update()
422
423			# Start the memory leak check
424			snapshot_begin = tracemalloc.take_snapshot()
425			for _ in range(3):
426			stats.update()
427			snapshot_end = tracemalloc.take_snapshot()
428			snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
429			memory_leak = sum([s.size_diff for s in snapshot_diff])
430			print('INFO: Memory leak: {} bytes'.format(memory_leak))
431
432			# snapshot_begin = tracemalloc.take_snapshot()
433			for _ in range(30):
434			stats.update()
435			snapshot_end = tracemalloc.take_snapshot()
436			snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
437			memory_leak = sum([s.size_diff for s in snapshot_diff])
438			print('INFO: Memory leak: {} bytes'.format(memory_leak))
439
440			# snapshot_begin = tracemalloc.take_snapshot()
441			for _ in range(300):
442			stats.update()
443			snapshot_end = tracemalloc.take_snapshot()
444			snapshot_diff = snapshot_end.compare_to(snapshot_begin, 'filename')
445			memory_leak = sum([s.size_diff for s in snapshot_diff])
446			print('INFO: Memory leak: {} bytes'.format(memory_leak))
447			snapshot_top = snapshot_end.compare_to(snapshot_begin, 'traceback')
448			print("Memory consumption (top 5):")
449			for stat in snapshot_top[:5]:
450			print(stat)
451			for line in stat.traceback.format():
452			print(line)
453
454			def test_999_the_end(self):
455			"""Free all the stats"""
456			print('INFO: [TEST_999] Free the stats')
457			stats.end()
458			self.assertTrue(True)
459
460
461			if __name__ == '__main__':
462			unittest.main()
463

nicolargo / glances

Push — master ( 05aaee...10b5c2 )

unitest.TestGlances.test_006_swap() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like