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 27
- compare with another revision
- download diff
- download tarball
- view history from revision 27
- Committer: Teddy Hogeborn
- Date: 2008-07-22 06:25:35 UTC
- mfrom: (24.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080722062535-whz5do0b3dzw6m08
Merge.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
mandos-ctl
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
#
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
15
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
20
#
21
# 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
#
24
# Contact the authors at <mandos@recompile.se>.
25
#
26
27
from __future__ import (division, absolute_import, print_function,
28
unicode_literals)
29
30
try:
31
from future_builtins import *
32
except ImportError:
33
pass
34
35
import sys
36
import argparse
37
import locale
38
import datetime
39
import re
40
import os
41
import collections
42
import json
43
import unittest
44
import logging
45
46
import dbus
47
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
if sys.version_info.major == 2:
60
str = unicode
61
62
locale.setlocale(locale.LC_ALL, "")
63
64
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
65
domain = "se.recompile"
66
busname = domain + ".Mandos"
67
server_path = "/"
68
server_interface = domain + ".Mandos"
69
client_interface = domain + ".Mandos.Client"
70
version = "1.8.3"
71
72
73
try:
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
78
79
def milliseconds_to_string(ms):
80
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))
86
87
88
def rfc3339_duration_to_delta(duration):
89
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
91
>>> rfc3339_duration_to_delta("P7D")
92
datetime.timedelta(7)
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):
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
"""
137
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.
144
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"),
164
None,
165
frozenset((token_hour, token_minute,
166
token_second)))
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,
182
token_week)))
183
# Define starting values:
184
# Value so far
185
value = datetime.timedelta()
186
found_token = None
187
# Following valid tokens
188
followers = frozenset((token_duration, ))
189
# String left to parse
190
s = duration
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:
197
# Token found
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)
205
# Go to found token
206
found_token = token
207
# Set valid next tokens
208
followers = found_token.followers
209
break
210
else:
211
# No currently valid tokens were found
212
raise ValueError("Invalid RFC 3339 duration: {!r}"
213
.format(duration))
214
# End token found
215
return value
216
217
218
def string_to_delta(interval):
219
"""Parse a string and return a datetime.timedelta"""
220
221
try:
222
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
253
value = datetime.timedelta(0)
254
regexp = re.compile(r"(\d+)([dsmhw]?)")
255
256
for num, suffix in regexp.findall(interval):
257
if suffix == "d":
258
value += datetime.timedelta(int(num))
259
elif suffix == "s":
260
value += datetime.timedelta(0, int(num))
261
elif suffix == "m":
262
value += datetime.timedelta(0, 0, 0, 0, int(num))
263
elif suffix == "h":
264
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
265
elif suffix == "w":
266
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
267
elif suffix == "":
268
value += datetime.timedelta(0, 0, 0, int(num))
269
return value
270
271
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
330
def valuetostring(value, keyword):
331
if isinstance(value, dbus.Boolean):
332
return "Yes" if value else "No"
333
if keyword in ("Timeout", "Interval", "ApprovalDelay",
334
"ApprovalDuration", "ExtendedTimeout"):
335
return milliseconds_to_string(value)
336
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})
345
346
347
def has_actions(options):
348
return any((options.enable,
349
options.disable,
350
options.bump_timeout,
351
options.start_checker,
352
options.stop_checker,
353
options.is_enabled,
354
options.remove,
355
options.checker is not None,
356
options.timeout is not None,
357
options.extended_timeout is not None,
358
options.interval is not None,
359
options.approved_by_default is not None,
360
options.approval_delay is not None,
361
options.approval_duration is not None,
362
options.host is not None,
363
options.secret is not None,
364
options.approve,
365
options.deny))
366
367
368
def main():
369
parser = argparse.ArgumentParser()
370
parser.add_argument("--version", action="version",
371
version="%(prog)s {}".format(version),
372
help="show version number and exit")
373
parser.add_argument("-a", "--all", action="store_true",
374
help="Select all clients")
375
parser.add_argument("-v", "--verbose", action="store_true",
376
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")
385
parser.add_argument("-b", "--bump-timeout", action="store_true",
386
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")
394
parser.add_argument("-V", "--is-enabled", action="store_true",
395
help="Check if client is enabled")
396
parser.add_argument("-r", "--remove", action="store_true",
397
help="Remove client")
398
parser.add_argument("-c", "--checker",
399
help="Set checker command for client")
400
parser.add_argument("-t", "--timeout",
401
help="Set timeout for client")
402
parser.add_argument("--extended-timeout",
403
help="Set extended timeout for client")
404
parser.add_argument("-i", "--interval",
405
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")
415
parser.add_argument("--approval-delay",
416
help="Set delay before client approve/deny")
417
parser.add_argument("--approval-duration",
418
help="Set duration of one client approval")
419
parser.add_argument("-H", "--host", help="Set host for client")
420
parser.add_argument("-s", "--secret",
421
type=argparse.FileType(mode="rb"),
422
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")
429
parser.add_argument("--check", action="store_true",
430
help="Run self-test")
431
parser.add_argument("client", nargs="*", help="Client name")
432
options = parser.parse_args()
433
434
if has_actions(options) and not (options.client or options.all):
435
parser.error("Options require clients names or --all.")
436
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.")
441
if options.all and not has_actions(options):
442
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
446
try:
447
bus = dbus.SystemBus()
448
mandos_dbus_objc = bus.get_object(busname, server_path)
449
except dbus.exceptions.DBusException:
450
log.critical("Could not connect to Mandos server")
451
sys.exit(1)
452
453
mandos_serv = dbus.Interface(mandos_dbus_objc,
454
dbus_interface=server_interface)
455
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
459
null = os.open(os.path.devnull, os.O_RDWR)
460
stderrcopy = os.dup(sys.stderr.fileno())
461
os.dup2(null, sys.stderr.fileno())
462
os.close(null)
463
try:
464
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}
470
finally:
471
# restore stderr
472
os.dup2(stderrcopy, sys.stderr.fileno())
473
os.close(stderrcopy)
474
except dbus.exceptions.DBusException as e:
475
log.critical("Failed to access Mandos server through D-Bus:"
476
"\n%s", e)
477
sys.exit(1)
478
479
# Compile dict of (clients: properties) to process
480
clients = {}
481
482
if options.all or not options.client:
483
clients = {bus.get_object(busname, path): properties
484
for path, properties in mandos_clients.items()}
485
else:
486
for name in options.client:
487
for path, client in mandos_clients.items():
488
if client["Name"] == name:
489
client_objc = bus.get_object(busname, path)
490
clients[client_objc] = client
491
break
492
else:
493
log.critical("Client not found on server: %r", name)
494
sys.exit(1)
495
496
if not has_actions(options) and clients:
497
if options.verbose or options.dump_json:
498
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")
506
else:
507
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))
522
else:
523
# Process each client in the list by all selected options
524
for client in clients:
525
526
def set_client_prop(prop, value):
527
"""Set a Client D-Bus property"""
528
client.Set(client_interface, prop, value,
529
dbus_interface=dbus.PROPERTIES_IFACE)
530
531
def set_client_prop_ms(prop, value):
532
"""Set a Client D-Bus property, converted
533
from a string to milliseconds."""
534
set_client_prop(prop,
535
string_to_delta(value).total_seconds()
536
* 1000)
537
538
if options.remove:
539
mandos_serv.RemoveClient(client.__dbus_object_path__)
540
if options.enable:
541
set_client_prop("Enabled", dbus.Boolean(True))
542
if options.disable:
543
set_client_prop("Enabled", dbus.Boolean(False))
544
if options.bump_timeout:
545
set_client_prop("LastCheckedOK", "")
546
if options.start_checker:
547
set_client_prop("CheckerRunning", dbus.Boolean(True))
548
if options.stop_checker:
549
set_client_prop("CheckerRunning", dbus.Boolean(False))
550
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)
556
if options.checker is not None:
557
set_client_prop("Checker", options.checker)
558
if options.host is not None:
559
set_client_prop("Host", options.host)
560
if options.interval is not None:
561
set_client_prop_ms("Interval", options.interval)
562
if options.approval_delay is not None:
563
set_client_prop_ms("ApprovalDelay",
564
options.approval_delay)
565
if options.approval_duration is not None:
566
set_client_prop_ms("ApprovalDuration",
567
options.approval_duration)
568
if options.timeout is not None:
569
set_client_prop_ms("Timeout", options.timeout)
570
if options.extended_timeout is not None:
571
set_client_prop_ms("ExtendedTimeout",
572
options.extended_timeout)
573
if options.secret is not None:
574
set_client_prop("Secret",
575
dbus.ByteArray(options.secret.read()))
576
if options.approved_by_default is not None:
577
set_client_prop("ApprovedByDefault",
578
dbus.Boolean(options
579
.approved_by_default))
580
if options.approve:
581
client.Approve(dbus.Boolean(True),
582
dbus_interface=client_interface)
583
elif options.deny:
584
client.Approve(dbus.Boolean(False),
585
dbus_interface=client_interface)
586
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
720
if __name__ == "__main__":
721
if should_only_run_tests():
722
# Call using ./tdd-python-script --check [--verbose]
723
unittest.main()
724
else:
725
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0