← Back to branch summary

~free.ekanayaka/landscape-client/lucid-1.5.0-0ubuntu0.10.04.0

« back to all changes in this revision

Viewing changes to landscape/lib/tests/test_sysstats.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/lib/tests/test_sysstats.py
 
1
import os
 
2
import re
 
3
 
 
4
from landscape.lib.sysstats import (
 
5
    MemoryStats, CommandError, get_logged_in_users, get_thermal_zones)
 
6
from landscape.tests.helpers import (
 
7
    LandscapeTest, MakePathHelper, EnvironSaverHelper)
 
8
 
 
9
 
 
10
SAMPLE_MEMORY_INFO = """
 
11
MemTotal:      1546436 kB
 
12
MemFree:         23452 kB
 
13
Buffers:         41656 kB
 
14
Cached:         807628 kB
 
15
SwapCached:      17572 kB
 
16
Active:        1030792 kB
 
17
Inactive:       426892 kB
 
18
HighTotal:           0 kB
 
19
HighFree:            0 kB
 
20
LowTotal:      1546436 kB
 
21
LowFree:         23452 kB
 
22
SwapTotal:     1622524 kB
 
23
SwapFree:      1604936 kB
 
24
Dirty:            1956 kB
 
25
Writeback:           0 kB
 
26
Mapped:         661772 kB
 
27
Slab:            54980 kB
 
28
CommitLimit:   2395740 kB
 
29
Committed_AS:  1566888 kB
 
30
PageTables:       2728 kB
 
31
VmallocTotal:   516088 kB
 
32
VmallocUsed:      5660 kB
 
33
VmallocChunk:   510252 kB
 
34
"""
 
35
 
 
36
 
 
37
class MemoryStatsTest(LandscapeTest):
 
38
 
 
39
    helpers = [MakePathHelper]
 
40
 
 
41
    def test_get_memory_info(self):
 
42
        filename = self.make_path(SAMPLE_MEMORY_INFO)
 
43
        memstats = MemoryStats(filename)
 
44
        self.assertEquals(memstats.total_memory, 1510)
 
45
        self.assertEquals(memstats.free_memory, 503)
 
46
        self.assertEquals(memstats.used_memory, 1007)
 
47
        self.assertEquals(memstats.total_swap, 1584)
 
48
        self.assertEquals(memstats.free_swap, 1567)
 
49
        self.assertEquals(memstats.used_swap, 17)
 
50
        self.assertEquals("%.2f" % memstats.free_memory_percentage, "33.31")
 
51
        self.assertEquals("%.2f" % memstats.free_swap_percentage, "98.93")
 
52
        self.assertEquals("%.2f" % memstats.used_memory_percentage, "66.69")
 
53
        self.assertEquals("%.2f" % memstats.used_swap_percentage, "1.07")
 
54
 
 
55
    def test_get_memory_info_without_swap(self):
 
56
        sample = re.subn(r"Swap(Free|Total): *\d+ kB", r"Swap\1:       0",
 
57
                         SAMPLE_MEMORY_INFO)[0]
 
58
        filename = self.make_path(sample)
 
59
        memstats = MemoryStats(filename)
 
60
        self.assertEquals(memstats.total_swap, 0)
 
61
        self.assertEquals(memstats.free_swap, 0)
 
62
        self.assertEquals(memstats.used_swap, 0)
 
63
        self.assertEquals(memstats.used_swap_percentage, 0)
 
64
        self.assertEquals(memstats.free_swap_percentage, 0)
 
65
        self.assertEquals(type(memstats.used_swap_percentage), float)
 
66
        self.assertEquals(type(memstats.free_swap_percentage), float)
 
67
 
 
68
 
 
69
class FakeWhoQTest(LandscapeTest):
 
70
 
 
71
    helpers = [EnvironSaverHelper]
 
72
 
 
73
    def fake_who(self, users):
 
74
        dirname = self.makeDir() 
 
75
        os.environ["PATH"] = "%s:%s" % (dirname, os.environ["PATH"])
 
76
 
 
77
        self.who_path = os.path.join(dirname, "who")
 
78
        who = open(self.who_path, "w")
 
79
        who.write("#!/bin/sh\n")
 
80
        who.write("test x$1 = x-q || echo missing-parameter\n")
 
81
        who.write("echo %s\n" % users)
 
82
        who.write("echo '# users=%d'\n" % len(users.split()))
 
83
        who.close()
 
84
 
 
85
        os.chmod(self.who_path, 0770)
 
86
 
 
87
 
 
88
class LoggedInUsersTest(FakeWhoQTest):
 
89
 
 
90
    def test_one_user(self):
 
91
        self.fake_who("joe")
 
92
        result = get_logged_in_users()
 
93
        result.addCallback(self.assertEquals, ["joe"])
 
94
        return result
 
95
 
 
96
    def test_one_user_multiple_times(self):
 
97
        self.fake_who("joe joe joe joe")
 
98
        result = get_logged_in_users()
 
99
        result.addCallback(self.assertEquals, ["joe"])
 
100
        return result
 
101
 
 
102
    def test_many_users(self):
 
103
        self.fake_who("joe moe boe doe")
 
104
        result = get_logged_in_users()
 
105
        result.addCallback(self.assertEquals, ["boe", "doe", "joe", "moe"])
 
106
        return result
 
107
 
 
108
    def test_command_error(self):
 
109
        self.fake_who("")
 
110
        who = open(self.who_path, "w")
 
111
        who.write("#!/bin/sh\necho ERROR 1>&2\nexit 1\n")
 
112
        who.close()
 
113
        result = get_logged_in_users()
 
114
        def assert_failure(failure):
 
115
            failure.trap(CommandError)
 
116
            self.assertEquals(str(failure.value), "ERROR\n")
 
117
        result.addErrback(assert_failure)
 
118
        return result
 
119
 
 
120
 
 
121
class ThermalZoneTest(LandscapeTest):
 
122
 
 
123
    def setUp(self):
 
124
        super(ThermalZoneTest, self).setUp()
 
125
        self.thermal_zone_path = self.makeDir()
 
126
 
 
127
    def get_thermal_zones(self):
 
128
        return list(get_thermal_zones(self.thermal_zone_path))
 
129
 
 
130
    def write_thermal_zone(self, name, temperature):
 
131
        zone_path = os.path.join(self.thermal_zone_path, name)
 
132
        if not os.path.isdir(zone_path):
 
133
            os.mkdir(zone_path)
 
134
        file = open(os.path.join(zone_path, "temperature"), "w")
 
135
        file.write("temperature:             " + temperature)
 
136
        file.close()
 
137
 
 
138
 
 
139
class GetThermalZonesTest(ThermalZoneTest):
 
140
 
 
141
    def test_non_existent_thermal_zone_directory(self):
 
142
        thermal_zones = list(get_thermal_zones("/non-existent/thermal_zone"))
 
143
        self.assertEquals(thermal_zones, [])
 
144
 
 
145
    def test_empty_thermal_zone_directory(self):
 
146
        self.assertEquals(self.get_thermal_zones(), [])
 
147
 
 
148
    def test_one_thermal_zone(self):
 
149
        self.write_thermal_zone("THM0", "50 C")
 
150
        thermal_zones = self.get_thermal_zones()
 
151
        self.assertEquals(len(thermal_zones), 1)
 
152
 
 
153
        self.assertEquals(thermal_zones[0].name, "THM0")
 
154
        self.assertEquals(thermal_zones[0].temperature, "50 C")
 
155
        self.assertEquals(thermal_zones[0].temperature_value, 50)
 
156
        self.assertEquals(thermal_zones[0].temperature_unit, "C")
 
157
        self.assertEquals(thermal_zones[0].path,
 
158
                          os.path.join(self.thermal_zone_path, "THM0"))
 
159
 
 
160
    def test_two_thermal_zones(self):
 
161
        self.write_thermal_zone("THM0", "50 C")
 
162
        self.write_thermal_zone("THM1", "51 C")
 
163
        thermal_zones = self.get_thermal_zones()
 
164
        self.assertEquals(len(thermal_zones), 2)
 
165
        self.assertEquals(thermal_zones[0].temperature, "50 C")
 
166
        self.assertEquals(thermal_zones[0].temperature_value, 50)
 
167
        self.assertEquals(thermal_zones[0].temperature_unit, "C")
 
168
        self.assertEquals(thermal_zones[1].temperature, "51 C")
 
169
        self.assertEquals(thermal_zones[1].temperature_value, 51)
 
170
        self.assertEquals(thermal_zones[1].temperature_unit, "C")
 
171
 
 
172
    def test_badly_formatted_temperature(self):
 
173
        self.write_thermal_zone("THM0", "SOMETHING BAD")
 
174
        thermal_zones = self.get_thermal_zones()
 
175
        self.assertEquals(len(thermal_zones), 1)
 
176
        self.assertEquals(thermal_zones[0].temperature, "SOMETHING BAD")
 
177
        self.assertEquals(thermal_zones[0].temperature_value, None)
 
178
        self.assertEquals(thermal_zones[0].temperature_unit, None)
 
179
 
 
180
    def test_badly_formatted_with_missing_space(self):
 
181
        self.write_thermal_zone("THM0", "SOMETHINGBAD")
 
182
        thermal_zones = self.get_thermal_zones()
 
183
        self.assertEquals(len(thermal_zones), 1)
 
184
        self.assertEquals(thermal_zones[0].temperature, "SOMETHINGBAD")
 
185
        self.assertEquals(thermal_zones[0].temperature_value, None)
 
186
        self.assertEquals(thermal_zones[0].temperature_unit, None)
 
187
 
 
188
    def test_temperature_file_with_missing_label(self):
 
189
        self.write_thermal_zone("THM0", "SOMETHINGBAD")
 
190
        temperature_path = os.path.join(self.thermal_zone_path,
 
191
                                        "THM0/temperature")
 
192
        file = open(temperature_path, "w")
 
193
        file.write("bad-label: foo bar\n")
 
194
        file.close()
 
195
        thermal_zones = self.get_thermal_zones()
 
196
        self.assertEquals(len(thermal_zones), 1)
 
197
        self.assertEquals(thermal_zones[0].temperature, None)
 
198
        self.assertEquals(thermal_zones[0].temperature_value, None)
 
199
        self.assertEquals(thermal_zones[0].temperature_unit, None)