2
# -*- mode: python; coding: utf-8 -*-
2
# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2008-2010 Teddy Hogeborn
7
# Copyright © 2008-2010 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
9
# This file is part of Mandos.
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (at your option) any later version.
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
19
# GNU General Public License for more details.
19
21
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
24
# Contact the authors at <mandos@recompile.se>.
25
27
from __future__ import (division, absolute_import, print_function,
31
from future_builtins import *
48
# Show warnings by default
49
if not sys.warnoptions:
51
warnings.simplefilter("default")
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
57
logging.captureWarnings(True) # Show warnings via the logging system
59
if sys.version_info.major == 2:
36
62
locale.setlocale(locale.LC_ALL, "")
42
"LastCheckedOK": "Last Successful Check",
43
"LastApprovalRequest": "Last Approval Request",
45
"Interval": "Interval",
47
"Fingerprint": "Fingerprint",
48
"CheckerRunning": "Check Is Running",
49
"LastEnabled": "Last Enabled",
50
"ApprovalPending": "Approval Is Pending",
51
"ApprovedByDefault": "Approved By Default",
52
"ApprovalDelay": "Approval Delay",
53
"ApprovalDuration": "Approval Duration",
55
"ExtendedTimeout" : "Extended Timeout"
57
64
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
58
65
domain = "se.recompile"
59
66
busname = domain + ".Mandos"
61
68
server_interface = domain + ".Mandos"
62
69
client_interface = domain + ".Mandos.Client"
65
def timedelta_to_milliseconds(td):
66
"""Convert a datetime.timedelta object to milliseconds"""
67
return ((td.days * 24 * 60 * 60 * 1000)
69
+ (td.microseconds // 1000))
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
71
79
def milliseconds_to_string(ms):
72
80
td = datetime.timedelta(0, 0, 0, ms)
73
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
74
% { "days": "%dT" % td.days if td.days else "",
75
"hours": td.seconds // 3600,
76
"minutes": (td.seconds % 3600) // 60,
77
"seconds": td.seconds % 60,
81
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
82
.format(days="{}T".format(td.days) if td.days else "",
83
hours=td.seconds // 3600,
84
minutes=(td.seconds % 3600) // 60,
85
seconds=td.seconds % 60))
88
def rfc3339_duration_to_delta(duration):
89
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
91
>>> rfc3339_duration_to_delta("P7D")
93
>>> rfc3339_duration_to_delta("PT60S")
94
datetime.timedelta(0, 60)
95
>>> rfc3339_duration_to_delta("PT60M")
96
datetime.timedelta(0, 3600)
97
>>> rfc3339_duration_to_delta("P60M")
98
datetime.timedelta(1680)
99
>>> rfc3339_duration_to_delta("PT24H")
100
datetime.timedelta(1)
101
>>> rfc3339_duration_to_delta("P1W")
102
datetime.timedelta(7)
103
>>> rfc3339_duration_to_delta("PT5M30S")
104
datetime.timedelta(0, 330)
105
>>> rfc3339_duration_to_delta("P1DT3M20S")
106
datetime.timedelta(1, 200)
107
>>> # Can not be empty:
108
>>> rfc3339_duration_to_delta("")
109
Traceback (most recent call last):
111
ValueError: Invalid RFC 3339 duration: u''
112
>>> # Must start with "P":
113
>>> rfc3339_duration_to_delta("1D")
114
Traceback (most recent call last):
116
ValueError: Invalid RFC 3339 duration: u'1D'
117
>>> # Must use correct order
118
>>> rfc3339_duration_to_delta("PT1S2M")
119
Traceback (most recent call last):
121
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
122
>>> # Time needs time marker
123
>>> rfc3339_duration_to_delta("P1H2S")
124
Traceback (most recent call last):
126
ValueError: Invalid RFC 3339 duration: u'P1H2S'
127
>>> # Weeks can not be combined with anything else
128
>>> rfc3339_duration_to_delta("P1D2W")
129
Traceback (most recent call last):
131
ValueError: Invalid RFC 3339 duration: u'P1D2W'
132
>>> rfc3339_duration_to_delta("P2W2H")
133
Traceback (most recent call last):
135
ValueError: Invalid RFC 3339 duration: u'P2W2H'
138
# Parsing an RFC 3339 duration with regular expressions is not
139
# possible - there would have to be multiple places for the same
140
# values, like seconds. The current code, while more esoteric, is
141
# cleaner without depending on a parsing library. If Python had a
142
# built-in library for parsing we would use it, but we'd like to
143
# avoid excessive use of external libraries.
145
# New type for defining tokens, syntax, and semantics all-in-one
146
Token = collections.namedtuple("Token", (
147
"regexp", # To match token; if "value" is not None, must have
148
# a "group" containing digits
149
"value", # datetime.timedelta or None
150
"followers")) # Tokens valid after this token
151
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
152
# the "duration" ABNF definition in RFC 3339, Appendix A.
153
token_end = Token(re.compile(r"$"), None, frozenset())
154
token_second = Token(re.compile(r"(\d+)S"),
155
datetime.timedelta(seconds=1),
156
frozenset((token_end, )))
157
token_minute = Token(re.compile(r"(\d+)M"),
158
datetime.timedelta(minutes=1),
159
frozenset((token_second, token_end)))
160
token_hour = Token(re.compile(r"(\d+)H"),
161
datetime.timedelta(hours=1),
162
frozenset((token_minute, token_end)))
163
token_time = Token(re.compile(r"T"),
165
frozenset((token_hour, token_minute,
167
token_day = Token(re.compile(r"(\d+)D"),
168
datetime.timedelta(days=1),
169
frozenset((token_time, token_end)))
170
token_month = Token(re.compile(r"(\d+)M"),
171
datetime.timedelta(weeks=4),
172
frozenset((token_day, token_end)))
173
token_year = Token(re.compile(r"(\d+)Y"),
174
datetime.timedelta(weeks=52),
175
frozenset((token_month, token_end)))
176
token_week = Token(re.compile(r"(\d+)W"),
177
datetime.timedelta(weeks=1),
178
frozenset((token_end, )))
179
token_duration = Token(re.compile(r"P"), None,
180
frozenset((token_year, token_month,
181
token_day, token_time,
183
# Define starting values:
185
value = datetime.timedelta()
187
# Following valid tokens
188
followers = frozenset((token_duration, ))
189
# String left to parse
191
# Loop until end token is found
192
while found_token is not token_end:
193
# Search for any currently valid tokens
194
for token in followers:
195
match = token.regexp.match(s)
196
if match is not None:
198
if token.value is not None:
199
# Value found, parse digits
200
factor = int(match.group(1), 10)
201
# Add to value so far
202
value += factor * token.value
203
# Strip token from string
204
s = token.regexp.sub("", s, 1)
207
# Set valid next tokens
208
followers = found_token.followers
211
# No currently valid tokens were found
212
raise ValueError("Invalid RFC 3339 duration: {!r}"
80
218
def string_to_delta(interval):
81
219
"""Parse a string and return a datetime.timedelta
83
>>> string_to_delta("7d")
223
return rfc3339_duration_to_delta(interval)
224
except ValueError as e:
225
log.warning("%s - Parsing as pre-1.6.1 interval instead",
227
return parse_pre_1_6_1_interval(interval)
230
def parse_pre_1_6_1_interval(interval):
231
"""Parse an interval string as documented by Mandos before 1.6.1, and
232
return a datetime.timedelta
233
>>> parse_pre_1_6_1_interval('7d')
84
234
datetime.timedelta(7)
85
>>> string_to_delta("60s")
235
>>> parse_pre_1_6_1_interval('60s')
86
236
datetime.timedelta(0, 60)
87
>>> string_to_delta("60m")
237
>>> parse_pre_1_6_1_interval('60m')
88
238
datetime.timedelta(0, 3600)
89
>>> string_to_delta("24h")
239
>>> parse_pre_1_6_1_interval('24h')
90
240
datetime.timedelta(1)
91
>>> string_to_delta("1w")
241
>>> parse_pre_1_6_1_interval('1w')
92
242
datetime.timedelta(7)
93
>>> string_to_delta("5m 30s")
243
>>> parse_pre_1_6_1_interval('5m 30s')
94
244
datetime.timedelta(0, 330)
245
>>> parse_pre_1_6_1_interval('')
246
datetime.timedelta(0)
247
>>> # Ignore unknown characters, allow any order and repetitions
248
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
249
datetime.timedelta(2, 480, 18000)
96
timevalue = datetime.timedelta(0)
97
regexp = re.compile("\d+[dsmhw]")
99
for s in regexp.findall(interval):
101
suffix = unicode(s[-1])
104
delta = datetime.timedelta(value)
106
delta = datetime.timedelta(0, value)
108
delta = datetime.timedelta(0, 0, 0, 0, value)
110
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
112
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
115
except (ValueError, IndexError):
253
value = datetime.timedelta(0)
254
regexp = re.compile(r"(\d+)([dsmhw]?)")
256
for num, suffix in regexp.findall(interval):
258
value += datetime.timedelta(int(num))
260
value += datetime.timedelta(0, int(num))
262
value += datetime.timedelta(0, 0, 0, 0, int(num))
264
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
266
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
268
value += datetime.timedelta(0, 0, 0, int(num))
120
272
def print_clients(clients, keywords):
273
print('\n'.join(TableOfClients(clients, keywords).rows()))
275
class TableOfClients(object):
278
"Enabled": "Enabled",
279
"Timeout": "Timeout",
280
"LastCheckedOK": "Last Successful Check",
281
"LastApprovalRequest": "Last Approval Request",
282
"Created": "Created",
283
"Interval": "Interval",
285
"Fingerprint": "Fingerprint",
287
"CheckerRunning": "Check Is Running",
288
"LastEnabled": "Last Enabled",
289
"ApprovalPending": "Approval Is Pending",
290
"ApprovedByDefault": "Approved By Default",
291
"ApprovalDelay": "Approval Delay",
292
"ApprovalDuration": "Approval Duration",
293
"Checker": "Checker",
294
"ExtendedTimeout": "Extended Timeout",
295
"Expires": "Expires",
296
"LastCheckerStatus": "Last Checker Status",
299
def __init__(self, clients, keywords, tablewords=None):
300
self.clients = clients
301
self.keywords = keywords
302
if tablewords is not None:
303
self.tablewords = tablewords
306
format_string = self.row_formatting_string()
307
rows = [self.header_line(format_string)]
308
rows.extend(self.client_line(client, format_string)
309
for client in self.clients)
312
def row_formatting_string(self):
313
"Format string used to format table rows"
314
return " ".join("{{{key}:{width}}}".format(
315
width=max(len(self.tablewords[key]),
316
max(len(self.string_from_client(client, key))
317
for client in self.clients)),
319
for key in self.keywords)
321
def string_from_client(self, client, key):
322
return self.valuetostring(client[key], key)
121
325
def valuetostring(value, keyword):
122
if type(value) is dbus.Boolean:
326
if isinstance(value, dbus.Boolean):
123
327
return "Yes" if value else "No"
124
328
if keyword in ("Timeout", "Interval", "ApprovalDelay",
329
"ApprovalDuration", "ExtendedTimeout"):
126
330
return milliseconds_to_string(value)
127
return unicode(value)
129
# Create format string to print table rows
130
format_string = " ".join("%%-%ds" %
131
max(len(tablewords[key]),
132
max(len(valuetostring(client[key],
138
print(format_string % tuple(tablewords[key] for key in keywords))
139
for client in clients:
140
print(format_string % tuple(valuetostring(client[key], key)
141
for key in keywords))
333
def header_line(self, format_string):
334
return format_string.format(**self.tablewords)
336
def client_line(self, client, format_string):
337
return format_string.format(
338
**{key: self.string_from_client(client, key)
339
for key in self.keywords})
143
342
def has_actions(options):
144
343
return any((options.enable,
202
404
parser.add_argument("--approval-duration",
203
405
help="Set duration of one client approval")
204
406
parser.add_argument("-H", "--host", help="Set host for client")
205
parser.add_argument("-s", "--secret", type=file,
407
parser.add_argument("-s", "--secret",
408
type=argparse.FileType(mode="rb"),
206
409
help="Set password blob (file) for client")
207
410
parser.add_argument("-A", "--approve", action="store_true",
208
411
help="Approve any current client request")
209
412
parser.add_argument("-D", "--deny", action="store_true",
210
413
help="Deny any current client request")
414
parser.add_argument("--check", action="store_true",
415
help="Run self-test")
211
416
parser.add_argument("client", nargs="*", help="Client name")
212
417
options = parser.parse_args()
214
if has_actions(options) and not options.client and not options.all:
419
if has_actions(options) and not (options.client or options.all):
215
420
parser.error("Options require clients names or --all.")
216
421
if options.verbose and has_actions(options):
217
parser.error("--verbose can only be used alone or with"
422
parser.error("--verbose can only be used alone.")
423
if options.dump_json and (options.verbose
424
or has_actions(options)):
425
parser.error("--dump-json can only be used alone.")
219
426
if options.all and not has_actions(options):
220
427
parser.error("--all requires an action.")
223
430
bus = dbus.SystemBus()
224
431
mandos_dbus_objc = bus.get_object(busname, server_path)
225
432
except dbus.exceptions.DBusException:
226
print("Could not connect to Mandos server",
433
log.critical("Could not connect to Mandos server")
230
436
mandos_serv = dbus.Interface(mandos_dbus_objc,
231
dbus_interface = server_interface)
233
#block stderr since dbus library prints to stderr
437
dbus_interface=server_interface)
438
mandos_serv_object_manager = dbus.Interface(
439
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
441
# block stderr since dbus library prints to stderr
234
442
null = os.open(os.path.devnull, os.O_RDWR)
235
443
stderrcopy = os.dup(sys.stderr.fileno())
236
444
os.dup2(null, sys.stderr.fileno())
240
mandos_clients = mandos_serv.GetAllClientsWithProperties()
448
mandos_clients = {path: ifs_and_props[client_interface]
449
for path, ifs_and_props in
450
mandos_serv_object_manager
451
.GetManagedObjects().items()
452
if client_interface in ifs_and_props}
243
455
os.dup2(stderrcopy, sys.stderr.fileno())
244
456
os.close(stderrcopy)
245
except dbus.exceptions.DBusException, e:
246
print("Access denied: Accessing mandos server through dbus.",
457
except dbus.exceptions.DBusException as e:
458
log.critical("Failed to access Mandos server through D-Bus:"
250
462
# Compile dict of (clients: properties) to process
253
465
if options.all or not options.client:
254
clients = dict((bus.get_object(busname, path), properties)
255
for path, properties in
256
mandos_clients.iteritems())
466
clients = {bus.get_object(busname, path): properties
467
for path, properties in mandos_clients.items()}
258
469
for name in options.client:
259
for path, client in mandos_clients.iteritems():
470
for path, client in mandos_clients.items():
260
471
if client["Name"] == name:
261
472
client_objc = bus.get_object(busname, path)
262
473
clients[client_objc] = client
265
print("Client not found on server: %r" % name,
476
log.critical("Client not found on server: %r", name)
269
479
if not has_actions(options) and clients:
271
keywords = ("Name", "Enabled", "Timeout",
272
"LastCheckedOK", "Created", "Interval",
273
"Host", "Fingerprint", "CheckerRunning",
480
if options.verbose or options.dump_json:
481
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
482
"Created", "Interval", "Host", "KeyID",
483
"Fingerprint", "CheckerRunning",
274
484
"LastEnabled", "ApprovalPending",
276
"LastApprovalRequest", "ApprovalDelay",
277
"ApprovalDuration", "Checker",
485
"ApprovedByDefault", "LastApprovalRequest",
486
"ApprovalDelay", "ApprovalDuration",
487
"Checker", "ExtendedTimeout", "Expires",
280
490
keywords = defaultkeywords
282
print_clients(clients.values(), keywords)
492
if options.dump_json:
493
json.dump({client["Name"]: {key:
495
if isinstance(client[key],
499
for client in clients.values()},
500
fp=sys.stdout, indent=4,
501
separators=(',', ': '))
504
print_clients(clients.values(), keywords)
284
506
# Process each client in the list by all selected options
285
507
for client in clients:
509
def set_client_prop(prop, value):
510
"""Set a Client D-Bus property"""
511
client.Set(client_interface, prop, value,
512
dbus_interface=dbus.PROPERTIES_IFACE)
514
def set_client_prop_ms(prop, value):
515
"""Set a Client D-Bus property, converted
516
from a string to milliseconds."""
517
set_client_prop(prop,
518
string_to_delta(value).total_seconds()
286
521
if options.remove:
287
522
mandos_serv.RemoveClient(client.__dbus_object_path__)
288
523
if options.enable:
289
client.Enable(dbus_interface=client_interface)
524
set_client_prop("Enabled", dbus.Boolean(True))
290
525
if options.disable:
291
client.Disable(dbus_interface=client_interface)
526
set_client_prop("Enabled", dbus.Boolean(False))
292
527
if options.bump_timeout:
293
client.CheckedOK(dbus_interface=client_interface)
528
set_client_prop("LastCheckedOK", "")
294
529
if options.start_checker:
295
client.StartChecker(dbus_interface=client_interface)
530
set_client_prop("CheckerRunning", dbus.Boolean(True))
296
531
if options.stop_checker:
297
client.StopChecker(dbus_interface=client_interface)
532
set_client_prop("CheckerRunning", dbus.Boolean(False))
298
533
if options.is_enabled:
299
sys.exit(0 if client.Get(client_interface,
302
dbus.PROPERTIES_IFACE)
305
client.Set(client_interface, "Checker",
307
dbus_interface=dbus.PROPERTIES_IFACE)
309
client.Set(client_interface, "Host", options.host,
310
dbus_interface=dbus.PROPERTIES_IFACE)
312
client.Set(client_interface, "Interval",
313
timedelta_to_milliseconds
314
(string_to_delta(options.interval)),
315
dbus_interface=dbus.PROPERTIES_IFACE)
316
if options.approval_delay:
317
client.Set(client_interface, "ApprovalDelay",
318
timedelta_to_milliseconds
319
(string_to_delta(options.
321
dbus_interface=dbus.PROPERTIES_IFACE)
322
if options.approval_duration:
323
client.Set(client_interface, "ApprovalDuration",
324
timedelta_to_milliseconds
325
(string_to_delta(options.
327
dbus_interface=dbus.PROPERTIES_IFACE)
329
client.Set(client_interface, "Timeout",
330
timedelta_to_milliseconds
331
(string_to_delta(options.timeout)),
332
dbus_interface=dbus.PROPERTIES_IFACE)
333
if options.extended_timeout:
334
client.Set(client_interface, "ExtendedTimeout",
335
timedelta_to_milliseconds
336
(string_to_delta(options.extended_timeout)),
337
dbus_interface=dbus.PROPERTIES_IFACE)
339
client.Set(client_interface, "Secret",
340
dbus.ByteArray(open(options.secret,
342
dbus_interface=dbus.PROPERTIES_IFACE)
534
if client.Get(client_interface, "Enabled",
535
dbus_interface=dbus.PROPERTIES_IFACE):
539
if options.checker is not None:
540
set_client_prop("Checker", options.checker)
541
if options.host is not None:
542
set_client_prop("Host", options.host)
543
if options.interval is not None:
544
set_client_prop_ms("Interval", options.interval)
545
if options.approval_delay is not None:
546
set_client_prop_ms("ApprovalDelay",
547
options.approval_delay)
548
if options.approval_duration is not None:
549
set_client_prop_ms("ApprovalDuration",
550
options.approval_duration)
551
if options.timeout is not None:
552
set_client_prop_ms("Timeout", options.timeout)
553
if options.extended_timeout is not None:
554
set_client_prop_ms("ExtendedTimeout",
555
options.extended_timeout)
556
if options.secret is not None:
557
set_client_prop("Secret",
558
dbus.ByteArray(options.secret.read()))
343
559
if options.approved_by_default is not None:
344
client.Set(client_interface, "ApprovedByDefault",
346
.approved_by_default),
347
dbus_interface=dbus.PROPERTIES_IFACE)
560
set_client_prop("ApprovedByDefault",
562
.approved_by_default))
348
563
if options.approve:
349
564
client.Approve(dbus.Boolean(True),
350
565
dbus_interface=client_interface)
352
567
client.Approve(dbus.Boolean(False),
353
568
dbus_interface=client_interface)
571
class Test_milliseconds_to_string(unittest.TestCase):
573
self.assertEqual(milliseconds_to_string(93785000),
575
def test_no_days(self):
576
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
577
def test_all_zero(self):
578
self.assertEqual(milliseconds_to_string(0), "00:00:00")
579
def test_no_fractional_seconds(self):
580
self.assertEqual(milliseconds_to_string(400), "00:00:00")
581
self.assertEqual(milliseconds_to_string(900), "00:00:00")
582
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
584
class Test_string_to_delta(unittest.TestCase):
585
def test_handles_basic_rfc3339(self):
586
self.assertEqual(string_to_delta("PT2H"),
587
datetime.timedelta(0, 7200))
588
def test_falls_back_to_pre_1_6_1_with_warning(self):
589
# assertLogs only exists in Python 3.4
590
if hasattr(self, "assertLogs"):
591
with self.assertLogs(log, logging.WARNING):
592
value = string_to_delta("2h")
594
value = string_to_delta("2h")
595
self.assertEqual(value, datetime.timedelta(0, 7200))
597
class Test_TableOfClients(unittest.TestCase):
603
"Bool": "A D-BUS Boolean",
604
"NonDbusBoolean": "A Non-D-BUS Boolean",
605
"Integer": "An Integer",
606
"Timeout": "Timedelta 1",
607
"Interval": "Timedelta 2",
608
"ApprovalDelay": "Timedelta 3",
609
"ApprovalDuration": "Timedelta 4",
610
"ExtendedTimeout": "Timedelta 5",
611
"String": "A String",
613
self.keywords = ["Attr1", "AttrTwo"]
619
"Bool": dbus.Boolean(False),
620
"NonDbusBoolean": False,
624
"ApprovalDelay": 2000,
625
"ApprovalDuration": 3000,
626
"ExtendedTimeout": 4000,
633
"Bool": dbus.Boolean(True),
634
"NonDbusBoolean": True,
637
"Interval": 93786000,
638
"ApprovalDelay": 93787000,
639
"ApprovalDuration": 93788000,
640
"ExtendedTimeout": 93789000,
641
"String": "A huge string which will not fit," * 10,
644
def test_short_header(self):
645
rows = TableOfClients(self.clients, self.keywords,
646
self.tablewords).rows()
651
self.assertEqual(rows, expected_rows)
652
def test_booleans(self):
653
keywords = ["Bool", "NonDbusBoolean"]
654
rows = TableOfClients(self.clients, keywords,
655
self.tablewords).rows()
657
"A D-BUS Boolean A Non-D-BUS Boolean",
661
self.assertEqual(rows, expected_rows)
662
def test_milliseconds_detection(self):
663
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
664
"ApprovalDuration", "ExtendedTimeout"]
665
rows = TableOfClients(self.clients, keywords,
666
self.tablewords).rows()
668
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
669
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
670
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
673
self.assertEqual(rows, expected_rows)
674
def test_empty_and_long_string_values(self):
675
keywords = ["String"]
676
rows = TableOfClients(self.clients, keywords,
677
self.tablewords).rows()
681
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
684
self.assertEqual(rows, expected_rows)
688
def should_only_run_tests():
689
parser = argparse.ArgumentParser(add_help=False)
690
parser.add_argument("--check", action='store_true')
691
args, unknown_args = parser.parse_known_args()
692
run_tests = args.check
694
# Remove --check argument from sys.argv
695
sys.argv[1:] = unknown_args
698
# Add all tests from doctest strings
699
def load_tests(loader, tests, none):
701
tests.addTests(doctest.DocTestSuite())
355
704
if __name__ == "__main__":
705
if should_only_run_tests():
706
# Call using ./tdd-python-script --check [--verbose]