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 182
- compare with another revision
- download diff
- download tarball
- view history from revision 182
- Committer: Teddy Hogeborn
- Date: 2008-09-12 19:12:40 UTC
- Revision ID: teddy@fukt.bsnet.se-20080912191240-edjlcll43eoijkx0
* Makefile (install): Use "install-client-nokey".
(install-server): Create "/etc/default" and "/usr/sbin", too.
(install-client): Do not depend on "$(INITRAMFSTOOLS)/hooks/.".
Renamed to "install-client-nokey". Split out
post-installation-stuff to new "install-client"
target.
* mandos-clients.conf.xml: White space adjustments.
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* overview.xml: Improved grammar.
(install-server): Create "/etc/default" and "/usr/sbin", too.
(install-client): Do not depend on "$(INITRAMFSTOOLS)/hooks/.".
Renamed to "install-client-nokey". Split out
post-installation-stuff to new "install-client"
target.
* mandos-clients.conf.xml: White space adjustments.
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* overview.xml: Improved grammar.
- files added:
- debian
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
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
parser.add_argument("-e", "--enable", action="store_true",
380
help="Enable client")
381
parser.add_argument("-d", "--disable", action="store_true",
382
help="disable client")
383
parser.add_argument("-b", "--bump-timeout", action="store_true",
384
help="Bump timeout for client")
385
parser.add_argument("--start-checker", action="store_true",
386
help="Start checker for client")
387
parser.add_argument("--stop-checker", action="store_true",
388
help="Stop checker for client")
389
parser.add_argument("-V", "--is-enabled", action="store_true",
390
help="Check if client is enabled")
391
parser.add_argument("-r", "--remove", action="store_true",
392
help="Remove client")
393
parser.add_argument("-c", "--checker",
394
help="Set checker command for client")
395
parser.add_argument("-t", "--timeout",
396
help="Set timeout for client")
397
parser.add_argument("--extended-timeout",
398
help="Set extended timeout for client")
399
parser.add_argument("-i", "--interval",
400
help="Set checker interval for client")
401
parser.add_argument("--approve-by-default", action="store_true",
402
default=None, dest="approved_by_default",
403
help="Set client to be approved by default")
404
parser.add_argument("--deny-by-default", action="store_false",
405
dest="approved_by_default",
406
help="Set client to be denied by default")
407
parser.add_argument("--approval-delay",
408
help="Set delay before client approve/deny")
409
parser.add_argument("--approval-duration",
410
help="Set duration of one client approval")
411
parser.add_argument("-H", "--host", help="Set host for client")
412
parser.add_argument("-s", "--secret",
413
type=argparse.FileType(mode="rb"),
414
help="Set password blob (file) for client")
415
parser.add_argument("-A", "--approve", action="store_true",
416
help="Approve any current client request")
417
parser.add_argument("-D", "--deny", action="store_true",
418
help="Deny any current client request")
419
parser.add_argument("--check", action="store_true",
420
help="Run self-test")
421
parser.add_argument("client", nargs="*", help="Client name")
422
options = parser.parse_args()
423
424
if has_actions(options) and not (options.client or options.all):
425
parser.error("Options require clients names or --all.")
426
if options.verbose and has_actions(options):
427
parser.error("--verbose can only be used alone.")
428
if options.dump_json and (options.verbose
429
or has_actions(options)):
430
parser.error("--dump-json can only be used alone.")
431
if options.all and not has_actions(options):
432
parser.error("--all requires an action.")
433
434
try:
435
bus = dbus.SystemBus()
436
mandos_dbus_objc = bus.get_object(busname, server_path)
437
except dbus.exceptions.DBusException:
438
log.critical("Could not connect to Mandos server")
439
sys.exit(1)
440
441
mandos_serv = dbus.Interface(mandos_dbus_objc,
442
dbus_interface=server_interface)
443
mandos_serv_object_manager = dbus.Interface(
444
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
445
446
# block stderr since dbus library prints to stderr
447
null = os.open(os.path.devnull, os.O_RDWR)
448
stderrcopy = os.dup(sys.stderr.fileno())
449
os.dup2(null, sys.stderr.fileno())
450
os.close(null)
451
try:
452
try:
453
mandos_clients = {path: ifs_and_props[client_interface]
454
for path, ifs_and_props in
455
mandos_serv_object_manager
456
.GetManagedObjects().items()
457
if client_interface in ifs_and_props}
458
finally:
459
# restore stderr
460
os.dup2(stderrcopy, sys.stderr.fileno())
461
os.close(stderrcopy)
462
except dbus.exceptions.DBusException as e:
463
log.critical("Failed to access Mandos server through D-Bus:"
464
"\n%s", e)
465
sys.exit(1)
466
467
# Compile dict of (clients: properties) to process
468
clients = {}
469
470
if options.all or not options.client:
471
clients = {bus.get_object(busname, path): properties
472
for path, properties in mandos_clients.items()}
473
else:
474
for name in options.client:
475
for path, client in mandos_clients.items():
476
if client["Name"] == name:
477
client_objc = bus.get_object(busname, path)
478
clients[client_objc] = client
479
break
480
else:
481
log.critical("Client not found on server: %r", name)
482
sys.exit(1)
483
484
if not has_actions(options) and clients:
485
if options.verbose or options.dump_json:
486
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
487
"Created", "Interval", "Host", "KeyID",
488
"Fingerprint", "CheckerRunning",
489
"LastEnabled", "ApprovalPending",
490
"ApprovedByDefault", "LastApprovalRequest",
491
"ApprovalDelay", "ApprovalDuration",
492
"Checker", "ExtendedTimeout", "Expires",
493
"LastCheckerStatus")
494
else:
495
keywords = defaultkeywords
496
497
if options.dump_json:
498
json.dump({client["Name"]: {key:
499
bool(client[key])
500
if isinstance(client[key],
501
dbus.Boolean)
502
else client[key]
503
for key in keywords}
504
for client in clients.values()},
505
fp=sys.stdout, indent=4,
506
separators=(',', ': '))
507
print()
508
else:
509
print(TableOfClients(clients.values(), keywords))
510
else:
511
# Process each client in the list by all selected options
512
for client in clients:
513
514
def set_client_prop(prop, value):
515
"""Set a Client D-Bus property"""
516
client.Set(client_interface, prop, value,
517
dbus_interface=dbus.PROPERTIES_IFACE)
518
519
def set_client_prop_ms(prop, value):
520
"""Set a Client D-Bus property, converted
521
from a string to milliseconds."""
522
set_client_prop(prop,
523
string_to_delta(value).total_seconds()
524
* 1000)
525
526
if options.remove:
527
mandos_serv.RemoveClient(client.__dbus_object_path__)
528
if options.enable:
529
set_client_prop("Enabled", dbus.Boolean(True))
530
if options.disable:
531
set_client_prop("Enabled", dbus.Boolean(False))
532
if options.bump_timeout:
533
set_client_prop("LastCheckedOK", "")
534
if options.start_checker:
535
set_client_prop("CheckerRunning", dbus.Boolean(True))
536
if options.stop_checker:
537
set_client_prop("CheckerRunning", dbus.Boolean(False))
538
if options.is_enabled:
539
if client.Get(client_interface, "Enabled",
540
dbus_interface=dbus.PROPERTIES_IFACE):
541
sys.exit(0)
542
else:
543
sys.exit(1)
544
if options.checker is not None:
545
set_client_prop("Checker", options.checker)
546
if options.host is not None:
547
set_client_prop("Host", options.host)
548
if options.interval is not None:
549
set_client_prop_ms("Interval", options.interval)
550
if options.approval_delay is not None:
551
set_client_prop_ms("ApprovalDelay",
552
options.approval_delay)
553
if options.approval_duration is not None:
554
set_client_prop_ms("ApprovalDuration",
555
options.approval_duration)
556
if options.timeout is not None:
557
set_client_prop_ms("Timeout", options.timeout)
558
if options.extended_timeout is not None:
559
set_client_prop_ms("ExtendedTimeout",
560
options.extended_timeout)
561
if options.secret is not None:
562
set_client_prop("Secret",
563
dbus.ByteArray(options.secret.read()))
564
if options.approved_by_default is not None:
565
set_client_prop("ApprovedByDefault",
566
dbus.Boolean(options
567
.approved_by_default))
568
if options.approve:
569
client.Approve(dbus.Boolean(True),
570
dbus_interface=client_interface)
571
elif options.deny:
572
client.Approve(dbus.Boolean(False),
573
dbus_interface=client_interface)
574
575
576
class Test_milliseconds_to_string(unittest.TestCase):
577
def test_all(self):
578
self.assertEqual(milliseconds_to_string(93785000),
579
"1T02:03:05")
580
def test_no_days(self):
581
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
582
def test_all_zero(self):
583
self.assertEqual(milliseconds_to_string(0), "00:00:00")
584
def test_no_fractional_seconds(self):
585
self.assertEqual(milliseconds_to_string(400), "00:00:00")
586
self.assertEqual(milliseconds_to_string(900), "00:00:00")
587
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
588
589
class Test_string_to_delta(unittest.TestCase):
590
def test_handles_basic_rfc3339(self):
591
self.assertEqual(string_to_delta("PT2H"),
592
datetime.timedelta(0, 7200))
593
def test_falls_back_to_pre_1_6_1_with_warning(self):
594
# assertLogs only exists in Python 3.4
595
if hasattr(self, "assertLogs"):
596
with self.assertLogs(log, logging.WARNING):
597
value = string_to_delta("2h")
598
else:
599
value = string_to_delta("2h")
600
self.assertEqual(value, datetime.timedelta(0, 7200))
601
602
class Test_TableOfClients(unittest.TestCase):
603
def setUp(self):
604
self.tablewords = {
605
"Attr1": "X",
606
"AttrTwo": "Yy",
607
"AttrThree": "Zzz",
608
"Bool": "A D-BUS Boolean",
609
"NonDbusBoolean": "A Non-D-BUS Boolean",
610
"Integer": "An Integer",
611
"Timeout": "Timedelta 1",
612
"Interval": "Timedelta 2",
613
"ApprovalDelay": "Timedelta 3",
614
"ApprovalDuration": "Timedelta 4",
615
"ExtendedTimeout": "Timedelta 5",
616
"String": "A String",
617
}
618
self.keywords = ["Attr1", "AttrTwo"]
619
self.clients = [
620
{
621
"Attr1": "x1",
622
"AttrTwo": "y1",
623
"AttrThree": "z1",
624
"Bool": dbus.Boolean(False),
625
"NonDbusBoolean": False,
626
"Integer": 0,
627
"Timeout": 0,
628
"Interval": 1000,
629
"ApprovalDelay": 2000,
630
"ApprovalDuration": 3000,
631
"ExtendedTimeout": 4000,
632
"String": "",
633
},
634
{
635
"Attr1": "x2",
636
"AttrTwo": "y2",
637
"AttrThree": "z2",
638
"Bool": dbus.Boolean(True),
639
"NonDbusBoolean": True,
640
"Integer": 1,
641
"Timeout": 93785000,
642
"Interval": 93786000,
643
"ApprovalDelay": 93787000,
644
"ApprovalDuration": 93788000,
645
"ExtendedTimeout": 93789000,
646
"String": "A huge string which will not fit," * 10,
647
},
648
]
649
def test_short_header(self):
650
text = str(TableOfClients(self.clients, self.keywords,
651
self.tablewords))
652
expected_text = """
653
X Yy
654
x1 y1
655
x2 y2
656
"""[1:-1]
657
self.assertEqual(text, expected_text)
658
def test_booleans(self):
659
keywords = ["Bool", "NonDbusBoolean"]
660
text = str(TableOfClients(self.clients, keywords,
661
self.tablewords))
662
expected_text = """
663
A D-BUS Boolean A Non-D-BUS Boolean
664
No False
665
Yes True
666
"""[1:-1]
667
self.assertEqual(text, expected_text)
668
def test_milliseconds_detection(self):
669
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
670
"ApprovalDuration", "ExtendedTimeout"]
671
text = str(TableOfClients(self.clients, keywords,
672
self.tablewords))
673
expected_text = """
674
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
675
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
676
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
677
"""[1:-1]
678
self.assertEqual(text, expected_text)
679
def test_empty_and_long_string_values(self):
680
keywords = ["String"]
681
text = str(TableOfClients(self.clients, keywords,
682
self.tablewords))
683
expected_text = """
684
A String
685
686
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,
687
"""[1:-1]
688
self.assertEqual(text, expected_text)
689
690
691
692
def should_only_run_tests():
693
parser = argparse.ArgumentParser(add_help=False)
694
parser.add_argument("--check", action='store_true')
695
args, unknown_args = parser.parse_known_args()
696
run_tests = args.check
697
if run_tests:
698
# Remove --check argument from sys.argv
699
sys.argv[1:] = unknown_args
700
return run_tests
701
702
# Add all tests from doctest strings
703
def load_tests(loader, tests, none):
704
import doctest
705
tests.addTests(doctest.DocTestSuite())
706
return tests
707
708
if __name__ == "__main__":
709
if should_only_run_tests():
710
# Call using ./tdd-python-script --check [--verbose]
711
unittest.main()
712
else:
713
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0