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 1011
- compare with another revision
- download diff
- download tarball
- view history from revision 1011
- Committer: Teddy Hogeborn
- Date: 2019-03-03 16:25:45 UTC
- Revision ID: teddy@recompile.se-20190303162545-vjdm7icnhpprzuwb
mandos-ctl: Refactor; move TableOfClients into PrintTableCmd
* mandos-ctl (TableOfClients): Moved into PrintTableCmd; user changed.
(PrintTableCmd.TableOfClients): New.
* mandos-ctl (TableOfClients): Moved into PrintTableCmd; user changed.
(PrintTableCmd.TableOfClients): 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
45
48
46
import dbus
49
47
280
278
commands which want to operate on all clients at the same time
281
279
can override this run() method instead."""
282
280
self.mandos = mandos
283
for client, properties in clients.items():
284
self.run_on_one_client(client, properties)
281
for client in clients:
282
self.run_on_one_client(client)
285
283
286
284
class PrintCmd(Command):
287
285
"""Abstract class for commands printing client details"""
297
295
298
296
class PropertyCmd(Command):
299
297
"""Abstract class for Actions for setting one client property"""
300
def run_on_one_client(self, client, properties):
298
def run_on_one_client(self, client):
301
299
"""Set the Client's D-Bus property"""
302
300
client.Set(client_interface, self.property, self.value_to_set,
303
301
dbus_interface=dbus.PROPERTIES_IFACE)
316
314
@value_to_set.setter
317
315
def value_to_set(self, value):
318
316
"""When setting, convert value to a datetime.timedelta"""
319
self._vts = int(round(value.total_seconds() * 1000))
317
self._vts = string_to_delta(value).total_seconds() * 1000
320
318
321
319
# Actual (non-abstract) command classes
322
320
325
323
self.verbose = verbose
326
324
327
325
def output(self, clients):
328
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
329
keywords = default_keywords
330
326
if self.verbose:
331
327
keywords = self.all_keywords
328
else:
329
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
332
330
return str(self.TableOfClients(clients.values(), keywords))
333
331
334
332
class TableOfClients(object):
421
419
return value
422
420
423
421
class IsEnabledCmd(Command):
424
def run_on_one_client(self, client, properties):
425
if self.is_enabled(client, properties):
422
def run_on_one_client(self, client):
423
if self.is_enabled(client):
426
424
sys.exit(0)
427
425
sys.exit(1)
428
def is_enabled(self, client, properties):
429
return bool(properties["Enabled"])
426
def is_enabled(self, client):
427
return client.Get(client_interface, "Enabled",
428
dbus_interface=dbus.PROPERTIES_IFACE)
430
429
431
430
class RemoveCmd(Command):
432
def run_on_one_client(self, client, properties):
431
def run_on_one_client(self, client):
433
432
self.mandos.RemoveClient(client.__dbus_object_path__)
434
433
435
434
class ApproveCmd(Command):
436
def run_on_one_client(self, client, properties):
435
def run_on_one_client(self, client):
437
436
client.Approve(dbus.Boolean(True),
438
437
dbus_interface=client_interface)
439
438
440
439
class DenyCmd(Command):
441
def run_on_one_client(self, client, properties):
440
def run_on_one_client(self, client):
442
441
client.Approve(dbus.Boolean(False),
443
442
dbus_interface=client_interface)
444
443
477
476
property = "Host"
478
477
479
478
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
480
@property
481
def value_to_set(self):
482
return self._vts
483
@value_to_set.setter
484
def value_to_set(self, value):
485
"""When setting, read data from supplied file object"""
486
self._vts = value.read()
487
value.close()
488
479
property = "Secret"
489
480
490
481
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
505
496
MillisecondsValueArgumentMixIn):
506
497
property = "ApprovalDuration"
507
498
508
def add_command_line_options(parser):
499
def has_actions(options):
500
return any((options.enable,
501
options.disable,
502
options.bump_timeout,
503
options.start_checker,
504
options.stop_checker,
505
options.is_enabled,
506
options.remove,
507
options.checker is not None,
508
options.timeout is not None,
509
options.extended_timeout is not None,
510
options.interval is not None,
511
options.approved_by_default is not None,
512
options.approval_delay is not None,
513
options.approval_duration is not None,
514
options.host is not None,
515
options.secret is not None,
516
options.approve,
517
options.deny))
518
519
520
def commands_and_clients_from_options(args=None):
521
if args is None:
522
args=sys.argv[1:]
523
parser = argparse.ArgumentParser()
509
524
parser.add_argument("--version", action="version",
510
525
version="%(prog)s {}".format(version),
511
526
help="show version number and exit")
536
551
help="Remove client")
537
552
parser.add_argument("-c", "--checker",
538
553
help="Set checker command for client")
539
parser.add_argument("-t", "--timeout", type=string_to_delta,
554
parser.add_argument("-t", "--timeout",
540
555
help="Set timeout for client")
541
parser.add_argument("--extended-timeout", type=string_to_delta,
556
parser.add_argument("--extended-timeout",
542
557
help="Set extended timeout for client")
543
parser.add_argument("-i", "--interval", type=string_to_delta,
558
parser.add_argument("-i", "--interval",
544
559
help="Set checker interval for client")
545
560
approve_deny_default = parser.add_mutually_exclusive_group()
546
561
approve_deny_default.add_argument(
551
566
"--deny-by-default", action="store_false",
552
567
dest="approved_by_default",
553
568
help="Set client to be denied by default")
554
parser.add_argument("--approval-delay", type=string_to_delta,
569
parser.add_argument("--approval-delay",
555
570
help="Set delay before client approve/deny")
556
parser.add_argument("--approval-duration", type=string_to_delta,
571
parser.add_argument("--approval-duration",
557
572
help="Set duration of one client approval")
558
573
parser.add_argument("-H", "--host", help="Set host for client")
559
574
parser.add_argument("-s", "--secret",
568
583
parser.add_argument("--check", action="store_true",
569
584
help="Run self-test")
570
585
parser.add_argument("client", nargs="*", help="Client name")
571
572
573
def commands_from_options(options):
586
options = parser.parse_args(args=args)
587
588
if has_actions(options) and not (options.client or options.all):
589
parser.error("Options require clients names or --all.")
590
if options.verbose and has_actions(options):
591
parser.error("--verbose can only be used alone.")
592
if options.dump_json and (options.verbose
593
or has_actions(options)):
594
parser.error("--dump-json can only be used alone.")
595
if options.all and not has_actions(options):
596
parser.error("--all requires an action.")
597
if options.is_enabled and len(options.client) > 1:
598
parser.error("--is-enabled requires exactly one client")
574
599
575
600
commands = []
576
601
584
609
commands.append(DisableCmd())
585
610
586
611
if options.bump_timeout:
587
commands.append(BumpTimeoutCmd())
612
commands.append(BumpTimeoutCmd(options.bump_timeout))
588
613
589
614
if options.start_checker:
590
615
commands.append(StartCheckerCmd())
599
624
commands.append(RemoveCmd())
600
625
601
626
if options.checker is not None:
602
commands.append(SetCheckerCmd(options.checker))
627
commands.append(SetCheckerCmd())
603
628
604
629
if options.timeout is not None:
605
630
commands.append(SetTimeoutCmd(options.timeout))
609
634
SetExtendedTimeoutCmd(options.extended_timeout))
610
635
611
636
if options.interval is not None:
612
commands.append(SetIntervalCmd(options.interval))
637
command.append(SetIntervalCmd(options.interval))
613
638
614
639
if options.approved_by_default is not None:
615
640
if options.approved_by_default:
616
commands.append(ApproveByDefaultCmd())
641
command.append(ApproveByDefaultCmd())
617
642
else:
618
commands.append(DenyByDefaultCmd())
643
command.append(DenyByDefaultCmd())
619
644
620
645
if options.approval_delay is not None:
621
commands.append(SetApprovalDelayCmd(options.approval_delay))
646
command.append(SetApprovalDelayCmd(options.approval_delay))
622
647
623
648
if options.approval_duration is not None:
624
commands.append(
649
command.append(
625
650
SetApprovalDurationCmd(options.approval_duration))
626
651
627
652
if options.host is not None:
628
commands.append(SetHostCmd(options.host))
653
command.append(SetHostCmd(options.host))
629
654
630
655
if options.secret is not None:
631
commands.append(SetSecretCmd(options.secret))
656
command.append(SetSecretCmd(options.secret))
632
657
633
658
if options.approve:
634
659
commands.append(ApproveCmd())
641
666
if not commands:
642
667
commands.append(PrintTableCmd(verbose=options.verbose))
643
668
644
return commands
669
return commands, options.client
645
670
646
671
647
672
def main():
648
parser = argparse.ArgumentParser()
649
650
add_command_line_options(parser)
651
652
options = parser.parse_args()
653
654
def has_actions(options):
655
return any((options.enable,
656
options.disable,
657
options.bump_timeout,
658
options.start_checker,
659
options.stop_checker,
660
options.is_enabled,
661
options.remove,
662
options.checker is not None,
663
options.timeout is not None,
664
options.extended_timeout is not None,
665
options.interval is not None,
666
options.approved_by_default is not None,
667
options.approval_delay is not None,
668
options.approval_duration is not None,
669
options.host is not None,
670
options.secret is not None,
671
options.approve,
672
options.deny))
673
674
if has_actions(options) and not (options.client or options.all):
675
parser.error("Options require clients names or --all.")
676
if options.verbose and has_actions(options):
677
parser.error("--verbose can only be used alone.")
678
if options.dump_json and (options.verbose
679
or has_actions(options)):
680
parser.error("--dump-json can only be used alone.")
681
if options.all and not has_actions(options):
682
parser.error("--all requires an action.")
683
if options.is_enabled and len(options.client) > 1:
684
parser.error("--is-enabled requires exactly one client")
685
686
clientnames = options.client
673
commands, clientnames = commands_and_clients_from_options()
687
674
688
675
try:
689
676
bus = dbus.SystemBus()
703
690
def filter(self, record):
704
691
return False
705
692
dbus_filter = NullFilter()
693
dbus_logger.addFilter(dbus_filter)
706
694
try:
707
dbus_logger.addFilter(dbus_filter)
708
mandos_clients = {path: ifs_and_props[client_interface]
709
for path, ifs_and_props in
710
mandos_serv_object_manager
711
.GetManagedObjects().items()
712
if client_interface in ifs_and_props}
695
try:
696
mandos_clients = {path: ifs_and_props[client_interface]
697
for path, ifs_and_props in
698
mandos_serv_object_manager
699
.GetManagedObjects().items()
700
if client_interface in ifs_and_props}
701
finally:
702
# restore dbus logger
703
dbus_logger.removeFilter(dbus_filter)
713
704
except dbus.exceptions.DBusException as e:
714
705
log.critical("Failed to access Mandos server through D-Bus:"
715
706
"\n%s", e)
716
707
sys.exit(1)
717
finally:
718
# restore dbus logger
719
dbus_logger.removeFilter(dbus_filter)
720
708
721
709
# Compile dict of (clients: properties) to process
722
710
clients = {}
736
724
sys.exit(1)
737
725
738
726
# Run all commands on clients
739
commands = commands_from_options(options)
740
727
for command in commands:
741
728
command.run(mandos_serv, clients)
742
729
756
743
757
744
class Test_string_to_delta(unittest.TestCase):
758
745
def test_handles_basic_rfc3339(self):
759
self.assertEqual(string_to_delta("PT0S"),
760
datetime.timedelta())
761
self.assertEqual(string_to_delta("P0D"),
762
datetime.timedelta())
763
self.assertEqual(string_to_delta("PT1S"),
764
datetime.timedelta(0, 1))
765
746
self.assertEqual(string_to_delta("PT2H"),
766
747
datetime.timedelta(0, 7200))
767
748
def test_falls_back_to_pre_1_6_1_with_warning(self):
796
777
self.__dbus_object_path__ = "objpath_{}".format(name)
797
778
self.attributes = attributes
798
779
self.attributes["Name"] = name
799
self.calls = []
800
def Set(self, interface, property, value, dbus_interface):
780
def Set(interface, property, value,
781
properties_interface):
801
782
testcase.assertEqual(interface, client_interface)
802
testcase.assertEqual(dbus_interface,
783
testcase.assertEqual(properties_interface,
803
784
dbus.PROPERTIES_IFACE)
804
785
self.attributes[property] = value
805
def Get(self, interface, property, dbus_interface):
786
def Get(interface, property, properties_interface):
806
787
testcase.assertEqual(interface, client_interface)
807
testcase.assertEqual(dbus_interface,
788
testcase.assertEqual(properties_interface,
808
789
dbus.PROPERTIES_IFACE)
809
790
return self.attributes[property]
810
def Approve(self, approve, dbus_interface):
811
testcase.assertEqual(dbus_interface, client_interface)
812
self.calls.append(("Approve", (approve,
813
dbus_interface)))
814
self.client = MockClient(
815
"foo",
816
KeyID=("92ed150794387c03ce684574b1139a65"
817
"94a34f895daaaf09fd8ea90a27cddb12"),
818
Secret=b"secret",
819
Host="foo.example.org",
820
Enabled=dbus.Boolean(True),
821
Timeout=300000,
822
LastCheckedOK="2019-02-03T00:00:00",
823
Created="2019-01-02T00:00:00",
824
Interval=120000,
825
Fingerprint=("778827225BA7DE539C5A"
826
"7CFA59CFF7CDBD9A5920"),
827
CheckerRunning=dbus.Boolean(False),
828
LastEnabled="2019-01-03T00:00:00",
829
ApprovalPending=dbus.Boolean(False),
830
ApprovedByDefault=dbus.Boolean(True),
831
LastApprovalRequest="",
832
ApprovalDelay=0,
833
ApprovalDuration=1000,
834
Checker="fping -q -- %(host)s",
835
ExtendedTimeout=900000,
836
Expires="2019-02-04T00:00:00",
837
LastCheckerStatus=0)
838
self.other_client = MockClient(
839
"barbar",
840
KeyID=("0558568eedd67d622f5c83b35a115f79"
841
"6ab612cff5ad227247e46c2b020f441c"),
842
Secret=b"secretbar",
843
Host="192.0.2.3",
844
Enabled=dbus.Boolean(True),
845
Timeout=300000,
846
LastCheckedOK="2019-02-04T00:00:00",
847
Created="2019-01-03T00:00:00",
848
Interval=120000,
849
Fingerprint=("3E393AEAEFB84C7E89E2"
850
"F547B3A107558FCA3A27"),
851
CheckerRunning=dbus.Boolean(True),
852
LastEnabled="2019-01-04T00:00:00",
853
ApprovalPending=dbus.Boolean(False),
854
ApprovedByDefault=dbus.Boolean(False),
855
LastApprovalRequest="2019-01-03T00:00:00",
856
ApprovalDelay=30000,
857
ApprovalDuration=1000,
858
Checker=":",
859
ExtendedTimeout=900000,
860
Expires="2019-02-05T00:00:00",
861
LastCheckerStatus=-2)
862
self.clients = collections.OrderedDict(
863
[
864
(self.client, self.client.attributes),
865
(self.other_client, self.other_client.attributes),
791
def __getitem__(self, key):
792
return self.attributes[key]
793
self.clients = collections.OrderedDict([
794
("foo",
795
MockClient(
796
"foo",
797
KeyID=("92ed150794387c03ce684574b1139a65"
798
"94a34f895daaaf09fd8ea90a27cddb12"),
799
Secret=b"secret",
800
Host="foo.example.org",
801
Enabled=dbus.Boolean(True),
802
Timeout=300000,
803
LastCheckedOK="2019-02-03T00:00:00",
804
Created="2019-01-02T00:00:00",
805
Interval=120000,
806
Fingerprint=("778827225BA7DE539C5A"
807
"7CFA59CFF7CDBD9A5920"),
808
CheckerRunning=dbus.Boolean(False),
809
LastEnabled="2019-01-03T00:00:00",
810
ApprovalPending=dbus.Boolean(False),
811
ApprovedByDefault=dbus.Boolean(True),
812
LastApprovalRequest="",
813
ApprovalDelay=0,
814
ApprovalDuration=1000,
815
Checker="fping -q -- %(host)s",
816
ExtendedTimeout=900000,
817
Expires="2019-02-04T00:00:00",
818
LastCheckerStatus=0)),
819
("barbar",
820
MockClient(
821
"barbar",
822
KeyID=("0558568eedd67d622f5c83b35a115f79"
823
"6ab612cff5ad227247e46c2b020f441c"),
824
Secret=b"secretbar",
825
Host="192.0.2.3",
826
Enabled=dbus.Boolean(True),
827
Timeout=300000,
828
LastCheckedOK="2019-02-04T00:00:00",
829
Created="2019-01-03T00:00:00",
830
Interval=120000,
831
Fingerprint=("3E393AEAEFB84C7E89E2"
832
"F547B3A107558FCA3A27"),
833
CheckerRunning=dbus.Boolean(True),
834
LastEnabled="2019-01-04T00:00:00",
835
ApprovalPending=dbus.Boolean(False),
836
ApprovedByDefault=dbus.Boolean(False),
837
LastApprovalRequest="2019-01-03T00:00:00",
838
ApprovalDelay=30000,
839
ApprovalDuration=1000,
840
Checker=":",
841
ExtendedTimeout=900000,
842
Expires="2019-02-05T00:00:00",
843
LastCheckerStatus=-2)),
866
844
])
867
self.one_client = {self.client: self.client.attributes}
868
845
869
846
class TestPrintTableCmd(TestCmd):
870
847
def test_normal(self):
884
861
"""[1:-1]
885
862
self.assertEqual(output, expected_output)
886
863
def test_one_client(self):
887
output = PrintTableCmd().output(self.one_client)
864
output = PrintTableCmd().output({"foo": self.clients["foo"]})
888
865
expected_output = """
889
866
Name Enabled Timeout Last Successful Check
890
867
foo Yes 00:05:00 2019-02-03T00:00:00
891
868
"""[1:-1]
892
869
self.assertEqual(output, expected_output)
893
870
894
class TestDumpJSONCmd(TestCmd):
895
def setUp(self):
896
self.expected_json = {
897
"foo": {
898
"Name": "foo",
899
"KeyID": ("92ed150794387c03ce684574b1139a65"
900
"94a34f895daaaf09fd8ea90a27cddb12"),
901
"Host": "foo.example.org",
902
"Enabled": True,
903
"Timeout": 300000,
904
"LastCheckedOK": "2019-02-03T00:00:00",
905
"Created": "2019-01-02T00:00:00",
906
"Interval": 120000,
907
"Fingerprint": ("778827225BA7DE539C5A"
908
"7CFA59CFF7CDBD9A5920"),
909
"CheckerRunning": False,
910
"LastEnabled": "2019-01-03T00:00:00",
911
"ApprovalPending": False,
912
"ApprovedByDefault": True,
913
"LastApprovalRequest": "",
914
"ApprovalDelay": 0,
915
"ApprovalDuration": 1000,
916
"Checker": "fping -q -- %(host)s",
917
"ExtendedTimeout": 900000,
918
"Expires": "2019-02-04T00:00:00",
919
"LastCheckerStatus": 0,
920
},
921
"barbar": {
922
"Name": "barbar",
923
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
924
"6ab612cff5ad227247e46c2b020f441c"),
925
"Host": "192.0.2.3",
926
"Enabled": True,
927
"Timeout": 300000,
928
"LastCheckedOK": "2019-02-04T00:00:00",
929
"Created": "2019-01-03T00:00:00",
930
"Interval": 120000,
931
"Fingerprint": ("3E393AEAEFB84C7E89E2"
932
"F547B3A107558FCA3A27"),
933
"CheckerRunning": True,
934
"LastEnabled": "2019-01-04T00:00:00",
935
"ApprovalPending": False,
936
"ApprovedByDefault": False,
937
"LastApprovalRequest": "2019-01-03T00:00:00",
938
"ApprovalDelay": 30000,
939
"ApprovalDuration": 1000,
940
"Checker": ":",
941
"ExtendedTimeout": 900000,
942
"Expires": "2019-02-05T00:00:00",
943
"LastCheckerStatus": -2,
944
},
945
}
946
return super(TestDumpJSONCmd, self).setUp()
947
def test_normal(self):
948
json_data = json.loads(DumpJSONCmd().output(self.clients))
949
self.assertDictEqual(json_data, self.expected_json)
950
def test_one_client(self):
951
clients = self.one_client
952
json_data = json.loads(DumpJSONCmd().output(clients))
953
expected_json = {"foo": self.expected_json["foo"]}
954
self.assertDictEqual(json_data, expected_json)
955
956
class TestIsEnabledCmd(TestCmd):
957
def test_is_enabled(self):
958
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
959
for client, properties in self.clients.items()))
960
def test_is_enabled_run_exits_successfully(self):
961
with self.assertRaises(SystemExit) as e:
962
IsEnabledCmd().run(None, self.one_client)
963
if e.exception.code is not None:
964
self.assertEqual(e.exception.code, 0)
965
else:
966
self.assertIsNone(e.exception.code)
967
def test_is_enabled_run_exits_with_failure(self):
968
self.client.attributes["Enabled"] = dbus.Boolean(False)
969
with self.assertRaises(SystemExit) as e:
970
IsEnabledCmd().run(None, self.one_client)
971
if isinstance(e.exception.code, int):
972
self.assertNotEqual(e.exception.code, 0)
973
else:
974
self.assertIsNotNone(e.exception.code)
975
976
class TestRemoveCmd(TestCmd):
977
def test_remove(self):
978
class MockMandos(object):
979
def __init__(self):
980
self.calls = []
981
def RemoveClient(self, dbus_path):
982
self.calls.append(("RemoveClient", (dbus_path,)))
983
mandos = MockMandos()
984
super(TestRemoveCmd, self).setUp()
985
RemoveCmd().run(mandos, self.clients)
986
self.assertEqual(len(mandos.calls), 2)
987
for client in self.clients:
988
self.assertIn(("RemoveClient",
989
(client.__dbus_object_path__,)),
990
mandos.calls)
991
992
class TestApproveCmd(TestCmd):
993
def test_approve(self):
994
ApproveCmd().run(None, self.clients)
995
for client in self.clients:
996
self.assertIn(("Approve", (True, client_interface)),
997
client.calls)
998
999
class TestDenyCmd(TestCmd):
1000
def test_deny(self):
1001
DenyCmd().run(None, self.clients)
1002
for client in self.clients:
1003
self.assertIn(("Approve", (False, client_interface)),
1004
client.calls)
1005
1006
class TestEnableCmd(TestCmd):
1007
def test_enable(self):
1008
for client in self.clients:
1009
client.attributes["Enabled"] = False
1010
1011
EnableCmd().run(None, self.clients)
1012
1013
for client in self.clients:
1014
self.assertTrue(client.attributes["Enabled"])
1015
1016
class TestDisableCmd(TestCmd):
1017
def test_disable(self):
1018
DisableCmd().run(None, self.clients)
1019
1020
for client in self.clients:
1021
self.assertFalse(client.attributes["Enabled"])
1022
1023
class Unique(object):
1024
"""Class for objects which exist only to be unique objects, since
1025
unittest.mock.sentinel only exists in Python 3.3"""
1026
1027
class TestPropertyCmd(TestCmd):
1028
"""Abstract class for tests of PropertyCmd classes"""
1029
def runTest(self):
1030
if not hasattr(self, "command"):
1031
return
1032
values_to_get = getattr(self, "values_to_get",
1033
self.values_to_set)
1034
for value_to_set, value_to_get in zip(self.values_to_set,
1035
values_to_get):
1036
for client in self.clients:
1037
old_value = client.attributes[self.property]
1038
self.assertNotIsInstance(old_value, Unique)
1039
client.attributes[self.property] = Unique()
1040
self.run_command(value_to_set, self.clients)
1041
for client in self.clients:
1042
value = client.attributes[self.property]
1043
self.assertNotIsInstance(value, Unique)
1044
self.assertEqual(value, value_to_get)
1045
def run_command(self, value, clients):
1046
self.command().run(None, clients)
1047
1048
class TestBumpTimeoutCmd(TestPropertyCmd):
1049
command = BumpTimeoutCmd
1050
property = "LastCheckedOK"
1051
values_to_set = [""]
1052
1053
class TestStartCheckerCmd(TestPropertyCmd):
1054
command = StartCheckerCmd
1055
property = "CheckerRunning"
1056
values_to_set = [dbus.Boolean(True)]
1057
1058
class TestStopCheckerCmd(TestPropertyCmd):
1059
command = StopCheckerCmd
1060
property = "CheckerRunning"
1061
values_to_set = [dbus.Boolean(False)]
1062
1063
class TestApproveByDefaultCmd(TestPropertyCmd):
1064
command = ApproveByDefaultCmd
1065
property = "ApprovedByDefault"
1066
values_to_set = [dbus.Boolean(True)]
1067
1068
class TestDenyByDefaultCmd(TestPropertyCmd):
1069
command = DenyByDefaultCmd
1070
property = "ApprovedByDefault"
1071
values_to_set = [dbus.Boolean(False)]
1072
1073
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1074
"""Abstract class for tests of PropertyCmd classes using the
1075
ValueArgumentMixIn"""
1076
def runTest(self):
1077
if type(self) is TestValueArgumentPropertyCmd:
1078
return
1079
return super(TestValueArgumentPropertyCmd, self).runTest()
1080
def run_command(self, value, clients):
1081
self.command(value).run(None, clients)
1082
1083
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1084
command = SetCheckerCmd
1085
property = "Checker"
1086
values_to_set = ["", ":", "fping -q -- %s"]
1087
1088
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1089
command = SetHostCmd
1090
property = "Host"
1091
values_to_set = ["192.0.2.3", "foo.example.org"]
1092
1093
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1094
command = SetSecretCmd
1095
property = "Secret"
1096
values_to_set = [open("/dev/null", "rb"),
1097
io.BytesIO(b"secret\0xyzzy\nbar")]
1098
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1099
1100
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1101
command = SetTimeoutCmd
1102
property = "Timeout"
1103
values_to_set = [datetime.timedelta(),
1104
datetime.timedelta(minutes=5),
1105
datetime.timedelta(seconds=1),
1106
datetime.timedelta(weeks=1),
1107
datetime.timedelta(weeks=52)]
1108
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1109
1110
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1111
command = SetExtendedTimeoutCmd
1112
property = "ExtendedTimeout"
1113
values_to_set = [datetime.timedelta(),
1114
datetime.timedelta(minutes=5),
1115
datetime.timedelta(seconds=1),
1116
datetime.timedelta(weeks=1),
1117
datetime.timedelta(weeks=52)]
1118
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1119
1120
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1121
command = SetIntervalCmd
1122
property = "Interval"
1123
values_to_set = [datetime.timedelta(),
1124
datetime.timedelta(minutes=5),
1125
datetime.timedelta(seconds=1),
1126
datetime.timedelta(weeks=1),
1127
datetime.timedelta(weeks=52)]
1128
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1129
1130
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1131
command = SetApprovalDelayCmd
1132
property = "ApprovalDelay"
1133
values_to_set = [datetime.timedelta(),
1134
datetime.timedelta(minutes=5),
1135
datetime.timedelta(seconds=1),
1136
datetime.timedelta(weeks=1),
1137
datetime.timedelta(weeks=52)]
1138
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1139
1140
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1141
command = SetApprovalDurationCmd
1142
property = "ApprovalDuration"
1143
values_to_set = [datetime.timedelta(),
1144
datetime.timedelta(minutes=5),
1145
datetime.timedelta(seconds=1),
1146
datetime.timedelta(weeks=1),
1147
datetime.timedelta(weeks=52)]
1148
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1149
1150
class Test_command_from_options(unittest.TestCase):
1151
def setUp(self):
1152
self.parser = argparse.ArgumentParser()
1153
add_command_line_options(self.parser)
1154
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1155
"""Assert that parsing ARGS should result in an instance of
1156
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1157
options = self.parser.parse_args(args)
1158
commands = commands_from_options(options)
1159
self.assertEqual(len(commands), 1)
1160
command = commands[0]
1161
self.assertIsInstance(command, command_cls)
1162
for key, value in cmd_attrs.items():
1163
self.assertEqual(getattr(command, key), value)
1164
def test_print_table(self):
1165
self.assert_command_from_args([], PrintTableCmd,
1166
verbose=False)
1167
1168
def test_print_table_verbose(self):
1169
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1170
verbose=True)
1171
1172
def test_print_table_verbose_short(self):
1173
self.assert_command_from_args(["-v"], PrintTableCmd,
1174
verbose=True)
1175
1176
def test_enable(self):
1177
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1178
1179
def test_enable_short(self):
1180
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1181
1182
def test_disable(self):
1183
self.assert_command_from_args(["--disable", "foo"],
1184
DisableCmd)
1185
1186
def test_disable_short(self):
1187
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1188
1189
def test_bump_timeout(self):
1190
self.assert_command_from_args(["--bump-timeout", "foo"],
1191
BumpTimeoutCmd)
1192
1193
def test_bump_timeout_short(self):
1194
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1195
1196
def test_start_checker(self):
1197
self.assert_command_from_args(["--start-checker", "foo"],
1198
StartCheckerCmd)
1199
1200
def test_stop_checker(self):
1201
self.assert_command_from_args(["--stop-checker", "foo"],
1202
StopCheckerCmd)
1203
1204
def test_remove(self):
1205
self.assert_command_from_args(["--remove", "foo"],
1206
RemoveCmd)
1207
1208
def test_remove_short(self):
1209
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1210
1211
def test_checker(self):
1212
self.assert_command_from_args(["--checker", ":", "foo"],
1213
SetCheckerCmd, value_to_set=":")
1214
1215
def test_checker_empty(self):
1216
self.assert_command_from_args(["--checker", "", "foo"],
1217
SetCheckerCmd, value_to_set="")
1218
1219
def test_checker_short(self):
1220
self.assert_command_from_args(["-c", ":", "foo"],
1221
SetCheckerCmd, value_to_set=":")
1222
1223
def test_timeout(self):
1224
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1225
SetTimeoutCmd,
1226
value_to_set=300000)
1227
1228
def test_timeout_short(self):
1229
self.assert_command_from_args(["-t", "PT5M", "foo"],
1230
SetTimeoutCmd,
1231
value_to_set=300000)
1232
1233
def test_extended_timeout(self):
1234
self.assert_command_from_args(["--extended-timeout", "PT15M",
1235
"foo"],
1236
SetExtendedTimeoutCmd,
1237
value_to_set=900000)
1238
1239
def test_interval(self):
1240
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1241
SetIntervalCmd,
1242
value_to_set=120000)
1243
1244
def test_interval_short(self):
1245
self.assert_command_from_args(["-i", "PT2M", "foo"],
1246
SetIntervalCmd,
1247
value_to_set=120000)
1248
1249
def test_approve_by_default(self):
1250
self.assert_command_from_args(["--approve-by-default", "foo"],
1251
ApproveByDefaultCmd)
1252
1253
def test_deny_by_default(self):
1254
self.assert_command_from_args(["--deny-by-default", "foo"],
1255
DenyByDefaultCmd)
1256
1257
def test_approval_delay(self):
1258
self.assert_command_from_args(["--approval-delay", "PT30S",
1259
"foo"], SetApprovalDelayCmd,
1260
value_to_set=30000)
1261
1262
def test_approval_duration(self):
1263
self.assert_command_from_args(["--approval-duration", "PT1S",
1264
"foo"], SetApprovalDurationCmd,
1265
value_to_set=1000)
1266
1267
def test_host(self):
1268
self.assert_command_from_args(["--host", "foo.example.org",
1269
"foo"], SetHostCmd,
1270
value_to_set="foo.example.org")
1271
1272
def test_host_short(self):
1273
self.assert_command_from_args(["-H", "foo.example.org",
1274
"foo"], SetHostCmd,
1275
value_to_set="foo.example.org")
1276
1277
def test_secret_devnull(self):
1278
self.assert_command_from_args(["--secret", os.path.devnull,
1279
"foo"], SetSecretCmd,
1280
value_to_set=b"")
1281
1282
def test_secret_tempfile(self):
1283
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1284
value = b"secret\0xyzzy\nbar"
1285
f.write(value)
1286
f.seek(0)
1287
self.assert_command_from_args(["--secret", f.name,
1288
"foo"], SetSecretCmd,
1289
value_to_set=value)
1290
1291
def test_secret_devnull_short(self):
1292
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1293
SetSecretCmd, value_to_set=b"")
1294
1295
def test_secret_tempfile_short(self):
1296
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1297
value = b"secret\0xyzzy\nbar"
1298
f.write(value)
1299
f.seek(0)
1300
self.assert_command_from_args(["-s", f.name, "foo"],
1301
SetSecretCmd,
1302
value_to_set=value)
1303
1304
def test_approve(self):
1305
self.assert_command_from_args(["--approve", "foo"],
1306
ApproveCmd)
1307
1308
def test_approve_short(self):
1309
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1310
1311
def test_deny(self):
1312
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1313
1314
def test_deny_short(self):
1315
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1316
1317
def test_dump_json(self):
1318
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1319
1320
def test_is_enabled(self):
1321
self.assert_command_from_args(["--is-enabled", "foo"],
1322
IsEnabledCmd)
1323
1324
def test_is_enabled_short(self):
1325
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1326
1327
871
1328
872
1329
873
def should_only_run_tests():
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0