unitest.TestGlances.test_200_memory_leak() - Code Metrics - Inspection of "Update release note for Glances 3.2.5" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 7e7379...128504 )

by Nicolas

created 2022-04-10 14:14 UTC

unitest.TestGlances.test_200_memory_leak() B

↳ Parent: unitest

Complexity

Conditions

Size

Total Lines	42
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
eloc	33
nop	1
dl	0
loc	42
rs	7.2213
c	0
b	0
f	0

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Glances - An eye on your system
#
# Copyright (C) 2019 Nicolargo <[email protected]>
#
# 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."""

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
from glances.secure import secure_popen
from glances.compat import PY3

if PY3:
    from tracemalloc import Snapshot

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

nicolargo / glances

Push — master ( 7e7379...128504 )

unitest.TestGlances.test_200_memory_leak() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like