← Back to branch summary

~ahasenack/landscape-client/landscape-client-1.5.5-0ubuntu0.9.04.0

« back to all changes in this revision

Viewing changes to landscape/sysinfo/tests/test_disk.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080908163557-l3ixzj5dxz37wnw2
Tags: 1.0.18-0ubuntu1
New upstream release 

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/sysinfo/tests/test_disk.py
 
1
from twisted.internet.defer import Deferred
 
2
 
 
3
from landscape.sysinfo.sysinfo import SysInfoPluginRegistry
 
4
from landscape.sysinfo.disk import Disk, format_megabytes
 
5
from landscape.tests.helpers import LandscapeTest
 
6
 
 
7
class DiskTest(LandscapeTest):
 
8
 
 
9
    def setUp(self):
 
10
        super(DiskTest, self).setUp()
 
11
        self.mount_file = self.make_path("")
 
12
        self.stat_results = {}
 
13
 
 
14
        self.disk = Disk(mounts_file=self.mount_file,
 
15
                         statvfs=self.stat_results.get)
 
16
        self.sysinfo = SysInfoPluginRegistry()
 
17
        self.sysinfo.add(self.disk)
 
18
 
 
19
    def add_mount(self, point, block_size=4096, capacity=1000, unused=1000,
 
20
                  fs="ext3", device=None):
 
21
        if device is None:
 
22
            device = "/dev/" + point.replace("/", "_")
 
23
        self.stat_results[point] = (block_size, 0, capacity, unused,
 
24
                                    0, 0, 0, 0, 0)
 
25
        f = open(self.mount_file, "a")
 
26
        f.write("/dev/%s %s %s rw 0 0\n" % (device, point, fs))
 
27
        f.close()
 
28
 
 
29
    def test_run_returns_succeeded_deferred(self):
 
30
        self.add_mount("/")
 
31
        result = self.disk.run()
 
32
        self.assertTrue(isinstance(result, Deferred))
 
33
        called = []
 
34
        def callback(result):
 
35
            called.append(True)
 
36
        result.addCallback(callback)
 
37
        self.assertTrue(called)
 
38
 
 
39
    def test_everything_is_cool(self):
 
40
        self.add_mount("/")
 
41
        self.disk.run()
 
42
        self.assertEquals(self.sysinfo.get_notes(), [])
 
43
 
 
44
    def test_zero_total_space(self):
 
45
        """
 
46
        When the total space for a mount is 0, the plugin shouldn't flip out
 
47
        and kill everybody.
 
48
 
 
49
        This is a regression test for a ZeroDivisionError!
 
50
        """
 
51
        self.add_mount("/sys", capacity=0, unused=0)
 
52
        self.add_mount("/")
 
53
        self.disk.run()
 
54
        self.assertEquals(self.sysinfo.get_notes(), [])
 
55
 
 
56
    def test_over_85_percent(self):
 
57
        """
 
58
        When a filesystem is using more than 85% capacity, a note will be
 
59
        displayed.
 
60
        """
 
61
        self.add_mount("/", capacity=1000000, unused=150000)
 
62
        self.disk.run()
 
63
        self.assertEquals(self.sysinfo.get_notes(),
 
64
                          ["/ is using 85.0% of 3.81GB"])
 
65
 
 
66
    def test_under_85_percent(self):
 
67
        """No note is displayed for a filesystem using less than 85% capacity.
 
68
        """
 
69
        self.add_mount("/", block_size=1024, capacity=1000000, unused=151000)
 
70
        self.disk.run()
 
71
        self.assertEquals(self.sysinfo.get_notes(), [])
 
72
 
 
73
    def test_multiple_notes(self):
 
74
        """
 
75
        A note will be displayed for each filesystem using 85% or more capacity.
 
76
        """
 
77
        self.add_mount("/", block_size=1024, capacity=1000000, unused=150000)
 
78
        self.add_mount("/use", block_size=2048, capacity=2000000, unused=200000)
 
79
        self.add_mount("/emp", block_size=4096, capacity=3000000, unused=460000)
 
80
        self.disk.run()
 
81
        self.assertEquals(self.sysinfo.get_notes(),
 
82
                          ["/ is using 85.0% of 976MB",
 
83
                           "/use is using 90.0% of 3.81GB"])
 
84
 
 
85
    def test_format_megabytes(self):
 
86
        self.assertEquals(format_megabytes(100), "100MB")
 
87
        self.assertEquals(format_megabytes(1023), "1023MB")
 
88
        self.assertEquals(format_megabytes(1024), "1.00GB")
 
89
        self.assertEquals(format_megabytes(1024*1024-1), "1024.00GB")
 
90
        self.assertEquals(format_megabytes(1024*1024), "1.00TB")
 
91
 
 
92
    def test_header(self):
 
93
        """
 
94
        A header is printed with usage for the 'primary' filesystem, where
 
95
        'primary' means 'filesystem that has /home on it'.
 
96
        """
 
97
        self.add_mount("/")
 
98
        self.add_mount("/home", capacity=1024, unused=512)
 
99
        self.disk.run()
 
100
        self.assertEquals(self.sysinfo.get_headers(),
 
101
                          [("Usage of /home", "50.0% of 4MB")])
 
102
 
 
103
    def test_header_shows_actual_filesystem(self):
 
104
        """
 
105
        If /home isn't on its own filesystem, the header will show whatever
 
106
        filesystem it's a part of.
 
107
        """
 
108
        self.add_mount("/", capacity=1024, unused=512)
 
109
        self.disk.run()
 
110
        self.assertEquals(self.sysinfo.get_headers(),
 
111
                          [("Usage of /", "50.0% of 4MB")])
 
112
 
 
113
    def test_ignore_optical_drives(self):
 
114
        """
 
115
        Optical drives (those with filesystems of udf or iso9660) should be
 
116
        ignored.
 
117
        """
 
118
        self.add_mount("/", capacity=1000, unused=1000, fs="ext3")
 
119
        self.add_mount("/media/dvdrom", capacity=1000, unused=0, fs="udf")
 
120
        self.add_mount("/media/cdrom", capacity=1000, unused=0, fs="iso9660")
 
121
        self.disk.run()
 
122
        self.assertEquals(self.sysinfo.get_notes(), [])
 
123
 
 
124
    def test_no_duplicate_roots(self):
 
125
        self.add_mount("/", capacity=0, unused=0, fs="rootfs")
 
126
        self.add_mount("/", capacity=1000, unused=1, fs="ext3")
 
127
        self.disk.run()
 
128
        self.assertEquals(self.sysinfo.get_notes(),
 
129
                          ["/ is using 100.0% of 3MB"])
 
130
 
 
131
    def test_no_duplicate_devices(self):
 
132
        self.add_mount("/", capacity=1000, unused=1, device="/dev/horgle")
 
133
        self.add_mount("/dev/.static/dev", capacity=1000, unused=1,
 
134
                       device="/dev/horgle")
 
135
        self.disk.run()
 
136
        self.assertEquals(self.sysinfo.get_notes(),
 
137
                          ["/ is using 100.0% of 3MB"])
 
138
 
 
139
    def test_shorter_mount_point_in_case_of_duplicate_devices(self):
 
140
        self.add_mount("/dev/.static/dev", capacity=1000, unused=1,
 
141
                       device="/dev/horgle")
 
142
        self.add_mount("/", capacity=1000, unused=1, device="/dev/horgle")
 
143
        self.disk.run()
 
144
        self.assertEquals(self.sysinfo.get_notes(),
 
145
                          ["/ is using 100.0% of 3MB"])
 
146
 
 
147
    def test_shorter_not_lexical(self):
 
148
        """
 
149
        This is a test for a fix for a regression, because I accidentally took
 
150
        the lexically "smallest" mount point instead of the shortest one.
 
151
        """
 
152
        self.add_mount("/")
 
153
        self.add_mount("/abc", capacity=1000, unused=1, device="/dev/horgle")
 
154
        self.add_mount("/b", capacity=1000, unused=1, device="/dev/horgle")
 
155
        self.disk.run()
 
156
        self.assertEquals(self.sysinfo.get_notes(),
 
157
                          ["/b is using 100.0% of 3MB"])