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 24.1.35
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.35
- Committer: Björn Påhlsson
- Date: 2008-08-10 00:18:25 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 59.
- Revision ID: belorn@braxen-20080810001825-nxr0rza1hclj4mr7
version 1.0
- files added:
- network-protocol.txt
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files renamed:
- plugin-runner.c => mandos-client.c
- plugin-runner.xml => mandos-client.xml
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- 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
tablewords = {
65
"Name": "Name",
66
"Enabled": "Enabled",
67
"Timeout": "Timeout",
68
"LastCheckedOK": "Last Successful Check",
69
"LastApprovalRequest": "Last Approval Request",
70
"Created": "Created",
71
"Interval": "Interval",
72
"Host": "Host",
73
"Fingerprint": "Fingerprint",
74
"KeyID": "Key ID",
75
"CheckerRunning": "Check Is Running",
76
"LastEnabled": "Last Enabled",
77
"ApprovalPending": "Approval Is Pending",
78
"ApprovedByDefault": "Approved By Default",
79
"ApprovalDelay": "Approval Delay",
80
"ApprovalDuration": "Approval Duration",
81
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
83
"Expires": "Expires",
84
"LastCheckerStatus": "Last Checker Status",
85
}
86
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
domain = "se.recompile"
88
busname = domain + ".Mandos"
89
server_path = "/"
90
server_interface = domain + ".Mandos"
91
client_interface = domain + ".Mandos.Client"
92
version = "1.8.3"
93
94
95
try:
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
99
100
101
def milliseconds_to_string(ms):
102
td = datetime.timedelta(0, 0, 0, ms)
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
104
.format(days="{}T".format(td.days) if td.days else "",
105
hours=td.seconds // 3600,
106
minutes=(td.seconds % 3600) // 60,
107
seconds=td.seconds % 60))
108
109
110
def rfc3339_duration_to_delta(duration):
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
112
113
>>> rfc3339_duration_to_delta("P7D")
114
datetime.timedelta(7)
115
>>> rfc3339_duration_to_delta("PT60S")
116
datetime.timedelta(0, 60)
117
>>> rfc3339_duration_to_delta("PT60M")
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
>>> rfc3339_duration_to_delta("PT24H")
122
datetime.timedelta(1)
123
>>> rfc3339_duration_to_delta("P1W")
124
datetime.timedelta(7)
125
>>> rfc3339_duration_to_delta("PT5M30S")
126
datetime.timedelta(0, 330)
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
datetime.timedelta(1, 200)
129
>>> # Can not be empty:
130
>>> rfc3339_duration_to_delta("")
131
Traceback (most recent call last):
132
...
133
ValueError: Invalid RFC 3339 duration: u''
134
>>> # Must start with "P":
135
>>> rfc3339_duration_to_delta("1D")
136
Traceback (most recent call last):
137
...
138
ValueError: Invalid RFC 3339 duration: u'1D'
139
>>> # Must use correct order
140
>>> rfc3339_duration_to_delta("PT1S2M")
141
Traceback (most recent call last):
142
...
143
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
144
>>> # Time needs time marker
145
>>> rfc3339_duration_to_delta("P1H2S")
146
Traceback (most recent call last):
147
...
148
ValueError: Invalid RFC 3339 duration: u'P1H2S'
149
>>> # Weeks can not be combined with anything else
150
>>> rfc3339_duration_to_delta("P1D2W")
151
Traceback (most recent call last):
152
...
153
ValueError: Invalid RFC 3339 duration: u'P1D2W'
154
>>> rfc3339_duration_to_delta("P2W2H")
155
Traceback (most recent call last):
156
...
157
ValueError: Invalid RFC 3339 duration: u'P2W2H'
158
"""
159
160
# Parsing an RFC 3339 duration with regular expressions is not
161
# possible - there would have to be multiple places for the same
162
# values, like seconds. The current code, while more esoteric, is
163
# cleaner without depending on a parsing library. If Python had a
164
# built-in library for parsing we would use it, but we'd like to
165
# avoid excessive use of external libraries.
166
167
# New type for defining tokens, syntax, and semantics all-in-one
168
Token = collections.namedtuple("Token", (
169
"regexp", # To match token; if "value" is not None, must have
170
# a "group" containing digits
171
"value", # datetime.timedelta or None
172
"followers")) # Tokens valid after this token
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
token_end = Token(re.compile(r"$"), None, frozenset())
176
token_second = Token(re.compile(r"(\d+)S"),
177
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
179
token_minute = Token(re.compile(r"(\d+)M"),
180
datetime.timedelta(minutes=1),
181
frozenset((token_second, token_end)))
182
token_hour = Token(re.compile(r"(\d+)H"),
183
datetime.timedelta(hours=1),
184
frozenset((token_minute, token_end)))
185
token_time = Token(re.compile(r"T"),
186
None,
187
frozenset((token_hour, token_minute,
188
token_second)))
189
token_day = Token(re.compile(r"(\d+)D"),
190
datetime.timedelta(days=1),
191
frozenset((token_time, token_end)))
192
token_month = Token(re.compile(r"(\d+)M"),
193
datetime.timedelta(weeks=4),
194
frozenset((token_day, token_end)))
195
token_year = Token(re.compile(r"(\d+)Y"),
196
datetime.timedelta(weeks=52),
197
frozenset((token_month, token_end)))
198
token_week = Token(re.compile(r"(\d+)W"),
199
datetime.timedelta(weeks=1),
200
frozenset((token_end, )))
201
token_duration = Token(re.compile(r"P"), None,
202
frozenset((token_year, token_month,
203
token_day, token_time,
204
token_week)))
205
# Define starting values:
206
# Value so far
207
value = datetime.timedelta()
208
found_token = None
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
212
s = duration
213
# Loop until end token is found
214
while found_token is not token_end:
215
# Search for any currently valid tokens
216
for token in followers:
217
match = token.regexp.match(s)
218
if match is not None:
219
# Token found
220
if token.value is not None:
221
# Value found, parse digits
222
factor = int(match.group(1), 10)
223
# Add to value so far
224
value += factor * token.value
225
# Strip token from string
226
s = token.regexp.sub("", s, 1)
227
# Go to found token
228
found_token = token
229
# Set valid next tokens
230
followers = found_token.followers
231
break
232
else:
233
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
235
.format(duration))
236
# End token found
237
return value
238
239
240
def string_to_delta(interval):
241
"""Parse a string and return a datetime.timedelta
242
"""
243
244
try:
245
return rfc3339_duration_to_delta(interval)
246
except ValueError as e:
247
log.warning("%s - Parsing as pre-1.6.1 interval instead",
248
' '.join(e.args))
249
return parse_pre_1_6_1_interval(interval)
250
251
252
def parse_pre_1_6_1_interval(interval):
253
"""Parse an interval string as documented by Mandos before 1.6.1, and
254
return a datetime.timedelta
255
>>> parse_pre_1_6_1_interval('7d')
256
datetime.timedelta(7)
257
>>> parse_pre_1_6_1_interval('60s')
258
datetime.timedelta(0, 60)
259
>>> parse_pre_1_6_1_interval('60m')
260
datetime.timedelta(0, 3600)
261
>>> parse_pre_1_6_1_interval('24h')
262
datetime.timedelta(1)
263
>>> parse_pre_1_6_1_interval('1w')
264
datetime.timedelta(7)
265
>>> parse_pre_1_6_1_interval('5m 30s')
266
datetime.timedelta(0, 330)
267
>>> parse_pre_1_6_1_interval('')
268
datetime.timedelta(0)
269
>>> # Ignore unknown characters, allow any order and repetitions
270
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
271
datetime.timedelta(2, 480, 18000)
272
273
"""
274
275
value = datetime.timedelta(0)
276
regexp = re.compile(r"(\d+)([dsmhw]?)")
277
278
for num, suffix in regexp.findall(interval):
279
if suffix == "d":
280
value += datetime.timedelta(int(num))
281
elif suffix == "s":
282
value += datetime.timedelta(0, int(num))
283
elif suffix == "m":
284
value += datetime.timedelta(0, 0, 0, 0, int(num))
285
elif suffix == "h":
286
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
287
elif suffix == "w":
288
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
289
elif suffix == "":
290
value += datetime.timedelta(0, 0, 0, int(num))
291
return value
292
293
294
def print_clients(clients, keywords):
295
print('\n'.join(TableOfClients(clients, keywords).rows()))
296
297
class TableOfClients(object):
298
def __init__(self, clients, keywords):
299
self.clients = clients
300
self.keywords = keywords
301
302
@staticmethod
303
def valuetostring(value, keyword):
304
if isinstance(value, dbus.Boolean):
305
return "Yes" if value else "No"
306
if keyword in ("Timeout", "Interval", "ApprovalDelay",
307
"ApprovalDuration", "ExtendedTimeout"):
308
return milliseconds_to_string(value)
309
return str(value)
310
311
def rows(self):
312
# Create format string to format table rows
313
format_string = " ".join("{{{key}:{width}}}".format(
314
width=max(len(tablewords[key]),
315
max(len(self.valuetostring(client[key], key))
316
for client in self.clients)),
317
key=key)
318
for key in self.keywords)
319
# Start with header line
320
rows = [format_string.format(**tablewords)]
321
for client in self.clients:
322
rows.append(format_string
323
.format(**{key: self.valuetostring(client[key], key)
324
for key in self.keywords}))
325
return rows
326
327
328
def has_actions(options):
329
return any((options.enable,
330
options.disable,
331
options.bump_timeout,
332
options.start_checker,
333
options.stop_checker,
334
options.is_enabled,
335
options.remove,
336
options.checker is not None,
337
options.timeout is not None,
338
options.extended_timeout is not None,
339
options.interval is not None,
340
options.approved_by_default is not None,
341
options.approval_delay is not None,
342
options.approval_duration is not None,
343
options.host is not None,
344
options.secret is not None,
345
options.approve,
346
options.deny))
347
348
349
def main():
350
parser = argparse.ArgumentParser()
351
parser.add_argument("--version", action="version",
352
version="%(prog)s {}".format(version),
353
help="show version number and exit")
354
parser.add_argument("-a", "--all", action="store_true",
355
help="Select all clients")
356
parser.add_argument("-v", "--verbose", action="store_true",
357
help="Print all fields")
358
parser.add_argument("-j", "--dump-json", action="store_true",
359
help="Dump client data in JSON format")
360
parser.add_argument("-e", "--enable", action="store_true",
361
help="Enable client")
362
parser.add_argument("-d", "--disable", action="store_true",
363
help="disable client")
364
parser.add_argument("-b", "--bump-timeout", action="store_true",
365
help="Bump timeout for client")
366
parser.add_argument("--start-checker", action="store_true",
367
help="Start checker for client")
368
parser.add_argument("--stop-checker", action="store_true",
369
help="Stop checker for client")
370
parser.add_argument("-V", "--is-enabled", action="store_true",
371
help="Check if client is enabled")
372
parser.add_argument("-r", "--remove", action="store_true",
373
help="Remove client")
374
parser.add_argument("-c", "--checker",
375
help="Set checker command for client")
376
parser.add_argument("-t", "--timeout",
377
help="Set timeout for client")
378
parser.add_argument("--extended-timeout",
379
help="Set extended timeout for client")
380
parser.add_argument("-i", "--interval",
381
help="Set checker interval for client")
382
parser.add_argument("--approve-by-default", action="store_true",
383
default=None, dest="approved_by_default",
384
help="Set client to be approved by default")
385
parser.add_argument("--deny-by-default", action="store_false",
386
dest="approved_by_default",
387
help="Set client to be denied by default")
388
parser.add_argument("--approval-delay",
389
help="Set delay before client approve/deny")
390
parser.add_argument("--approval-duration",
391
help="Set duration of one client approval")
392
parser.add_argument("-H", "--host", help="Set host for client")
393
parser.add_argument("-s", "--secret",
394
type=argparse.FileType(mode="rb"),
395
help="Set password blob (file) for client")
396
parser.add_argument("-A", "--approve", action="store_true",
397
help="Approve any current client request")
398
parser.add_argument("-D", "--deny", action="store_true",
399
help="Deny any current client request")
400
parser.add_argument("--check", action="store_true",
401
help="Run self-test")
402
parser.add_argument("client", nargs="*", help="Client name")
403
options = parser.parse_args()
404
405
if has_actions(options) and not (options.client or options.all):
406
parser.error("Options require clients names or --all.")
407
if options.verbose and has_actions(options):
408
parser.error("--verbose can only be used alone.")
409
if options.dump_json and (options.verbose
410
or has_actions(options)):
411
parser.error("--dump-json can only be used alone.")
412
if options.all and not has_actions(options):
413
parser.error("--all requires an action.")
414
415
try:
416
bus = dbus.SystemBus()
417
mandos_dbus_objc = bus.get_object(busname, server_path)
418
except dbus.exceptions.DBusException:
419
log.critical("Could not connect to Mandos server")
420
sys.exit(1)
421
422
mandos_serv = dbus.Interface(mandos_dbus_objc,
423
dbus_interface=server_interface)
424
mandos_serv_object_manager = dbus.Interface(
425
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
426
427
# block stderr since dbus library prints to stderr
428
null = os.open(os.path.devnull, os.O_RDWR)
429
stderrcopy = os.dup(sys.stderr.fileno())
430
os.dup2(null, sys.stderr.fileno())
431
os.close(null)
432
try:
433
try:
434
mandos_clients = {path: ifs_and_props[client_interface]
435
for path, ifs_and_props in
436
mandos_serv_object_manager
437
.GetManagedObjects().items()
438
if client_interface in ifs_and_props}
439
finally:
440
# restore stderr
441
os.dup2(stderrcopy, sys.stderr.fileno())
442
os.close(stderrcopy)
443
except dbus.exceptions.DBusException as e:
444
log.critical("Failed to access Mandos server through D-Bus:"
445
"\n%s", e)
446
sys.exit(1)
447
448
# Compile dict of (clients: properties) to process
449
clients = {}
450
451
if options.all or not options.client:
452
clients = {bus.get_object(busname, path): properties
453
for path, properties in mandos_clients.items()}
454
else:
455
for name in options.client:
456
for path, client in mandos_clients.items():
457
if client["Name"] == name:
458
client_objc = bus.get_object(busname, path)
459
clients[client_objc] = client
460
break
461
else:
462
log.critical("Client not found on server: %r", name)
463
sys.exit(1)
464
465
if not has_actions(options) and clients:
466
if options.verbose or options.dump_json:
467
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
468
"Created", "Interval", "Host", "KeyID",
469
"Fingerprint", "CheckerRunning",
470
"LastEnabled", "ApprovalPending",
471
"ApprovedByDefault", "LastApprovalRequest",
472
"ApprovalDelay", "ApprovalDuration",
473
"Checker", "ExtendedTimeout", "Expires",
474
"LastCheckerStatus")
475
else:
476
keywords = defaultkeywords
477
478
if options.dump_json:
479
json.dump({client["Name"]: {key:
480
bool(client[key])
481
if isinstance(client[key],
482
dbus.Boolean)
483
else client[key]
484
for key in keywords}
485
for client in clients.values()},
486
fp=sys.stdout, indent=4,
487
separators=(',', ': '))
488
print()
489
else:
490
print_clients(clients.values(), keywords)
491
else:
492
# Process each client in the list by all selected options
493
for client in clients:
494
495
def set_client_prop(prop, value):
496
"""Set a Client D-Bus property"""
497
client.Set(client_interface, prop, value,
498
dbus_interface=dbus.PROPERTIES_IFACE)
499
500
def set_client_prop_ms(prop, value):
501
"""Set a Client D-Bus property, converted
502
from a string to milliseconds."""
503
set_client_prop(prop,
504
string_to_delta(value).total_seconds()
505
* 1000)
506
507
if options.remove:
508
mandos_serv.RemoveClient(client.__dbus_object_path__)
509
if options.enable:
510
set_client_prop("Enabled", dbus.Boolean(True))
511
if options.disable:
512
set_client_prop("Enabled", dbus.Boolean(False))
513
if options.bump_timeout:
514
set_client_prop("LastCheckedOK", "")
515
if options.start_checker:
516
set_client_prop("CheckerRunning", dbus.Boolean(True))
517
if options.stop_checker:
518
set_client_prop("CheckerRunning", dbus.Boolean(False))
519
if options.is_enabled:
520
if client.Get(client_interface, "Enabled",
521
dbus_interface=dbus.PROPERTIES_IFACE):
522
sys.exit(0)
523
else:
524
sys.exit(1)
525
if options.checker is not None:
526
set_client_prop("Checker", options.checker)
527
if options.host is not None:
528
set_client_prop("Host", options.host)
529
if options.interval is not None:
530
set_client_prop_ms("Interval", options.interval)
531
if options.approval_delay is not None:
532
set_client_prop_ms("ApprovalDelay",
533
options.approval_delay)
534
if options.approval_duration is not None:
535
set_client_prop_ms("ApprovalDuration",
536
options.approval_duration)
537
if options.timeout is not None:
538
set_client_prop_ms("Timeout", options.timeout)
539
if options.extended_timeout is not None:
540
set_client_prop_ms("ExtendedTimeout",
541
options.extended_timeout)
542
if options.secret is not None:
543
set_client_prop("Secret",
544
dbus.ByteArray(options.secret.read()))
545
if options.approved_by_default is not None:
546
set_client_prop("ApprovedByDefault",
547
dbus.Boolean(options
548
.approved_by_default))
549
if options.approve:
550
client.Approve(dbus.Boolean(True),
551
dbus_interface=client_interface)
552
elif options.deny:
553
client.Approve(dbus.Boolean(False),
554
dbus_interface=client_interface)
555
556
557
class Test_milliseconds_to_string(unittest.TestCase):
558
def test_all(self):
559
self.assertEqual(milliseconds_to_string(93785000),
560
"1T02:03:05")
561
def test_no_days(self):
562
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
563
def test_all_zero(self):
564
self.assertEqual(milliseconds_to_string(0), "00:00:00")
565
def test_no_fractional_seconds(self):
566
self.assertEqual(milliseconds_to_string(400), "00:00:00")
567
self.assertEqual(milliseconds_to_string(900), "00:00:00")
568
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
569
570
class Test_string_to_delta(unittest.TestCase):
571
def test_handles_basic_rfc3339(self):
572
self.assertEqual(string_to_delta("PT2H"),
573
datetime.timedelta(0, 7200))
574
def test_falls_back_to_pre_1_6_1_with_warning(self):
575
# assertLogs only exists in Python 3.4
576
if hasattr(self, "assertLogs"):
577
with self.assertLogs(log, logging.WARNING):
578
value = string_to_delta("2h")
579
else:
580
value = string_to_delta("2h")
581
self.assertEqual(value, datetime.timedelta(0, 7200))
582
583
class Test_TableOfClients(unittest.TestCase):
584
def setUp(self):
585
global tablewords
586
self.old_tablewords = tablewords
587
tablewords = {
588
"Attr1": "X",
589
"AttrTwo": "Yy",
590
"AttrThree": "Zzz",
591
"Bool": "A D-BUS Boolean",
592
"NonDbusBoolean": "A Non-D-BUS Boolean",
593
"Integer": "An Integer",
594
"Timeout": "Timedelta 1",
595
"Interval": "Timedelta 2",
596
"ApprovalDelay": "Timedelta 3",
597
"ApprovalDuration": "Timedelta 4",
598
"ExtendedTimeout": "Timedelta 5",
599
"String": "A String",
600
}
601
self.keywords = ["Attr1", "AttrTwo"]
602
self.clients = [
603
{
604
"Attr1": "x1",
605
"AttrTwo": "y1",
606
"AttrThree": "z1",
607
"Bool": dbus.Boolean(False),
608
"NonDbusBoolean": False,
609
"Integer": 0,
610
"Timeout": 0,
611
"Interval": 1000,
612
"ApprovalDelay": 2000,
613
"ApprovalDuration": 3000,
614
"ExtendedTimeout": 4000,
615
"String": "",
616
},
617
{
618
"Attr1": "x2",
619
"AttrTwo": "y2",
620
"AttrThree": "z2",
621
"Bool": dbus.Boolean(True),
622
"NonDbusBoolean": True,
623
"Integer": 1,
624
"Timeout": 93785000,
625
"Interval": 93786000,
626
"ApprovalDelay": 93787000,
627
"ApprovalDuration": 93788000,
628
"ExtendedTimeout": 93789000,
629
"String": "A huge string which will not fit," * 10,
630
},
631
]
632
def tearDown(self):
633
global tablewords
634
tablewords = self.old_tablewords
635
def test_short_header(self):
636
rows = TableOfClients(self.clients, self.keywords).rows()
637
expected_rows = [
638
"X Yy",
639
"x1 y1",
640
"x2 y2"]
641
self.assertEqual(rows, expected_rows)
642
def test_booleans(self):
643
keywords = ["Bool", "NonDbusBoolean"]
644
rows = TableOfClients(self.clients, keywords).rows()
645
expected_rows = [
646
"A D-BUS Boolean A Non-D-BUS Boolean",
647
"No False ",
648
"Yes True ",
649
]
650
self.assertEqual(rows, expected_rows)
651
def test_milliseconds_detection(self):
652
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
653
"ApprovalDuration", "ExtendedTimeout"]
654
rows = TableOfClients(self.clients, keywords).rows()
655
expected_rows = ("""
656
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
657
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
658
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
659
"""
660
).splitlines()[1:]
661
self.assertEqual(rows, expected_rows)
662
def test_empty_and_long_string_values(self):
663
keywords = ["String"]
664
rows = TableOfClients(self.clients, keywords).rows()
665
expected_rows = ("""
666
A String
667
668
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,
669
"""
670
).splitlines()[1:]
671
self.assertEqual(rows, expected_rows)
672
673
674
675
def should_only_run_tests():
676
parser = argparse.ArgumentParser(add_help=False)
677
parser.add_argument("--check", action='store_true')
678
args, unknown_args = parser.parse_known_args()
679
run_tests = args.check
680
if run_tests:
681
# Remove --check argument from sys.argv
682
sys.argv[1:] = unknown_args
683
return run_tests
684
685
# Add all tests from doctest strings
686
def load_tests(loader, tests, none):
687
import doctest
688
tests.addTests(doctest.DocTestSuite())
689
return tests
690
691
if __name__ == "__main__":
692
if should_only_run_tests():
693
# Call using ./tdd-python-script --check [--verbose]
694
unittest.main()
695
else:
696
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0