To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 237.7.643
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.643
- Committer: Teddy Hogeborn
- Date: 2019-03-31 04:47:26 UTC
- mto: This revision was merged to the branch mainline in revision 382.
- Revision ID: teddy@recompile.se-20190331044726-po11kmjmug07mw00
mandos-ctl: Remove import of unused module
* mandos-ctl: Remove "import abc".
* mandos-ctl: Remove "import abc".
- files modified:
- intro.xml
added
removed
mandos-ctl
45
45
import io
46
46
import tempfile
47
47
import contextlib
48
import abc
49
48
50
49
import dbus as dbus_python
51
50
122
121
help="Select all clients")
123
122
parser.add_argument("-v", "--verbose", action="store_true",
124
123
help="Print all fields")
125
parser.add_argument("-j", "--dump-json", action="store_true",
124
parser.add_argument("-j", "--dump-json", dest="commands",
125
action="append_const", default=[],
126
const=command.DumpJSON(),
126
127
help="Dump client data in JSON format")
127
128
enable_disable = parser.add_mutually_exclusive_group()
128
enable_disable.add_argument("-e", "--enable", action="store_true",
129
enable_disable.add_argument("-e", "--enable", dest="commands",
130
action="append_const", default=[],
131
const=command.Enable(),
129
132
help="Enable client")
130
enable_disable.add_argument("-d", "--disable",
131
action="store_true",
133
enable_disable.add_argument("-d", "--disable", dest="commands",
134
action="append_const", default=[],
135
const=command.Disable(),
132
136
help="disable client")
133
parser.add_argument("-b", "--bump-timeout", action="store_true",
137
parser.add_argument("-b", "--bump-timeout", dest="commands",
138
action="append_const", default=[],
139
const=command.BumpTimeout(),
134
140
help="Bump timeout for client")
135
141
start_stop_checker = parser.add_mutually_exclusive_group()
136
142
start_stop_checker.add_argument("--start-checker",
137
action="store_true",
143
dest="commands",
144
action="append_const", default=[],
145
const=command.StartChecker(),
138
146
help="Start checker for client")
139
start_stop_checker.add_argument("--stop-checker",
140
action="store_true",
147
start_stop_checker.add_argument("--stop-checker", dest="commands",
148
action="append_const", default=[],
149
const=command.StopChecker(),
141
150
help="Stop checker for client")
142
parser.add_argument("-V", "--is-enabled", action="store_true",
151
parser.add_argument("-V", "--is-enabled", dest="commands",
152
action="append_const", default=[],
153
const=command.IsEnabled(),
143
154
help="Check if client is enabled")
144
parser.add_argument("-r", "--remove", action="store_true",
155
parser.add_argument("-r", "--remove", dest="commands",
156
action="append_const", default=[],
157
const=command.Remove(),
145
158
help="Remove client")
146
parser.add_argument("-c", "--checker",
159
parser.add_argument("-c", "--checker", dest="commands",
160
action="append", default=[],
161
metavar="COMMAND", type=command.SetChecker,
147
162
help="Set checker command for client")
148
parser.add_argument("-t", "--timeout", type=string_to_delta,
149
help="Set timeout for client")
150
parser.add_argument("--extended-timeout", type=string_to_delta,
151
help="Set extended timeout for client")
152
parser.add_argument("-i", "--interval", type=string_to_delta,
153
help="Set checker interval for client")
163
parser.add_argument(
164
"-t", "--timeout", dest="commands", action="append",
165
default=[], metavar="TIME",
166
type=command.SetTimeout.argparse(string_to_delta),
167
help="Set timeout for client")
168
parser.add_argument(
169
"--extended-timeout", dest="commands", action="append",
170
default=[], metavar="TIME",
171
type=command.SetExtendedTimeout.argparse(string_to_delta),
172
help="Set extended timeout for client")
173
parser.add_argument(
174
"-i", "--interval", dest="commands", action="append",
175
default=[], metavar="TIME",
176
type=command.SetInterval.argparse(string_to_delta),
177
help="Set checker interval for client")
154
178
approve_deny_default = parser.add_mutually_exclusive_group()
155
179
approve_deny_default.add_argument(
156
"--approve-by-default", action="store_true",
157
default=None, dest="approved_by_default",
180
"--approve-by-default", dest="commands",
181
action="append_const", default=[],
182
const=command.ApproveByDefault(),
158
183
help="Set client to be approved by default")
159
184
approve_deny_default.add_argument(
160
"--deny-by-default", action="store_false",
161
dest="approved_by_default",
185
"--deny-by-default", dest="commands",
186
action="append_const", default=[],
187
const=command.DenyByDefault(),
162
188
help="Set client to be denied by default")
163
parser.add_argument("--approval-delay", type=string_to_delta,
164
help="Set delay before client approve/deny")
165
parser.add_argument("--approval-duration", type=string_to_delta,
166
help="Set duration of one client approval")
167
parser.add_argument("-H", "--host", help="Set host for client")
168
parser.add_argument("-s", "--secret",
169
type=argparse.FileType(mode="rb"),
170
help="Set password blob (file) for client")
189
parser.add_argument(
190
"--approval-delay", dest="commands", action="append",
191
default=[], metavar="TIME",
192
type=command.SetApprovalDelay.argparse(string_to_delta),
193
help="Set delay before client approve/deny")
194
parser.add_argument(
195
"--approval-duration", dest="commands", action="append",
196
default=[], metavar="TIME",
197
type=command.SetApprovalDuration.argparse(string_to_delta),
198
help="Set duration of one client approval")
199
parser.add_argument("-H", "--host", dest="commands",
200
action="append", default=[], metavar="STRING",
201
type=command.SetHost,
202
help="Set host for client")
203
parser.add_argument(
204
"-s", "--secret", dest="commands", action="append",
205
default=[], metavar="FILENAME",
206
type=command.SetSecret.argparse(argparse.FileType(mode="rb")),
207
help="Set password blob (file) for client")
171
208
approve_deny = parser.add_mutually_exclusive_group()
172
209
approve_deny.add_argument(
173
"-A", "--approve", action="store_true",
210
"-A", "--approve", dest="commands", action="append_const",
211
default=[], const=command.Approve(),
174
212
help="Approve any current client request")
175
approve_deny.add_argument("-D", "--deny", action="store_true",
213
approve_deny.add_argument("-D", "--deny", dest="commands",
214
action="append_const", default=[],
215
const=command.Deny(),
176
216
help="Deny any current client request")
177
217
parser.add_argument("--debug", action="store_true",
178
218
help="Debug mode (show D-Bus commands)")
369
409
"""Apply additional restrictions on options, not expressible in
370
410
argparse"""
371
411
372
def has_actions(options):
373
return any((options.enable,
374
options.disable,
375
options.bump_timeout,
376
options.start_checker,
377
options.stop_checker,
378
options.is_enabled,
379
options.remove,
380
options.checker is not None,
381
options.timeout is not None,
382
options.extended_timeout is not None,
383
options.interval is not None,
384
options.approved_by_default is not None,
385
options.approval_delay is not None,
386
options.approval_duration is not None,
387
options.host is not None,
388
options.secret is not None,
389
options.approve,
390
options.deny))
412
def has_commands(options, commands=None):
413
if commands is None:
414
commands = (command.Enable,
415
command.Disable,
416
command.BumpTimeout,
417
command.StartChecker,
418
command.StopChecker,
419
command.IsEnabled,
420
command.Remove,
421
command.SetChecker,
422
command.SetTimeout,
423
command.SetExtendedTimeout,
424
command.SetInterval,
425
command.ApproveByDefault,
426
command.DenyByDefault,
427
command.SetApprovalDelay,
428
command.SetApprovalDuration,
429
command.SetHost,
430
command.SetSecret,
431
command.Approve,
432
command.Deny)
433
return any(isinstance(cmd, commands)
434
for cmd in options.commands)
391
435
392
if has_actions(options) and not (options.client or options.all):
436
if has_commands(options) and not (options.client or options.all):
393
437
parser.error("Options require clients names or --all.")
394
if options.verbose and has_actions(options):
438
if options.verbose and has_commands(options):
395
439
parser.error("--verbose can only be used alone.")
396
if options.dump_json and (options.verbose
397
or has_actions(options)):
440
if (has_commands(options, (command.DumpJSON,))
441
and (options.verbose or len(options.commands) > 1)):
398
442
parser.error("--dump-json can only be used alone.")
399
if options.all and not has_actions(options):
443
if options.all and not has_commands(options):
400
444
parser.error("--all requires an action.")
401
if options.is_enabled and len(options.client) > 1:
445
if (has_commands(options, (command.IsEnabled,))
446
and len(options.client) > 1):
402
447
parser.error("--is-enabled requires exactly one client")
403
if options.remove:
404
options.remove = False
405
if has_actions(options) and not options.deny:
406
parser.error("--remove can only be combined with --deny")
407
options.remove = True
408
448
if (len(options.commands) > 1
449
and has_commands(options, (command.Remove,))
450
and not has_commands(options, (command.Deny,))):
451
parser.error("--remove can only be combined with --deny")
409
452
410
453
411
454
class dbus(object):
551
594
552
595
def commands_from_options(options):
553
596
554
commands = []
555
556
if options.is_enabled:
557
commands.append(command.IsEnabled())
558
559
if options.approve:
560
commands.append(command.Approve())
561
562
if options.deny:
563
commands.append(command.Deny())
564
565
if options.remove:
566
commands.append(command.Remove())
567
568
if options.dump_json:
569
commands.append(command.DumpJSON())
570
571
if options.enable:
572
commands.append(command.Enable())
573
574
if options.disable:
575
commands.append(command.Disable())
576
577
if options.bump_timeout:
578
commands.append(command.BumpTimeout())
579
580
if options.start_checker:
581
commands.append(command.StartChecker())
582
583
if options.stop_checker:
584
commands.append(command.StopChecker())
585
586
if options.approved_by_default is not None:
587
if options.approved_by_default:
588
commands.append(command.ApproveByDefault())
597
commands = list(options.commands)
598
599
def find_cmd(cmd, commands):
600
i = 0
601
for i, c in enumerate(commands):
602
if isinstance(c, cmd):
603
return i
604
return i+1
605
606
# If command.Remove is present, move any instances of command.Deny
607
# to occur ahead of command.Remove.
608
index_of_remove = find_cmd(command.Remove, commands)
609
before_remove = commands[:index_of_remove]
610
after_remove = commands[index_of_remove:]
611
cleaned_after = []
612
for cmd in after_remove:
613
if isinstance(cmd, command.Deny):
614
before_remove.append(cmd)
589
615
else:
590
commands.append(command.DenyByDefault())
591
592
if options.checker is not None:
593
commands.append(command.SetChecker(options.checker))
594
595
if options.host is not None:
596
commands.append(command.SetHost(options.host))
597
598
if options.secret is not None:
599
commands.append(command.SetSecret(options.secret))
600
601
if options.timeout is not None:
602
commands.append(command.SetTimeout(options.timeout))
603
604
if options.extended_timeout:
605
commands.append(
606
command.SetExtendedTimeout(options.extended_timeout))
607
608
if options.interval is not None:
609
commands.append(command.SetInterval(options.interval))
610
611
if options.approval_delay is not None:
612
commands.append(
613
command.SetApprovalDelay(options.approval_delay))
614
615
if options.approval_duration is not None:
616
commands.append(
617
command.SetApprovalDuration(options.approval_duration))
616
cleaned_after.append(cmd)
617
if cleaned_after != after_remove:
618
commands = before_remove + cleaned_after
618
619
619
620
# If no command option has been given, show table of clients,
620
621
# optionally verbosely
835
836
def __init__(self, value):
836
837
self.value_to_set = value
837
838
839
@classmethod
840
def argparse(cls, argtype):
841
def cmdtype(arg):
842
return cls(argtype(arg))
843
return cmdtype
838
844
839
845
class SetChecker(PropertySetterValue):
840
846
propname = "Checker"
966
972
967
973
def test_actions_requires_client_or_all(self):
968
974
for action, value in self.actions.items():
969
options = self.parser.parse_args()
970
setattr(options, action, value)
975
args = self.actionargs(action, value)
971
976
with self.assertParseError():
972
self.check_option_syntax(options)
977
self.parse_args(args)
973
978
974
# This mostly corresponds to the definition from has_actions() in
979
# This mostly corresponds to the definition from has_commands() in
975
980
# check_option_syntax()
976
981
actions = {
977
# The actual values set here are not that important, but we do
978
# at least stick to the correct types, even though they are
979
# never used
980
"enable": True,
981
"disable": True,
982
"bump_timeout": True,
983
"start_checker": True,
984
"stop_checker": True,
985
"is_enabled": True,
986
"remove": True,
987
"checker": "x",
988
"timeout": datetime.timedelta(),
989
"extended_timeout": datetime.timedelta(),
990
"interval": datetime.timedelta(),
991
"approved_by_default": True,
992
"approval_delay": datetime.timedelta(),
993
"approval_duration": datetime.timedelta(),
994
"host": "x",
995
"secret": io.BytesIO(b"x"),
996
"approve": True,
997
"deny": True,
982
"--enable": None,
983
"--disable": None,
984
"--bump-timeout": None,
985
"--start-checker": None,
986
"--stop-checker": None,
987
"--is-enabled": None,
988
"--remove": None,
989
"--checker": "x",
990
"--timeout": "PT0S",
991
"--extended-timeout": "PT0S",
992
"--interval": "PT0S",
993
"--approve-by-default": None,
994
"--deny-by-default": None,
995
"--approval-delay": "PT0S",
996
"--approval-duration": "PT0S",
997
"--host": "hostname",
998
"--secret": "/dev/null",
999
"--approve": None,
1000
"--deny": None,
998
1001
}
999
1002
1003
@staticmethod
1004
def actionargs(action, value, *args):
1005
if value is not None:
1006
return [action, value] + list(args)
1007
else:
1008
return [action] + list(args)
1009
1000
1010
@contextlib.contextmanager
1001
1011
def assertParseError(self):
1002
1012
with self.assertRaises(SystemExit) as e:
1007
1017
# /argparse.html#exiting-methods
1008
1018
self.assertEqual(2, e.exception.code)
1009
1019
1020
def parse_args(self, args):
1021
options = self.parser.parse_args(args)
1022
check_option_syntax(self.parser, options)
1023
1010
1024
@staticmethod
1011
1025
@contextlib.contextmanager
1012
1026
def redirect_stderr_to_devnull():
1023
1037
1024
1038
def test_actions_all_conflicts_with_verbose(self):
1025
1039
for action, value in self.actions.items():
1026
options = self.parser.parse_args()
1027
setattr(options, action, value)
1028
options.all = True
1029
options.verbose = True
1040
args = self.actionargs(action, value, "--all",
1041
"--verbose")
1030
1042
with self.assertParseError():
1031
self.check_option_syntax(options)
1043
self.parse_args(args)
1032
1044
1033
1045
def test_actions_with_client_conflicts_with_verbose(self):
1034
1046
for action, value in self.actions.items():
1035
options = self.parser.parse_args()
1036
setattr(options, action, value)
1037
options.verbose = True
1038
options.client = ["client"]
1047
args = self.actionargs(action, value, "--verbose",
1048
"client")
1039
1049
with self.assertParseError():
1040
self.check_option_syntax(options)
1050
self.parse_args(args)
1041
1051
1042
1052
def test_dump_json_conflicts_with_verbose(self):
1043
options = self.parser.parse_args()
1044
options.dump_json = True
1045
options.verbose = True
1053
args = ["--dump-json", "--verbose"]
1046
1054
with self.assertParseError():
1047
self.check_option_syntax(options)
1055
self.parse_args(args)
1048
1056
1049
1057
def test_dump_json_conflicts_with_action(self):
1050
1058
for action, value in self.actions.items():
1051
options = self.parser.parse_args()
1052
setattr(options, action, value)
1053
options.dump_json = True
1059
args = self.actionargs(action, value, "--dump-json")
1054
1060
with self.assertParseError():
1055
self.check_option_syntax(options)
1061
self.parse_args(args)
1056
1062
1057
1063
def test_all_can_not_be_alone(self):
1058
options = self.parser.parse_args()
1059
options.all = True
1064
args = ["--all"]
1060
1065
with self.assertParseError():
1061
self.check_option_syntax(options)
1066
self.parse_args(args)
1062
1067
1063
1068
def test_all_is_ok_with_any_action(self):
1064
1069
for action, value in self.actions.items():
1065
options = self.parser.parse_args()
1066
setattr(options, action, value)
1067
options.all = True
1068
self.check_option_syntax(options)
1070
args = self.actionargs(action, value, "--all")
1071
self.parse_args(args)
1069
1072
1070
1073
def test_any_action_is_ok_with_one_client(self):
1071
1074
for action, value in self.actions.items():
1072
options = self.parser.parse_args()
1073
setattr(options, action, value)
1074
options.client = ["client"]
1075
self.check_option_syntax(options)
1075
args = self.actionargs(action, value, "client")
1076
self.parse_args(args)
1076
1077
1077
1078
def test_one_client_with_all_actions_except_is_enabled(self):
1078
options = self.parser.parse_args()
1079
1079
for action, value in self.actions.items():
1080
if action == "is_enabled":
1080
if action == "--is-enabled":
1081
1081
continue
1082
setattr(options, action, value)
1083
options.client = ["client"]
1084
self.check_option_syntax(options)
1082
args = self.actionargs(action, value, "client")
1083
self.parse_args(args)
1085
1084
1086
1085
def test_two_clients_with_all_actions_except_is_enabled(self):
1087
options = self.parser.parse_args()
1088
1086
for action, value in self.actions.items():
1089
if action == "is_enabled":
1087
if action == "--is-enabled":
1090
1088
continue
1091
setattr(options, action, value)
1092
options.client = ["client1", "client2"]
1093
self.check_option_syntax(options)
1089
args = self.actionargs(action, value, "client1",
1090
"client2")
1091
self.parse_args(args)
1094
1092
1095
1093
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1096
1094
for action, value in self.actions.items():
1097
if action == "is_enabled":
1095
if action == "--is-enabled":
1098
1096
continue
1099
options = self.parser.parse_args()
1100
setattr(options, action, value)
1101
options.client = ["client1", "client2"]
1102
self.check_option_syntax(options)
1097
args = self.actionargs(action, value, "client1",
1098
"client2")
1099
self.parse_args(args)
1103
1100
1104
1101
def test_is_enabled_fails_without_client(self):
1105
options = self.parser.parse_args()
1106
options.is_enabled = True
1102
args = ["--is-enabled"]
1107
1103
with self.assertParseError():
1108
self.check_option_syntax(options)
1104
self.parse_args(args)
1109
1105
1110
1106
def test_is_enabled_fails_with_two_clients(self):
1111
options = self.parser.parse_args()
1112
options.is_enabled = True
1113
options.client = ["client1", "client2"]
1107
args = ["--is-enabled", "client1", "client2"]
1114
1108
with self.assertParseError():
1115
self.check_option_syntax(options)
1109
self.parse_args(args)
1116
1110
1117
1111
def test_remove_can_only_be_combined_with_action_deny(self):
1118
1112
for action, value in self.actions.items():
1119
if action in {"remove", "deny"}:
1113
if action in {"--remove", "--deny"}:
1120
1114
continue
1121
options = self.parser.parse_args()
1122
setattr(options, action, value)
1123
options.all = True
1124
options.remove = True
1115
args = self.actionargs(action, value, "--all",
1116
"--remove")
1125
1117
with self.assertParseError():
1126
self.check_option_syntax(options)
1118
self.parse_args(args)
1127
1119
1128
1120
1129
1121
class Test_dbus_exceptions(unittest.TestCase):
2070
2062
def runTest(self):
2071
2063
if not hasattr(self, "command"):
2072
2064
return # Abstract TestCase class
2073
values_to_get = getattr(self, "values_to_get",
2074
self.values_to_set)
2075
for value_to_set, value_to_get in zip(self.values_to_set,
2076
values_to_get):
2077
for clientpath in self.bus.clients:
2078
self.bus.clients[clientpath][self.propname] = Unique()
2079
self.run_command(value_to_set, self.bus.clients)
2080
for clientpath in self.bus.clients:
2081
value = self.bus.clients[clientpath][self.propname]
2065
2066
if hasattr(self, "values_to_set"):
2067
cmd_args = [(value,) for value in self.values_to_set]
2068
values_to_get = getattr(self, "values_to_get",
2069
self.values_to_set)
2070
else:
2071
cmd_args = [() for x in range(len(self.values_to_get))]
2072
values_to_get = self.values_to_get
2073
for value_to_get, cmd_arg in zip(values_to_get, cmd_args):
2074
for clientpath in self.bus.clients:
2075
self.bus.clients[clientpath][self.propname] = (
2076
Unique())
2077
self.command(*cmd_arg).run(self.bus.clients, self.bus)
2078
for clientpath in self.bus.clients:
2079
value = (self.bus.clients[clientpath]
2080
[self.propname])
2082
2081
self.assertNotIsInstance(value, Unique)
2083
2082
self.assertEqual(value_to_get, value)
2084
2083
2085
def run_command(self, value, clients):
2086
self.command().run(clients, self.bus)
2087
2088
2084
2089
2085
class TestEnableCmd(TestPropertySetterCmd):
2090
2086
command = command.Enable
2091
2087
propname = "Enabled"
2092
values_to_set = [True]
2088
values_to_get = [True]
2093
2089
2094
2090
2095
2091
class TestDisableCmd(TestPropertySetterCmd):
2096
2092
command = command.Disable
2097
2093
propname = "Enabled"
2098
values_to_set = [False]
2094
values_to_get = [False]
2099
2095
2100
2096
2101
2097
class TestBumpTimeoutCmd(TestPropertySetterCmd):
2102
2098
command = command.BumpTimeout
2103
2099
propname = "LastCheckedOK"
2104
values_to_set = [""]
2100
values_to_get = [""]
2105
2101
2106
2102
2107
2103
class TestStartCheckerCmd(TestPropertySetterCmd):
2108
2104
command = command.StartChecker
2109
2105
propname = "CheckerRunning"
2110
values_to_set = [True]
2106
values_to_get = [True]
2111
2107
2112
2108
2113
2109
class TestStopCheckerCmd(TestPropertySetterCmd):
2114
2110
command = command.StopChecker
2115
2111
propname = "CheckerRunning"
2116
values_to_set = [False]
2112
values_to_get = [False]
2117
2113
2118
2114
2119
2115
class TestApproveByDefaultCmd(TestPropertySetterCmd):
2120
2116
command = command.ApproveByDefault
2121
2117
propname = "ApprovedByDefault"
2122
values_to_set = [True]
2118
values_to_get = [True]
2123
2119
2124
2120
2125
2121
class TestDenyByDefaultCmd(TestPropertySetterCmd):
2126
2122
command = command.DenyByDefault
2127
2123
propname = "ApprovedByDefault"
2128
values_to_set = [False]
2129
2130
2131
class TestPropertySetterValueCmd(TestPropertySetterCmd):
2132
"""Abstract class for tests of PropertySetterValueCmd classes"""
2133
2134
def run_command(self, value, clients):
2135
self.command(value).run(clients, self.bus)
2136
2137
2138
class TestSetCheckerCmd(TestPropertySetterValueCmd):
2124
values_to_get = [False]
2125
2126
2127
class TestSetCheckerCmd(TestPropertySetterCmd):
2139
2128
command = command.SetChecker
2140
2129
propname = "Checker"
2141
2130
values_to_set = ["", ":", "fping -q -- %s"]
2142
2131
2143
2132
2144
class TestSetHostCmd(TestPropertySetterValueCmd):
2133
class TestSetHostCmd(TestPropertySetterCmd):
2145
2134
command = command.SetHost
2146
2135
propname = "Host"
2147
2136
values_to_set = ["192.0.2.3", "client.example.org"]
2148
2137
2149
2138
2150
class TestSetSecretCmd(TestPropertySetterValueCmd):
2139
class TestSetSecretCmd(TestPropertySetterCmd):
2151
2140
command = command.SetSecret
2152
2141
propname = "Secret"
2153
2142
values_to_set = [io.BytesIO(b""),
2155
2144
values_to_get = [f.getvalue() for f in values_to_set]
2156
2145
2157
2146
2158
class TestSetTimeoutCmd(TestPropertySetterValueCmd):
2147
class TestSetTimeoutCmd(TestPropertySetterCmd):
2159
2148
command = command.SetTimeout
2160
2149
propname = "Timeout"
2161
2150
values_to_set = [datetime.timedelta(),
2166
2155
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2167
2156
2168
2157
2169
class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):
2158
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
2170
2159
command = command.SetExtendedTimeout
2171
2160
propname = "ExtendedTimeout"
2172
2161
values_to_set = [datetime.timedelta(),
2177
2166
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2178
2167
2179
2168
2180
class TestSetIntervalCmd(TestPropertySetterValueCmd):
2169
class TestSetIntervalCmd(TestPropertySetterCmd):
2181
2170
command = command.SetInterval
2182
2171
propname = "Interval"
2183
2172
values_to_set = [datetime.timedelta(),
2188
2177
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2189
2178
2190
2179
2191
class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):
2180
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
2192
2181
command = command.SetApprovalDelay
2193
2182
propname = "ApprovalDelay"
2194
2183
values_to_set = [datetime.timedelta(),
2199
2188
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2200
2189
2201
2190
2202
class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):
2191
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
2203
2192
command = command.SetApprovalDuration
2204
2193
propname = "ApprovalDuration"
2205
2194
values_to_set = [datetime.timedelta(),
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0