/mandos/release

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

  • Committer: Teddy Hogeborn
  • Date: 2019-03-06 22:21:51 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 382.
  • Revision ID: teddy@recompile.se-20190306222151-cp303jcuqhast6nu
mandos-ctl: Refactor tests and add more tests

* mandos-ctl (TestOptions): Rename to "Test_command_from_options".
  (Test_command_from_options.test_default_is_show_table): Rename to
                         "Test_command_from_options.test_print_table".
  (Test_command_from_options.test_show_table_verbose): Rename to
                 "Test_command_from_options.test_print_table_verbose".
  (Test_command_from_options.test_bump_timeout): New.
  (Test_command_from_options.test_start_checker): - '' -
  (Test_command_from_options.test_stop_checker): - '' -
  (Test_command_from_options.test_remove): - '' -
  (Test_command_from_options.test_checker): - '' -
  (Test_command_from_options.test_timeout): - '' -
  (Test_command_from_options.test_extended_timeout): - '' -
  (Test_command_from_options.test_interval): - '' -
  (Test_command_from_options.test_approve_by_default): - '' -
  (Test_command_from_options.test_deny_by_default): - '' -
  (Test_command_from_options.test_approval_delay): - '' -
  (Test_command_from_options.test_approval_duration): - '' -
  (Test_command_from_options.test_host): - '' -
  (Test_command_from_options.test_secret_devnull): - '' -
  (Test_command_from_options.test_secret_tempfile): - '' -
  (Test_command_from_options.test_approve): - '' -
  (Test_command_from_options.test_deny): - '' -
  (Test_command_from_options.test_dump_json): - '' -
  (Test_command_from_options.test_is_enabled): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
316
316
    @value_to_set.setter
317
317
    def value_to_set(self, value):
318
318
        """When setting, convert value to a datetime.timedelta"""
319
 
        self._vts = int(round(value.total_seconds() * 1000))
 
319
        self._vts = string_to_delta(value).total_seconds() * 1000
320
320
 
321
321
# Actual (non-abstract) command classes
322
322
 
505
505
                             MillisecondsValueArgumentMixIn):
506
506
    property = "ApprovalDuration"
507
507
 
 
508
def has_actions(options):
 
509
    return any((options.enable,
 
510
                options.disable,
 
511
                options.bump_timeout,
 
512
                options.start_checker,
 
513
                options.stop_checker,
 
514
                options.is_enabled,
 
515
                options.remove,
 
516
                options.checker is not None,
 
517
                options.timeout is not None,
 
518
                options.extended_timeout is not None,
 
519
                options.interval is not None,
 
520
                options.approved_by_default is not None,
 
521
                options.approval_delay is not None,
 
522
                options.approval_duration is not None,
 
523
                options.host is not None,
 
524
                options.secret is not None,
 
525
                options.approve,
 
526
                options.deny))
 
527
 
508
528
def add_command_line_options(parser):
509
529
    parser.add_argument("--version", action="version",
510
530
                        version="%(prog)s {}".format(version),
536
556
                        help="Remove client")
537
557
    parser.add_argument("-c", "--checker",
538
558
                        help="Set checker command for client")
539
 
    parser.add_argument("-t", "--timeout", type=string_to_delta,
 
559
    parser.add_argument("-t", "--timeout",
540
560
                        help="Set timeout for client")
541
 
    parser.add_argument("--extended-timeout", type=string_to_delta,
 
561
    parser.add_argument("--extended-timeout",
542
562
                        help="Set extended timeout for client")
543
 
    parser.add_argument("-i", "--interval", type=string_to_delta,
 
563
    parser.add_argument("-i", "--interval",
544
564
                        help="Set checker interval for client")
545
565
    approve_deny_default = parser.add_mutually_exclusive_group()
546
566
    approve_deny_default.add_argument(
551
571
        "--deny-by-default", action="store_false",
552
572
        dest="approved_by_default",
553
573
        help="Set client to be denied by default")
554
 
    parser.add_argument("--approval-delay", type=string_to_delta,
 
574
    parser.add_argument("--approval-delay",
555
575
                        help="Set delay before client approve/deny")
556
 
    parser.add_argument("--approval-duration", type=string_to_delta,
 
576
    parser.add_argument("--approval-duration",
557
577
                        help="Set duration of one client approval")
558
578
    parser.add_argument("-H", "--host", help="Set host for client")
559
579
    parser.add_argument("-s", "--secret",
644
664
    return commands
645
665
 
646
666
 
647
 
def check_option_syntax(parser, options):
648
 
 
649
 
    def has_actions(options):
650
 
        return any((options.enable,
651
 
                    options.disable,
652
 
                    options.bump_timeout,
653
 
                    options.start_checker,
654
 
                    options.stop_checker,
655
 
                    options.is_enabled,
656
 
                    options.remove,
657
 
                    options.checker is not None,
658
 
                    options.timeout is not None,
659
 
                    options.extended_timeout is not None,
660
 
                    options.interval is not None,
661
 
                    options.approved_by_default is not None,
662
 
                    options.approval_delay is not None,
663
 
                    options.approval_duration is not None,
664
 
                    options.host is not None,
665
 
                    options.secret is not None,
666
 
                    options.approve,
667
 
                    options.deny))
 
667
def main():
 
668
    parser = argparse.ArgumentParser()
 
669
 
 
670
    add_command_line_options(parser)
 
671
 
 
672
    options = parser.parse_args()
668
673
 
669
674
    if has_actions(options) and not (options.client or options.all):
670
675
        parser.error("Options require clients names or --all.")
678
683
    if options.is_enabled and len(options.client) > 1:
679
684
        parser.error("--is-enabled requires exactly one client")
680
685
 
681
 
 
682
 
def main():
683
 
    parser = argparse.ArgumentParser()
684
 
 
685
 
    add_command_line_options(parser)
686
 
 
687
 
    options = parser.parse_args()
688
 
 
689
 
    check_option_syntax(parser, options)
690
 
 
691
686
    clientnames = options.client
692
687
 
693
688
    try:
1105
1100
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1106
1101
    command = SetTimeoutCmd
1107
1102
    property = "Timeout"
1108
 
    values_to_set = [datetime.timedelta(),
1109
 
                     datetime.timedelta(minutes=5),
1110
 
                     datetime.timedelta(seconds=1),
1111
 
                     datetime.timedelta(weeks=1),
1112
 
                     datetime.timedelta(weeks=52)]
1113
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1103
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1104
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1114
1105
 
1115
1106
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1116
1107
    command = SetExtendedTimeoutCmd
1117
1108
    property = "ExtendedTimeout"
1118
 
    values_to_set = [datetime.timedelta(),
1119
 
                     datetime.timedelta(minutes=5),
1120
 
                     datetime.timedelta(seconds=1),
1121
 
                     datetime.timedelta(weeks=1),
1122
 
                     datetime.timedelta(weeks=52)]
1123
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1109
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1110
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1124
1111
 
1125
1112
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1126
1113
    command = SetIntervalCmd
1127
1114
    property = "Interval"
1128
 
    values_to_set = [datetime.timedelta(),
1129
 
                     datetime.timedelta(minutes=5),
1130
 
                     datetime.timedelta(seconds=1),
1131
 
                     datetime.timedelta(weeks=1),
1132
 
                     datetime.timedelta(weeks=52)]
1133
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1115
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1116
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1134
1117
 
1135
1118
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1136
1119
    command = SetApprovalDelayCmd
1137
1120
    property = "ApprovalDelay"
1138
 
    values_to_set = [datetime.timedelta(),
1139
 
                     datetime.timedelta(minutes=5),
1140
 
                     datetime.timedelta(seconds=1),
1141
 
                     datetime.timedelta(weeks=1),
1142
 
                     datetime.timedelta(weeks=52)]
1143
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1121
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1122
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1144
1123
 
1145
1124
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1146
1125
    command = SetApprovalDurationCmd
1147
1126
    property = "ApprovalDuration"
1148
 
    values_to_set = [datetime.timedelta(),
1149
 
                     datetime.timedelta(minutes=5),
1150
 
                     datetime.timedelta(seconds=1),
1151
 
                     datetime.timedelta(weeks=1),
1152
 
                     datetime.timedelta(weeks=52)]
1153
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1127
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1128
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1154
1129
 
1155
1130
class Test_command_from_options(unittest.TestCase):
1156
1131
    def setUp(self):
1160
1135
        """Assert that parsing ARGS should result in an instance of
1161
1136
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1162
1137
        options = self.parser.parse_args(args)
1163
 
        check_option_syntax(self.parser, options)
1164
1138
        commands = commands_from_options(options)
1165
1139
        self.assertEqual(len(commands), 1)
1166
1140
        command = commands[0]
1175
1149
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
1176
1150
                                      verbose=True)
1177
1151
 
1178
 
    def test_print_table_verbose_short(self):
1179
 
        self.assert_command_from_args(["-v"], PrintTableCmd,
1180
 
                                      verbose=True)
1181
 
 
1182
1152
    def test_enable(self):
1183
1153
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1184
1154
 
1185
 
    def test_enable_short(self):
1186
 
        self.assert_command_from_args(["-e", "foo"], EnableCmd)
1187
 
 
1188
1155
    def test_disable(self):
1189
1156
        self.assert_command_from_args(["--disable", "foo"],
1190
1157
                                      DisableCmd)
1191
1158
 
1192
 
    def test_disable_short(self):
1193
 
        self.assert_command_from_args(["-d", "foo"], DisableCmd)
1194
 
 
1195
1159
    def test_bump_timeout(self):
1196
1160
        self.assert_command_from_args(["--bump-timeout", "foo"],
1197
1161
                                      BumpTimeoutCmd)
1198
1162
 
1199
 
    def test_bump_timeout_short(self):
1200
 
        self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1201
 
 
1202
1163
    def test_start_checker(self):
1203
1164
        self.assert_command_from_args(["--start-checker", "foo"],
1204
1165
                                      StartCheckerCmd)
1211
1172
        self.assert_command_from_args(["--remove", "foo"],
1212
1173
                                      RemoveCmd)
1213
1174
 
1214
 
    def test_remove_short(self):
1215
 
        self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1216
 
 
1217
1175
    def test_checker(self):
1218
1176
        self.assert_command_from_args(["--checker", ":", "foo"],
1219
1177
                                      SetCheckerCmd, value_to_set=":")
1220
1178
 
1221
 
    def test_checker_empty(self):
1222
 
        self.assert_command_from_args(["--checker", "", "foo"],
1223
 
                                      SetCheckerCmd, value_to_set="")
1224
 
 
1225
 
    def test_checker_short(self):
1226
 
        self.assert_command_from_args(["-c", ":", "foo"],
1227
 
                                      SetCheckerCmd, value_to_set=":")
1228
 
 
1229
1179
    def test_timeout(self):
1230
1180
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1231
1181
                                      SetTimeoutCmd,
1232
1182
                                      value_to_set=300000)
1233
1183
 
1234
 
    def test_timeout_short(self):
1235
 
        self.assert_command_from_args(["-t", "PT5M", "foo"],
1236
 
                                      SetTimeoutCmd,
1237
 
                                      value_to_set=300000)
1238
 
 
1239
1184
    def test_extended_timeout(self):
1240
1185
        self.assert_command_from_args(["--extended-timeout", "PT15M",
1241
1186
                                       "foo"],
1247
1192
                                      SetIntervalCmd,
1248
1193
                                      value_to_set=120000)
1249
1194
 
1250
 
    def test_interval_short(self):
1251
 
        self.assert_command_from_args(["-i", "PT2M", "foo"],
1252
 
                                      SetIntervalCmd,
1253
 
                                      value_to_set=120000)
1254
 
 
1255
1195
    def test_approve_by_default(self):
1256
1196
        self.assert_command_from_args(["--approve-by-default", "foo"],
1257
1197
                                      ApproveByDefaultCmd)
1275
1215
                                       "foo"], SetHostCmd,
1276
1216
                                      value_to_set="foo.example.org")
1277
1217
 
1278
 
    def test_host_short(self):
1279
 
        self.assert_command_from_args(["-H", "foo.example.org",
1280
 
                                       "foo"], SetHostCmd,
1281
 
                                      value_to_set="foo.example.org")
1282
 
 
1283
1218
    def test_secret_devnull(self):
1284
1219
        self.assert_command_from_args(["--secret", os.path.devnull,
1285
1220
                                       "foo"], SetSecretCmd,
1294
1229
                                           "foo"], SetSecretCmd,
1295
1230
                                          value_to_set=value)
1296
1231
 
1297
 
    def test_secret_devnull_short(self):
1298
 
        self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1299
 
                                      SetSecretCmd, value_to_set=b"")
1300
 
 
1301
 
    def test_secret_tempfile_short(self):
1302
 
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
1303
 
            value = b"secret\0xyzzy\nbar"
1304
 
            f.write(value)
1305
 
            f.seek(0)
1306
 
            self.assert_command_from_args(["-s", f.name, "foo"],
1307
 
                                          SetSecretCmd,
1308
 
                                          value_to_set=value)
1309
 
 
1310
1232
    def test_approve(self):
1311
1233
        self.assert_command_from_args(["--approve", "foo"],
1312
1234
                                      ApproveCmd)
1313
1235
 
1314
 
    def test_approve_short(self):
1315
 
        self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1316
 
 
1317
1236
    def test_deny(self):
1318
1237
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1319
1238
 
1320
 
    def test_deny_short(self):
1321
 
        self.assert_command_from_args(["-D", "foo"], DenyCmd)
1322
 
 
1323
1239
    def test_dump_json(self):
1324
1240
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1325
1241
 
1327
1243
        self.assert_command_from_args(["--is-enabled", "foo"],
1328
1244
                                      IsEnabledCmd)
1329
1245
 
1330
 
    def test_is_enabled_short(self):
1331
 
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1332
 
 
1333
1246
 
1334
1247
 
1335
1248
def should_only_run_tests():