274
## Classes for commands.
276
# Abstract classes first
277
class Command(object):
278
"""Abstract class for commands"""
279
def run(self, mandos, clients):
280
"""Normal commands should implement run_on_one_client(), but
281
commands which want to operate on all clients at the same time
282
can override this run() method instead."""
284
for client, properties in clients.items():
285
self.run_on_one_client(client, properties)
287
class PrintCmd(Command):
288
"""Abstract class for commands printing client details"""
289
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
290
"Created", "Interval", "Host", "KeyID",
291
"Fingerprint", "CheckerRunning", "LastEnabled",
292
"ApprovalPending", "ApprovedByDefault",
293
"LastApprovalRequest", "ApprovalDelay",
294
"ApprovalDuration", "Checker", "ExtendedTimeout",
295
"Expires", "LastCheckerStatus")
296
def run(self, mandos, clients):
297
print(self.output(clients.values()))
299
class PropertyCmd(Command):
300
"""Abstract class for Actions for setting one client property"""
301
def run_on_one_client(self, client, properties):
302
"""Set the Client's D-Bus property"""
303
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
304
client.__dbus_object_path__,
305
dbus.PROPERTIES_IFACE, client_interface,
306
self.propname, self.value_to_set
307
if not isinstance(self.value_to_set, dbus.Boolean)
308
else bool(self.value_to_set))
309
client.Set(client_interface, self.propname, self.value_to_set,
310
dbus_interface=dbus.PROPERTIES_IFACE)
312
class ValueArgumentMixIn(object):
313
"""Mixin class for commands taking a value as argument"""
314
def __init__(self, value):
315
self.value_to_set = value
317
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
318
"""Mixin class for commands taking a value argument as
321
def value_to_set(self):
324
def value_to_set(self, value):
325
"""When setting, convert value to a datetime.timedelta"""
326
self._vts = int(round(value.total_seconds() * 1000))
328
# Actual (non-abstract) command classes
330
class PrintTableCmd(PrintCmd):
331
def __init__(self, verbose=False):
332
self.verbose = verbose
334
def output(self, clients):
335
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
336
keywords = default_keywords
338
keywords = self.all_keywords
339
return str(self.TableOfClients(clients, keywords))
341
class TableOfClients(object):
344
"Enabled": "Enabled",
345
"Timeout": "Timeout",
346
"LastCheckedOK": "Last Successful Check",
347
"LastApprovalRequest": "Last Approval Request",
348
"Created": "Created",
349
"Interval": "Interval",
351
"Fingerprint": "Fingerprint",
353
"CheckerRunning": "Check Is Running",
354
"LastEnabled": "Last Enabled",
355
"ApprovalPending": "Approval Is Pending",
356
"ApprovedByDefault": "Approved By Default",
357
"ApprovalDelay": "Approval Delay",
358
"ApprovalDuration": "Approval Duration",
359
"Checker": "Checker",
360
"ExtendedTimeout": "Extended Timeout",
361
"Expires": "Expires",
362
"LastCheckerStatus": "Last Checker Status",
365
def __init__(self, clients, keywords, tableheaders=None):
366
self.clients = clients
367
self.keywords = keywords
368
if tableheaders is not None:
369
self.tableheaders = tableheaders
372
return "\n".join(self.rows())
374
if sys.version_info.major == 2:
375
__unicode__ = __str__
377
return str(self).encode(locale.getpreferredencoding())
380
format_string = self.row_formatting_string()
381
rows = [self.header_line(format_string)]
382
rows.extend(self.client_line(client, format_string)
383
for client in self.clients)
386
def row_formatting_string(self):
387
"Format string used to format table rows"
388
return " ".join("{{{key}:{width}}}".format(
389
width=max(len(self.tableheaders[key]),
390
*(len(self.string_from_client(client, key))
391
for client in self.clients)),
393
for key in self.keywords)
395
def string_from_client(self, client, key):
396
return self.valuetostring(client[key], key)
399
def valuetostring(value, keyword):
400
if isinstance(value, dbus.Boolean):
401
return "Yes" if value else "No"
402
if keyword in ("Timeout", "Interval", "ApprovalDelay",
403
"ApprovalDuration", "ExtendedTimeout"):
404
return milliseconds_to_string(value)
407
def header_line(self, format_string):
408
return format_string.format(**self.tableheaders)
410
def client_line(self, client, format_string):
411
return format_string.format(
412
**{key: self.string_from_client(client, key)
413
for key in self.keywords})
417
class DumpJSONCmd(PrintCmd):
418
def output(self, clients):
419
data = {client["Name"]:
420
{key: self.dbus_boolean_to_bool(client[key])
421
for key in self.all_keywords}
422
for client in clients.values()}
423
return json.dumps(data, indent=4, separators=(',', ': '))
425
def dbus_boolean_to_bool(value):
426
if isinstance(value, dbus.Boolean):
430
class IsEnabledCmd(Command):
431
def run_on_one_client(self, client, properties):
432
if self.is_enabled(client, properties):
435
def is_enabled(self, client, properties):
436
log.debug("D-Bus: %s:%s:%s.Get(%r, %r)", busname,
437
client.__dbus_object_path__,
438
dbus.PROPERTIES_IFACE, client_interface,
440
return bool(client.Get(client_interface, "Enabled",
441
dbus_interface=dbus.PROPERTIES_IFACE))
443
class RemoveCmd(Command):
444
def run_on_one_client(self, client, properties):
445
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", busname,
446
server_path, server_interface,
447
str(client.__dbus_object_path__))
448
self.mandos.RemoveClient(client.__dbus_object_path__)
450
class ApproveCmd(Command):
451
def run_on_one_client(self, client, properties):
452
log.debug("D-Bus: %s:%s.Approve(True)",
453
client.__dbus_object_path__, client_interface)
454
client.Approve(dbus.Boolean(True),
455
dbus_interface=client_interface)
457
class DenyCmd(Command):
458
def run_on_one_client(self, client, properties):
459
log.debug("D-Bus: %s:%s.Approve(False)",
460
client.__dbus_object_path__, client_interface)
461
client.Approve(dbus.Boolean(False),
462
dbus_interface=client_interface)
464
class EnableCmd(PropertyCmd):
466
value_to_set = dbus.Boolean(True)
468
class DisableCmd(PropertyCmd):
470
value_to_set = dbus.Boolean(False)
472
class BumpTimeoutCmd(PropertyCmd):
473
propname = "LastCheckedOK"
476
class StartCheckerCmd(PropertyCmd):
477
propname = "CheckerRunning"
478
value_to_set = dbus.Boolean(True)
480
class StopCheckerCmd(PropertyCmd):
481
propname = "CheckerRunning"
482
value_to_set = dbus.Boolean(False)
484
class ApproveByDefaultCmd(PropertyCmd):
485
propname = "ApprovedByDefault"
486
value_to_set = dbus.Boolean(True)
488
class DenyByDefaultCmd(PropertyCmd):
489
propname = "ApprovedByDefault"
490
value_to_set = dbus.Boolean(False)
492
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
495
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
498
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
501
def value_to_set(self):
504
def value_to_set(self, value):
505
"""When setting, read data from supplied file object"""
506
self._vts = value.read()
509
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
512
class SetExtendedTimeoutCmd(PropertyCmd,
513
MillisecondsValueArgumentMixIn):
514
propname = "ExtendedTimeout"
516
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
517
propname = "Interval"
519
class SetApprovalDelayCmd(PropertyCmd,
520
MillisecondsValueArgumentMixIn):
521
propname = "ApprovalDelay"
523
class SetApprovalDurationCmd(PropertyCmd,
524
MillisecondsValueArgumentMixIn):
525
propname = "ApprovalDuration"
527
def add_command_line_options(parser):
528
parser.add_argument("--version", action="version",
529
version="%(prog)s {}".format(version),
530
help="show version number and exit")
531
parser.add_argument("-a", "--all", action="store_true",
532
help="Select all clients")
533
parser.add_argument("-v", "--verbose", action="store_true",
534
help="Print all fields")
535
parser.add_argument("-j", "--dump-json", action="store_true",
536
help="Dump client data in JSON format")
537
enable_disable = parser.add_mutually_exclusive_group()
538
enable_disable.add_argument("-e", "--enable", action="store_true",
539
help="Enable client")
540
enable_disable.add_argument("-d", "--disable",
542
help="disable client")
543
parser.add_argument("-b", "--bump-timeout", action="store_true",
544
help="Bump timeout for client")
545
start_stop_checker = parser.add_mutually_exclusive_group()
546
start_stop_checker.add_argument("--start-checker",
548
help="Start checker for client")
549
start_stop_checker.add_argument("--stop-checker",
551
help="Stop checker for client")
552
parser.add_argument("-V", "--is-enabled", action="store_true",
553
help="Check if client is enabled")
554
parser.add_argument("-r", "--remove", action="store_true",
555
help="Remove client")
556
parser.add_argument("-c", "--checker",
557
help="Set checker command for client")
558
parser.add_argument("-t", "--timeout", type=string_to_delta,
559
help="Set timeout for client")
560
parser.add_argument("--extended-timeout", type=string_to_delta,
561
help="Set extended timeout for client")
562
parser.add_argument("-i", "--interval", type=string_to_delta,
563
help="Set checker interval for client")
564
approve_deny_default = parser.add_mutually_exclusive_group()
565
approve_deny_default.add_argument(
566
"--approve-by-default", action="store_true",
567
default=None, dest="approved_by_default",
568
help="Set client to be approved by default")
569
approve_deny_default.add_argument(
570
"--deny-by-default", action="store_false",
571
dest="approved_by_default",
572
help="Set client to be denied by default")
573
parser.add_argument("--approval-delay", type=string_to_delta,
574
help="Set delay before client approve/deny")
575
parser.add_argument("--approval-duration", type=string_to_delta,
576
help="Set duration of one client approval")
577
parser.add_argument("-H", "--host", help="Set host for client")
578
parser.add_argument("-s", "--secret",
579
type=argparse.FileType(mode="rb"),
580
help="Set password blob (file) for client")
581
approve_deny = parser.add_mutually_exclusive_group()
582
approve_deny.add_argument(
583
"-A", "--approve", action="store_true",
584
help="Approve any current client request")
585
approve_deny.add_argument("-D", "--deny", action="store_true",
586
help="Deny any current client request")
587
parser.add_argument("--debug", action="store_true",
588
help="Debug mode (show D-Bus commands)")
589
parser.add_argument("--check", action="store_true",
590
help="Run self-test")
591
parser.add_argument("client", nargs="*", help="Client name")
594
def commands_from_options(options):
598
if options.dump_json:
599
commands.append(DumpJSONCmd())
602
commands.append(EnableCmd())
605
commands.append(DisableCmd())
607
if options.bump_timeout:
608
commands.append(BumpTimeoutCmd())
610
if options.start_checker:
611
commands.append(StartCheckerCmd())
613
if options.stop_checker:
614
commands.append(StopCheckerCmd())
616
if options.is_enabled:
617
commands.append(IsEnabledCmd())
619
if options.checker is not None:
620
commands.append(SetCheckerCmd(options.checker))
622
if options.timeout is not None:
623
commands.append(SetTimeoutCmd(options.timeout))
625
if options.extended_timeout:
627
SetExtendedTimeoutCmd(options.extended_timeout))
629
if options.interval is not None:
630
commands.append(SetIntervalCmd(options.interval))
632
if options.approved_by_default is not None:
633
if options.approved_by_default:
634
commands.append(ApproveByDefaultCmd())
636
commands.append(DenyByDefaultCmd())
638
if options.approval_delay is not None:
639
commands.append(SetApprovalDelayCmd(options.approval_delay))
641
if options.approval_duration is not None:
643
SetApprovalDurationCmd(options.approval_duration))
645
if options.host is not None:
646
commands.append(SetHostCmd(options.host))
648
if options.secret is not None:
649
commands.append(SetSecretCmd(options.secret))
652
commands.append(ApproveCmd())
655
commands.append(DenyCmd())
658
commands.append(RemoveCmd())
660
# If no command option has been given, show table of clients,
661
# optionally verbosely
663
commands.append(PrintTableCmd(verbose=options.verbose))
668
385
def check_option_syntax(parser, options):
669
386
"""Apply additional restrictions on options, not expressible in
707
424
options.remove = True
711
parser = argparse.ArgumentParser()
713
add_command_line_options(parser)
715
options = parser.parse_args()
717
check_option_syntax(parser, options)
719
clientnames = options.client
722
log.setLevel(logging.DEBUG)
427
def get_mandos_dbus_object(bus):
428
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
429
dbus_busname, server_dbus_path)
430
with if_dbus_exception_log_with_exception_and_exit(
431
"Could not connect to Mandos server: %s"):
432
mandos_dbus_object = bus.get_object(dbus_busname,
434
return mandos_dbus_object
437
@contextlib.contextmanager
438
def if_dbus_exception_log_with_exception_and_exit(*args, **kwargs):
725
bus = dbus.SystemBus()
726
log.debug("D-Bus: Connect to: (name=%r, path=%r)", busname,
728
mandos_dbus_objc = bus.get_object(busname, server_path)
729
except dbus.exceptions.DBusException:
730
log.critical("Could not connect to Mandos server")
441
except dbus.exceptions.DBusException as e:
442
log.critical(*(args + (e,)), **kwargs)
733
mandos_serv = dbus.Interface(mandos_dbus_objc,
734
dbus_interface=server_interface)
735
mandos_serv_object_manager = dbus.Interface(
736
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
738
# Filter out log message from dbus module
739
dbus_logger = logging.getLogger("dbus.proxies")
446
def get_managed_objects(object_manager):
447
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
448
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
449
with if_dbus_exception_log_with_exception_and_exit(
450
"Failed to access Mandos server through D-Bus:\n%s"):
451
with SilenceLogger("dbus.proxies"):
452
managed_objects = object_manager.GetManagedObjects()
453
return managed_objects
456
class SilenceLogger(object):
457
"Simple context manager to silence a particular logger"
458
def __init__(self, loggername):
459
self.logger = logging.getLogger(loggername)
462
self.logger.addFilter(self.nullfilter)
740
464
class NullFilter(logging.Filter):
741
465
def filter(self, record):
743
dbus_filter = NullFilter()
745
dbus_logger.addFilter(dbus_filter)
746
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", busname,
747
server_path, dbus.OBJECT_MANAGER_IFACE)
748
mandos_clients = {path: ifs_and_props[client_interface]
749
for path, ifs_and_props in
750
mandos_serv_object_manager
751
.GetManagedObjects().items()
752
if client_interface in ifs_and_props}
753
except dbus.exceptions.DBusException as e:
754
log.critical("Failed to access Mandos server through D-Bus:"
758
# restore dbus logger
759
dbus_logger.removeFilter(dbus_filter)
761
# Compile dict of (clients: properties) to process
765
clients = {(log.debug("D-Bus: Connect to: (name=%r, path=%r)",
766
busname, str(path)) and False) or
767
bus.get_object(busname, path): properties
768
for path, properties in mandos_clients.items()}
770
for name in clientnames:
771
for path, client in mandos_clients.items():
772
if client["Name"] == name:
773
log.debug("D-Bus: Connect to: (name=%r, path=%r)",
775
client_objc = bus.get_object(busname, path)
776
clients[client_objc] = client
779
log.critical("Client not found on server: %r", name)
782
# Run all commands on clients
783
commands = commands_from_options(options)
784
for command in commands:
785
command.run(mandos_serv, clients)
468
nullfilter = NullFilter()
470
def __exit__(self, exc_type, exc_val, exc_tb):
471
self.logger.removeFilter(self.nullfilter)
474
def commands_from_options(options):
478
if options.is_enabled:
479
commands.append(command.IsEnabled())
482
commands.append(command.Approve())
485
commands.append(command.Deny())
488
commands.append(command.Remove())
490
if options.dump_json:
491
commands.append(command.DumpJSON())
494
commands.append(command.Enable())
497
commands.append(command.Disable())
499
if options.bump_timeout:
500
commands.append(command.BumpTimeout())
502
if options.start_checker:
503
commands.append(command.StartChecker())
505
if options.stop_checker:
506
commands.append(command.StopChecker())
508
if options.approved_by_default is not None:
509
if options.approved_by_default:
510
commands.append(command.ApproveByDefault())
512
commands.append(command.DenyByDefault())
514
if options.checker is not None:
515
commands.append(command.SetChecker(options.checker))
517
if options.host is not None:
518
commands.append(command.SetHost(options.host))
520
if options.secret is not None:
521
commands.append(command.SetSecret(options.secret))
523
if options.timeout is not None:
524
commands.append(command.SetTimeout(options.timeout))
526
if options.extended_timeout:
528
command.SetExtendedTimeout(options.extended_timeout))
530
if options.interval is not None:
531
commands.append(command.SetInterval(options.interval))
533
if options.approval_delay is not None:
535
command.SetApprovalDelay(options.approval_delay))
537
if options.approval_duration is not None:
539
command.SetApprovalDuration(options.approval_duration))
541
# If no command option has been given, show table of clients,
542
# optionally verbosely
544
commands.append(command.PrintTable(verbose=options.verbose))
549
class command(object):
550
"""A namespace for command classes"""
553
"""Abstract base class for commands"""
554
def run(self, clients, bus=None, mandos=None):
555
"""Normal commands should implement run_on_one_client(),
556
but commands which want to operate on all clients at the same time can
557
override this run() method instead.
560
for clientpath, properties in clients.items():
561
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
562
dbus_busname, str(clientpath))
563
client = bus.get_object(dbus_busname, clientpath)
564
self.run_on_one_client(client, properties)
567
class IsEnabled(Base):
568
def run(self, clients, bus=None, mandos=None):
569
client, properties = next(iter(clients.items()))
570
if self.is_enabled(client, properties):
573
def is_enabled(self, client, properties):
574
return properties["Enabled"]
578
def run_on_one_client(self, client, properties):
579
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
580
client.__dbus_object_path__,
581
client_dbus_interface)
582
client.Approve(dbus.Boolean(True),
583
dbus_interface=client_dbus_interface)
587
def run_on_one_client(self, client, properties):
588
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
589
client.__dbus_object_path__,
590
client_dbus_interface)
591
client.Approve(dbus.Boolean(False),
592
dbus_interface=client_dbus_interface)
596
def run_on_one_client(self, client, properties):
597
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
598
dbus_busname, server_dbus_path,
599
server_dbus_interface,
600
str(client.__dbus_object_path__))
601
self.mandos.RemoveClient(client.__dbus_object_path__)
605
"""Abstract class for commands outputting client details"""
606
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
607
"Created", "Interval", "Host", "KeyID",
608
"Fingerprint", "CheckerRunning",
609
"LastEnabled", "ApprovalPending",
610
"ApprovedByDefault", "LastApprovalRequest",
611
"ApprovalDelay", "ApprovalDuration",
612
"Checker", "ExtendedTimeout", "Expires",
616
class DumpJSON(Output):
617
def run(self, clients, bus=None, mandos=None):
618
data = {client["Name"]:
619
{key: self.dbus_boolean_to_bool(client[key])
620
for key in self.all_keywords}
621
for client in clients.values()}
622
print(json.dumps(data, indent=4, separators=(',', ': ')))
625
def dbus_boolean_to_bool(value):
626
if isinstance(value, dbus.Boolean):
631
class PrintTable(Output):
632
def __init__(self, verbose=False):
633
self.verbose = verbose
635
def run(self, clients, bus=None, mandos=None):
636
default_keywords = ("Name", "Enabled", "Timeout",
638
keywords = default_keywords
640
keywords = self.all_keywords
641
print(self.TableOfClients(clients.values(), keywords))
643
class TableOfClients(object):
646
"Enabled": "Enabled",
647
"Timeout": "Timeout",
648
"LastCheckedOK": "Last Successful Check",
649
"LastApprovalRequest": "Last Approval Request",
650
"Created": "Created",
651
"Interval": "Interval",
653
"Fingerprint": "Fingerprint",
655
"CheckerRunning": "Check Is Running",
656
"LastEnabled": "Last Enabled",
657
"ApprovalPending": "Approval Is Pending",
658
"ApprovedByDefault": "Approved By Default",
659
"ApprovalDelay": "Approval Delay",
660
"ApprovalDuration": "Approval Duration",
661
"Checker": "Checker",
662
"ExtendedTimeout": "Extended Timeout",
663
"Expires": "Expires",
664
"LastCheckerStatus": "Last Checker Status",
667
def __init__(self, clients, keywords):
668
self.clients = clients
669
self.keywords = keywords
672
return "\n".join(self.rows())
674
if sys.version_info.major == 2:
675
__unicode__ = __str__
677
return str(self).encode(
678
locale.getpreferredencoding())
681
format_string = self.row_formatting_string()
682
rows = [self.header_line(format_string)]
683
rows.extend(self.client_line(client, format_string)
684
for client in self.clients)
687
def row_formatting_string(self):
688
"Format string used to format table rows"
689
return " ".join("{{{key}:{width}}}".format(
690
width=max(len(self.tableheaders[key]),
691
*(len(self.string_from_client(client,
693
for client in self.clients)),
695
for key in self.keywords)
697
def string_from_client(self, client, key):
698
return self.valuetostring(client[key], key)
701
def valuetostring(cls, value, keyword):
702
if isinstance(value, dbus.Boolean):
703
return "Yes" if value else "No"
704
if keyword in ("Timeout", "Interval", "ApprovalDelay",
705
"ApprovalDuration", "ExtendedTimeout"):
706
return cls.milliseconds_to_string(value)
709
def header_line(self, format_string):
710
return format_string.format(**self.tableheaders)
712
def client_line(self, client, format_string):
713
return format_string.format(
714
**{key: self.string_from_client(client, key)
715
for key in self.keywords})
718
def milliseconds_to_string(ms):
719
td = datetime.timedelta(0, 0, 0, ms)
720
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
721
.format(days="{}T".format(td.days)
723
hours=td.seconds // 3600,
724
minutes=(td.seconds % 3600) // 60,
725
seconds=td.seconds % 60))
728
class PropertySetter(Base):
729
"Abstract class for Actions for setting one client property"
731
def run_on_one_client(self, client, properties):
732
"""Set the Client's D-Bus property"""
733
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
734
client.__dbus_object_path__,
735
dbus.PROPERTIES_IFACE, client_dbus_interface,
736
self.propname, self.value_to_set
737
if not isinstance(self.value_to_set,
739
else bool(self.value_to_set))
740
client.Set(client_dbus_interface, self.propname,
742
dbus_interface=dbus.PROPERTIES_IFACE)
746
raise NotImplementedError()
749
class Enable(PropertySetter):
751
value_to_set = dbus.Boolean(True)
754
class Disable(PropertySetter):
756
value_to_set = dbus.Boolean(False)
759
class BumpTimeout(PropertySetter):
760
propname = "LastCheckedOK"
764
class StartChecker(PropertySetter):
765
propname = "CheckerRunning"
766
value_to_set = dbus.Boolean(True)
769
class StopChecker(PropertySetter):
770
propname = "CheckerRunning"
771
value_to_set = dbus.Boolean(False)
774
class ApproveByDefault(PropertySetter):
775
propname = "ApprovedByDefault"
776
value_to_set = dbus.Boolean(True)
779
class DenyByDefault(PropertySetter):
780
propname = "ApprovedByDefault"
781
value_to_set = dbus.Boolean(False)
784
class PropertySetterValue(PropertySetter):
785
"""Abstract class for PropertySetter recieving a value as
786
constructor argument instead of a class attribute."""
787
def __init__(self, value):
788
self.value_to_set = value
791
class SetChecker(PropertySetterValue):
795
class SetHost(PropertySetterValue):
799
class SetSecret(PropertySetterValue):
803
def value_to_set(self):
807
def value_to_set(self, value):
808
"""When setting, read data from supplied file object"""
809
self._vts = value.read()
813
class PropertySetterValueMilliseconds(PropertySetterValue):
814
"""Abstract class for PropertySetterValue taking a value
815
argument as a datetime.timedelta() but should store it as
819
def value_to_set(self):
823
def value_to_set(self, value):
824
"When setting, convert value from a datetime.timedelta"
825
self._vts = int(round(value.total_seconds() * 1000))
828
class SetTimeout(PropertySetterValueMilliseconds):
832
class SetExtendedTimeout(PropertySetterValueMilliseconds):
833
propname = "ExtendedTimeout"
836
class SetInterval(PropertySetterValueMilliseconds):
837
propname = "Interval"
840
class SetApprovalDelay(PropertySetterValueMilliseconds):
841
propname = "ApprovalDelay"
844
class SetApprovalDuration(PropertySetterValueMilliseconds):
845
propname = "ApprovalDuration"
788
class Test_milliseconds_to_string(unittest.TestCase):
790
self.assertEqual(milliseconds_to_string(93785000),
792
def test_no_days(self):
793
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
794
def test_all_zero(self):
795
self.assertEqual(milliseconds_to_string(0), "00:00:00")
796
def test_no_fractional_seconds(self):
797
self.assertEqual(milliseconds_to_string(400), "00:00:00")
798
self.assertEqual(milliseconds_to_string(900), "00:00:00")
799
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
801
class Test_string_to_delta(unittest.TestCase):
802
def test_handles_basic_rfc3339(self):
803
self.assertEqual(string_to_delta("PT0S"),
804
datetime.timedelta())
805
self.assertEqual(string_to_delta("P0D"),
806
datetime.timedelta())
807
self.assertEqual(string_to_delta("PT1S"),
808
datetime.timedelta(0, 1))
809
self.assertEqual(string_to_delta("PT2H"),
810
datetime.timedelta(0, 7200))
849
class TestCaseWithAssertLogs(unittest.TestCase):
850
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
852
if not hasattr(unittest.TestCase, "assertLogs"):
853
@contextlib.contextmanager
854
def assertLogs(self, logger, level=logging.INFO):
855
capturing_handler = self.CapturingLevelHandler(level)
856
old_level = logger.level
857
old_propagate = logger.propagate
858
logger.addHandler(capturing_handler)
859
logger.setLevel(level)
860
logger.propagate = False
862
yield capturing_handler.watcher
864
logger.propagate = old_propagate
865
logger.removeHandler(capturing_handler)
866
logger.setLevel(old_level)
867
self.assertGreater(len(capturing_handler.watcher.records),
870
class CapturingLevelHandler(logging.Handler):
871
def __init__(self, level, *args, **kwargs):
872
logging.Handler.__init__(self, *args, **kwargs)
873
self.watcher = self.LoggingWatcher([], [])
874
def emit(self, record):
875
self.watcher.records.append(record)
876
self.watcher.output.append(self.format(record))
878
LoggingWatcher = collections.namedtuple("LoggingWatcher",
883
class Test_string_to_delta(TestCaseWithAssertLogs):
884
# Just test basic RFC 3339 functionality here, the doc string for
885
# rfc3339_duration_to_delta() already has more comprehensive
886
# tests, which is run by doctest.
888
def test_rfc3339_zero_seconds(self):
889
self.assertEqual(datetime.timedelta(),
890
string_to_delta("PT0S"))
892
def test_rfc3339_zero_days(self):
893
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
895
def test_rfc3339_one_second(self):
896
self.assertEqual(datetime.timedelta(0, 1),
897
string_to_delta("PT1S"))
899
def test_rfc3339_two_hours(self):
900
self.assertEqual(datetime.timedelta(0, 7200),
901
string_to_delta("PT2H"))
811
903
def test_falls_back_to_pre_1_6_1_with_warning(self):
812
# assertLogs only exists in Python 3.4
813
if hasattr(self, "assertLogs"):
814
with self.assertLogs(log, logging.WARNING):
815
value = string_to_delta("2h")
817
class WarningFilter(logging.Filter):
818
"""Don't show, but record the presence of, warnings"""
819
def filter(self, record):
820
is_warning = record.levelno >= logging.WARNING
821
self.found = is_warning or getattr(self, "found",
823
return not is_warning
824
warning_filter = WarningFilter()
825
log.addFilter(warning_filter)
904
with self.assertLogs(log, logging.WARNING):
905
value = string_to_delta("2h")
906
self.assertEqual(datetime.timedelta(0, 7200), value)
909
class Test_check_option_syntax(unittest.TestCase):
911
self.parser = argparse.ArgumentParser()
912
add_command_line_options(self.parser)
914
def test_actions_requires_client_or_all(self):
915
for action, value in self.actions.items():
916
options = self.parser.parse_args()
917
setattr(options, action, value)
918
with self.assertParseError():
919
self.check_option_syntax(options)
921
# This mostly corresponds to the definition from has_actions() in
922
# check_option_syntax()
924
# The actual values set here are not that important, but we do
925
# at least stick to the correct types, even though they are
929
"bump_timeout": True,
930
"start_checker": True,
931
"stop_checker": True,
935
"timeout": datetime.timedelta(),
936
"extended_timeout": datetime.timedelta(),
937
"interval": datetime.timedelta(),
938
"approved_by_default": True,
939
"approval_delay": datetime.timedelta(),
940
"approval_duration": datetime.timedelta(),
942
"secret": io.BytesIO(b"x"),
947
@contextlib.contextmanager
948
def assertParseError(self):
949
with self.assertRaises(SystemExit) as e:
950
with self.redirect_stderr_to_devnull():
952
# Exit code from argparse is guaranteed to be "2". Reference:
953
# https://docs.python.org/3/library
954
# /argparse.html#exiting-methods
955
self.assertEqual(2, e.exception.code)
958
@contextlib.contextmanager
959
def redirect_stderr_to_devnull():
960
old_stderr = sys.stderr
961
with contextlib.closing(open(os.devnull, "w")) as null:
827
value = string_to_delta("2h")
829
log.removeFilter(warning_filter)
830
self.assertTrue(getattr(warning_filter, "found", False))
831
self.assertEqual(value, datetime.timedelta(0, 7200))
834
class TestCmd(unittest.TestCase):
966
sys.stderr = old_stderr
968
def check_option_syntax(self, options):
969
check_option_syntax(self.parser, options)
971
def test_actions_all_conflicts_with_verbose(self):
972
for action, value in self.actions.items():
973
options = self.parser.parse_args()
974
setattr(options, action, value)
976
options.verbose = True
977
with self.assertParseError():
978
self.check_option_syntax(options)
980
def test_actions_with_client_conflicts_with_verbose(self):
981
for action, value in self.actions.items():
982
options = self.parser.parse_args()
983
setattr(options, action, value)
984
options.verbose = True
985
options.client = ["client"]
986
with self.assertParseError():
987
self.check_option_syntax(options)
989
def test_dump_json_conflicts_with_verbose(self):
990
options = self.parser.parse_args()
991
options.dump_json = True
992
options.verbose = True
993
with self.assertParseError():
994
self.check_option_syntax(options)
996
def test_dump_json_conflicts_with_action(self):
997
for action, value in self.actions.items():
998
options = self.parser.parse_args()
999
setattr(options, action, value)
1000
options.dump_json = True
1001
with self.assertParseError():
1002
self.check_option_syntax(options)
1004
def test_all_can_not_be_alone(self):
1005
options = self.parser.parse_args()
1007
with self.assertParseError():
1008
self.check_option_syntax(options)
1010
def test_all_is_ok_with_any_action(self):
1011
for action, value in self.actions.items():
1012
options = self.parser.parse_args()
1013
setattr(options, action, value)
1015
self.check_option_syntax(options)
1017
def test_any_action_is_ok_with_one_client(self):
1018
for action, value in self.actions.items():
1019
options = self.parser.parse_args()
1020
setattr(options, action, value)
1021
options.client = ["client"]
1022
self.check_option_syntax(options)
1024
def test_one_client_with_all_actions_except_is_enabled(self):
1025
options = self.parser.parse_args()
1026
for action, value in self.actions.items():
1027
if action == "is_enabled":
1029
setattr(options, action, value)
1030
options.client = ["client"]
1031
self.check_option_syntax(options)
1033
def test_two_clients_with_all_actions_except_is_enabled(self):
1034
options = self.parser.parse_args()
1035
for action, value in self.actions.items():
1036
if action == "is_enabled":
1038
setattr(options, action, value)
1039
options.client = ["client1", "client2"]
1040
self.check_option_syntax(options)
1042
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1043
for action, value in self.actions.items():
1044
if action == "is_enabled":
1046
options = self.parser.parse_args()
1047
setattr(options, action, value)
1048
options.client = ["client1", "client2"]
1049
self.check_option_syntax(options)
1051
def test_is_enabled_fails_without_client(self):
1052
options = self.parser.parse_args()
1053
options.is_enabled = True
1054
with self.assertParseError():
1055
self.check_option_syntax(options)
1057
def test_is_enabled_fails_with_two_clients(self):
1058
options = self.parser.parse_args()
1059
options.is_enabled = True
1060
options.client = ["client1", "client2"]
1061
with self.assertParseError():
1062
self.check_option_syntax(options)
1064
def test_remove_can_only_be_combined_with_action_deny(self):
1065
for action, value in self.actions.items():
1066
if action in {"remove", "deny"}:
1068
options = self.parser.parse_args()
1069
setattr(options, action, value)
1071
options.remove = True
1072
with self.assertParseError():
1073
self.check_option_syntax(options)
1076
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1077
def test_calls_and_returns_get_object_on_bus(self):
1078
class MockBus(object):
1080
def get_object(mockbus_self, busname, dbus_path):
1081
# Note that "self" is still the testcase instance,
1082
# this MockBus instance is in "mockbus_self".
1083
self.assertEqual(dbus_busname, busname)
1084
self.assertEqual(server_dbus_path, dbus_path)
1085
mockbus_self.called = True
1088
mockbus = get_mandos_dbus_object(bus=MockBus())
1089
self.assertIsInstance(mockbus, MockBus)
1090
self.assertTrue(mockbus.called)
1092
def test_logs_and_exits_on_dbus_error(self):
1093
class FailingBusStub(object):
1094
def get_object(self, busname, dbus_path):
1095
raise dbus.exceptions.DBusException("Test")
1097
with self.assertLogs(log, logging.CRITICAL):
1098
with self.assertRaises(SystemExit) as e:
1099
bus = get_mandos_dbus_object(bus=FailingBusStub())
1101
if isinstance(e.exception.code, int):
1102
self.assertNotEqual(0, e.exception.code)
1104
self.assertIsNotNone(e.exception.code)
1107
class Test_get_managed_objects(TestCaseWithAssertLogs):
1108
def test_calls_and_returns_GetManagedObjects(self):
1109
managed_objects = {"/clients/client": { "Name": "client"}}
1110
class ObjectManagerStub(object):
1111
def GetManagedObjects(self):
1112
return managed_objects
1113
retval = get_managed_objects(ObjectManagerStub())
1114
self.assertDictEqual(managed_objects, retval)
1116
def test_logs_and_exits_on_dbus_error(self):
1117
dbus_logger = logging.getLogger("dbus.proxies")
1119
class ObjectManagerFailingStub(object):
1120
def GetManagedObjects(self):
1121
dbus_logger.error("Test")
1122
raise dbus.exceptions.DBusException("Test")
1124
class CountingHandler(logging.Handler):
1126
def emit(self, record):
1129
counting_handler = CountingHandler()
1131
dbus_logger.addHandler(counting_handler)
1134
with self.assertLogs(log, logging.CRITICAL) as watcher:
1135
with self.assertRaises(SystemExit) as e:
1136
get_managed_objects(ObjectManagerFailingStub())
1138
dbus_logger.removeFilter(counting_handler)
1140
# Make sure the dbus logger was suppressed
1141
self.assertEqual(0, counting_handler.count)
1143
# Test that the dbus_logger still works
1144
with self.assertLogs(dbus_logger, logging.ERROR):
1145
dbus_logger.error("Test")
1147
if isinstance(e.exception.code, int):
1148
self.assertNotEqual(0, e.exception.code)
1150
self.assertIsNotNone(e.exception.code)
1153
class Test_commands_from_options(unittest.TestCase):
1155
self.parser = argparse.ArgumentParser()
1156
add_command_line_options(self.parser)
1158
def test_is_enabled(self):
1159
self.assert_command_from_args(["--is-enabled", "client"],
1162
def assert_command_from_args(self, args, command_cls,
1164
"""Assert that parsing ARGS should result in an instance of
1165
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1166
options = self.parser.parse_args(args)
1167
check_option_syntax(self.parser, options)
1168
commands = commands_from_options(options)
1169
self.assertEqual(1, len(commands))
1170
command = commands[0]
1171
self.assertIsInstance(command, command_cls)
1172
for key, value in cmd_attrs.items():
1173
self.assertEqual(value, getattr(command, key))
1175
def test_is_enabled_short(self):
1176
self.assert_command_from_args(["-V", "client"],
1179
def test_approve(self):
1180
self.assert_command_from_args(["--approve", "client"],
1183
def test_approve_short(self):
1184
self.assert_command_from_args(["-A", "client"],
1187
def test_deny(self):
1188
self.assert_command_from_args(["--deny", "client"],
1191
def test_deny_short(self):
1192
self.assert_command_from_args(["-D", "client"], command.Deny)
1194
def test_remove(self):
1195
self.assert_command_from_args(["--remove", "client"],
1198
def test_deny_before_remove(self):
1199
options = self.parser.parse_args(["--deny", "--remove",
1201
check_option_syntax(self.parser, options)
1202
commands = commands_from_options(options)
1203
self.assertEqual(2, len(commands))
1204
self.assertIsInstance(commands[0], command.Deny)
1205
self.assertIsInstance(commands[1], command.Remove)
1207
def test_deny_before_remove_reversed(self):
1208
options = self.parser.parse_args(["--remove", "--deny",
1210
check_option_syntax(self.parser, options)
1211
commands = commands_from_options(options)
1212
self.assertEqual(2, len(commands))
1213
self.assertIsInstance(commands[0], command.Deny)
1214
self.assertIsInstance(commands[1], command.Remove)
1216
def test_remove_short(self):
1217
self.assert_command_from_args(["-r", "client"],
1220
def test_dump_json(self):
1221
self.assert_command_from_args(["--dump-json"],
1224
def test_enable(self):
1225
self.assert_command_from_args(["--enable", "client"],
1228
def test_enable_short(self):
1229
self.assert_command_from_args(["-e", "client"],
1232
def test_disable(self):
1233
self.assert_command_from_args(["--disable", "client"],
1236
def test_disable_short(self):
1237
self.assert_command_from_args(["-d", "client"],
1240
def test_bump_timeout(self):
1241
self.assert_command_from_args(["--bump-timeout", "client"],
1242
command.BumpTimeout)
1244
def test_bump_timeout_short(self):
1245
self.assert_command_from_args(["-b", "client"],
1246
command.BumpTimeout)
1248
def test_start_checker(self):
1249
self.assert_command_from_args(["--start-checker", "client"],
1250
command.StartChecker)
1252
def test_stop_checker(self):
1253
self.assert_command_from_args(["--stop-checker", "client"],
1254
command.StopChecker)
1256
def test_approve_by_default(self):
1257
self.assert_command_from_args(["--approve-by-default",
1259
command.ApproveByDefault)
1261
def test_deny_by_default(self):
1262
self.assert_command_from_args(["--deny-by-default", "client"],
1263
command.DenyByDefault)
1265
def test_checker(self):
1266
self.assert_command_from_args(["--checker", ":", "client"],
1270
def test_checker_empty(self):
1271
self.assert_command_from_args(["--checker", "", "client"],
1275
def test_checker_short(self):
1276
self.assert_command_from_args(["-c", ":", "client"],
1280
def test_host(self):
1281
self.assert_command_from_args(
1282
["--host", "client.example.org", "client"],
1283
command.SetHost, value_to_set="client.example.org")
1285
def test_host_short(self):
1286
self.assert_command_from_args(
1287
["-H", "client.example.org", "client"], command.SetHost,
1288
value_to_set="client.example.org")
1290
def test_secret_devnull(self):
1291
self.assert_command_from_args(["--secret", os.path.devnull,
1292
"client"], command.SetSecret,
1295
def test_secret_tempfile(self):
1296
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1297
value = b"secret\0xyzzy\nbar"
1300
self.assert_command_from_args(["--secret", f.name,
1305
def test_secret_devnull_short(self):
1306
self.assert_command_from_args(["-s", os.path.devnull,
1307
"client"], command.SetSecret,
1310
def test_secret_tempfile_short(self):
1311
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1312
value = b"secret\0xyzzy\nbar"
1315
self.assert_command_from_args(["-s", f.name, "client"],
1319
def test_timeout(self):
1320
self.assert_command_from_args(["--timeout", "PT5M", "client"],
1322
value_to_set=300000)
1324
def test_timeout_short(self):
1325
self.assert_command_from_args(["-t", "PT5M", "client"],
1327
value_to_set=300000)
1329
def test_extended_timeout(self):
1330
self.assert_command_from_args(["--extended-timeout", "PT15M",
1332
command.SetExtendedTimeout,
1333
value_to_set=900000)
1335
def test_interval(self):
1336
self.assert_command_from_args(["--interval", "PT2M",
1337
"client"], command.SetInterval,
1338
value_to_set=120000)
1340
def test_interval_short(self):
1341
self.assert_command_from_args(["-i", "PT2M", "client"],
1342
command.SetInterval,
1343
value_to_set=120000)
1345
def test_approval_delay(self):
1346
self.assert_command_from_args(["--approval-delay", "PT30S",
1348
command.SetApprovalDelay,
1351
def test_approval_duration(self):
1352
self.assert_command_from_args(["--approval-duration", "PT1S",
1354
command.SetApprovalDuration,
1357
def test_print_table(self):
1358
self.assert_command_from_args([], command.PrintTable,
1361
def test_print_table_verbose(self):
1362
self.assert_command_from_args(["--verbose"],
1366
def test_print_table_verbose_short(self):
1367
self.assert_command_from_args(["-v"], command.PrintTable,
1371
class TestCommand(unittest.TestCase):
835
1372
"""Abstract class for tests of command classes"""
836
1374
def setUp(self):
838
1376
class MockClient(object):
839
1377
def __init__(self, name, **attributes):
840
self.__dbus_object_path__ = "objpath_{}".format(name)
1378
self.__dbus_object_path__ = "/clients/{}".format(name)
841
1379
self.attributes = attributes
842
1380
self.attributes["Name"] = name
844
1382
def Set(self, interface, propname, value, dbus_interface):
845
testcase.assertEqual(interface, client_interface)
846
testcase.assertEqual(dbus_interface,
847
dbus.PROPERTIES_IFACE)
1383
testcase.assertEqual(client_dbus_interface, interface)
1384
testcase.assertEqual(dbus.PROPERTIES_IFACE,
848
1386
self.attributes[propname] = value
849
def Get(self, interface, propname, dbus_interface):
850
testcase.assertEqual(interface, client_interface)
851
testcase.assertEqual(dbus_interface,
852
dbus.PROPERTIES_IFACE)
853
return self.attributes[propname]
854
1387
def Approve(self, approve, dbus_interface):
855
testcase.assertEqual(dbus_interface, client_interface)
1388
testcase.assertEqual(client_dbus_interface,
856
1390
self.calls.append(("Approve", (approve,
857
1391
dbus_interface)))
858
1392
self.client = MockClient(
898
1432
ApprovedByDefault=dbus.Boolean(False),
899
1433
LastApprovalRequest="2019-01-03T00:00:00",
900
1434
ApprovalDelay=30000,
901
ApprovalDuration=1000,
1435
ApprovalDuration=93785000,
903
1437
ExtendedTimeout=900000,
904
1438
Expires="2019-02-05T00:00:00",
905
1439
LastCheckerStatus=-2)
906
1440
self.clients = collections.OrderedDict(
908
(self.client, self.client.attributes),
909
(self.other_client, self.other_client.attributes),
1442
(self.client.__dbus_object_path__,
1443
self.client.attributes),
1444
(self.other_client.__dbus_object_path__,
1445
self.other_client.attributes),
911
self.one_client = {self.client: self.client.attributes}
913
class TestPrintTableCmd(TestCmd):
914
def test_normal(self):
915
output = PrintTableCmd().output(self.clients.values())
916
expected_output = """
917
Name Enabled Timeout Last Successful Check
918
foo Yes 00:05:00 2019-02-03T00:00:00
919
barbar Yes 00:05:00 2019-02-04T00:00:00
921
self.assertEqual(output, expected_output)
922
def test_verbose(self):
923
output = PrintTableCmd(verbose=True).output(
924
self.clients.values())
925
expected_output = """
926
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
927
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
928
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
930
self.assertEqual(output, expected_output)
931
def test_one_client(self):
932
output = PrintTableCmd().output(self.one_client.values())
933
expected_output = """
934
Name Enabled Timeout Last Successful Check
935
foo Yes 00:05:00 2019-02-03T00:00:00
937
self.assertEqual(output, expected_output)
939
class TestDumpJSONCmd(TestCmd):
941
self.expected_json = {
944
"KeyID": ("92ed150794387c03ce684574b1139a65"
945
"94a34f895daaaf09fd8ea90a27cddb12"),
946
"Host": "foo.example.org",
949
"LastCheckedOK": "2019-02-03T00:00:00",
950
"Created": "2019-01-02T00:00:00",
952
"Fingerprint": ("778827225BA7DE539C5A"
953
"7CFA59CFF7CDBD9A5920"),
954
"CheckerRunning": False,
955
"LastEnabled": "2019-01-03T00:00:00",
956
"ApprovalPending": False,
957
"ApprovedByDefault": True,
958
"LastApprovalRequest": "",
960
"ApprovalDuration": 1000,
961
"Checker": "fping -q -- %(host)s",
962
"ExtendedTimeout": 900000,
963
"Expires": "2019-02-04T00:00:00",
964
"LastCheckerStatus": 0,
968
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
969
"6ab612cff5ad227247e46c2b020f441c"),
973
"LastCheckedOK": "2019-02-04T00:00:00",
974
"Created": "2019-01-03T00:00:00",
976
"Fingerprint": ("3E393AEAEFB84C7E89E2"
977
"F547B3A107558FCA3A27"),
978
"CheckerRunning": True,
979
"LastEnabled": "2019-01-04T00:00:00",
980
"ApprovalPending": False,
981
"ApprovedByDefault": False,
982
"LastApprovalRequest": "2019-01-03T00:00:00",
983
"ApprovalDelay": 30000,
984
"ApprovalDuration": 1000,
986
"ExtendedTimeout": 900000,
987
"Expires": "2019-02-05T00:00:00",
988
"LastCheckerStatus": -2,
991
return super(TestDumpJSONCmd, self).setUp()
992
def test_normal(self):
993
json_data = json.loads(DumpJSONCmd().output(self.clients))
994
self.assertDictEqual(json_data, self.expected_json)
995
def test_one_client(self):
996
clients = self.one_client
997
json_data = json.loads(DumpJSONCmd().output(clients))
998
expected_json = {"foo": self.expected_json["foo"]}
999
self.assertDictEqual(json_data, expected_json)
1001
class TestIsEnabledCmd(TestCmd):
1002
def test_is_enabled(self):
1003
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
1004
for client, properties in self.clients.items()))
1005
def test_is_enabled_run_exits_successfully(self):
1447
self.one_client = {self.client.__dbus_object_path__:
1448
self.client.attributes}
1452
class MockBus(object):
1454
def get_object(client_bus_name, path):
1455
self.assertEqual(dbus_busname, client_bus_name)
1456
# Note: "self" here is the TestCmd instance, not the
1457
# MockBus instance, since this is a static method!
1458
if path == self.client.__dbus_object_path__:
1460
elif path == self.other_client.__dbus_object_path__:
1461
return self.other_client
1465
class TestBaseCommands(TestCommand):
1467
def test_IsEnabled_exits_successfully(self):
1006
1468
with self.assertRaises(SystemExit) as e:
1007
IsEnabledCmd().run(None, self.one_client)
1469
command.IsEnabled().run(self.one_client)
1008
1470
if e.exception.code is not None:
1009
self.assertEqual(e.exception.code, 0)
1471
self.assertEqual(0, e.exception.code)
1011
1473
self.assertIsNone(e.exception.code)
1012
def test_is_enabled_run_exits_with_failure(self):
1475
def test_IsEnabled_exits_with_failure(self):
1013
1476
self.client.attributes["Enabled"] = dbus.Boolean(False)
1014
1477
with self.assertRaises(SystemExit) as e:
1015
IsEnabledCmd().run(None, self.one_client)
1478
command.IsEnabled().run(self.one_client)
1016
1479
if isinstance(e.exception.code, int):
1017
self.assertNotEqual(e.exception.code, 0)
1480
self.assertNotEqual(0, e.exception.code)
1019
1482
self.assertIsNotNone(e.exception.code)
1021
class TestRemoveCmd(TestCmd):
1022
def test_remove(self):
1023
class MockMandos(object):
1484
def test_Approve(self):
1485
command.Approve().run(self.clients, self.bus)
1486
for clientpath in self.clients:
1487
client = self.bus.get_object(dbus_busname, clientpath)
1488
self.assertIn(("Approve", (True, client_dbus_interface)),
1491
def test_Deny(self):
1492
command.Deny().run(self.clients, self.bus)
1493
for clientpath in self.clients:
1494
client = self.bus.get_object(dbus_busname, clientpath)
1495
self.assertIn(("Approve", (False, client_dbus_interface)),
1498
def test_Remove(self):
1499
class MandosSpy(object):
1024
1500
def __init__(self):
1025
1501
self.calls = []
1026
1502
def RemoveClient(self, dbus_path):
1027
1503
self.calls.append(("RemoveClient", (dbus_path,)))
1028
mandos = MockMandos()
1029
super(TestRemoveCmd, self).setUp()
1030
RemoveCmd().run(mandos, self.clients)
1031
self.assertEqual(len(mandos.calls), 2)
1032
for client in self.clients:
1033
self.assertIn(("RemoveClient",
1034
(client.__dbus_object_path__,)),
1504
mandos = MandosSpy()
1505
command.Remove().run(self.clients, self.bus, mandos)
1506
for clientpath in self.clients:
1507
self.assertIn(("RemoveClient", (clientpath,)),
1037
class TestApproveCmd(TestCmd):
1038
def test_approve(self):
1039
ApproveCmd().run(None, self.clients)
1040
for client in self.clients:
1041
self.assertIn(("Approve", (True, client_interface)),
1044
class TestDenyCmd(TestCmd):
1045
def test_deny(self):
1046
DenyCmd().run(None, self.clients)
1047
for client in self.clients:
1048
self.assertIn(("Approve", (False, client_interface)),
1051
class TestEnableCmd(TestCmd):
1052
def test_enable(self):
1053
for client in self.clients:
1054
client.attributes["Enabled"] = False
1056
EnableCmd().run(None, self.clients)
1058
for client in self.clients:
1059
self.assertTrue(client.attributes["Enabled"])
1061
class TestDisableCmd(TestCmd):
1062
def test_disable(self):
1063
DisableCmd().run(None, self.clients)
1065
for client in self.clients:
1066
self.assertFalse(client.attributes["Enabled"])
1068
class Unique(object):
1069
"""Class for objects which exist only to be unique objects, since
1070
unittest.mock.sentinel only exists in Python 3.3"""
1072
class TestPropertyCmd(TestCmd):
1073
"""Abstract class for tests of PropertyCmd classes"""
1513
"KeyID": ("92ed150794387c03ce684574b1139a65"
1514
"94a34f895daaaf09fd8ea90a27cddb12"),
1515
"Host": "foo.example.org",
1518
"LastCheckedOK": "2019-02-03T00:00:00",
1519
"Created": "2019-01-02T00:00:00",
1521
"Fingerprint": ("778827225BA7DE539C5A"
1522
"7CFA59CFF7CDBD9A5920"),
1523
"CheckerRunning": False,
1524
"LastEnabled": "2019-01-03T00:00:00",
1525
"ApprovalPending": False,
1526
"ApprovedByDefault": True,
1527
"LastApprovalRequest": "",
1529
"ApprovalDuration": 1000,
1530
"Checker": "fping -q -- %(host)s",
1531
"ExtendedTimeout": 900000,
1532
"Expires": "2019-02-04T00:00:00",
1533
"LastCheckerStatus": 0,
1537
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1538
"6ab612cff5ad227247e46c2b020f441c"),
1539
"Host": "192.0.2.3",
1542
"LastCheckedOK": "2019-02-04T00:00:00",
1543
"Created": "2019-01-03T00:00:00",
1545
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1546
"F547B3A107558FCA3A27"),
1547
"CheckerRunning": True,
1548
"LastEnabled": "2019-01-04T00:00:00",
1549
"ApprovalPending": False,
1550
"ApprovedByDefault": False,
1551
"LastApprovalRequest": "2019-01-03T00:00:00",
1552
"ApprovalDelay": 30000,
1553
"ApprovalDuration": 93785000,
1555
"ExtendedTimeout": 900000,
1556
"Expires": "2019-02-05T00:00:00",
1557
"LastCheckerStatus": -2,
1561
def test_DumpJSON_normal(self):
1562
with self.capture_stdout_to_buffer() as buffer:
1563
command.DumpJSON().run(self.clients)
1564
json_data = json.loads(buffer.getvalue())
1565
self.assertDictEqual(self.expected_json, json_data)
1568
@contextlib.contextmanager
1569
def capture_stdout_to_buffer():
1570
capture_buffer = io.StringIO()
1571
old_stdout = sys.stdout
1572
sys.stdout = capture_buffer
1574
yield capture_buffer
1576
sys.stdout = old_stdout
1578
def test_DumpJSON_one_client(self):
1579
with self.capture_stdout_to_buffer() as buffer:
1580
command.DumpJSON().run(self.one_client)
1581
json_data = json.loads(buffer.getvalue())
1582
expected_json = {"foo": self.expected_json["foo"]}
1583
self.assertDictEqual(expected_json, json_data)
1585
def test_PrintTable_normal(self):
1586
with self.capture_stdout_to_buffer() as buffer:
1587
command.PrintTable().run(self.clients)
1588
expected_output = "\n".join((
1589
"Name Enabled Timeout Last Successful Check",
1590
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1591
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1593
self.assertEqual(expected_output, buffer.getvalue())
1595
def test_PrintTable_verbose(self):
1596
with self.capture_stdout_to_buffer() as buffer:
1597
command.PrintTable(verbose=True).run(self.clients)
1612
"Last Successful Check ",
1613
"2019-02-03T00:00:00 ",
1614
"2019-02-04T00:00:00 ",
1617
"2019-01-02T00:00:00 ",
1618
"2019-01-03T00:00:00 ",
1630
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1632
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1636
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1637
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1639
"Check Is Running ",
1644
"2019-01-03T00:00:00 ",
1645
"2019-01-04T00:00:00 ",
1647
"Approval Is Pending ",
1651
"Approved By Default ",
1655
"Last Approval Request ",
1657
"2019-01-03T00:00:00 ",
1663
"Approval Duration ",
1668
"fping -q -- %(host)s ",
1671
"Extended Timeout ",
1676
"2019-02-04T00:00:00 ",
1677
"2019-02-05T00:00:00 ",
1679
"Last Checker Status",
1684
num_lines = max(len(rows) for rows in columns)
1685
expected_output = ("\n".join("".join(rows[line]
1686
for rows in columns)
1687
for line in range(num_lines))
1689
self.assertEqual(expected_output, buffer.getvalue())
1691
def test_PrintTable_one_client(self):
1692
with self.capture_stdout_to_buffer() as buffer:
1693
command.PrintTable().run(self.one_client)
1694
expected_output = "\n".join((
1695
"Name Enabled Timeout Last Successful Check",
1696
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1698
self.assertEqual(expected_output, buffer.getvalue())
1701
class TestPropertySetterCmd(TestCommand):
1702
"""Abstract class for tests of command.PropertySetter classes"""
1074
1703
def runTest(self):
1075
1704
if not hasattr(self, "command"):
1078
1707
self.values_to_set)
1079
1708
for value_to_set, value_to_get in zip(self.values_to_set,
1080
1709
values_to_get):
1081
for client in self.clients:
1710
for clientpath in self.clients:
1711
client = self.bus.get_object(dbus_busname, clientpath)
1082
1712
old_value = client.attributes[self.propname]
1083
self.assertNotIsInstance(old_value, Unique)
1084
client.attributes[self.propname] = Unique()
1713
client.attributes[self.propname] = self.Unique()
1085
1714
self.run_command(value_to_set, self.clients)
1086
for client in self.clients:
1715
for clientpath in self.clients:
1716
client = self.bus.get_object(dbus_busname, clientpath)
1087
1717
value = client.attributes[self.propname]
1088
self.assertNotIsInstance(value, Unique)
1089
self.assertEqual(value, value_to_get)
1718
self.assertNotIsInstance(value, self.Unique)
1719
self.assertEqual(value_to_get, value)
1721
class Unique(object):
1722
"""Class for objects which exist only to be unique objects,
1723
since unittest.mock.sentinel only exists in Python 3.3"""
1090
1725
def run_command(self, value, clients):
1091
self.command().run(None, clients)
1093
class TestBumpTimeoutCmd(TestPropertyCmd):
1094
command = BumpTimeoutCmd
1726
self.command().run(clients, self.bus)
1729
class TestEnableCmd(TestPropertySetterCmd):
1730
command = command.Enable
1731
propname = "Enabled"
1732
values_to_set = [dbus.Boolean(True)]
1735
class TestDisableCmd(TestPropertySetterCmd):
1736
command = command.Disable
1737
propname = "Enabled"
1738
values_to_set = [dbus.Boolean(False)]
1741
class TestBumpTimeoutCmd(TestPropertySetterCmd):
1742
command = command.BumpTimeout
1095
1743
propname = "LastCheckedOK"
1096
1744
values_to_set = [""]
1098
class TestStartCheckerCmd(TestPropertyCmd):
1099
command = StartCheckerCmd
1100
propname = "CheckerRunning"
1101
values_to_set = [dbus.Boolean(True)]
1103
class TestStopCheckerCmd(TestPropertyCmd):
1104
command = StopCheckerCmd
1105
propname = "CheckerRunning"
1106
values_to_set = [dbus.Boolean(False)]
1108
class TestApproveByDefaultCmd(TestPropertyCmd):
1109
command = ApproveByDefaultCmd
1110
propname = "ApprovedByDefault"
1111
values_to_set = [dbus.Boolean(True)]
1113
class TestDenyByDefaultCmd(TestPropertyCmd):
1114
command = DenyByDefaultCmd
1115
propname = "ApprovedByDefault"
1116
values_to_set = [dbus.Boolean(False)]
1118
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1119
"""Abstract class for tests of PropertyCmd classes using the
1120
ValueArgumentMixIn"""
1747
class TestStartCheckerCmd(TestPropertySetterCmd):
1748
command = command.StartChecker
1749
propname = "CheckerRunning"
1750
values_to_set = [dbus.Boolean(True)]
1753
class TestStopCheckerCmd(TestPropertySetterCmd):
1754
command = command.StopChecker
1755
propname = "CheckerRunning"
1756
values_to_set = [dbus.Boolean(False)]
1759
class TestApproveByDefaultCmd(TestPropertySetterCmd):
1760
command = command.ApproveByDefault
1761
propname = "ApprovedByDefault"
1762
values_to_set = [dbus.Boolean(True)]
1765
class TestDenyByDefaultCmd(TestPropertySetterCmd):
1766
command = command.DenyByDefault
1767
propname = "ApprovedByDefault"
1768
values_to_set = [dbus.Boolean(False)]
1771
class TestPropertySetterValueCmd(TestPropertySetterCmd):
1772
"""Abstract class for tests of PropertySetterValueCmd classes"""
1121
1774
def runTest(self):
1122
if type(self) is TestValueArgumentPropertyCmd:
1775
if type(self) is TestPropertySetterValueCmd:
1124
return super(TestValueArgumentPropertyCmd, self).runTest()
1777
return super(TestPropertySetterValueCmd, self).runTest()
1125
1779
def run_command(self, value, clients):
1126
self.command(value).run(None, clients)
1128
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1129
command = SetCheckerCmd
1780
self.command(value).run(clients, self.bus)
1783
class TestSetCheckerCmd(TestPropertySetterValueCmd):
1784
command = command.SetChecker
1130
1785
propname = "Checker"
1131
1786
values_to_set = ["", ":", "fping -q -- %s"]
1133
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1134
command = SetHostCmd
1789
class TestSetHostCmd(TestPropertySetterValueCmd):
1790
command = command.SetHost
1135
1791
propname = "Host"
1136
values_to_set = ["192.0.2.3", "foo.example.org"]
1138
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1139
command = SetSecretCmd
1792
values_to_set = ["192.0.2.3", "client.example.org"]
1795
class TestSetSecretCmd(TestPropertySetterValueCmd):
1796
command = command.SetSecret
1140
1797
propname = "Secret"
1141
1798
values_to_set = [io.BytesIO(b""),
1142
1799
io.BytesIO(b"secret\0xyzzy\nbar")]
1143
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1145
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1146
command = SetTimeoutCmd
1800
values_to_get = [f.getvalue() for f in values_to_set]
1803
class TestSetTimeoutCmd(TestPropertySetterValueCmd):
1804
command = command.SetTimeout
1147
1805
propname = "Timeout"
1148
1806
values_to_set = [datetime.timedelta(),
1149
1807
datetime.timedelta(minutes=5),
1150
1808
datetime.timedelta(seconds=1),
1151
1809
datetime.timedelta(weeks=1),
1152
1810
datetime.timedelta(weeks=52)]
1153
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1155
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1156
command = SetExtendedTimeoutCmd
1811
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1814
class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):
1815
command = command.SetExtendedTimeout
1157
1816
propname = "ExtendedTimeout"
1158
1817
values_to_set = [datetime.timedelta(),
1159
1818
datetime.timedelta(minutes=5),
1160
1819
datetime.timedelta(seconds=1),
1161
1820
datetime.timedelta(weeks=1),
1162
1821
datetime.timedelta(weeks=52)]
1163
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1165
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1166
command = SetIntervalCmd
1822
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1825
class TestSetIntervalCmd(TestPropertySetterValueCmd):
1826
command = command.SetInterval
1167
1827
propname = "Interval"
1168
1828
values_to_set = [datetime.timedelta(),
1169
1829
datetime.timedelta(minutes=5),
1170
1830
datetime.timedelta(seconds=1),
1171
1831
datetime.timedelta(weeks=1),
1172
1832
datetime.timedelta(weeks=52)]
1173
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1175
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1176
command = SetApprovalDelayCmd
1833
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1836
class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):
1837
command = command.SetApprovalDelay
1177
1838
propname = "ApprovalDelay"
1178
1839
values_to_set = [datetime.timedelta(),
1179
1840
datetime.timedelta(minutes=5),
1180
1841
datetime.timedelta(seconds=1),
1181
1842
datetime.timedelta(weeks=1),
1182
1843
datetime.timedelta(weeks=52)]
1183
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1185
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1186
command = SetApprovalDurationCmd
1844
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1847
class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):
1848
command = command.SetApprovalDuration
1187
1849
propname = "ApprovalDuration"
1188
1850
values_to_set = [datetime.timedelta(),
1189
1851
datetime.timedelta(minutes=5),
1190
1852
datetime.timedelta(seconds=1),
1191
1853
datetime.timedelta(weeks=1),
1192
1854
datetime.timedelta(weeks=52)]
1193
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1195
class Test_command_from_options(unittest.TestCase):
1197
self.parser = argparse.ArgumentParser()
1198
add_command_line_options(self.parser)
1199
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1200
"""Assert that parsing ARGS should result in an instance of
1201
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1202
options = self.parser.parse_args(args)
1203
check_option_syntax(self.parser, options)
1204
commands = commands_from_options(options)
1205
self.assertEqual(len(commands), 1)
1206
command = commands[0]
1207
self.assertIsInstance(command, command_cls)
1208
for key, value in cmd_attrs.items():
1209
self.assertEqual(getattr(command, key), value)
1210
def test_print_table(self):
1211
self.assert_command_from_args([], PrintTableCmd,
1214
def test_print_table_verbose(self):
1215
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1218
def test_print_table_verbose_short(self):
1219
self.assert_command_from_args(["-v"], PrintTableCmd,
1222
def test_enable(self):
1223
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1225
def test_enable_short(self):
1226
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1228
def test_disable(self):
1229
self.assert_command_from_args(["--disable", "foo"],
1232
def test_disable_short(self):
1233
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1235
def test_bump_timeout(self):
1236
self.assert_command_from_args(["--bump-timeout", "foo"],
1239
def test_bump_timeout_short(self):
1240
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1242
def test_start_checker(self):
1243
self.assert_command_from_args(["--start-checker", "foo"],
1246
def test_stop_checker(self):
1247
self.assert_command_from_args(["--stop-checker", "foo"],
1250
def test_remove(self):
1251
self.assert_command_from_args(["--remove", "foo"],
1254
def test_remove_short(self):
1255
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1257
def test_checker(self):
1258
self.assert_command_from_args(["--checker", ":", "foo"],
1259
SetCheckerCmd, value_to_set=":")
1261
def test_checker_empty(self):
1262
self.assert_command_from_args(["--checker", "", "foo"],
1263
SetCheckerCmd, value_to_set="")
1265
def test_checker_short(self):
1266
self.assert_command_from_args(["-c", ":", "foo"],
1267
SetCheckerCmd, value_to_set=":")
1269
def test_timeout(self):
1270
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1272
value_to_set=300000)
1274
def test_timeout_short(self):
1275
self.assert_command_from_args(["-t", "PT5M", "foo"],
1277
value_to_set=300000)
1279
def test_extended_timeout(self):
1280
self.assert_command_from_args(["--extended-timeout", "PT15M",
1282
SetExtendedTimeoutCmd,
1283
value_to_set=900000)
1285
def test_interval(self):
1286
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1288
value_to_set=120000)
1290
def test_interval_short(self):
1291
self.assert_command_from_args(["-i", "PT2M", "foo"],
1293
value_to_set=120000)
1295
def test_approve_by_default(self):
1296
self.assert_command_from_args(["--approve-by-default", "foo"],
1297
ApproveByDefaultCmd)
1299
def test_deny_by_default(self):
1300
self.assert_command_from_args(["--deny-by-default", "foo"],
1303
def test_approval_delay(self):
1304
self.assert_command_from_args(["--approval-delay", "PT30S",
1305
"foo"], SetApprovalDelayCmd,
1308
def test_approval_duration(self):
1309
self.assert_command_from_args(["--approval-duration", "PT1S",
1310
"foo"], SetApprovalDurationCmd,
1313
def test_host(self):
1314
self.assert_command_from_args(["--host", "foo.example.org",
1316
value_to_set="foo.example.org")
1318
def test_host_short(self):
1319
self.assert_command_from_args(["-H", "foo.example.org",
1321
value_to_set="foo.example.org")
1323
def test_secret_devnull(self):
1324
self.assert_command_from_args(["--secret", os.path.devnull,
1325
"foo"], SetSecretCmd,
1328
def test_secret_tempfile(self):
1329
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1330
value = b"secret\0xyzzy\nbar"
1333
self.assert_command_from_args(["--secret", f.name,
1334
"foo"], SetSecretCmd,
1337
def test_secret_devnull_short(self):
1338
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1339
SetSecretCmd, value_to_set=b"")
1341
def test_secret_tempfile_short(self):
1342
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1343
value = b"secret\0xyzzy\nbar"
1346
self.assert_command_from_args(["-s", f.name, "foo"],
1350
def test_approve(self):
1351
self.assert_command_from_args(["--approve", "foo"],
1354
def test_approve_short(self):
1355
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1357
def test_deny(self):
1358
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1360
def test_deny_short(self):
1361
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1363
def test_dump_json(self):
1364
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1366
def test_is_enabled(self):
1367
self.assert_command_from_args(["--is-enabled", "foo"],
1370
def test_is_enabled_short(self):
1371
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1373
def test_deny_before_remove(self):
1374
options = self.parser.parse_args(["--deny", "--remove", "foo"])
1375
check_option_syntax(self.parser, options)
1376
commands = commands_from_options(options)
1377
self.assertEqual(len(commands), 2)
1378
self.assertIsInstance(commands[0], DenyCmd)
1379
self.assertIsInstance(commands[1], RemoveCmd)
1381
def test_deny_before_remove_reversed(self):
1382
options = self.parser.parse_args(["--remove", "--deny", "--all"])
1383
check_option_syntax(self.parser, options)
1384
commands = commands_from_options(options)
1385
self.assertEqual(len(commands), 2)
1386
self.assertIsInstance(commands[0], DenyCmd)
1387
self.assertIsInstance(commands[1], RemoveCmd)
1390
class Test_check_option_syntax(unittest.TestCase):
1391
# This mostly corresponds to the definition from has_actions() in
1392
# check_option_syntax()
1394
# The actual values set here are not that important, but we do
1395
# at least stick to the correct types, even though they are
1399
"bump_timeout": True,
1400
"start_checker": True,
1401
"stop_checker": True,
1405
"timeout": datetime.timedelta(),
1406
"extended_timeout": datetime.timedelta(),
1407
"interval": datetime.timedelta(),
1408
"approved_by_default": True,
1409
"approval_delay": datetime.timedelta(),
1410
"approval_duration": datetime.timedelta(),
1412
"secret": io.BytesIO(b"x"),
1418
self.parser = argparse.ArgumentParser()
1419
add_command_line_options(self.parser)
1421
@contextlib.contextmanager
1422
def assertParseError(self):
1423
with self.assertRaises(SystemExit) as e:
1424
with self.temporarily_suppress_stderr():
1426
# Exit code from argparse is guaranteed to be "2". Reference:
1427
# https://docs.python.org/3/library/argparse.html#exiting-methods
1428
self.assertEqual(e.exception.code, 2)
1431
@contextlib.contextmanager
1432
def temporarily_suppress_stderr():
1433
null = os.open(os.path.devnull, os.O_RDWR)
1434
stderrcopy = os.dup(sys.stderr.fileno())
1435
os.dup2(null, sys.stderr.fileno())
1441
os.dup2(stderrcopy, sys.stderr.fileno())
1442
os.close(stderrcopy)
1444
def check_option_syntax(self, options):
1445
check_option_syntax(self.parser, options)
1447
def test_actions_requires_client_or_all(self):
1448
for action, value in self.actions.items():
1449
options = self.parser.parse_args()
1450
setattr(options, action, value)
1451
with self.assertParseError():
1452
self.check_option_syntax(options)
1454
def test_actions_conflicts_with_verbose(self):
1455
for action, value in self.actions.items():
1456
options = self.parser.parse_args()
1457
setattr(options, action, value)
1458
options.verbose = True
1459
with self.assertParseError():
1460
self.check_option_syntax(options)
1462
def test_dump_json_conflicts_with_verbose(self):
1463
options = self.parser.parse_args()
1464
options.dump_json = True
1465
options.verbose = True
1466
with self.assertParseError():
1467
self.check_option_syntax(options)
1469
def test_dump_json_conflicts_with_action(self):
1470
for action, value in self.actions.items():
1471
options = self.parser.parse_args()
1472
setattr(options, action, value)
1473
options.dump_json = True
1474
with self.assertParseError():
1475
self.check_option_syntax(options)
1477
def test_all_can_not_be_alone(self):
1478
options = self.parser.parse_args()
1480
with self.assertParseError():
1481
self.check_option_syntax(options)
1483
def test_all_is_ok_with_any_action(self):
1484
for action, value in self.actions.items():
1485
options = self.parser.parse_args()
1486
setattr(options, action, value)
1488
self.check_option_syntax(options)
1490
def test_is_enabled_fails_without_client(self):
1491
options = self.parser.parse_args()
1492
options.is_enabled = True
1493
with self.assertParseError():
1494
self.check_option_syntax(options)
1496
def test_is_enabled_works_with_one_client(self):
1497
options = self.parser.parse_args()
1498
options.is_enabled = True
1499
options.client = ["foo"]
1500
self.check_option_syntax(options)
1502
def test_is_enabled_fails_with_two_clients(self):
1503
options = self.parser.parse_args()
1504
options.is_enabled = True
1505
options.client = ["foo", "barbar"]
1506
with self.assertParseError():
1507
self.check_option_syntax(options)
1509
def test_remove_can_only_be_combined_with_action_deny(self):
1510
for action, value in self.actions.items():
1511
if action in {"remove", "deny"}:
1513
options = self.parser.parse_args()
1514
setattr(options, action, value)
1516
options.remove = True
1517
with self.assertParseError():
1518
self.check_option_syntax(options)
1855
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]