77
79
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
80
def milliseconds_to_string(ms):
81
td = datetime.timedelta(0, 0, 0, ms)
82
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
83
.format(days="{}T".format(td.days) if td.days else "",
84
hours=td.seconds // 3600,
85
minutes=(td.seconds % 3600) // 60,
86
seconds=td.seconds % 60))
83
parser = argparse.ArgumentParser()
85
add_command_line_options(parser)
87
options = parser.parse_args()
89
check_option_syntax(parser, options)
91
clientnames = options.client
94
log.setLevel(logging.DEBUG)
97
bus = dbus.SystemBus()
98
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
99
dbus_busname, server_dbus_path)
100
mandos_dbus_objc = bus.get_object(dbus_busname,
102
except dbus.exceptions.DBusException:
103
log.critical("Could not connect to Mandos server")
106
mandos_serv = dbus.Interface(mandos_dbus_objc,
107
dbus_interface=server_dbus_interface)
108
mandos_serv_object_manager = dbus.Interface(
109
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
111
# Filter out log message from dbus module
112
dbus_logger = logging.getLogger("dbus.proxies")
113
class NullFilter(logging.Filter):
114
def filter(self, record):
116
dbus_filter = NullFilter()
118
dbus_logger.addFilter(dbus_filter)
119
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
120
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
121
all_clients = {path: ifs_and_props[client_dbus_interface]
122
for path, ifs_and_props in
123
mandos_serv_object_manager
124
.GetManagedObjects().items()
125
if client_dbus_interface in ifs_and_props}
126
except dbus.exceptions.DBusException as e:
127
log.critical("Failed to access Mandos server through D-Bus:"
131
# restore dbus logger
132
dbus_logger.removeFilter(dbus_filter)
134
# Compile dict of (clients: properties) to process
138
clients = all_clients
140
for name in clientnames:
141
for objpath, properties in all_clients.items():
142
if properties["Name"] == name:
143
clients[objpath] = properties
146
log.critical("Client not found on server: %r", name)
149
# Run all commands on clients
150
commands = commands_from_options(options)
151
for command in commands:
152
command.run(clients, bus, mandos_serv)
155
def add_command_line_options(parser):
156
parser.add_argument("--version", action="version",
157
version="%(prog)s {}".format(version),
158
help="show version number and exit")
159
parser.add_argument("-a", "--all", action="store_true",
160
help="Select all clients")
161
parser.add_argument("-v", "--verbose", action="store_true",
162
help="Print all fields")
163
parser.add_argument("-j", "--dump-json", action="store_true",
164
help="Dump client data in JSON format")
165
enable_disable = parser.add_mutually_exclusive_group()
166
enable_disable.add_argument("-e", "--enable", action="store_true",
167
help="Enable client")
168
enable_disable.add_argument("-d", "--disable",
170
help="disable client")
171
parser.add_argument("-b", "--bump-timeout", action="store_true",
172
help="Bump timeout for client")
173
start_stop_checker = parser.add_mutually_exclusive_group()
174
start_stop_checker.add_argument("--start-checker",
176
help="Start checker for client")
177
start_stop_checker.add_argument("--stop-checker",
179
help="Stop checker for client")
180
parser.add_argument("-V", "--is-enabled", action="store_true",
181
help="Check if client is enabled")
182
parser.add_argument("-r", "--remove", action="store_true",
183
help="Remove client")
184
parser.add_argument("-c", "--checker",
185
help="Set checker command for client")
186
parser.add_argument("-t", "--timeout", type=string_to_delta,
187
help="Set timeout for client")
188
parser.add_argument("--extended-timeout", type=string_to_delta,
189
help="Set extended timeout for client")
190
parser.add_argument("-i", "--interval", type=string_to_delta,
191
help="Set checker interval for client")
192
approve_deny_default = parser.add_mutually_exclusive_group()
193
approve_deny_default.add_argument(
194
"--approve-by-default", action="store_true",
195
default=None, dest="approved_by_default",
196
help="Set client to be approved by default")
197
approve_deny_default.add_argument(
198
"--deny-by-default", action="store_false",
199
dest="approved_by_default",
200
help="Set client to be denied by default")
201
parser.add_argument("--approval-delay", type=string_to_delta,
202
help="Set delay before client approve/deny")
203
parser.add_argument("--approval-duration", type=string_to_delta,
204
help="Set duration of one client approval")
205
parser.add_argument("-H", "--host", help="Set host for client")
206
parser.add_argument("-s", "--secret",
207
type=argparse.FileType(mode="rb"),
208
help="Set password blob (file) for client")
209
approve_deny = parser.add_mutually_exclusive_group()
210
approve_deny.add_argument(
211
"-A", "--approve", action="store_true",
212
help="Approve any current client request")
213
approve_deny.add_argument("-D", "--deny", action="store_true",
214
help="Deny any current client request")
215
parser.add_argument("--debug", action="store_true",
216
help="Debug mode (show D-Bus commands)")
217
parser.add_argument("--check", action="store_true",
218
help="Run self-test")
219
parser.add_argument("client", nargs="*", help="Client name")
222
def string_to_delta(interval):
223
"""Parse a string and return a datetime.timedelta"""
226
return rfc3339_duration_to_delta(interval)
227
except ValueError as e:
228
log.warning("%s - Parsing as pre-1.6.1 interval instead",
230
return parse_pre_1_6_1_interval(interval)
89
233
def rfc3339_duration_to_delta(duration):
273
## Classes for commands.
275
# Abstract classes first
406
def check_option_syntax(parser, options):
407
"""Apply additional restrictions on options, not expressible in
410
def has_actions(options):
411
return any((options.enable,
413
options.bump_timeout,
414
options.start_checker,
415
options.stop_checker,
418
options.checker is not None,
419
options.timeout is not None,
420
options.extended_timeout is not None,
421
options.interval is not None,
422
options.approved_by_default is not None,
423
options.approval_delay is not None,
424
options.approval_duration is not None,
425
options.host is not None,
426
options.secret is not None,
430
if has_actions(options) and not (options.client or options.all):
431
parser.error("Options require clients names or --all.")
432
if options.verbose and has_actions(options):
433
parser.error("--verbose can only be used alone.")
434
if options.dump_json and (options.verbose
435
or has_actions(options)):
436
parser.error("--dump-json can only be used alone.")
437
if options.all and not has_actions(options):
438
parser.error("--all requires an action.")
439
if options.is_enabled and len(options.client) > 1:
440
parser.error("--is-enabled requires exactly one client")
442
options.remove = False
443
if has_actions(options) and not options.deny:
444
parser.error("--remove can only be combined with --deny")
445
options.remove = True
448
def commands_from_options(options):
452
if options.is_enabled:
453
commands.append(IsEnabledCmd())
456
commands.append(ApproveCmd())
459
commands.append(DenyCmd())
462
commands.append(RemoveCmd())
464
if options.dump_json:
465
commands.append(DumpJSONCmd())
468
commands.append(EnableCmd())
471
commands.append(DisableCmd())
473
if options.bump_timeout:
474
commands.append(BumpTimeoutCmd())
476
if options.start_checker:
477
commands.append(StartCheckerCmd())
479
if options.stop_checker:
480
commands.append(StopCheckerCmd())
482
if options.approved_by_default is not None:
483
if options.approved_by_default:
484
commands.append(ApproveByDefaultCmd())
486
commands.append(DenyByDefaultCmd())
488
if options.checker is not None:
489
commands.append(SetCheckerCmd(options.checker))
491
if options.host is not None:
492
commands.append(SetHostCmd(options.host))
494
if options.secret is not None:
495
commands.append(SetSecretCmd(options.secret))
497
if options.timeout is not None:
498
commands.append(SetTimeoutCmd(options.timeout))
500
if options.extended_timeout:
502
SetExtendedTimeoutCmd(options.extended_timeout))
504
if options.interval is not None:
505
commands.append(SetIntervalCmd(options.interval))
507
if options.approval_delay is not None:
508
commands.append(SetApprovalDelayCmd(options.approval_delay))
510
if options.approval_duration is not None:
512
SetApprovalDurationCmd(options.approval_duration))
514
# If no command option has been given, show table of clients,
515
# optionally verbosely
517
commands.append(PrintTableCmd(verbose=options.verbose))
276
522
class Command(object):
277
523
"""Abstract class for commands"""
278
def run(self, mandos, clients):
524
def run(self, clients, bus=None, mandos=None):
279
525
"""Normal commands should implement run_on_one_client(), but
280
526
commands which want to operate on all clients at the same time
281
527
can override this run() method instead."""
282
528
self.mandos = mandos
283
for client, properties in clients.items():
529
for clientpath, properties in clients.items():
530
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
531
dbus_busname, str(clientpath))
532
client = bus.get_object(dbus_busname, clientpath)
284
533
self.run_on_one_client(client, properties)
286
class PrintCmd(Command):
287
"""Abstract class for commands printing client details"""
536
class IsEnabledCmd(Command):
537
def run(self, clients, bus=None, mandos=None):
538
client, properties = next(iter(clients.items()))
539
if self.is_enabled(client, properties):
542
def is_enabled(self, client, properties):
543
return properties["Enabled"]
546
class ApproveCmd(Command):
547
def run_on_one_client(self, client, properties):
548
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
549
client.__dbus_object_path__, client_dbus_interface)
550
client.Approve(dbus.Boolean(True),
551
dbus_interface=client_dbus_interface)
554
class DenyCmd(Command):
555
def run_on_one_client(self, client, properties):
556
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
557
client.__dbus_object_path__, client_dbus_interface)
558
client.Approve(dbus.Boolean(False),
559
dbus_interface=client_dbus_interface)
562
class RemoveCmd(Command):
563
def run_on_one_client(self, client, properties):
564
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
565
server_dbus_path, server_dbus_interface,
566
str(client.__dbus_object_path__))
567
self.mandos.RemoveClient(client.__dbus_object_path__)
570
class OutputCmd(Command):
571
"""Abstract class for commands outputting client details"""
288
572
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
289
573
"Created", "Interval", "Host", "KeyID",
290
574
"Fingerprint", "CheckerRunning", "LastEnabled",
405
683
**{key: self.string_from_client(client, key)
406
684
for key in self.keywords})
410
class DumpJSONCmd(PrintCmd):
411
def output(self, clients):
412
data = {client["Name"]:
413
{key: self.dbus_boolean_to_bool(client[key])
414
for key in self.all_keywords}
415
for client in clients.values()}
416
return json.dumps(data, indent=4, separators=(',', ': '))
418
def dbus_boolean_to_bool(value):
419
if isinstance(value, dbus.Boolean):
423
class IsEnabledCmd(Command):
424
def run_on_one_client(self, client, properties):
425
if self.is_enabled(client, properties):
428
def is_enabled(self, client, properties):
429
return bool(properties["Enabled"])
431
class RemoveCmd(Command):
432
def run_on_one_client(self, client, properties):
433
self.mandos.RemoveClient(client.__dbus_object_path__)
435
class ApproveCmd(Command):
436
def run_on_one_client(self, client, properties):
437
client.Approve(dbus.Boolean(True),
438
dbus_interface=client_interface)
440
class DenyCmd(Command):
441
def run_on_one_client(self, client, properties):
442
client.Approve(dbus.Boolean(False),
443
dbus_interface=client_interface)
687
def milliseconds_to_string(ms):
688
td = datetime.timedelta(0, 0, 0, ms)
689
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
690
.format(days="{}T".format(td.days)
692
hours=td.seconds // 3600,
693
minutes=(td.seconds % 3600) // 60,
694
seconds=td.seconds % 60))
697
class PropertyCmd(Command):
698
"""Abstract class for Actions for setting one client property"""
700
def run_on_one_client(self, client, properties):
701
"""Set the Client's D-Bus property"""
702
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
703
client.__dbus_object_path__,
704
dbus.PROPERTIES_IFACE, client_dbus_interface,
705
self.propname, self.value_to_set
706
if not isinstance(self.value_to_set, dbus.Boolean)
707
else bool(self.value_to_set))
708
client.Set(client_dbus_interface, self.propname,
710
dbus_interface=dbus.PROPERTIES_IFACE)
714
raise NotImplementedError()
445
717
class EnableCmd(PropertyCmd):
447
719
value_to_set = dbus.Boolean(True)
449
722
class DisableCmd(PropertyCmd):
451
724
value_to_set = dbus.Boolean(False)
453
727
class BumpTimeoutCmd(PropertyCmd):
454
property = "LastCheckedOK"
728
propname = "LastCheckedOK"
455
729
value_to_set = ""
457
732
class StartCheckerCmd(PropertyCmd):
458
property = "CheckerRunning"
733
propname = "CheckerRunning"
459
734
value_to_set = dbus.Boolean(True)
461
737
class StopCheckerCmd(PropertyCmd):
462
property = "CheckerRunning"
738
propname = "CheckerRunning"
463
739
value_to_set = dbus.Boolean(False)
465
742
class ApproveByDefaultCmd(PropertyCmd):
466
property = "ApprovedByDefault"
743
propname = "ApprovedByDefault"
467
744
value_to_set = dbus.Boolean(True)
469
747
class DenyByDefaultCmd(PropertyCmd):
470
property = "ApprovedByDefault"
748
propname = "ApprovedByDefault"
471
749
value_to_set = dbus.Boolean(False)
473
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
476
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
479
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
752
class PropertyValueCmd(PropertyCmd):
753
"""Abstract class for PropertyCmd recieving a value as argument"""
754
def __init__(self, value):
755
self.value_to_set = value
758
class SetCheckerCmd(PropertyValueCmd):
762
class SetHostCmd(PropertyValueCmd):
766
class SetSecretCmd(PropertyValueCmd):
481
770
def value_to_set(self):
483
773
@value_to_set.setter
484
774
def value_to_set(self, value):
485
775
"""When setting, read data from supplied file object"""
486
776
self._vts = value.read()
490
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
493
class SetExtendedTimeoutCmd(PropertyCmd,
494
MillisecondsValueArgumentMixIn):
495
property = "ExtendedTimeout"
497
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
498
property = "Interval"
500
class SetApprovalDelayCmd(PropertyCmd,
501
MillisecondsValueArgumentMixIn):
502
property = "ApprovalDelay"
504
class SetApprovalDurationCmd(PropertyCmd,
505
MillisecondsValueArgumentMixIn):
506
property = "ApprovalDuration"
508
def add_command_line_options(parser):
509
parser.add_argument("--version", action="version",
510
version="%(prog)s {}".format(version),
511
help="show version number and exit")
512
parser.add_argument("-a", "--all", action="store_true",
513
help="Select all clients")
514
parser.add_argument("-v", "--verbose", action="store_true",
515
help="Print all fields")
516
parser.add_argument("-j", "--dump-json", action="store_true",
517
help="Dump client data in JSON format")
518
enable_disable = parser.add_mutually_exclusive_group()
519
enable_disable.add_argument("-e", "--enable", action="store_true",
520
help="Enable client")
521
enable_disable.add_argument("-d", "--disable",
523
help="disable client")
524
parser.add_argument("-b", "--bump-timeout", action="store_true",
525
help="Bump timeout for client")
526
start_stop_checker = parser.add_mutually_exclusive_group()
527
start_stop_checker.add_argument("--start-checker",
529
help="Start checker for client")
530
start_stop_checker.add_argument("--stop-checker",
532
help="Stop checker for client")
533
parser.add_argument("-V", "--is-enabled", action="store_true",
534
help="Check if client is enabled")
535
parser.add_argument("-r", "--remove", action="store_true",
536
help="Remove client")
537
parser.add_argument("-c", "--checker",
538
help="Set checker command for client")
539
parser.add_argument("-t", "--timeout", type=string_to_delta,
540
help="Set timeout for client")
541
parser.add_argument("--extended-timeout", type=string_to_delta,
542
help="Set extended timeout for client")
543
parser.add_argument("-i", "--interval", type=string_to_delta,
544
help="Set checker interval for client")
545
approve_deny_default = parser.add_mutually_exclusive_group()
546
approve_deny_default.add_argument(
547
"--approve-by-default", action="store_true",
548
default=None, dest="approved_by_default",
549
help="Set client to be approved by default")
550
approve_deny_default.add_argument(
551
"--deny-by-default", action="store_false",
552
dest="approved_by_default",
553
help="Set client to be denied by default")
554
parser.add_argument("--approval-delay", type=string_to_delta,
555
help="Set delay before client approve/deny")
556
parser.add_argument("--approval-duration", type=string_to_delta,
557
help="Set duration of one client approval")
558
parser.add_argument("-H", "--host", help="Set host for client")
559
parser.add_argument("-s", "--secret",
560
type=argparse.FileType(mode="rb"),
561
help="Set password blob (file) for client")
562
approve_deny = parser.add_mutually_exclusive_group()
563
approve_deny.add_argument(
564
"-A", "--approve", action="store_true",
565
help="Approve any current client request")
566
approve_deny.add_argument("-D", "--deny", action="store_true",
567
help="Deny any current client request")
568
parser.add_argument("--check", action="store_true",
569
help="Run self-test")
570
parser.add_argument("client", nargs="*", help="Client name")
573
def commands_from_options(options):
577
if options.dump_json:
578
commands.append(DumpJSONCmd())
581
commands.append(EnableCmd())
584
commands.append(DisableCmd())
586
if options.bump_timeout:
587
commands.append(BumpTimeoutCmd())
589
if options.start_checker:
590
commands.append(StartCheckerCmd())
592
if options.stop_checker:
593
commands.append(StopCheckerCmd())
595
if options.is_enabled:
596
commands.append(IsEnabledCmd())
599
commands.append(RemoveCmd())
601
if options.checker is not None:
602
commands.append(SetCheckerCmd(options.checker))
604
if options.timeout is not None:
605
commands.append(SetTimeoutCmd(options.timeout))
607
if options.extended_timeout:
609
SetExtendedTimeoutCmd(options.extended_timeout))
611
if options.interval is not None:
612
commands.append(SetIntervalCmd(options.interval))
614
if options.approved_by_default is not None:
615
if options.approved_by_default:
616
commands.append(ApproveByDefaultCmd())
618
commands.append(DenyByDefaultCmd())
620
if options.approval_delay is not None:
621
commands.append(SetApprovalDelayCmd(options.approval_delay))
623
if options.approval_duration is not None:
625
SetApprovalDurationCmd(options.approval_duration))
627
if options.host is not None:
628
commands.append(SetHostCmd(options.host))
630
if options.secret is not None:
631
commands.append(SetSecretCmd(options.secret))
634
commands.append(ApproveCmd())
637
commands.append(DenyCmd())
639
# If no command option has been given, show table of clients,
640
# optionally verbosely
642
commands.append(PrintTableCmd(verbose=options.verbose))
647
def check_option_syntax(parser, options):
649
def has_actions(options):
650
return any((options.enable,
652
options.bump_timeout,
653
options.start_checker,
654
options.stop_checker,
657
options.checker is not None,
658
options.timeout is not None,
659
options.extended_timeout is not None,
660
options.interval is not None,
661
options.approved_by_default is not None,
662
options.approval_delay is not None,
663
options.approval_duration is not None,
664
options.host is not None,
665
options.secret is not None,
669
if has_actions(options) and not (options.client or options.all):
670
parser.error("Options require clients names or --all.")
671
if options.verbose and has_actions(options):
672
parser.error("--verbose can only be used alone.")
673
if options.dump_json and (options.verbose
674
or has_actions(options)):
675
parser.error("--dump-json can only be used alone.")
676
if options.all and not has_actions(options):
677
parser.error("--all requires an action.")
678
if options.is_enabled and len(options.client) > 1:
679
parser.error("--is-enabled requires exactly one client")
683
parser = argparse.ArgumentParser()
685
add_command_line_options(parser)
687
options = parser.parse_args()
689
check_option_syntax(parser, options)
691
clientnames = options.client
694
bus = dbus.SystemBus()
695
mandos_dbus_objc = bus.get_object(busname, server_path)
696
except dbus.exceptions.DBusException:
697
log.critical("Could not connect to Mandos server")
700
mandos_serv = dbus.Interface(mandos_dbus_objc,
701
dbus_interface=server_interface)
702
mandos_serv_object_manager = dbus.Interface(
703
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
705
# Filter out log message from dbus module
706
dbus_logger = logging.getLogger("dbus.proxies")
707
class NullFilter(logging.Filter):
708
def filter(self, record):
710
dbus_filter = NullFilter()
712
dbus_logger.addFilter(dbus_filter)
713
mandos_clients = {path: ifs_and_props[client_interface]
714
for path, ifs_and_props in
715
mandos_serv_object_manager
716
.GetManagedObjects().items()
717
if client_interface in ifs_and_props}
718
except dbus.exceptions.DBusException as e:
719
log.critical("Failed to access Mandos server through D-Bus:"
723
# restore dbus logger
724
dbus_logger.removeFilter(dbus_filter)
726
# Compile dict of (clients: properties) to process
730
clients = {bus.get_object(busname, path): properties
731
for path, properties in mandos_clients.items()}
733
for name in clientnames:
734
for path, client in mandos_clients.items():
735
if client["Name"] == name:
736
client_objc = bus.get_object(busname, path)
737
clients[client_objc] = client
740
log.critical("Client not found on server: %r", name)
743
# Run all commands on clients
744
commands = commands_from_options(options)
745
for command in commands:
746
command.run(mandos_serv, clients)
780
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
781
"""Abstract class for PropertyValueCmd taking a value argument as
782
a datetime.timedelta() but should store it as milliseconds."""
785
def value_to_set(self):
789
def value_to_set(self, value):
790
"""When setting, convert value from a datetime.timedelta"""
791
self._vts = int(round(value.total_seconds() * 1000))
794
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
798
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
799
propname = "ExtendedTimeout"
802
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
803
propname = "Interval"
806
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
807
propname = "ApprovalDelay"
810
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
811
propname = "ApprovalDuration"
749
class Test_milliseconds_to_string(unittest.TestCase):
751
self.assertEqual(milliseconds_to_string(93785000),
753
def test_no_days(self):
754
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
755
def test_all_zero(self):
756
self.assertEqual(milliseconds_to_string(0), "00:00:00")
757
def test_no_fractional_seconds(self):
758
self.assertEqual(milliseconds_to_string(400), "00:00:00")
759
self.assertEqual(milliseconds_to_string(900), "00:00:00")
760
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
762
815
class Test_string_to_delta(unittest.TestCase):
763
816
def test_handles_basic_rfc3339(self):
764
817
self.assertEqual(string_to_delta("PT0S"),
792
846
self.assertEqual(value, datetime.timedelta(0, 7200))
849
class Test_check_option_syntax(unittest.TestCase):
851
self.parser = argparse.ArgumentParser()
852
add_command_line_options(self.parser)
854
def test_actions_requires_client_or_all(self):
855
for action, value in self.actions.items():
856
options = self.parser.parse_args()
857
setattr(options, action, value)
858
with self.assertParseError():
859
self.check_option_syntax(options)
861
# This mostly corresponds to the definition from has_actions() in
862
# check_option_syntax()
864
# The actual values set here are not that important, but we do
865
# at least stick to the correct types, even though they are
869
"bump_timeout": True,
870
"start_checker": True,
871
"stop_checker": True,
875
"timeout": datetime.timedelta(),
876
"extended_timeout": datetime.timedelta(),
877
"interval": datetime.timedelta(),
878
"approved_by_default": True,
879
"approval_delay": datetime.timedelta(),
880
"approval_duration": datetime.timedelta(),
882
"secret": io.BytesIO(b"x"),
887
@contextlib.contextmanager
888
def assertParseError(self):
889
with self.assertRaises(SystemExit) as e:
890
with self.temporarily_suppress_stderr():
892
# Exit code from argparse is guaranteed to be "2". Reference:
893
# https://docs.python.org/3/library
894
# /argparse.html#exiting-methods
895
self.assertEqual(e.exception.code, 2)
898
@contextlib.contextmanager
899
def temporarily_suppress_stderr():
900
null = os.open(os.path.devnull, os.O_RDWR)
901
stderrcopy = os.dup(sys.stderr.fileno())
902
os.dup2(null, sys.stderr.fileno())
908
os.dup2(stderrcopy, sys.stderr.fileno())
911
def check_option_syntax(self, options):
912
check_option_syntax(self.parser, options)
914
def test_actions_conflicts_with_verbose(self):
915
for action, value in self.actions.items():
916
options = self.parser.parse_args()
917
setattr(options, action, value)
918
options.verbose = True
919
with self.assertParseError():
920
self.check_option_syntax(options)
922
def test_dump_json_conflicts_with_verbose(self):
923
options = self.parser.parse_args()
924
options.dump_json = True
925
options.verbose = True
926
with self.assertParseError():
927
self.check_option_syntax(options)
929
def test_dump_json_conflicts_with_action(self):
930
for action, value in self.actions.items():
931
options = self.parser.parse_args()
932
setattr(options, action, value)
933
options.dump_json = True
934
with self.assertParseError():
935
self.check_option_syntax(options)
937
def test_all_can_not_be_alone(self):
938
options = self.parser.parse_args()
940
with self.assertParseError():
941
self.check_option_syntax(options)
943
def test_all_is_ok_with_any_action(self):
944
for action, value in self.actions.items():
945
options = self.parser.parse_args()
946
setattr(options, action, value)
948
self.check_option_syntax(options)
950
def test_is_enabled_fails_without_client(self):
951
options = self.parser.parse_args()
952
options.is_enabled = True
953
with self.assertParseError():
954
self.check_option_syntax(options)
956
def test_is_enabled_works_with_one_client(self):
957
options = self.parser.parse_args()
958
options.is_enabled = True
959
options.client = ["foo"]
960
self.check_option_syntax(options)
962
def test_is_enabled_fails_with_two_clients(self):
963
options = self.parser.parse_args()
964
options.is_enabled = True
965
options.client = ["foo", "barbar"]
966
with self.assertParseError():
967
self.check_option_syntax(options)
969
def test_remove_can_only_be_combined_with_action_deny(self):
970
for action, value in self.actions.items():
971
if action in {"remove", "deny"}:
973
options = self.parser.parse_args()
974
setattr(options, action, value)
976
options.remove = True
977
with self.assertParseError():
978
self.check_option_syntax(options)
981
class Test_commands_from_options(unittest.TestCase):
983
self.parser = argparse.ArgumentParser()
984
add_command_line_options(self.parser)
986
def test_is_enabled(self):
987
self.assert_command_from_args(["--is-enabled", "foo"],
990
def assert_command_from_args(self, args, command_cls,
992
"""Assert that parsing ARGS should result in an instance of
993
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
994
options = self.parser.parse_args(args)
995
check_option_syntax(self.parser, options)
996
commands = commands_from_options(options)
997
self.assertEqual(len(commands), 1)
998
command = commands[0]
999
self.assertIsInstance(command, command_cls)
1000
for key, value in cmd_attrs.items():
1001
self.assertEqual(getattr(command, key), value)
1003
def test_is_enabled_short(self):
1004
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1006
def test_approve(self):
1007
self.assert_command_from_args(["--approve", "foo"],
1010
def test_approve_short(self):
1011
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1013
def test_deny(self):
1014
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1016
def test_deny_short(self):
1017
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1019
def test_remove(self):
1020
self.assert_command_from_args(["--remove", "foo"],
1023
def test_deny_before_remove(self):
1024
options = self.parser.parse_args(["--deny", "--remove",
1026
check_option_syntax(self.parser, options)
1027
commands = commands_from_options(options)
1028
self.assertEqual(len(commands), 2)
1029
self.assertIsInstance(commands[0], DenyCmd)
1030
self.assertIsInstance(commands[1], RemoveCmd)
1032
def test_deny_before_remove_reversed(self):
1033
options = self.parser.parse_args(["--remove", "--deny",
1035
check_option_syntax(self.parser, options)
1036
commands = commands_from_options(options)
1037
self.assertEqual(len(commands), 2)
1038
self.assertIsInstance(commands[0], DenyCmd)
1039
self.assertIsInstance(commands[1], RemoveCmd)
1041
def test_remove_short(self):
1042
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1044
def test_dump_json(self):
1045
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1047
def test_enable(self):
1048
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1050
def test_enable_short(self):
1051
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1053
def test_disable(self):
1054
self.assert_command_from_args(["--disable", "foo"],
1057
def test_disable_short(self):
1058
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1060
def test_bump_timeout(self):
1061
self.assert_command_from_args(["--bump-timeout", "foo"],
1064
def test_bump_timeout_short(self):
1065
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1067
def test_start_checker(self):
1068
self.assert_command_from_args(["--start-checker", "foo"],
1071
def test_stop_checker(self):
1072
self.assert_command_from_args(["--stop-checker", "foo"],
1075
def test_approve_by_default(self):
1076
self.assert_command_from_args(["--approve-by-default", "foo"],
1077
ApproveByDefaultCmd)
1079
def test_deny_by_default(self):
1080
self.assert_command_from_args(["--deny-by-default", "foo"],
1083
def test_checker(self):
1084
self.assert_command_from_args(["--checker", ":", "foo"],
1085
SetCheckerCmd, value_to_set=":")
1087
def test_checker_empty(self):
1088
self.assert_command_from_args(["--checker", "", "foo"],
1089
SetCheckerCmd, value_to_set="")
1091
def test_checker_short(self):
1092
self.assert_command_from_args(["-c", ":", "foo"],
1093
SetCheckerCmd, value_to_set=":")
1095
def test_host(self):
1096
self.assert_command_from_args(["--host", "foo.example.org",
1098
value_to_set="foo.example.org")
1100
def test_host_short(self):
1101
self.assert_command_from_args(["-H", "foo.example.org",
1103
value_to_set="foo.example.org")
1105
def test_secret_devnull(self):
1106
self.assert_command_from_args(["--secret", os.path.devnull,
1107
"foo"], SetSecretCmd,
1110
def test_secret_tempfile(self):
1111
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1112
value = b"secret\0xyzzy\nbar"
1115
self.assert_command_from_args(["--secret", f.name,
1116
"foo"], SetSecretCmd,
1119
def test_secret_devnull_short(self):
1120
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1121
SetSecretCmd, value_to_set=b"")
1123
def test_secret_tempfile_short(self):
1124
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1125
value = b"secret\0xyzzy\nbar"
1128
self.assert_command_from_args(["-s", f.name, "foo"],
1132
def test_timeout(self):
1133
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1135
value_to_set=300000)
1137
def test_timeout_short(self):
1138
self.assert_command_from_args(["-t", "PT5M", "foo"],
1140
value_to_set=300000)
1142
def test_extended_timeout(self):
1143
self.assert_command_from_args(["--extended-timeout", "PT15M",
1145
SetExtendedTimeoutCmd,
1146
value_to_set=900000)
1148
def test_interval(self):
1149
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1151
value_to_set=120000)
1153
def test_interval_short(self):
1154
self.assert_command_from_args(["-i", "PT2M", "foo"],
1156
value_to_set=120000)
1158
def test_approval_delay(self):
1159
self.assert_command_from_args(["--approval-delay", "PT30S",
1160
"foo"], SetApprovalDelayCmd,
1163
def test_approval_duration(self):
1164
self.assert_command_from_args(["--approval-duration", "PT1S",
1165
"foo"], SetApprovalDurationCmd,
1168
def test_print_table(self):
1169
self.assert_command_from_args([], PrintTableCmd,
1172
def test_print_table_verbose(self):
1173
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1176
def test_print_table_verbose_short(self):
1177
self.assert_command_from_args(["-v"], PrintTableCmd,
795
1181
class TestCmd(unittest.TestCase):
796
1182
"""Abstract class for tests of command classes"""
797
1184
def setUp(self):
799
1186
class MockClient(object):
800
1187
def __init__(self, name, **attributes):
801
self.__dbus_object_path__ = "objpath_{}".format(name)
1188
self.__dbus_object_path__ = "/clients/{}".format(name)
802
1189
self.attributes = attributes
803
1190
self.attributes["Name"] = name
805
def Set(self, interface, property, value, dbus_interface):
806
testcase.assertEqual(interface, client_interface)
807
testcase.assertEqual(dbus_interface,
808
dbus.PROPERTIES_IFACE)
809
self.attributes[property] = value
810
def Get(self, interface, property, dbus_interface):
811
testcase.assertEqual(interface, client_interface)
812
testcase.assertEqual(dbus_interface,
813
dbus.PROPERTIES_IFACE)
814
return self.attributes[property]
1192
def Set(self, interface, propname, value, dbus_interface):
1193
testcase.assertEqual(interface, client_dbus_interface)
1194
testcase.assertEqual(dbus_interface,
1195
dbus.PROPERTIES_IFACE)
1196
self.attributes[propname] = value
1197
def Get(self, interface, propname, dbus_interface):
1198
testcase.assertEqual(interface, client_dbus_interface)
1199
testcase.assertEqual(dbus_interface,
1200
dbus.PROPERTIES_IFACE)
1201
return self.attributes[propname]
815
1202
def Approve(self, approve, dbus_interface):
816
testcase.assertEqual(dbus_interface, client_interface)
1203
testcase.assertEqual(dbus_interface,
1204
client_dbus_interface)
817
1205
self.calls.append(("Approve", (approve,
818
1206
dbus_interface)))
819
1207
self.client = MockClient(
859
1247
ApprovedByDefault=dbus.Boolean(False),
860
1248
LastApprovalRequest="2019-01-03T00:00:00",
861
1249
ApprovalDelay=30000,
862
ApprovalDuration=1000,
1250
ApprovalDuration=93785000,
864
1252
ExtendedTimeout=900000,
865
1253
Expires="2019-02-05T00:00:00",
866
1254
LastCheckerStatus=-2)
867
1255
self.clients = collections.OrderedDict(
869
(self.client, self.client.attributes),
870
(self.other_client, self.other_client.attributes),
1257
("/clients/foo", self.client.attributes),
1258
("/clients/barbar", self.other_client.attributes),
872
self.one_client = {self.client: self.client.attributes}
874
class TestPrintTableCmd(TestCmd):
875
def test_normal(self):
876
output = PrintTableCmd().output(self.clients)
877
expected_output = """
878
Name Enabled Timeout Last Successful Check
879
foo Yes 00:05:00 2019-02-03T00:00:00
880
barbar Yes 00:05:00 2019-02-04T00:00:00
882
self.assertEqual(output, expected_output)
883
def test_verbose(self):
884
output = PrintTableCmd(verbose=True).output(self.clients)
885
expected_output = """
886
Name Enabled Timeout Last Successful Check Created Interval Host Key ID Fingerprint Check Is Running Last Enabled Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker Extended Timeout Expires Last Checker Status
887
foo Yes 00:05:00 2019-02-03T00:00:00 2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No 2019-01-03T00:00:00 No Yes 00:00:00 00:00:01 fping -q -- %(host)s 00:15:00 2019-02-04T00:00:00 0
888
barbar Yes 00:05:00 2019-02-04T00:00:00 2019-01-03T00:00:00 00:02:00 192.0.2.3 0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes 2019-01-04T00:00:00 No No 2019-01-03T00:00:00 00:00:30 00:00:01 : 00:15:00 2019-02-05T00:00:00 -2
890
self.assertEqual(output, expected_output)
891
def test_one_client(self):
892
output = PrintTableCmd().output(self.one_client)
893
expected_output = """
894
Name Enabled Timeout Last Successful Check
895
foo Yes 00:05:00 2019-02-03T00:00:00
897
self.assertEqual(output, expected_output)
1260
self.one_client = {"/clients/foo": self.client.attributes}
1266
def get_object(client_bus_name, path):
1267
self.assertEqual(client_bus_name, dbus_busname)
1269
# Note: "self" here is the TestCmd instance, not
1270
# the Bus instance, since this is a static method!
1271
"/clients/foo": self.client,
1272
"/clients/barbar": self.other_client,
1277
class TestIsEnabledCmd(TestCmd):
1278
def test_is_enabled(self):
1279
self.assertTrue(all(IsEnabledCmd().is_enabled(client,
1281
for client, properties
1282
in self.clients.items()))
1284
def test_is_enabled_run_exits_successfully(self):
1285
with self.assertRaises(SystemExit) as e:
1286
IsEnabledCmd().run(self.one_client)
1287
if e.exception.code is not None:
1288
self.assertEqual(e.exception.code, 0)
1290
self.assertIsNone(e.exception.code)
1292
def test_is_enabled_run_exits_with_failure(self):
1293
self.client.attributes["Enabled"] = dbus.Boolean(False)
1294
with self.assertRaises(SystemExit) as e:
1295
IsEnabledCmd().run(self.one_client)
1296
if isinstance(e.exception.code, int):
1297
self.assertNotEqual(e.exception.code, 0)
1299
self.assertIsNotNone(e.exception.code)
1302
class TestApproveCmd(TestCmd):
1303
def test_approve(self):
1304
ApproveCmd().run(self.clients, self.bus)
1305
for clientpath in self.clients:
1306
client = self.bus.get_object(dbus_busname, clientpath)
1307
self.assertIn(("Approve", (True, client_dbus_interface)),
1311
class TestDenyCmd(TestCmd):
1312
def test_deny(self):
1313
DenyCmd().run(self.clients, self.bus)
1314
for clientpath in self.clients:
1315
client = self.bus.get_object(dbus_busname, clientpath)
1316
self.assertIn(("Approve", (False, client_dbus_interface)),
1320
class TestRemoveCmd(TestCmd):
1321
def test_remove(self):
1322
class MockMandos(object):
1325
def RemoveClient(self, dbus_path):
1326
self.calls.append(("RemoveClient", (dbus_path,)))
1327
mandos = MockMandos()
1328
super(TestRemoveCmd, self).setUp()
1329
RemoveCmd().run(self.clients, self.bus, mandos)
1330
self.assertEqual(len(mandos.calls), 2)
1331
for clientpath in self.clients:
1332
self.assertIn(("RemoveClient", (clientpath,)),
899
1336
class TestDumpJSONCmd(TestCmd):
900
1337
def setUp(self):
951
1388
return super(TestDumpJSONCmd, self).setUp()
952
1390
def test_normal(self):
953
json_data = json.loads(DumpJSONCmd().output(self.clients))
1391
output = DumpJSONCmd().output(self.clients.values())
1392
json_data = json.loads(output)
954
1393
self.assertDictEqual(json_data, self.expected_json)
955
1395
def test_one_client(self):
956
clients = self.one_client
957
json_data = json.loads(DumpJSONCmd().output(clients))
1396
output = DumpJSONCmd().output(self.one_client.values())
1397
json_data = json.loads(output)
958
1398
expected_json = {"foo": self.expected_json["foo"]}
959
1399
self.assertDictEqual(json_data, expected_json)
961
class TestIsEnabledCmd(TestCmd):
962
def test_is_enabled(self):
963
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
964
for client, properties in self.clients.items()))
965
def test_is_enabled_run_exits_successfully(self):
966
with self.assertRaises(SystemExit) as e:
967
IsEnabledCmd().run(None, self.one_client)
968
if e.exception.code is not None:
969
self.assertEqual(e.exception.code, 0)
971
self.assertIsNone(e.exception.code)
972
def test_is_enabled_run_exits_with_failure(self):
973
self.client.attributes["Enabled"] = dbus.Boolean(False)
974
with self.assertRaises(SystemExit) as e:
975
IsEnabledCmd().run(None, self.one_client)
976
if isinstance(e.exception.code, int):
977
self.assertNotEqual(e.exception.code, 0)
979
self.assertIsNotNone(e.exception.code)
981
class TestRemoveCmd(TestCmd):
982
def test_remove(self):
983
class MockMandos(object):
986
def RemoveClient(self, dbus_path):
987
self.calls.append(("RemoveClient", (dbus_path,)))
988
mandos = MockMandos()
989
super(TestRemoveCmd, self).setUp()
990
RemoveCmd().run(mandos, self.clients)
991
self.assertEqual(len(mandos.calls), 2)
992
for client in self.clients:
993
self.assertIn(("RemoveClient",
994
(client.__dbus_object_path__,)),
997
class TestApproveCmd(TestCmd):
998
def test_approve(self):
999
ApproveCmd().run(None, self.clients)
1000
for client in self.clients:
1001
self.assertIn(("Approve", (True, client_interface)),
1004
class TestDenyCmd(TestCmd):
1005
def test_deny(self):
1006
DenyCmd().run(None, self.clients)
1007
for client in self.clients:
1008
self.assertIn(("Approve", (False, client_interface)),
1011
class TestEnableCmd(TestCmd):
1012
def test_enable(self):
1013
for client in self.clients:
1014
client.attributes["Enabled"] = False
1016
EnableCmd().run(None, self.clients)
1018
for client in self.clients:
1019
self.assertTrue(client.attributes["Enabled"])
1021
class TestDisableCmd(TestCmd):
1022
def test_disable(self):
1023
DisableCmd().run(None, self.clients)
1025
for client in self.clients:
1026
self.assertFalse(client.attributes["Enabled"])
1028
class Unique(object):
1029
"""Class for objects which exist only to be unique objects, since
1030
unittest.mock.sentinel only exists in Python 3.3"""
1402
class TestPrintTableCmd(TestCmd):
1403
def test_normal(self):
1404
output = PrintTableCmd().output(self.clients.values())
1405
expected_output = "\n".join((
1406
"Name Enabled Timeout Last Successful Check",
1407
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1408
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1410
self.assertEqual(output, expected_output)
1412
def test_verbose(self):
1413
output = PrintTableCmd(verbose=True).output(
1414
self.clients.values())
1429
"Last Successful Check ",
1430
"2019-02-03T00:00:00 ",
1431
"2019-02-04T00:00:00 ",
1434
"2019-01-02T00:00:00 ",
1435
"2019-01-03T00:00:00 ",
1447
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1449
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1453
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1454
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1456
"Check Is Running ",
1461
"2019-01-03T00:00:00 ",
1462
"2019-01-04T00:00:00 ",
1464
"Approval Is Pending ",
1468
"Approved By Default ",
1472
"Last Approval Request ",
1474
"2019-01-03T00:00:00 ",
1480
"Approval Duration ",
1485
"fping -q -- %(host)s ",
1488
"Extended Timeout ",
1493
"2019-02-04T00:00:00 ",
1494
"2019-02-05T00:00:00 ",
1496
"Last Checker Status",
1501
num_lines = max(len(rows) for rows in columns)
1502
expected_output = "\n".join("".join(rows[line]
1503
for rows in columns)
1504
for line in range(num_lines))
1505
self.assertEqual(output, expected_output)
1507
def test_one_client(self):
1508
output = PrintTableCmd().output(self.one_client.values())
1509
expected_output = "\n".join((
1510
"Name Enabled Timeout Last Successful Check",
1511
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1513
self.assertEqual(output, expected_output)
1032
1516
class TestPropertyCmd(TestCmd):
1033
1517
"""Abstract class for tests of PropertyCmd classes"""
1038
1522
self.values_to_set)
1039
1523
for value_to_set, value_to_get in zip(self.values_to_set,
1040
1524
values_to_get):
1041
for client in self.clients:
1042
old_value = client.attributes[self.property]
1043
self.assertNotIsInstance(old_value, Unique)
1044
client.attributes[self.property] = Unique()
1525
for clientpath in self.clients:
1526
client = self.bus.get_object(dbus_busname, clientpath)
1527
old_value = client.attributes[self.propname]
1528
self.assertNotIsInstance(old_value, self.Unique)
1529
client.attributes[self.propname] = self.Unique()
1045
1530
self.run_command(value_to_set, self.clients)
1046
for client in self.clients:
1047
value = client.attributes[self.property]
1048
self.assertNotIsInstance(value, Unique)
1531
for clientpath in self.clients:
1532
client = self.bus.get_object(dbus_busname, clientpath)
1533
value = client.attributes[self.propname]
1534
self.assertNotIsInstance(value, self.Unique)
1049
1535
self.assertEqual(value, value_to_get)
1537
class Unique(object):
1538
"""Class for objects which exist only to be unique objects,
1539
since unittest.mock.sentinel only exists in Python 3.3"""
1050
1541
def run_command(self, value, clients):
1051
self.command().run(None, clients)
1542
self.command().run(clients, self.bus)
1545
class TestEnableCmd(TestPropertyCmd):
1547
propname = "Enabled"
1548
values_to_set = [dbus.Boolean(True)]
1551
class TestDisableCmd(TestPropertyCmd):
1552
command = DisableCmd
1553
propname = "Enabled"
1554
values_to_set = [dbus.Boolean(False)]
1053
1557
class TestBumpTimeoutCmd(TestPropertyCmd):
1054
1558
command = BumpTimeoutCmd
1055
property = "LastCheckedOK"
1559
propname = "LastCheckedOK"
1056
1560
values_to_set = [""]
1058
1563
class TestStartCheckerCmd(TestPropertyCmd):
1059
1564
command = StartCheckerCmd
1060
property = "CheckerRunning"
1565
propname = "CheckerRunning"
1061
1566
values_to_set = [dbus.Boolean(True)]
1063
1569
class TestStopCheckerCmd(TestPropertyCmd):
1064
1570
command = StopCheckerCmd
1065
property = "CheckerRunning"
1571
propname = "CheckerRunning"
1066
1572
values_to_set = [dbus.Boolean(False)]
1068
1575
class TestApproveByDefaultCmd(TestPropertyCmd):
1069
1576
command = ApproveByDefaultCmd
1070
property = "ApprovedByDefault"
1577
propname = "ApprovedByDefault"
1071
1578
values_to_set = [dbus.Boolean(True)]
1073
1581
class TestDenyByDefaultCmd(TestPropertyCmd):
1074
1582
command = DenyByDefaultCmd
1075
property = "ApprovedByDefault"
1583
propname = "ApprovedByDefault"
1076
1584
values_to_set = [dbus.Boolean(False)]
1078
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1079
"""Abstract class for tests of PropertyCmd classes using the
1080
ValueArgumentMixIn"""
1587
class TestPropertyValueCmd(TestPropertyCmd):
1588
"""Abstract class for tests of PropertyValueCmd classes"""
1081
1590
def runTest(self):
1082
if type(self) is TestValueArgumentPropertyCmd:
1591
if type(self) is TestPropertyValueCmd:
1084
return super(TestValueArgumentPropertyCmd, self).runTest()
1593
return super(TestPropertyValueCmd, self).runTest()
1085
1595
def run_command(self, value, clients):
1086
self.command(value).run(None, clients)
1088
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1596
self.command(value).run(clients, self.bus)
1599
class TestSetCheckerCmd(TestPropertyValueCmd):
1089
1600
command = SetCheckerCmd
1090
property = "Checker"
1601
propname = "Checker"
1091
1602
values_to_set = ["", ":", "fping -q -- %s"]
1093
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1605
class TestSetHostCmd(TestPropertyValueCmd):
1094
1606
command = SetHostCmd
1096
1608
values_to_set = ["192.0.2.3", "foo.example.org"]
1098
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1611
class TestSetSecretCmd(TestPropertyValueCmd):
1099
1612
command = SetSecretCmd
1101
values_to_set = [open("/dev/null", "rb"),
1614
values_to_set = [io.BytesIO(b""),
1102
1615
io.BytesIO(b"secret\0xyzzy\nbar")]
1103
1616
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1105
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1619
class TestSetTimeoutCmd(TestPropertyValueCmd):
1106
1620
command = SetTimeoutCmd
1107
property = "Timeout"
1621
propname = "Timeout"
1108
1622
values_to_set = [datetime.timedelta(),
1109
1623
datetime.timedelta(minutes=5),
1110
1624
datetime.timedelta(seconds=1),
1152
1670
datetime.timedelta(weeks=52)]
1153
1671
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1155
class Test_command_from_options(unittest.TestCase):
1157
self.parser = argparse.ArgumentParser()
1158
add_command_line_options(self.parser)
1159
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1160
"""Assert that parsing ARGS should result in an instance of
1161
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1162
options = self.parser.parse_args(args)
1163
check_option_syntax(self.parser, options)
1164
commands = commands_from_options(options)
1165
self.assertEqual(len(commands), 1)
1166
command = commands[0]
1167
self.assertIsInstance(command, command_cls)
1168
for key, value in cmd_attrs.items():
1169
self.assertEqual(getattr(command, key), value)
1170
def test_print_table(self):
1171
self.assert_command_from_args([], PrintTableCmd,
1174
def test_print_table_verbose(self):
1175
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1178
def test_print_table_verbose_short(self):
1179
self.assert_command_from_args(["-v"], PrintTableCmd,
1182
def test_enable(self):
1183
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1185
def test_enable_short(self):
1186
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1188
def test_disable(self):
1189
self.assert_command_from_args(["--disable", "foo"],
1192
def test_disable_short(self):
1193
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1195
def test_bump_timeout(self):
1196
self.assert_command_from_args(["--bump-timeout", "foo"],
1199
def test_bump_timeout_short(self):
1200
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1202
def test_start_checker(self):
1203
self.assert_command_from_args(["--start-checker", "foo"],
1206
def test_stop_checker(self):
1207
self.assert_command_from_args(["--stop-checker", "foo"],
1210
def test_remove(self):
1211
self.assert_command_from_args(["--remove", "foo"],
1214
def test_remove_short(self):
1215
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1217
def test_checker(self):
1218
self.assert_command_from_args(["--checker", ":", "foo"],
1219
SetCheckerCmd, value_to_set=":")
1221
def test_checker_empty(self):
1222
self.assert_command_from_args(["--checker", "", "foo"],
1223
SetCheckerCmd, value_to_set="")
1225
def test_checker_short(self):
1226
self.assert_command_from_args(["-c", ":", "foo"],
1227
SetCheckerCmd, value_to_set=":")
1229
def test_timeout(self):
1230
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1232
value_to_set=300000)
1234
def test_timeout_short(self):
1235
self.assert_command_from_args(["-t", "PT5M", "foo"],
1237
value_to_set=300000)
1239
def test_extended_timeout(self):
1240
self.assert_command_from_args(["--extended-timeout", "PT15M",
1242
SetExtendedTimeoutCmd,
1243
value_to_set=900000)
1245
def test_interval(self):
1246
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1248
value_to_set=120000)
1250
def test_interval_short(self):
1251
self.assert_command_from_args(["-i", "PT2M", "foo"],
1253
value_to_set=120000)
1255
def test_approve_by_default(self):
1256
self.assert_command_from_args(["--approve-by-default", "foo"],
1257
ApproveByDefaultCmd)
1259
def test_deny_by_default(self):
1260
self.assert_command_from_args(["--deny-by-default", "foo"],
1263
def test_approval_delay(self):
1264
self.assert_command_from_args(["--approval-delay", "PT30S",
1265
"foo"], SetApprovalDelayCmd,
1268
def test_approval_duration(self):
1269
self.assert_command_from_args(["--approval-duration", "PT1S",
1270
"foo"], SetApprovalDurationCmd,
1273
def test_host(self):
1274
self.assert_command_from_args(["--host", "foo.example.org",
1276
value_to_set="foo.example.org")
1278
def test_host_short(self):
1279
self.assert_command_from_args(["-H", "foo.example.org",
1281
value_to_set="foo.example.org")
1283
def test_secret_devnull(self):
1284
self.assert_command_from_args(["--secret", os.path.devnull,
1285
"foo"], SetSecretCmd,
1288
def test_secret_tempfile(self):
1289
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1290
value = b"secret\0xyzzy\nbar"
1293
self.assert_command_from_args(["--secret", f.name,
1294
"foo"], SetSecretCmd,
1297
def test_secret_devnull_short(self):
1298
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1299
SetSecretCmd, value_to_set=b"")
1301
def test_secret_tempfile_short(self):
1302
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1303
value = b"secret\0xyzzy\nbar"
1306
self.assert_command_from_args(["-s", f.name, "foo"],
1310
def test_approve(self):
1311
self.assert_command_from_args(["--approve", "foo"],
1314
def test_approve_short(self):
1315
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1317
def test_deny(self):
1318
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1320
def test_deny_short(self):
1321
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1323
def test_dump_json(self):
1324
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1326
def test_is_enabled(self):
1327
self.assert_command_from_args(["--is-enabled", "foo"],
1330
def test_is_enabled_short(self):
1331
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1335
1675
def should_only_run_tests():