To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 844
- compare with another revision
- download diff
- download tarball
- view history from revision 844
- Committer: Teddy Hogeborn
- Date: 2016-03-23 07:11:22 UTC
- Revision ID: teddy@recompile.se-20160323071122-55srtjdizr21rr7f
Use HTTPS in home page links
Since we have a real certificate now, change all links to the home
page to use HTTPS.
* README: Use HTTPS in home page links
* debian/control (Source: mandos/Homepage): - '' -
* debian/copyright (Source): - '' -
* intro.xml (SEE ALSO): - '' -
* mandos.lsm (Primary-site): - '' -
Since we have a real certificate now, change all links to the home
page to use HTTPS.
* README: Use HTTPS in home page links
* debian/control (Source: mandos/Homepage): - '' -
* debian/copyright (Source): - '' -
* intro.xml (SEE ALSO): - '' -
* mandos.lsm (Primary-site): - '' -
- files added:
- initramfs-tools-hook-conf
- files removed:
- debian/mandos-client.templates
- files modified:
- DBUS-API
added
removed
mandos-ctl
1
1
#!/usr/bin/python
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*")))); -*-
3
#
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
8
#
9
# This file is part of Mandos.
10
#
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
5
#
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 Björn Påhlsson
8
#
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
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
15
13
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
20
#
18
#
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
#
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
#
24
23
# Contact the authors at <mandos@recompile.se>.
25
#
24
#
26
25
27
26
from __future__ import (division, absolute_import, print_function,
28
27
unicode_literals)
39
38
import re
40
39
import os
41
40
import collections
42
import json
43
import unittest
44
import logging
41
import doctest
45
42
46
43
import dbus
47
44
48
# Show warnings by default
49
if not sys.warnoptions:
50
import warnings
51
warnings.simplefilter("default")
52
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
56
57
logging.captureWarnings(True) # Show warnings via the logging system
58
59
45
if sys.version_info.major == 2:
60
46
str = unicode
61
47
62
48
locale.setlocale(locale.LC_ALL, "")
63
49
50
tablewords = {
51
"Name": "Name",
52
"Enabled": "Enabled",
53
"Timeout": "Timeout",
54
"LastCheckedOK": "Last Successful Check",
55
"LastApprovalRequest": "Last Approval Request",
56
"Created": "Created",
57
"Interval": "Interval",
58
"Host": "Host",
59
"Fingerprint": "Fingerprint",
60
"CheckerRunning": "Check Is Running",
61
"LastEnabled": "Last Enabled",
62
"ApprovalPending": "Approval Is Pending",
63
"ApprovedByDefault": "Approved By Default",
64
"ApprovalDelay": "Approval Delay",
65
"ApprovalDuration": "Approval Duration",
66
"Checker": "Checker",
67
"ExtendedTimeout": "Extended Timeout"
68
}
64
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
65
70
domain = "se.recompile"
66
71
busname = domain + ".Mandos"
67
72
server_path = "/"
68
73
server_interface = domain + ".Mandos"
69
74
client_interface = domain + ".Mandos.Client"
70
version = "1.8.3"
75
version = "1.7.7"
71
76
72
77
73
78
try:
75
80
except AttributeError:
76
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
82
78
79
83
def milliseconds_to_string(ms):
80
84
td = datetime.timedelta(0, 0, 0, ms)
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))
85
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
86
days = "{}T".format(td.days) if td.days else "",
87
hours = td.seconds // 3600,
88
minutes = (td.seconds % 3600) // 60,
89
seconds = td.seconds % 60))
86
90
87
91
88
92
def rfc3339_duration_to_delta(duration):
89
93
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
94
91
95
>>> rfc3339_duration_to_delta("P7D")
92
96
datetime.timedelta(7)
93
97
>>> rfc3339_duration_to_delta("PT60S")
94
98
datetime.timedelta(0, 60)
95
99
>>> rfc3339_duration_to_delta("PT60M")
96
100
datetime.timedelta(0, 3600)
97
>>> rfc3339_duration_to_delta("P60M")
98
datetime.timedelta(1680)
99
101
>>> rfc3339_duration_to_delta("PT24H")
100
102
datetime.timedelta(1)
101
103
>>> rfc3339_duration_to_delta("P1W")
104
106
datetime.timedelta(0, 330)
105
107
>>> rfc3339_duration_to_delta("P1DT3M20S")
106
108
datetime.timedelta(1, 200)
107
>>> # Can not be empty:
108
>>> rfc3339_duration_to_delta("")
109
Traceback (most recent call last):
110
...
111
ValueError: Invalid RFC 3339 duration: u''
112
>>> # Must start with "P":
113
>>> rfc3339_duration_to_delta("1D")
114
Traceback (most recent call last):
115
...
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):
120
...
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):
125
...
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):
130
...
131
ValueError: Invalid RFC 3339 duration: u'P1D2W'
132
>>> rfc3339_duration_to_delta("P2W2H")
133
Traceback (most recent call last):
134
...
135
ValueError: Invalid RFC 3339 duration: u'P2W2H'
136
109
"""
137
110
138
111
# Parsing an RFC 3339 duration with regular expressions is not
139
112
# possible - there would have to be multiple places for the same
140
113
# values, like seconds. The current code, while more esoteric, is
141
114
# cleaner without depending on a parsing library. If Python had a
142
115
# built-in library for parsing we would use it, but we'd like to
143
116
# avoid excessive use of external libraries.
144
117
145
118
# New type for defining tokens, syntax, and semantics all-in-one
146
119
Token = collections.namedtuple("Token", (
147
120
"regexp", # To match token; if "value" is not None, must have
180
153
frozenset((token_year, token_month,
181
154
token_day, token_time,
182
155
token_week)))
183
# Define starting values:
184
# Value so far
185
value = datetime.timedelta()
156
# Define starting values
157
value = datetime.timedelta() # Value so far
186
158
found_token = None
187
# Following valid tokens
188
followers = frozenset((token_duration, ))
189
# String left to parse
190
s = duration
159
followers = frozenset((token_duration, )) # Following valid tokens
160
s = duration # String left to parse
191
161
# Loop until end token is found
192
162
while found_token is not token_end:
193
163
# Search for any currently valid tokens
216
186
217
187
218
188
def string_to_delta(interval):
219
"""Parse a string and return a datetime.timedelta"""
220
189
"""Parse a string and return a datetime.timedelta
190
191
>>> string_to_delta('7d')
192
datetime.timedelta(7)
193
>>> string_to_delta('60s')
194
datetime.timedelta(0, 60)
195
>>> string_to_delta('60m')
196
datetime.timedelta(0, 3600)
197
>>> string_to_delta('24h')
198
datetime.timedelta(1)
199
>>> string_to_delta('1w')
200
datetime.timedelta(7)
201
>>> string_to_delta('5m 30s')
202
datetime.timedelta(0, 330)
203
"""
204
221
205
try:
222
206
return rfc3339_duration_to_delta(interval)
223
except ValueError as e:
224
log.warning("%s - Parsing as pre-1.6.1 interval instead",
225
' '.join(e.args))
226
return parse_pre_1_6_1_interval(interval)
227
228
229
def parse_pre_1_6_1_interval(interval):
230
"""Parse an interval string as documented by Mandos before 1.6.1,
231
and return a datetime.timedelta
232
233
>>> parse_pre_1_6_1_interval('7d')
234
datetime.timedelta(7)
235
>>> parse_pre_1_6_1_interval('60s')
236
datetime.timedelta(0, 60)
237
>>> parse_pre_1_6_1_interval('60m')
238
datetime.timedelta(0, 3600)
239
>>> parse_pre_1_6_1_interval('24h')
240
datetime.timedelta(1)
241
>>> parse_pre_1_6_1_interval('1w')
242
datetime.timedelta(7)
243
>>> parse_pre_1_6_1_interval('5m 30s')
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)
250
251
"""
252
207
except ValueError:
208
pass
209
253
210
value = datetime.timedelta(0)
254
211
regexp = re.compile(r"(\d+)([dsmhw]?)")
255
212
256
213
for num, suffix in regexp.findall(interval):
257
214
if suffix == "d":
258
215
value += datetime.timedelta(int(num))
269
226
return value
270
227
271
228
272
class TableOfClients(object):
273
tablewords = {
274
"Name": "Name",
275
"Enabled": "Enabled",
276
"Timeout": "Timeout",
277
"LastCheckedOK": "Last Successful Check",
278
"LastApprovalRequest": "Last Approval Request",
279
"Created": "Created",
280
"Interval": "Interval",
281
"Host": "Host",
282
"Fingerprint": "Fingerprint",
283
"KeyID": "Key ID",
284
"CheckerRunning": "Check Is Running",
285
"LastEnabled": "Last Enabled",
286
"ApprovalPending": "Approval Is Pending",
287
"ApprovedByDefault": "Approved By Default",
288
"ApprovalDelay": "Approval Delay",
289
"ApprovalDuration": "Approval Duration",
290
"Checker": "Checker",
291
"ExtendedTimeout": "Extended Timeout",
292
"Expires": "Expires",
293
"LastCheckerStatus": "Last Checker Status",
294
}
295
296
def __init__(self, clients, keywords, tablewords=None):
297
self.clients = clients
298
self.keywords = keywords
299
if tablewords is not None:
300
self.tablewords = tablewords
301
302
def __str__(self):
303
return "\n".join(self.rows())
304
305
if sys.version_info.major == 2:
306
__unicode__ = __str__
307
def __str__(self):
308
return str(self).encode(locale.getpreferredencoding())
309
310
def rows(self):
311
format_string = self.row_formatting_string()
312
rows = [self.header_line(format_string)]
313
rows.extend(self.client_line(client, format_string)
314
for client in self.clients)
315
return rows
316
317
def row_formatting_string(self):
318
"Format string used to format table rows"
319
return " ".join("{{{key}:{width}}}".format(
320
width=max(len(self.tablewords[key]),
321
*(len(self.string_from_client(client, key))
322
for client in self.clients)),
323
key=key)
324
for key in self.keywords)
325
326
def string_from_client(self, client, key):
327
return self.valuetostring(client[key], key)
328
329
@staticmethod
229
def print_clients(clients, keywords):
330
230
def valuetostring(value, keyword):
331
if isinstance(value, dbus.Boolean):
231
if type(value) is dbus.Boolean:
332
232
return "Yes" if value else "No"
333
233
if keyword in ("Timeout", "Interval", "ApprovalDelay",
334
234
"ApprovalDuration", "ExtendedTimeout"):
335
235
return milliseconds_to_string(value)
336
236
return str(value)
337
338
def header_line(self, format_string):
339
return format_string.format(**self.tablewords)
340
341
def client_line(self, client, format_string):
342
return format_string.format(
343
**{key: self.string_from_client(client, key)
344
for key in self.keywords})
237
238
# Create format string to print table rows
239
format_string = " ".join("{{{key}:{width}}}".format(
240
width = max(len(tablewords[key]),
241
max(len(valuetostring(client[key], key))
242
for client in clients)),
243
key = key)
244
for key in keywords)
245
# Print header line
246
print(format_string.format(**tablewords))
247
for client in clients:
248
print(format_string.format(**{
249
key: valuetostring(client[key], key)
250
for key in keywords }))
345
251
346
252
347
253
def has_actions(options):
368
274
def main():
369
275
parser = argparse.ArgumentParser()
370
276
parser.add_argument("--version", action="version",
371
version="%(prog)s {}".format(version),
277
version = "%(prog)s {}".format(version),
372
278
help="show version number and exit")
373
279
parser.add_argument("-a", "--all", action="store_true",
374
280
help="Select all clients")
375
281
parser.add_argument("-v", "--verbose", action="store_true",
376
282
help="Print all fields")
377
parser.add_argument("-j", "--dump-json", action="store_true",
378
help="Dump client data in JSON format")
379
enable_disable = parser.add_mutually_exclusive_group()
380
enable_disable.add_argument("-e", "--enable", action="store_true",
381
help="Enable client")
382
enable_disable.add_argument("-d", "--disable",
383
action="store_true",
384
help="disable client")
283
parser.add_argument("-e", "--enable", action="store_true",
284
help="Enable client")
285
parser.add_argument("-d", "--disable", action="store_true",
286
help="disable client")
385
287
parser.add_argument("-b", "--bump-timeout", action="store_true",
386
288
help="Bump timeout for client")
387
start_stop_checker = parser.add_mutually_exclusive_group()
388
start_stop_checker.add_argument("--start-checker",
389
action="store_true",
390
help="Start checker for client")
391
start_stop_checker.add_argument("--stop-checker",
392
action="store_true",
393
help="Stop checker for client")
289
parser.add_argument("--start-checker", action="store_true",
290
help="Start checker for client")
291
parser.add_argument("--stop-checker", action="store_true",
292
help="Stop checker for client")
394
293
parser.add_argument("-V", "--is-enabled", action="store_true",
395
294
help="Check if client is enabled")
396
295
parser.add_argument("-r", "--remove", action="store_true",
403
302
help="Set extended timeout for client")
404
303
parser.add_argument("-i", "--interval",
405
304
help="Set checker interval for client")
406
approve_deny_default = parser.add_mutually_exclusive_group()
407
approve_deny_default.add_argument(
408
"--approve-by-default", action="store_true",
409
default=None, dest="approved_by_default",
410
help="Set client to be approved by default")
411
approve_deny_default.add_argument(
412
"--deny-by-default", action="store_false",
413
dest="approved_by_default",
414
help="Set client to be denied by default")
305
parser.add_argument("--approve-by-default", action="store_true",
306
default=None, dest="approved_by_default",
307
help="Set client to be approved by default")
308
parser.add_argument("--deny-by-default", action="store_false",
309
dest="approved_by_default",
310
help="Set client to be denied by default")
415
311
parser.add_argument("--approval-delay",
416
312
help="Set delay before client approve/deny")
417
313
parser.add_argument("--approval-duration",
420
316
parser.add_argument("-s", "--secret",
421
317
type=argparse.FileType(mode="rb"),
422
318
help="Set password blob (file) for client")
423
approve_deny = parser.add_mutually_exclusive_group()
424
approve_deny.add_argument(
425
"-A", "--approve", action="store_true",
426
help="Approve any current client request")
427
approve_deny.add_argument("-D", "--deny", action="store_true",
428
help="Deny any current client request")
319
parser.add_argument("-A", "--approve", action="store_true",
320
help="Approve any current client request")
321
parser.add_argument("-D", "--deny", action="store_true",
322
help="Deny any current client request")
429
323
parser.add_argument("--check", action="store_true",
430
324
help="Run self-test")
431
325
parser.add_argument("client", nargs="*", help="Client name")
432
326
options = parser.parse_args()
433
327
434
328
if has_actions(options) and not (options.client or options.all):
435
329
parser.error("Options require clients names or --all.")
436
330
if options.verbose and has_actions(options):
437
parser.error("--verbose can only be used alone.")
438
if options.dump_json and (options.verbose
439
or has_actions(options)):
440
parser.error("--dump-json can only be used alone.")
331
parser.error("--verbose can only be used alone or with"
332
" --all.")
441
333
if options.all and not has_actions(options):
442
334
parser.error("--all requires an action.")
443
if options.is_enabled and len(options.client) > 1:
444
parser.error("--is-enabled requires exactly one client")
445
335
336
if options.check:
337
fail_count, test_count = doctest.testmod()
338
sys.exit(os.EX_OK if fail_count == 0 else 1)
339
446
340
try:
447
341
bus = dbus.SystemBus()
448
342
mandos_dbus_objc = bus.get_object(busname, server_path)
449
343
except dbus.exceptions.DBusException:
450
log.critical("Could not connect to Mandos server")
344
print("Could not connect to Mandos server", file=sys.stderr)
451
345
sys.exit(1)
452
346
453
347
mandos_serv = dbus.Interface(mandos_dbus_objc,
454
dbus_interface=server_interface)
348
dbus_interface = server_interface)
455
349
mandos_serv_object_manager = dbus.Interface(
456
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
457
458
# block stderr since dbus library prints to stderr
350
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
351
352
#block stderr since dbus library prints to stderr
459
353
null = os.open(os.path.devnull, os.O_RDWR)
460
354
stderrcopy = os.dup(sys.stderr.fileno())
461
355
os.dup2(null, sys.stderr.fileno())
462
356
os.close(null)
463
357
try:
464
358
try:
465
mandos_clients = {path: ifs_and_props[client_interface]
466
for path, ifs_and_props in
467
mandos_serv_object_manager
468
.GetManagedObjects().items()
469
if client_interface in ifs_and_props}
359
mandos_clients = { path: ifs_and_props[client_interface]
360
for path, ifs_and_props in
361
mandos_serv_object_manager
362
.GetManagedObjects().items()
363
if client_interface in ifs_and_props }
470
364
finally:
471
# restore stderr
365
#restore stderr
472
366
os.dup2(stderrcopy, sys.stderr.fileno())
473
367
os.close(stderrcopy)
474
368
except dbus.exceptions.DBusException as e:
475
log.critical("Failed to access Mandos server through D-Bus:"
476
"\n%s", e)
369
print("Access denied: Accessing mandos server through D-Bus: {}"
370
.format(e), file=sys.stderr)
477
371
sys.exit(1)
478
372
479
373
# Compile dict of (clients: properties) to process
480
clients = {}
481
374
clients={}
375
482
376
if options.all or not options.client:
483
clients = {bus.get_object(busname, path): properties
484
for path, properties in mandos_clients.items()}
377
clients = { bus.get_object(busname, path): properties
378
for path, properties in mandos_clients.items() }
485
379
else:
486
380
for name in options.client:
487
381
for path, client in mandos_clients.items():
490
384
clients[client_objc] = client
491
385
break
492
386
else:
493
log.critical("Client not found on server: %r", name)
387
print("Client not found on server: {!r}"
388
.format(name), file=sys.stderr)
494
389
sys.exit(1)
495
390
496
391
if not has_actions(options) and clients:
497
if options.verbose or options.dump_json:
392
if options.verbose:
498
393
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
499
"Created", "Interval", "Host", "KeyID",
500
"Fingerprint", "CheckerRunning",
501
"LastEnabled", "ApprovalPending",
502
"ApprovedByDefault", "LastApprovalRequest",
503
"ApprovalDelay", "ApprovalDuration",
504
"Checker", "ExtendedTimeout", "Expires",
505
"LastCheckerStatus")
394
"Created", "Interval", "Host", "Fingerprint",
395
"CheckerRunning", "LastEnabled",
396
"ApprovalPending", "ApprovedByDefault",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
399
"ExtendedTimeout")
506
400
else:
507
401
keywords = defaultkeywords
508
509
if options.dump_json:
510
json.dump({client["Name"]: {key:
511
bool(client[key])
512
if isinstance(client[key],
513
dbus.Boolean)
514
else client[key]
515
for key in keywords}
516
for client in clients.values()},
517
fp=sys.stdout, indent=4,
518
separators=(',', ': '))
519
print()
520
else:
521
print(TableOfClients(clients.values(), keywords))
402
403
print_clients(clients.values(), keywords)
522
404
else:
523
405
# Process each client in the list by all selected options
524
406
for client in clients:
525
407
526
408
def set_client_prop(prop, value):
527
409
"""Set a Client D-Bus property"""
528
410
client.Set(client_interface, prop, value,
529
411
dbus_interface=dbus.PROPERTIES_IFACE)
530
412
531
413
def set_client_prop_ms(prop, value):
532
414
"""Set a Client D-Bus property, converted
533
415
from a string to milliseconds."""
534
416
set_client_prop(prop,
535
417
string_to_delta(value).total_seconds()
536
418
* 1000)
537
419
538
420
if options.remove:
539
421
mandos_serv.RemoveClient(client.__dbus_object_path__)
540
422
if options.enable:
548
430
if options.stop_checker:
549
431
set_client_prop("CheckerRunning", dbus.Boolean(False))
550
432
if options.is_enabled:
551
if client.Get(client_interface, "Enabled",
552
dbus_interface=dbus.PROPERTIES_IFACE):
553
sys.exit(0)
554
else:
555
sys.exit(1)
433
sys.exit(0 if client.Get(client_interface,
434
"Enabled",
435
dbus_interface=
436
dbus.PROPERTIES_IFACE)
437
else 1)
556
438
if options.checker is not None:
557
439
set_client_prop("Checker", options.checker)
558
440
if options.host is not None:
584
466
client.Approve(dbus.Boolean(False),
585
467
dbus_interface=client_interface)
586
468
587
588
class Test_milliseconds_to_string(unittest.TestCase):
589
def test_all(self):
590
self.assertEqual(milliseconds_to_string(93785000),
591
"1T02:03:05")
592
def test_no_days(self):
593
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
594
def test_all_zero(self):
595
self.assertEqual(milliseconds_to_string(0), "00:00:00")
596
def test_no_fractional_seconds(self):
597
self.assertEqual(milliseconds_to_string(400), "00:00:00")
598
self.assertEqual(milliseconds_to_string(900), "00:00:00")
599
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
600
601
class Test_string_to_delta(unittest.TestCase):
602
def test_handles_basic_rfc3339(self):
603
self.assertEqual(string_to_delta("PT2H"),
604
datetime.timedelta(0, 7200))
605
def test_falls_back_to_pre_1_6_1_with_warning(self):
606
# assertLogs only exists in Python 3.4
607
if hasattr(self, "assertLogs"):
608
with self.assertLogs(log, logging.WARNING):
609
value = string_to_delta("2h")
610
else:
611
value = string_to_delta("2h")
612
self.assertEqual(value, datetime.timedelta(0, 7200))
613
614
class Test_TableOfClients(unittest.TestCase):
615
def setUp(self):
616
self.tablewords = {
617
"Attr1": "X",
618
"AttrTwo": "Yy",
619
"AttrThree": "Zzz",
620
"Bool": "A D-BUS Boolean",
621
"NonDbusBoolean": "A Non-D-BUS Boolean",
622
"Integer": "An Integer",
623
"Timeout": "Timedelta 1",
624
"Interval": "Timedelta 2",
625
"ApprovalDelay": "Timedelta 3",
626
"ApprovalDuration": "Timedelta 4",
627
"ExtendedTimeout": "Timedelta 5",
628
"String": "A String",
629
}
630
self.keywords = ["Attr1", "AttrTwo"]
631
self.clients = [
632
{
633
"Attr1": "x1",
634
"AttrTwo": "y1",
635
"AttrThree": "z1",
636
"Bool": dbus.Boolean(False),
637
"NonDbusBoolean": False,
638
"Integer": 0,
639
"Timeout": 0,
640
"Interval": 1000,
641
"ApprovalDelay": 2000,
642
"ApprovalDuration": 3000,
643
"ExtendedTimeout": 4000,
644
"String": "",
645
},
646
{
647
"Attr1": "x2",
648
"AttrTwo": "y2",
649
"AttrThree": "z2",
650
"Bool": dbus.Boolean(True),
651
"NonDbusBoolean": True,
652
"Integer": 1,
653
"Timeout": 93785000,
654
"Interval": 93786000,
655
"ApprovalDelay": 93787000,
656
"ApprovalDuration": 93788000,
657
"ExtendedTimeout": 93789000,
658
"String": "A huge string which will not fit," * 10,
659
},
660
]
661
def test_short_header(self):
662
text = str(TableOfClients(self.clients, self.keywords,
663
self.tablewords))
664
expected_text = """
665
X Yy
666
x1 y1
667
x2 y2
668
"""[1:-1]
669
self.assertEqual(text, expected_text)
670
def test_booleans(self):
671
keywords = ["Bool", "NonDbusBoolean"]
672
text = str(TableOfClients(self.clients, keywords,
673
self.tablewords))
674
expected_text = """
675
A D-BUS Boolean A Non-D-BUS Boolean
676
No False
677
Yes True
678
"""[1:-1]
679
self.assertEqual(text, expected_text)
680
def test_milliseconds_detection(self):
681
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
682
"ApprovalDuration", "ExtendedTimeout"]
683
text = str(TableOfClients(self.clients, keywords,
684
self.tablewords))
685
expected_text = """
686
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
687
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
688
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
689
"""[1:-1]
690
self.assertEqual(text, expected_text)
691
def test_empty_and_long_string_values(self):
692
keywords = ["String"]
693
text = str(TableOfClients(self.clients, keywords,
694
self.tablewords))
695
expected_text = """
696
A String
697
698
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,
699
"""[1:-1]
700
self.assertEqual(text, expected_text)
701
702
703
704
def should_only_run_tests():
705
parser = argparse.ArgumentParser(add_help=False)
706
parser.add_argument("--check", action='store_true')
707
args, unknown_args = parser.parse_known_args()
708
run_tests = args.check
709
if run_tests:
710
# Remove --check argument from sys.argv
711
sys.argv[1:] = unknown_args
712
return run_tests
713
714
# Add all tests from doctest strings
715
def load_tests(loader, tests, none):
716
import doctest
717
tests.addTests(doctest.DocTestSuite())
718
return tests
719
469
720
470
if __name__ == "__main__":
721
if should_only_run_tests():
722
# Call using ./tdd-python-script --check [--verbose]
723
unittest.main()
724
else:
725
main()
471
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0