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 1035
- compare with another revision
- download diff
- download tarball
- view history from revision 1035
- Committer: Teddy Hogeborn
- Date: 2019-03-07 20:28:17 UTC
- Revision ID: teddy@recompile.se-20190307202817-avhha20s3pl14j6y
mandos-ctl: Refactor; move parsing of intervals into argument parsing
* mandos-ctl (MillisecondsValueArgumentMixIn.value_to_set): Assume
that an incoming value is datetime.timedelta(), not a string.
(add_command_line_options): Add "type=string_to_delta" to --timeout,
--extended-timeout, --interval, --approval-delay, and
--approval-duration.
(TestSetTimeoutCmd, TestSetExtendedTimeoutCmd, TestSetIntervalCmd,
TestSetApprovalDelayCmd, TestSetApprovalDurationCmd): Change
values_to_set to be datetime.timedelta() values, and change to more
appropriate values to test. Also adjust values_to_get accordingly.
* mandos-ctl (MillisecondsValueArgumentMixIn.value_to_set): Assume
that an incoming value is datetime.timedelta(), not a string.
(add_command_line_options): Add "type=string_to_delta" to --timeout,
--extended-timeout, --interval, --approval-delay, and
--approval-duration.
(TestSetTimeoutCmd, TestSetExtendedTimeoutCmd, TestSetIntervalCmd,
TestSetApprovalDelayCmd, TestSetApprovalDurationCmd): Change
values_to_set to be datetime.timedelta() values, and change to more
appropriate values to test. Also adjust values_to_get accordingly.
- 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
45
47
46
48
import dbus
47
49
278
280
commands which want to operate on all clients at the same time
279
281
can override this run() method instead."""
280
282
self.mandos = mandos
281
for client in clients:
282
self.run_on_one_client(client)
283
for client, properties in clients.items():
284
self.run_on_one_client(client, properties)
283
285
284
286
class PrintCmd(Command):
285
287
"""Abstract class for commands printing client details"""
295
297
296
298
class PropertyCmd(Command):
297
299
"""Abstract class for Actions for setting one client property"""
298
def run_on_one_client(self, client):
300
def run_on_one_client(self, client, properties):
299
301
"""Set the Client's D-Bus property"""
300
302
client.Set(client_interface, self.property, self.value_to_set,
301
303
dbus_interface=dbus.PROPERTIES_IFACE)
314
316
@value_to_set.setter
315
317
def value_to_set(self, value):
316
318
"""When setting, convert value to a datetime.timedelta"""
317
self._vts = string_to_delta(value).total_seconds() * 1000
319
self._vts = int(round(value.total_seconds() * 1000))
318
320
319
321
# Actual (non-abstract) command classes
320
322
323
325
self.verbose = verbose
324
326
325
327
def output(self, clients):
328
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
329
keywords = default_keywords
326
330
if self.verbose:
327
331
keywords = self.all_keywords
328
else:
329
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
330
332
return str(self.TableOfClients(clients.values(), keywords))
331
333
332
334
class TableOfClients(object):
419
421
return value
420
422
421
423
class IsEnabledCmd(Command):
422
def run_on_one_client(self, client):
423
if self.is_enabled(client):
424
def run_on_one_client(self, client, properties):
425
if self.is_enabled(client, properties):
424
426
sys.exit(0)
425
427
sys.exit(1)
426
def is_enabled(self, client):
427
return client.Get(client_interface, "Enabled",
428
dbus_interface=dbus.PROPERTIES_IFACE)
428
def is_enabled(self, client, properties):
429
return bool(properties["Enabled"])
429
430
430
431
class RemoveCmd(Command):
431
def run_on_one_client(self, client):
432
def run_on_one_client(self, client, properties):
432
433
self.mandos.RemoveClient(client.__dbus_object_path__)
433
434
434
435
class ApproveCmd(Command):
435
def run_on_one_client(self, client):
436
def run_on_one_client(self, client, properties):
436
437
client.Approve(dbus.Boolean(True),
437
438
dbus_interface=client_interface)
438
439
439
440
class DenyCmd(Command):
440
def run_on_one_client(self, client):
441
def run_on_one_client(self, client, properties):
441
442
client.Approve(dbus.Boolean(False),
442
443
dbus_interface=client_interface)
443
444
476
477
property = "Host"
477
478
478
479
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()
479
488
property = "Secret"
480
489
481
490
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
496
505
MillisecondsValueArgumentMixIn):
497
506
property = "ApprovalDuration"
498
507
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
508
def add_command_line_options(parser):
520
509
parser.add_argument("--version", action="version",
521
510
version="%(prog)s {}".format(version),
547
536
help="Remove client")
548
537
parser.add_argument("-c", "--checker",
549
538
help="Set checker command for client")
550
parser.add_argument("-t", "--timeout",
539
parser.add_argument("-t", "--timeout", type=string_to_delta,
551
540
help="Set timeout for client")
552
parser.add_argument("--extended-timeout",
541
parser.add_argument("--extended-timeout", type=string_to_delta,
553
542
help="Set extended timeout for client")
554
parser.add_argument("-i", "--interval",
543
parser.add_argument("-i", "--interval", type=string_to_delta,
555
544
help="Set checker interval for client")
556
545
approve_deny_default = parser.add_mutually_exclusive_group()
557
546
approve_deny_default.add_argument(
562
551
"--deny-by-default", action="store_false",
563
552
dest="approved_by_default",
564
553
help="Set client to be denied by default")
565
parser.add_argument("--approval-delay",
554
parser.add_argument("--approval-delay", type=string_to_delta,
566
555
help="Set delay before client approve/deny")
567
parser.add_argument("--approval-duration",
556
parser.add_argument("--approval-duration", type=string_to_delta,
568
557
help="Set duration of one client approval")
569
558
parser.add_argument("-H", "--host", help="Set host for client")
570
559
parser.add_argument("-s", "--secret",
581
570
parser.add_argument("client", nargs="*", help="Client name")
582
571
583
572
584
def commands_and_clients_from_options(options):
573
def commands_from_options(options):
585
574
586
575
commands = []
587
576
595
584
commands.append(DisableCmd())
596
585
597
586
if options.bump_timeout:
598
commands.append(BumpTimeoutCmd(options.bump_timeout))
587
commands.append(BumpTimeoutCmd())
599
588
600
589
if options.start_checker:
601
590
commands.append(StartCheckerCmd())
610
599
commands.append(RemoveCmd())
611
600
612
601
if options.checker is not None:
613
commands.append(SetCheckerCmd())
602
commands.append(SetCheckerCmd(options.checker))
614
603
615
604
if options.timeout is not None:
616
605
commands.append(SetTimeoutCmd(options.timeout))
620
609
SetExtendedTimeoutCmd(options.extended_timeout))
621
610
622
611
if options.interval is not None:
623
command.append(SetIntervalCmd(options.interval))
612
commands.append(SetIntervalCmd(options.interval))
624
613
625
614
if options.approved_by_default is not None:
626
615
if options.approved_by_default:
627
command.append(ApproveByDefaultCmd())
616
commands.append(ApproveByDefaultCmd())
628
617
else:
629
command.append(DenyByDefaultCmd())
618
commands.append(DenyByDefaultCmd())
630
619
631
620
if options.approval_delay is not None:
632
command.append(SetApprovalDelayCmd(options.approval_delay))
621
commands.append(SetApprovalDelayCmd(options.approval_delay))
633
622
634
623
if options.approval_duration is not None:
635
command.append(
624
commands.append(
636
625
SetApprovalDurationCmd(options.approval_duration))
637
626
638
627
if options.host is not None:
639
command.append(SetHostCmd(options.host))
628
commands.append(SetHostCmd(options.host))
640
629
641
630
if options.secret is not None:
642
command.append(SetSecretCmd(options.secret))
631
commands.append(SetSecretCmd(options.secret))
643
632
644
633
if options.approve:
645
634
commands.append(ApproveCmd())
652
641
if not commands:
653
642
commands.append(PrintTableCmd(verbose=options.verbose))
654
643
655
return commands, options.client
644
return commands
656
645
657
646
658
647
def main():
662
651
663
652
options = parser.parse_args()
664
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
665
674
if has_actions(options) and not (options.client or options.all):
666
675
parser.error("Options require clients names or --all.")
667
676
if options.verbose and has_actions(options):
674
683
if options.is_enabled and len(options.client) > 1:
675
684
parser.error("--is-enabled requires exactly one client")
676
685
677
commands, clientnames = commands_and_clients_from_options(options)
686
clientnames = options.client
678
687
679
688
try:
680
689
bus = dbus.SystemBus()
727
736
sys.exit(1)
728
737
729
738
# Run all commands on clients
739
commands = commands_from_options(options)
730
740
for command in commands:
731
741
command.run(mandos_serv, clients)
732
742
746
756
747
757
class Test_string_to_delta(unittest.TestCase):
748
758
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))
749
765
self.assertEqual(string_to_delta("PT2H"),
750
766
datetime.timedelta(0, 7200))
751
767
def test_falls_back_to_pre_1_6_1_with_warning(self):
786
802
testcase.assertEqual(dbus_interface,
787
803
dbus.PROPERTIES_IFACE)
788
804
self.attributes[property] = value
789
self.calls.append(("Set", (interface, property, value,
790
dbus_interface)))
791
805
def Get(self, interface, property, dbus_interface):
792
806
testcase.assertEqual(interface, client_interface)
793
807
testcase.assertEqual(dbus_interface,
794
808
dbus.PROPERTIES_IFACE)
795
self.calls.append(("Get", (interface, property,
796
dbus_interface)))
797
809
return self.attributes[property]
798
def __getitem__(self, key):
799
return self.attributes[key]
800
def __setitem__(self, key, value):
801
self.attributes[key] = value
802
self.clients = collections.OrderedDict([
803
("foo",
804
MockClient(
805
"foo",
806
KeyID=("92ed150794387c03ce684574b1139a65"
807
"94a34f895daaaf09fd8ea90a27cddb12"),
808
Secret=b"secret",
809
Host="foo.example.org",
810
Enabled=dbus.Boolean(True),
811
Timeout=300000,
812
LastCheckedOK="2019-02-03T00:00:00",
813
Created="2019-01-02T00:00:00",
814
Interval=120000,
815
Fingerprint=("778827225BA7DE539C5A"
816
"7CFA59CFF7CDBD9A5920"),
817
CheckerRunning=dbus.Boolean(False),
818
LastEnabled="2019-01-03T00:00:00",
819
ApprovalPending=dbus.Boolean(False),
820
ApprovedByDefault=dbus.Boolean(True),
821
LastApprovalRequest="",
822
ApprovalDelay=0,
823
ApprovalDuration=1000,
824
Checker="fping -q -- %(host)s",
825
ExtendedTimeout=900000,
826
Expires="2019-02-04T00:00:00",
827
LastCheckerStatus=0)),
828
("barbar",
829
MockClient(
830
"barbar",
831
KeyID=("0558568eedd67d622f5c83b35a115f79"
832
"6ab612cff5ad227247e46c2b020f441c"),
833
Secret=b"secretbar",
834
Host="192.0.2.3",
835
Enabled=dbus.Boolean(True),
836
Timeout=300000,
837
LastCheckedOK="2019-02-04T00:00:00",
838
Created="2019-01-03T00:00:00",
839
Interval=120000,
840
Fingerprint=("3E393AEAEFB84C7E89E2"
841
"F547B3A107558FCA3A27"),
842
CheckerRunning=dbus.Boolean(True),
843
LastEnabled="2019-01-04T00:00:00",
844
ApprovalPending=dbus.Boolean(False),
845
ApprovedByDefault=dbus.Boolean(False),
846
LastApprovalRequest="2019-01-03T00:00:00",
847
ApprovalDelay=30000,
848
ApprovalDuration=1000,
849
Checker=":",
850
ExtendedTimeout=900000,
851
Expires="2019-02-05T00:00:00",
852
LastCheckerStatus=-2)),
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),
853
866
])
867
self.one_client = {self.client: self.client.attributes}
854
868
855
869
class TestPrintTableCmd(TestCmd):
856
870
def test_normal(self):
870
884
"""[1:-1]
871
885
self.assertEqual(output, expected_output)
872
886
def test_one_client(self):
873
output = PrintTableCmd().output({"foo": self.clients["foo"]})
887
output = PrintTableCmd().output(self.one_client)
874
888
expected_output = """
875
889
Name Enabled Timeout Last Successful Check
876
890
foo Yes 00:05:00 2019-02-03T00:00:00
934
948
json_data = json.loads(DumpJSONCmd().output(self.clients))
935
949
self.assertDictEqual(json_data, self.expected_json)
936
950
def test_one_client(self):
937
clients = {"foo": self.clients["foo"]}
951
clients = self.one_client
938
952
json_data = json.loads(DumpJSONCmd().output(clients))
939
953
expected_json = {"foo": self.expected_json["foo"]}
940
954
self.assertDictEqual(json_data, expected_json)
941
955
942
956
class TestIsEnabledCmd(TestCmd):
943
957
def test_is_enabled(self):
944
self.assertTrue(all(IsEnabledCmd().is_enabled(client)
945
for client in self.clients.values()))
946
def test_is_enabled_does_get_attribute(self):
947
client = self.clients["foo"]
948
self.assertTrue(IsEnabledCmd().is_enabled(client))
949
self.assertListEqual(client.calls,
950
[("Get",
951
("se.recompile.Mandos.Client",
952
"Enabled",
953
"org.freedesktop.DBus.Properties"))])
958
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
959
for client, properties in self.clients.items()))
954
960
def test_is_enabled_run_exits_successfully(self):
955
client = self.clients["foo"]
956
961
with self.assertRaises(SystemExit) as e:
957
IsEnabledCmd().run(None, [client])
962
IsEnabledCmd().run(None, self.one_client)
958
963
if e.exception.code is not None:
959
964
self.assertEqual(e.exception.code, 0)
960
965
else:
961
966
self.assertIsNone(e.exception.code)
962
967
def test_is_enabled_run_exits_with_failure(self):
963
client = self.clients["foo"]
964
client["Enabled"] = dbus.Boolean(False)
968
self.client.attributes["Enabled"] = dbus.Boolean(False)
965
969
with self.assertRaises(SystemExit) as e:
966
IsEnabledCmd().run(None, [client])
970
IsEnabledCmd().run(None, self.one_client)
967
971
if isinstance(e.exception.code, int):
968
972
self.assertNotEqual(e.exception.code, 0)
969
973
else:
970
974
self.assertIsNotNone(e.exception.code)
971
975
972
973
976
class TestRemoveCmd(TestCmd):
974
977
def test_remove(self):
975
client = self.clients["foo"]
976
978
class MockMandos(object):
977
979
def __init__(self):
978
980
self.calls = []
979
981
def RemoveClient(self, dbus_path):
980
982
self.calls.append(("RemoveClient", (dbus_path,)))
981
983
mandos = MockMandos()
982
RemoveCmd().run(mandos, [client])
983
self.assertEqual(len(mandos.calls), 1)
984
self.assertListEqual(mandos.calls,
985
[("RemoveClient",
986
(client.__dbus_object_path__,))])
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_enable(self):
1173
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1174
1175
def test_disable(self):
1176
self.assert_command_from_args(["--disable", "foo"],
1177
DisableCmd)
1178
1179
def test_bump_timeout(self):
1180
self.assert_command_from_args(["--bump-timeout", "foo"],
1181
BumpTimeoutCmd)
1182
1183
def test_start_checker(self):
1184
self.assert_command_from_args(["--start-checker", "foo"],
1185
StartCheckerCmd)
1186
1187
def test_stop_checker(self):
1188
self.assert_command_from_args(["--stop-checker", "foo"],
1189
StopCheckerCmd)
1190
1191
def test_remove(self):
1192
self.assert_command_from_args(["--remove", "foo"],
1193
RemoveCmd)
1194
1195
def test_checker(self):
1196
self.assert_command_from_args(["--checker", ":", "foo"],
1197
SetCheckerCmd, value_to_set=":")
1198
1199
def test_checker_empty(self):
1200
self.assert_command_from_args(["--checker", "", "foo"],
1201
SetCheckerCmd, value_to_set="")
1202
1203
def test_timeout(self):
1204
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1205
SetTimeoutCmd,
1206
value_to_set=300000)
1207
1208
def test_extended_timeout(self):
1209
self.assert_command_from_args(["--extended-timeout", "PT15M",
1210
"foo"],
1211
SetExtendedTimeoutCmd,
1212
value_to_set=900000)
1213
1214
def test_interval(self):
1215
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1216
SetIntervalCmd,
1217
value_to_set=120000)
1218
1219
def test_approve_by_default(self):
1220
self.assert_command_from_args(["--approve-by-default", "foo"],
1221
ApproveByDefaultCmd)
1222
1223
def test_deny_by_default(self):
1224
self.assert_command_from_args(["--deny-by-default", "foo"],
1225
DenyByDefaultCmd)
1226
1227
def test_approval_delay(self):
1228
self.assert_command_from_args(["--approval-delay", "PT30S",
1229
"foo"], SetApprovalDelayCmd,
1230
value_to_set=30000)
1231
1232
def test_approval_duration(self):
1233
self.assert_command_from_args(["--approval-duration", "PT1S",
1234
"foo"], SetApprovalDurationCmd,
1235
value_to_set=1000)
1236
1237
def test_host(self):
1238
self.assert_command_from_args(["--host", "foo.example.org",
1239
"foo"], SetHostCmd,
1240
value_to_set="foo.example.org")
1241
1242
def test_secret_devnull(self):
1243
self.assert_command_from_args(["--secret", os.path.devnull,
1244
"foo"], SetSecretCmd,
1245
value_to_set=b"")
1246
1247
def test_secret_tempfile(self):
1248
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1249
value = b"secret\0xyzzy\nbar"
1250
f.write(value)
1251
f.seek(0)
1252
self.assert_command_from_args(["--secret", f.name,
1253
"foo"], SetSecretCmd,
1254
value_to_set=value)
1255
1256
def test_approve(self):
1257
self.assert_command_from_args(["--approve", "foo"],
1258
ApproveCmd)
1259
1260
def test_deny(self):
1261
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1262
1263
def test_dump_json(self):
1264
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1265
1266
def test_is_enabled(self):
1267
self.assert_command_from_args(["--is-enabled", "foo"],
1268
IsEnabledCmd)
987
1269
988
1270
989
1271
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0