/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-07 21:41:04 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 382.
  • Revision ID: teddy@recompile.se-20190307214104-covfbvw1ch6ermzl
mandos-ctl.xml: Use RFC3339 duration values in examples

* mandos-ctl.xml (EXAMPLE): Use RFC3339 duration values.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
44
44
import logging
45
45
import io
46
46
import tempfile
47
 
import contextlib
48
47
 
49
48
import dbus
50
49
 
646
645
 
647
646
 
648
647
def check_option_syntax(parser, options):
649
 
    """Apply additional restrictions on options, not expressible in
650
 
argparse"""
651
648
 
652
649
    def has_actions(options):
653
650
        return any((options.enable,
1101
1098
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1102
1099
    command = SetSecretCmd
1103
1100
    property = "Secret"
1104
 
    values_to_set = [io.BytesIO(b""),
 
1101
    values_to_set = [open("/dev/null", "rb"),
1105
1102
                     io.BytesIO(b"secret\0xyzzy\nbar")]
1106
1103
    values_to_get = [b"", b"secret\0xyzzy\nbar"]
1107
1104
 
1334
1331
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1335
1332
 
1336
1333
 
1337
 
class Test_check_option_syntax(unittest.TestCase):
1338
 
    # This mostly corresponds to the definition from has_actions() in
1339
 
    # check_option_syntax()
1340
 
    actions = {
1341
 
        # The actual values set here are not that important, but we do
1342
 
        # at least stick to the correct types, even though they are
1343
 
        # never used
1344
 
        "enable": True,
1345
 
        "disable": True,
1346
 
        "bump_timeout": True,
1347
 
        "start_checker": True,
1348
 
        "stop_checker": True,
1349
 
        "is_enabled": True,
1350
 
        "remove": True,
1351
 
        "checker": "x",
1352
 
        "timeout": datetime.timedelta(),
1353
 
        "extended_timeout": datetime.timedelta(),
1354
 
        "interval": datetime.timedelta(),
1355
 
        "approved_by_default": True,
1356
 
        "approval_delay": datetime.timedelta(),
1357
 
        "approval_duration": datetime.timedelta(),
1358
 
        "host": "x",
1359
 
        "secret": io.BytesIO(b"x"),
1360
 
        "approve": True,
1361
 
        "deny": True,
1362
 
    }
1363
 
 
1364
 
    def setUp(self):
1365
 
        self.parser = argparse.ArgumentParser()
1366
 
        add_command_line_options(self.parser)
1367
 
 
1368
 
    @contextlib.contextmanager
1369
 
    def assertParseError(self):
1370
 
        with self.assertRaises(SystemExit) as e:
1371
 
            with self.temporarily_suppress_stderr():
1372
 
                yield
1373
 
        # Exit code from argparse is guaranteed to be "2".  Reference:
1374
 
        # https://docs.python.org/3/library/argparse.html#exiting-methods
1375
 
        self.assertEqual(e.exception.code, 2)
1376
 
 
1377
 
    @staticmethod
1378
 
    @contextlib.contextmanager
1379
 
    def temporarily_suppress_stderr():
1380
 
        null = os.open(os.path.devnull, os.O_RDWR)
1381
 
        stderrcopy = os.dup(sys.stderr.fileno())
1382
 
        os.dup2(null, sys.stderr.fileno())
1383
 
        os.close(null)
1384
 
        try:
1385
 
            yield
1386
 
        finally:
1387
 
            # restore stderr
1388
 
            os.dup2(stderrcopy, sys.stderr.fileno())
1389
 
            os.close(stderrcopy)
1390
 
 
1391
 
    def check_option_syntax(self, options):
1392
 
        check_option_syntax(self.parser, options)
1393
 
 
1394
 
    def test_actions_requires_client_or_all(self):
1395
 
        for action, value in self.actions.items():
1396
 
            options = self.parser.parse_args()
1397
 
            setattr(options, action, value)
1398
 
            with self.assertParseError():
1399
 
                self.check_option_syntax(options)
1400
 
 
1401
 
    def test_actions_conflicts_with_verbose(self):
1402
 
        for action, value in self.actions.items():
1403
 
            options = self.parser.parse_args()
1404
 
            setattr(options, action, value)
1405
 
            options.verbose = True
1406
 
            with self.assertParseError():
1407
 
                self.check_option_syntax(options)
1408
 
 
1409
 
    def test_dump_json_conflicts_with_verbose(self):
1410
 
        options = self.parser.parse_args()
1411
 
        options.dump_json = True
1412
 
        options.verbose = True
1413
 
        with self.assertParseError():
1414
 
            self.check_option_syntax(options)
1415
 
 
1416
 
    def test_dump_json_conflicts_with_action(self):
1417
 
        for action, value in self.actions.items():
1418
 
            options = self.parser.parse_args()
1419
 
            setattr(options, action, value)
1420
 
            options.dump_json = True
1421
 
            with self.assertParseError():
1422
 
                self.check_option_syntax(options)
1423
 
 
1424
 
    def test_all_can_not_be_alone(self):
1425
 
        options = self.parser.parse_args()
1426
 
        options.all = True
1427
 
        with self.assertParseError():
1428
 
            self.check_option_syntax(options)
1429
 
 
1430
 
    def test_all_is_ok_with_any_action(self):
1431
 
        for action, value in self.actions.items():
1432
 
            options = self.parser.parse_args()
1433
 
            setattr(options, action, value)
1434
 
            options.all = True
1435
 
            self.check_option_syntax(options)
1436
 
 
1437
 
    def test_is_enabled_fails_without_client(self):
1438
 
        options = self.parser.parse_args()
1439
 
        options.is_enabled = True
1440
 
        with self.assertParseError():
1441
 
            self.check_option_syntax(options)
1442
 
 
1443
 
    def test_is_enabled_works_with_one_client(self):
1444
 
        options = self.parser.parse_args()
1445
 
        options.is_enabled = True
1446
 
        options.client = ["foo"]
1447
 
        self.check_option_syntax(options)
1448
 
 
1449
 
    def test_is_enabled_fails_with_two_clients(self):
1450
 
        options = self.parser.parse_args()
1451
 
        options.is_enabled = True
1452
 
        options.client = ["foo", "barbar"]
1453
 
        with self.assertParseError():
1454
 
            self.check_option_syntax(options)
1455
 
 
1456
 
 
1457
1334
 
1458
1335
def should_only_run_tests():
1459
1336
    parser = argparse.ArgumentParser(add_help=False)