To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 1021
- compare with another revision
- download diff
- download tarball
- view history from revision 1021
- Committer: Teddy Hogeborn
- Date: 2019-03-04 20:50:40 UTC
- Revision ID: teddy@recompile.se-20190304205040-c0ecwnigjedch1j9
mandos-ctl: Add test for EnableCmd and DisableCmd
* mandos-ctl (TestEnableCmd, TestDisableCmd): New.
* mandos-ctl (TestEnableCmd, TestDisableCmd): New.
- files modified:
- mandos-ctl
added
removed
mandos-ctl
42
42
import json
43
43
import unittest
44
44
import logging
45
import io
46
import tempfile
47
import contextlib
48
45
49
46
import dbus
50
47
276
273
# Abstract classes first
277
274
class Command(object):
278
275
"""Abstract class for commands"""
279
def run(self, clients, bus=None, mandos=None):
276
def run(self, mandos, clients):
280
277
"""Normal commands should implement run_on_one_client(), but
281
278
commands which want to operate on all clients at the same time
282
279
can override this run() method instead."""
283
280
self.mandos = mandos
284
for clientpath, properties in clients.items():
285
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
286
busname, str(clientpath))
287
client = bus.get_object(busname, clientpath)
281
for client, properties in clients.items():
288
282
self.run_on_one_client(client, properties)
289
283
290
284
class PrintCmd(Command):
296
290
"LastApprovalRequest", "ApprovalDelay",
297
291
"ApprovalDuration", "Checker", "ExtendedTimeout",
298
292
"Expires", "LastCheckerStatus")
299
def run(self, clients, bus=None, mandos=None):
300
print(self.output(clients.values()))
301
def output(self, clients):
302
raise NotImplementedError()
293
def run(self, mandos, clients):
294
print(self.output(clients))
303
295
304
296
class PropertyCmd(Command):
305
297
"""Abstract class for Actions for setting one client property"""
306
298
def run_on_one_client(self, client, properties):
307
299
"""Set the Client's D-Bus property"""
308
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
309
client.__dbus_object_path__,
310
dbus.PROPERTIES_IFACE, client_interface,
311
self.propname, self.value_to_set
312
if not isinstance(self.value_to_set, dbus.Boolean)
313
else bool(self.value_to_set))
314
client.Set(client_interface, self.propname, self.value_to_set,
300
client.Set(client_interface, self.property, self.value_to_set,
315
301
dbus_interface=dbus.PROPERTIES_IFACE)
316
@property
317
def propname(self):
318
raise NotImplementedError()
319
302
320
303
class ValueArgumentMixIn(object):
321
304
"""Mixin class for commands taking a value as argument"""
331
314
@value_to_set.setter
332
315
def value_to_set(self, value):
333
316
"""When setting, convert value to a datetime.timedelta"""
334
self._vts = int(round(value.total_seconds() * 1000))
317
self._vts = string_to_delta(value).total_seconds() * 1000
335
318
336
319
# Actual (non-abstract) command classes
337
320
340
323
self.verbose = verbose
341
324
342
325
def output(self, clients):
343
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
344
keywords = default_keywords
345
326
if self.verbose:
346
327
keywords = self.all_keywords
347
return str(self.TableOfClients(clients, keywords))
328
else:
329
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
330
return str(self.TableOfClients(clients.values(), keywords))
348
331
349
332
class TableOfClients(object):
350
333
tableheaders = {
436
419
return value
437
420
438
421
class IsEnabledCmd(Command):
439
def run(self, clients, bus=None, mandos=None):
440
client, properties = next(iter(clients.items()))
422
def run_on_one_client(self, client, properties):
441
423
if self.is_enabled(client, properties):
442
424
sys.exit(0)
443
425
sys.exit(1)
444
426
def is_enabled(self, client, properties):
445
return properties["Enabled"]
427
return bool(properties["Enabled"])
446
428
447
429
class RemoveCmd(Command):
448
430
def run_on_one_client(self, client, properties):
449
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", busname,
450
server_path, server_interface,
451
str(client.__dbus_object_path__))
452
431
self.mandos.RemoveClient(client.__dbus_object_path__)
453
432
454
433
class ApproveCmd(Command):
455
434
def run_on_one_client(self, client, properties):
456
log.debug("D-Bus: %s:%s:%s.Approve(True)", busname,
457
client.__dbus_object_path__, client_interface)
458
435
client.Approve(dbus.Boolean(True),
459
436
dbus_interface=client_interface)
460
437
461
438
class DenyCmd(Command):
462
439
def run_on_one_client(self, client, properties):
463
log.debug("D-Bus: %s:%s:%s.Approve(False)", busname,
464
client.__dbus_object_path__, client_interface)
465
440
client.Approve(dbus.Boolean(False),
466
441
dbus_interface=client_interface)
467
442
468
443
class EnableCmd(PropertyCmd):
469
propname = "Enabled"
444
property = "Enabled"
470
445
value_to_set = dbus.Boolean(True)
471
446
472
447
class DisableCmd(PropertyCmd):
473
propname = "Enabled"
448
property = "Enabled"
474
449
value_to_set = dbus.Boolean(False)
475
450
476
451
class BumpTimeoutCmd(PropertyCmd):
477
propname = "LastCheckedOK"
452
property = "LastCheckedOK"
478
453
value_to_set = ""
479
454
480
455
class StartCheckerCmd(PropertyCmd):
481
propname = "CheckerRunning"
456
property = "CheckerRunning"
482
457
value_to_set = dbus.Boolean(True)
483
458
484
459
class StopCheckerCmd(PropertyCmd):
485
propname = "CheckerRunning"
460
property = "CheckerRunning"
486
461
value_to_set = dbus.Boolean(False)
487
462
488
463
class ApproveByDefaultCmd(PropertyCmd):
489
propname = "ApprovedByDefault"
464
property = "ApprovedByDefault"
490
465
value_to_set = dbus.Boolean(True)
491
466
492
467
class DenyByDefaultCmd(PropertyCmd):
493
propname = "ApprovedByDefault"
468
property = "ApprovedByDefault"
494
469
value_to_set = dbus.Boolean(False)
495
470
496
471
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
497
propname = "Checker"
472
property = "Checker"
498
473
499
474
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
500
propname = "Host"
475
property = "Host"
501
476
502
477
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
503
propname = "Secret"
504
@property
505
def value_to_set(self):
506
return self._vts
507
@value_to_set.setter
508
def value_to_set(self, value):
509
"""When setting, read data from supplied file object"""
510
self._vts = value.read()
511
value.close()
478
property = "Secret"
512
479
513
480
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
514
propname = "Timeout"
481
property = "Timeout"
515
482
516
483
class SetExtendedTimeoutCmd(PropertyCmd,
517
484
MillisecondsValueArgumentMixIn):
518
propname = "ExtendedTimeout"
485
property = "ExtendedTimeout"
519
486
520
487
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
521
propname = "Interval"
488
property = "Interval"
522
489
523
490
class SetApprovalDelayCmd(PropertyCmd,
524
491
MillisecondsValueArgumentMixIn):
525
propname = "ApprovalDelay"
492
property = "ApprovalDelay"
526
493
527
494
class SetApprovalDurationCmd(PropertyCmd,
528
495
MillisecondsValueArgumentMixIn):
529
propname = "ApprovalDuration"
496
property = "ApprovalDuration"
497
498
def has_actions(options):
499
return any((options.enable,
500
options.disable,
501
options.bump_timeout,
502
options.start_checker,
503
options.stop_checker,
504
options.is_enabled,
505
options.remove,
506
options.checker is not None,
507
options.timeout is not None,
508
options.extended_timeout is not None,
509
options.interval is not None,
510
options.approved_by_default is not None,
511
options.approval_delay is not None,
512
options.approval_duration is not None,
513
options.host is not None,
514
options.secret is not None,
515
options.approve,
516
options.deny))
530
517
531
518
def add_command_line_options(parser):
532
519
parser.add_argument("--version", action="version",
559
546
help="Remove client")
560
547
parser.add_argument("-c", "--checker",
561
548
help="Set checker command for client")
562
parser.add_argument("-t", "--timeout", type=string_to_delta,
549
parser.add_argument("-t", "--timeout",
563
550
help="Set timeout for client")
564
parser.add_argument("--extended-timeout", type=string_to_delta,
551
parser.add_argument("--extended-timeout",
565
552
help="Set extended timeout for client")
566
parser.add_argument("-i", "--interval", type=string_to_delta,
553
parser.add_argument("-i", "--interval",
567
554
help="Set checker interval for client")
568
555
approve_deny_default = parser.add_mutually_exclusive_group()
569
556
approve_deny_default.add_argument(
574
561
"--deny-by-default", action="store_false",
575
562
dest="approved_by_default",
576
563
help="Set client to be denied by default")
577
parser.add_argument("--approval-delay", type=string_to_delta,
564
parser.add_argument("--approval-delay",
578
565
help="Set delay before client approve/deny")
579
parser.add_argument("--approval-duration", type=string_to_delta,
566
parser.add_argument("--approval-duration",
580
567
help="Set duration of one client approval")
581
568
parser.add_argument("-H", "--host", help="Set host for client")
582
569
parser.add_argument("-s", "--secret",
588
575
help="Approve any current client request")
589
576
approve_deny.add_argument("-D", "--deny", action="store_true",
590
577
help="Deny any current client request")
591
parser.add_argument("--debug", action="store_true",
592
help="Debug mode (show D-Bus commands)")
593
578
parser.add_argument("--check", action="store_true",
594
579
help="Run self-test")
595
580
parser.add_argument("client", nargs="*", help="Client name")
596
581
597
582
598
def commands_from_options(options):
583
def commands_and_clients_from_options(options):
599
584
600
585
commands = []
601
586
609
594
commands.append(DisableCmd())
610
595
611
596
if options.bump_timeout:
612
commands.append(BumpTimeoutCmd())
597
commands.append(BumpTimeoutCmd(options.bump_timeout))
613
598
614
599
if options.start_checker:
615
600
commands.append(StartCheckerCmd())
620
605
if options.is_enabled:
621
606
commands.append(IsEnabledCmd())
622
607
608
if options.remove:
609
commands.append(RemoveCmd())
610
623
611
if options.checker is not None:
624
commands.append(SetCheckerCmd(options.checker))
612
commands.append(SetCheckerCmd())
625
613
626
614
if options.timeout is not None:
627
615
commands.append(SetTimeoutCmd(options.timeout))
631
619
SetExtendedTimeoutCmd(options.extended_timeout))
632
620
633
621
if options.interval is not None:
634
commands.append(SetIntervalCmd(options.interval))
622
command.append(SetIntervalCmd(options.interval))
635
623
636
624
if options.approved_by_default is not None:
637
625
if options.approved_by_default:
638
commands.append(ApproveByDefaultCmd())
626
command.append(ApproveByDefaultCmd())
639
627
else:
640
commands.append(DenyByDefaultCmd())
628
command.append(DenyByDefaultCmd())
641
629
642
630
if options.approval_delay is not None:
643
commands.append(SetApprovalDelayCmd(options.approval_delay))
631
command.append(SetApprovalDelayCmd(options.approval_delay))
644
632
645
633
if options.approval_duration is not None:
646
commands.append(
634
command.append(
647
635
SetApprovalDurationCmd(options.approval_duration))
648
636
649
637
if options.host is not None:
650
commands.append(SetHostCmd(options.host))
638
command.append(SetHostCmd(options.host))
651
639
652
640
if options.secret is not None:
653
commands.append(SetSecretCmd(options.secret))
641
command.append(SetSecretCmd(options.secret))
654
642
655
643
if options.approve:
656
644
commands.append(ApproveCmd())
658
646
if options.deny:
659
647
commands.append(DenyCmd())
660
648
661
if options.remove:
662
commands.append(RemoveCmd())
663
664
649
# If no command option has been given, show table of clients,
665
650
# optionally verbosely
666
651
if not commands:
667
652
commands.append(PrintTableCmd(verbose=options.verbose))
668
653
669
return commands
670
671
672
def check_option_syntax(parser, options):
673
"""Apply additional restrictions on options, not expressible in
674
argparse"""
675
676
def has_actions(options):
677
return any((options.enable,
678
options.disable,
679
options.bump_timeout,
680
options.start_checker,
681
options.stop_checker,
682
options.is_enabled,
683
options.remove,
684
options.checker is not None,
685
options.timeout is not None,
686
options.extended_timeout is not None,
687
options.interval is not None,
688
options.approved_by_default is not None,
689
options.approval_delay is not None,
690
options.approval_duration is not None,
691
options.host is not None,
692
options.secret is not None,
693
options.approve,
694
options.deny))
654
return commands, options.client
655
656
657
def main():
658
parser = argparse.ArgumentParser()
659
660
add_command_line_options(parser)
661
662
options = parser.parse_args()
695
663
696
664
if has_actions(options) and not (options.client or options.all):
697
665
parser.error("Options require clients names or --all.")
704
672
parser.error("--all requires an action.")
705
673
if options.is_enabled and len(options.client) > 1:
706
674
parser.error("--is-enabled requires exactly one client")
707
if options.remove:
708
options.remove = False
709
if has_actions(options) and not options.deny:
710
parser.error("--remove can only be combined with --deny")
711
options.remove = True
712
713
714
def main():
715
parser = argparse.ArgumentParser()
716
717
add_command_line_options(parser)
718
719
options = parser.parse_args()
720
721
check_option_syntax(parser, options)
722
723
clientnames = options.client
724
725
if options.debug:
726
log.setLevel(logging.DEBUG)
675
676
commands, clientnames = commands_and_clients_from_options(options)
727
677
728
678
try:
729
679
bus = dbus.SystemBus()
730
log.debug("D-Bus: Connect to: (busname=%r, path=%r)", busname,
731
server_path)
732
680
mandos_dbus_objc = bus.get_object(busname, server_path)
733
681
except dbus.exceptions.DBusException:
734
682
log.critical("Could not connect to Mandos server")
747
695
dbus_filter = NullFilter()
748
696
try:
749
697
dbus_logger.addFilter(dbus_filter)
750
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", busname,
751
server_path, dbus.OBJECT_MANAGER_IFACE)
752
698
mandos_clients = {path: ifs_and_props[client_interface]
753
699
for path, ifs_and_props in
754
700
mandos_serv_object_manager
766
712
clients = {}
767
713
768
714
if not clientnames:
769
clients = {objpath: properties
770
for objpath, properties in mandos_clients.items()}
715
clients = {bus.get_object(busname, path): properties
716
for path, properties in mandos_clients.items()}
771
717
else:
772
718
for name in clientnames:
773
for objpath, properties in mandos_clients.items():
774
if properties["Name"] == name:
775
clients[objpath] = properties
719
for path, client in mandos_clients.items():
720
if client["Name"] == name:
721
client_objc = bus.get_object(busname, path)
722
clients[client_objc] = client
776
723
break
777
724
else:
778
725
log.critical("Client not found on server: %r", name)
779
726
sys.exit(1)
780
727
781
728
# Run all commands on clients
782
commands = commands_from_options(options)
783
729
for command in commands:
784
command.run(clients, bus, mandos_serv)
730
command.run(mandos_serv, clients)
785
731
786
732
787
733
class Test_milliseconds_to_string(unittest.TestCase):
799
745
800
746
class Test_string_to_delta(unittest.TestCase):
801
747
def test_handles_basic_rfc3339(self):
802
self.assertEqual(string_to_delta("PT0S"),
803
datetime.timedelta())
804
self.assertEqual(string_to_delta("P0D"),
805
datetime.timedelta())
806
self.assertEqual(string_to_delta("PT1S"),
807
datetime.timedelta(0, 1))
808
748
self.assertEqual(string_to_delta("PT2H"),
809
749
datetime.timedelta(0, 7200))
810
750
def test_falls_back_to_pre_1_6_1_with_warning(self):
836
776
testcase = self
837
777
class MockClient(object):
838
778
def __init__(self, name, **attributes):
839
self.__dbus_object_path__ = "/clients/{}".format(name)
779
self.__dbus_object_path__ = "objpath_{}".format(name)
840
780
self.attributes = attributes
841
781
self.attributes["Name"] = name
842
782
self.calls = []
843
def Set(self, interface, propname, value, dbus_interface):
844
testcase.assertEqual(interface, client_interface)
845
testcase.assertEqual(dbus_interface,
846
dbus.PROPERTIES_IFACE)
847
self.attributes[propname] = value
848
def Get(self, interface, propname, dbus_interface):
849
testcase.assertEqual(interface, client_interface)
850
testcase.assertEqual(dbus_interface,
851
dbus.PROPERTIES_IFACE)
852
return self.attributes[propname]
783
def Set(self, interface, property, value, dbus_interface):
784
testcase.assertEqual(interface, client_interface)
785
testcase.assertEqual(dbus_interface,
786
dbus.PROPERTIES_IFACE)
787
self.attributes[property] = value
788
self.calls.append(("Set", (interface, property, value,
789
dbus_interface)))
790
def Get(self, interface, property, dbus_interface):
791
testcase.assertEqual(interface, client_interface)
792
testcase.assertEqual(dbus_interface,
793
dbus.PROPERTIES_IFACE)
794
self.calls.append(("Get", (interface, property,
795
dbus_interface)))
796
return self.attributes[property]
853
797
def Approve(self, approve, dbus_interface):
854
798
testcase.assertEqual(dbus_interface, client_interface)
855
799
self.calls.append(("Approve", (approve,
904
848
LastCheckerStatus=-2)
905
849
self.clients = collections.OrderedDict(
906
850
[
907
("/clients/foo", self.client.attributes),
908
("/clients/barbar", self.other_client.attributes),
851
(self.client, self.client.attributes),
852
(self.other_client, self.other_client.attributes),
909
853
])
910
self.one_client = {"/clients/foo": self.client.attributes}
911
@property
912
def bus(self):
913
class Bus(object):
914
@staticmethod
915
def get_object(client_bus_name, path):
916
self.assertEqual(client_bus_name, busname)
917
return {
918
"/clients/foo": self.client,
919
"/clients/barbar": self.other_client,
920
}[path]
921
return Bus()
854
self.one_client = {self.client: self.client.attributes}
922
855
923
856
class TestPrintTableCmd(TestCmd):
924
857
def test_normal(self):
925
output = PrintTableCmd().output(self.clients.values())
858
output = PrintTableCmd().output(self.clients)
926
859
expected_output = """
927
860
Name Enabled Timeout Last Successful Check
928
861
foo Yes 00:05:00 2019-02-03T00:00:00
930
863
"""[1:-1]
931
864
self.assertEqual(output, expected_output)
932
865
def test_verbose(self):
933
output = PrintTableCmd(verbose=True).output(
934
self.clients.values())
866
output = PrintTableCmd(verbose=True).output(self.clients)
935
867
expected_output = """
936
868
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
937
869
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
939
871
"""[1:-1]
940
872
self.assertEqual(output, expected_output)
941
873
def test_one_client(self):
942
output = PrintTableCmd().output(self.one_client.values())
874
output = PrintTableCmd().output(self.one_client)
943
875
expected_output = """
944
876
Name Enabled Timeout Last Successful Check
945
877
foo Yes 00:05:00 2019-02-03T00:00:00
1014
946
for client, properties in self.clients.items()))
1015
947
def test_is_enabled_run_exits_successfully(self):
1016
948
with self.assertRaises(SystemExit) as e:
1017
IsEnabledCmd().run(self.one_client)
949
IsEnabledCmd().run(None, self.one_client)
1018
950
if e.exception.code is not None:
1019
951
self.assertEqual(e.exception.code, 0)
1020
952
else:
1022
954
def test_is_enabled_run_exits_with_failure(self):
1023
955
self.client.attributes["Enabled"] = dbus.Boolean(False)
1024
956
with self.assertRaises(SystemExit) as e:
1025
IsEnabledCmd().run(self.one_client)
957
IsEnabledCmd().run(None, self.one_client)
1026
958
if isinstance(e.exception.code, int):
1027
959
self.assertNotEqual(e.exception.code, 0)
1028
960
else:
1037
969
self.calls.append(("RemoveClient", (dbus_path,)))
1038
970
mandos = MockMandos()
1039
971
super(TestRemoveCmd, self).setUp()
1040
RemoveCmd().run(self.clients, self.bus, mandos)
972
RemoveCmd().run(mandos, self.clients)
1041
973
self.assertEqual(len(mandos.calls), 2)
1042
for clientpath in self.clients:
1043
self.assertIn(("RemoveClient", (clientpath,)),
974
for client in self.clients:
975
self.assertIn(("RemoveClient",
976
(client.__dbus_object_path__,)),
1044
977
mandos.calls)
1045
978
1046
979
class TestApproveCmd(TestCmd):
1047
980
def test_approve(self):
1048
ApproveCmd().run(self.clients, self.bus)
1049
for clientpath in self.clients:
1050
client = self.bus.get_object(busname, clientpath)
981
ApproveCmd().run(None, self.clients)
982
for client in self.clients:
1051
983
self.assertIn(("Approve", (True, client_interface)),
1052
984
client.calls)
1053
985
1054
986
class TestDenyCmd(TestCmd):
1055
987
def test_deny(self):
1056
DenyCmd().run(self.clients, self.bus)
1057
for clientpath in self.clients:
1058
client = self.bus.get_object(busname, clientpath)
988
DenyCmd().run(None, self.clients)
989
for client in self.clients:
1059
990
self.assertIn(("Approve", (False, client_interface)),
1060
991
client.calls)
1061
992
1062
993
class TestEnableCmd(TestCmd):
1063
994
def test_enable(self):
1064
for clientpath in self.clients:
1065
client = self.bus.get_object(busname, clientpath)
995
for client in self.clients:
1066
996
client.attributes["Enabled"] = False
1067
997
1068
EnableCmd().run(self.clients, self.bus)
998
EnableCmd().run(None, self.clients)
1069
999
1070
for clientpath in self.clients:
1071
client = self.bus.get_object(busname, clientpath)
1000
for client in self.clients:
1072
1001
self.assertTrue(client.attributes["Enabled"])
1073
1002
1074
1003
class TestDisableCmd(TestCmd):
1075
1004
def test_disable(self):
1076
DisableCmd().run(self.clients, self.bus)
1077
for clientpath in self.clients:
1078
client = self.bus.get_object(busname, clientpath)
1005
DisableCmd().run(None, self.clients)
1006
1007
for client in self.clients:
1079
1008
self.assertFalse(client.attributes["Enabled"])
1080
1009
1081
class Unique(object):
1082
"""Class for objects which exist only to be unique objects, since
1083
unittest.mock.sentinel only exists in Python 3.3"""
1084
1085
class TestPropertyCmd(TestCmd):
1086
"""Abstract class for tests of PropertyCmd classes"""
1087
def runTest(self):
1088
if not hasattr(self, "command"):
1089
return
1090
values_to_get = getattr(self, "values_to_get",
1091
self.values_to_set)
1092
for value_to_set, value_to_get in zip(self.values_to_set,
1093
values_to_get):
1094
for clientpath in self.clients:
1095
client = self.bus.get_object(busname, clientpath)
1096
old_value = client.attributes[self.propname]
1097
self.assertNotIsInstance(old_value, Unique)
1098
client.attributes[self.propname] = Unique()
1099
self.run_command(value_to_set, self.clients)
1100
for clientpath in self.clients:
1101
client = self.bus.get_object(busname, clientpath)
1102
value = client.attributes[self.propname]
1103
self.assertNotIsInstance(value, Unique)
1104
self.assertEqual(value, value_to_get)
1105
def run_command(self, value, clients):
1106
self.command().run(clients, self.bus)
1107
1108
class TestBumpTimeoutCmd(TestPropertyCmd):
1109
command = BumpTimeoutCmd
1110
propname = "LastCheckedOK"
1111
values_to_set = [""]
1112
1113
class TestStartCheckerCmd(TestPropertyCmd):
1114
command = StartCheckerCmd
1115
propname = "CheckerRunning"
1116
values_to_set = [dbus.Boolean(True)]
1117
1118
class TestStopCheckerCmd(TestPropertyCmd):
1119
command = StopCheckerCmd
1120
propname = "CheckerRunning"
1121
values_to_set = [dbus.Boolean(False)]
1122
1123
class TestApproveByDefaultCmd(TestPropertyCmd):
1124
command = ApproveByDefaultCmd
1125
propname = "ApprovedByDefault"
1126
values_to_set = [dbus.Boolean(True)]
1127
1128
class TestDenyByDefaultCmd(TestPropertyCmd):
1129
command = DenyByDefaultCmd
1130
propname = "ApprovedByDefault"
1131
values_to_set = [dbus.Boolean(False)]
1132
1133
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1134
"""Abstract class for tests of PropertyCmd classes using the
1135
ValueArgumentMixIn"""
1136
def runTest(self):
1137
if type(self) is TestValueArgumentPropertyCmd:
1138
return
1139
return super(TestValueArgumentPropertyCmd, self).runTest()
1140
def run_command(self, value, clients):
1141
self.command(value).run(clients, self.bus)
1142
1143
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1144
command = SetCheckerCmd
1145
propname = "Checker"
1146
values_to_set = ["", ":", "fping -q -- %s"]
1147
1148
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1149
command = SetHostCmd
1150
propname = "Host"
1151
values_to_set = ["192.0.2.3", "foo.example.org"]
1152
1153
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1154
command = SetSecretCmd
1155
propname = "Secret"
1156
values_to_set = [io.BytesIO(b""),
1157
io.BytesIO(b"secret\0xyzzy\nbar")]
1158
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1159
1160
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1161
command = SetTimeoutCmd
1162
propname = "Timeout"
1163
values_to_set = [datetime.timedelta(),
1164
datetime.timedelta(minutes=5),
1165
datetime.timedelta(seconds=1),
1166
datetime.timedelta(weeks=1),
1167
datetime.timedelta(weeks=52)]
1168
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1169
1170
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1171
command = SetExtendedTimeoutCmd
1172
propname = "ExtendedTimeout"
1173
values_to_set = [datetime.timedelta(),
1174
datetime.timedelta(minutes=5),
1175
datetime.timedelta(seconds=1),
1176
datetime.timedelta(weeks=1),
1177
datetime.timedelta(weeks=52)]
1178
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1179
1180
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1181
command = SetIntervalCmd
1182
propname = "Interval"
1183
values_to_set = [datetime.timedelta(),
1184
datetime.timedelta(minutes=5),
1185
datetime.timedelta(seconds=1),
1186
datetime.timedelta(weeks=1),
1187
datetime.timedelta(weeks=52)]
1188
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1189
1190
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1191
command = SetApprovalDelayCmd
1192
propname = "ApprovalDelay"
1193
values_to_set = [datetime.timedelta(),
1194
datetime.timedelta(minutes=5),
1195
datetime.timedelta(seconds=1),
1196
datetime.timedelta(weeks=1),
1197
datetime.timedelta(weeks=52)]
1198
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1199
1200
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1201
command = SetApprovalDurationCmd
1202
propname = "ApprovalDuration"
1203
values_to_set = [datetime.timedelta(),
1204
datetime.timedelta(minutes=5),
1205
datetime.timedelta(seconds=1),
1206
datetime.timedelta(weeks=1),
1207
datetime.timedelta(weeks=52)]
1208
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1209
1210
class Test_command_from_options(unittest.TestCase):
1211
def setUp(self):
1212
self.parser = argparse.ArgumentParser()
1213
add_command_line_options(self.parser)
1214
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1215
"""Assert that parsing ARGS should result in an instance of
1216
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1217
options = self.parser.parse_args(args)
1218
check_option_syntax(self.parser, options)
1219
commands = commands_from_options(options)
1220
self.assertEqual(len(commands), 1)
1221
command = commands[0]
1222
self.assertIsInstance(command, command_cls)
1223
for key, value in cmd_attrs.items():
1224
self.assertEqual(getattr(command, key), value)
1225
def test_print_table(self):
1226
self.assert_command_from_args([], PrintTableCmd,
1227
verbose=False)
1228
1229
def test_print_table_verbose(self):
1230
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1231
verbose=True)
1232
1233
def test_print_table_verbose_short(self):
1234
self.assert_command_from_args(["-v"], PrintTableCmd,
1235
verbose=True)
1236
1237
def test_enable(self):
1238
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1239
1240
def test_enable_short(self):
1241
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1242
1243
def test_disable(self):
1244
self.assert_command_from_args(["--disable", "foo"],
1245
DisableCmd)
1246
1247
def test_disable_short(self):
1248
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1249
1250
def test_bump_timeout(self):
1251
self.assert_command_from_args(["--bump-timeout", "foo"],
1252
BumpTimeoutCmd)
1253
1254
def test_bump_timeout_short(self):
1255
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1256
1257
def test_start_checker(self):
1258
self.assert_command_from_args(["--start-checker", "foo"],
1259
StartCheckerCmd)
1260
1261
def test_stop_checker(self):
1262
self.assert_command_from_args(["--stop-checker", "foo"],
1263
StopCheckerCmd)
1264
1265
def test_remove(self):
1266
self.assert_command_from_args(["--remove", "foo"],
1267
RemoveCmd)
1268
1269
def test_remove_short(self):
1270
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1271
1272
def test_checker(self):
1273
self.assert_command_from_args(["--checker", ":", "foo"],
1274
SetCheckerCmd, value_to_set=":")
1275
1276
def test_checker_empty(self):
1277
self.assert_command_from_args(["--checker", "", "foo"],
1278
SetCheckerCmd, value_to_set="")
1279
1280
def test_checker_short(self):
1281
self.assert_command_from_args(["-c", ":", "foo"],
1282
SetCheckerCmd, value_to_set=":")
1283
1284
def test_timeout(self):
1285
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1286
SetTimeoutCmd,
1287
value_to_set=300000)
1288
1289
def test_timeout_short(self):
1290
self.assert_command_from_args(["-t", "PT5M", "foo"],
1291
SetTimeoutCmd,
1292
value_to_set=300000)
1293
1294
def test_extended_timeout(self):
1295
self.assert_command_from_args(["--extended-timeout", "PT15M",
1296
"foo"],
1297
SetExtendedTimeoutCmd,
1298
value_to_set=900000)
1299
1300
def test_interval(self):
1301
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1302
SetIntervalCmd,
1303
value_to_set=120000)
1304
1305
def test_interval_short(self):
1306
self.assert_command_from_args(["-i", "PT2M", "foo"],
1307
SetIntervalCmd,
1308
value_to_set=120000)
1309
1310
def test_approve_by_default(self):
1311
self.assert_command_from_args(["--approve-by-default", "foo"],
1312
ApproveByDefaultCmd)
1313
1314
def test_deny_by_default(self):
1315
self.assert_command_from_args(["--deny-by-default", "foo"],
1316
DenyByDefaultCmd)
1317
1318
def test_approval_delay(self):
1319
self.assert_command_from_args(["--approval-delay", "PT30S",
1320
"foo"], SetApprovalDelayCmd,
1321
value_to_set=30000)
1322
1323
def test_approval_duration(self):
1324
self.assert_command_from_args(["--approval-duration", "PT1S",
1325
"foo"], SetApprovalDurationCmd,
1326
value_to_set=1000)
1327
1328
def test_host(self):
1329
self.assert_command_from_args(["--host", "foo.example.org",
1330
"foo"], SetHostCmd,
1331
value_to_set="foo.example.org")
1332
1333
def test_host_short(self):
1334
self.assert_command_from_args(["-H", "foo.example.org",
1335
"foo"], SetHostCmd,
1336
value_to_set="foo.example.org")
1337
1338
def test_secret_devnull(self):
1339
self.assert_command_from_args(["--secret", os.path.devnull,
1340
"foo"], SetSecretCmd,
1341
value_to_set=b"")
1342
1343
def test_secret_tempfile(self):
1344
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1345
value = b"secret\0xyzzy\nbar"
1346
f.write(value)
1347
f.seek(0)
1348
self.assert_command_from_args(["--secret", f.name,
1349
"foo"], SetSecretCmd,
1350
value_to_set=value)
1351
1352
def test_secret_devnull_short(self):
1353
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1354
SetSecretCmd, value_to_set=b"")
1355
1356
def test_secret_tempfile_short(self):
1357
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1358
value = b"secret\0xyzzy\nbar"
1359
f.write(value)
1360
f.seek(0)
1361
self.assert_command_from_args(["-s", f.name, "foo"],
1362
SetSecretCmd,
1363
value_to_set=value)
1364
1365
def test_approve(self):
1366
self.assert_command_from_args(["--approve", "foo"],
1367
ApproveCmd)
1368
1369
def test_approve_short(self):
1370
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1371
1372
def test_deny(self):
1373
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1374
1375
def test_deny_short(self):
1376
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1377
1378
def test_dump_json(self):
1379
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1380
1381
def test_is_enabled(self):
1382
self.assert_command_from_args(["--is-enabled", "foo"],
1383
IsEnabledCmd)
1384
1385
def test_is_enabled_short(self):
1386
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1387
1388
def test_deny_before_remove(self):
1389
options = self.parser.parse_args(["--deny", "--remove", "foo"])
1390
check_option_syntax(self.parser, options)
1391
commands = commands_from_options(options)
1392
self.assertEqual(len(commands), 2)
1393
self.assertIsInstance(commands[0], DenyCmd)
1394
self.assertIsInstance(commands[1], RemoveCmd)
1395
1396
def test_deny_before_remove_reversed(self):
1397
options = self.parser.parse_args(["--remove", "--deny", "--all"])
1398
check_option_syntax(self.parser, options)
1399
commands = commands_from_options(options)
1400
self.assertEqual(len(commands), 2)
1401
self.assertIsInstance(commands[0], DenyCmd)
1402
self.assertIsInstance(commands[1], RemoveCmd)
1403
1404
1405
class Test_check_option_syntax(unittest.TestCase):
1406
# This mostly corresponds to the definition from has_actions() in
1407
# check_option_syntax()
1408
actions = {
1409
# The actual values set here are not that important, but we do
1410
# at least stick to the correct types, even though they are
1411
# never used
1412
"enable": True,
1413
"disable": True,
1414
"bump_timeout": True,
1415
"start_checker": True,
1416
"stop_checker": True,
1417
"is_enabled": True,
1418
"remove": True,
1419
"checker": "x",
1420
"timeout": datetime.timedelta(),
1421
"extended_timeout": datetime.timedelta(),
1422
"interval": datetime.timedelta(),
1423
"approved_by_default": True,
1424
"approval_delay": datetime.timedelta(),
1425
"approval_duration": datetime.timedelta(),
1426
"host": "x",
1427
"secret": io.BytesIO(b"x"),
1428
"approve": True,
1429
"deny": True,
1430
}
1431
1432
def setUp(self):
1433
self.parser = argparse.ArgumentParser()
1434
add_command_line_options(self.parser)
1435
1436
@contextlib.contextmanager
1437
def assertParseError(self):
1438
with self.assertRaises(SystemExit) as e:
1439
with self.temporarily_suppress_stderr():
1440
yield
1441
# Exit code from argparse is guaranteed to be "2". Reference:
1442
# https://docs.python.org/3/library/argparse.html#exiting-methods
1443
self.assertEqual(e.exception.code, 2)
1444
1445
@staticmethod
1446
@contextlib.contextmanager
1447
def temporarily_suppress_stderr():
1448
null = os.open(os.path.devnull, os.O_RDWR)
1449
stderrcopy = os.dup(sys.stderr.fileno())
1450
os.dup2(null, sys.stderr.fileno())
1451
os.close(null)
1452
try:
1453
yield
1454
finally:
1455
# restore stderr
1456
os.dup2(stderrcopy, sys.stderr.fileno())
1457
os.close(stderrcopy)
1458
1459
def check_option_syntax(self, options):
1460
check_option_syntax(self.parser, options)
1461
1462
def test_actions_requires_client_or_all(self):
1463
for action, value in self.actions.items():
1464
options = self.parser.parse_args()
1465
setattr(options, action, value)
1466
with self.assertParseError():
1467
self.check_option_syntax(options)
1468
1469
def test_actions_conflicts_with_verbose(self):
1470
for action, value in self.actions.items():
1471
options = self.parser.parse_args()
1472
setattr(options, action, value)
1473
options.verbose = True
1474
with self.assertParseError():
1475
self.check_option_syntax(options)
1476
1477
def test_dump_json_conflicts_with_verbose(self):
1478
options = self.parser.parse_args()
1479
options.dump_json = True
1480
options.verbose = True
1481
with self.assertParseError():
1482
self.check_option_syntax(options)
1483
1484
def test_dump_json_conflicts_with_action(self):
1485
for action, value in self.actions.items():
1486
options = self.parser.parse_args()
1487
setattr(options, action, value)
1488
options.dump_json = True
1489
with self.assertParseError():
1490
self.check_option_syntax(options)
1491
1492
def test_all_can_not_be_alone(self):
1493
options = self.parser.parse_args()
1494
options.all = True
1495
with self.assertParseError():
1496
self.check_option_syntax(options)
1497
1498
def test_all_is_ok_with_any_action(self):
1499
for action, value in self.actions.items():
1500
options = self.parser.parse_args()
1501
setattr(options, action, value)
1502
options.all = True
1503
self.check_option_syntax(options)
1504
1505
def test_is_enabled_fails_without_client(self):
1506
options = self.parser.parse_args()
1507
options.is_enabled = True
1508
with self.assertParseError():
1509
self.check_option_syntax(options)
1510
1511
def test_is_enabled_works_with_one_client(self):
1512
options = self.parser.parse_args()
1513
options.is_enabled = True
1514
options.client = ["foo"]
1515
self.check_option_syntax(options)
1516
1517
def test_is_enabled_fails_with_two_clients(self):
1518
options = self.parser.parse_args()
1519
options.is_enabled = True
1520
options.client = ["foo", "barbar"]
1521
with self.assertParseError():
1522
self.check_option_syntax(options)
1523
1524
def test_remove_can_only_be_combined_with_action_deny(self):
1525
for action, value in self.actions.items():
1526
if action in {"remove", "deny"}:
1527
continue
1528
options = self.parser.parse_args()
1529
setattr(options, action, value)
1530
options.all = True
1531
options.remove = True
1532
with self.assertParseError():
1533
self.check_option_syntax(options)
1534
1535
1010
1536
1011
1537
1012
def should_only_run_tests():
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0