/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 18:30:45 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 382.
  • Revision ID: teddy@recompile.se-20190306183045-blmd3hb7vy4q6waj
mandos-ctl: Add test for the --enable option

* mandos-ctl (TestOptions.test_enable): New.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
268
268
    return value
269
269
 
270
270
 
271
 
class TableOfClients(object):
272
 
    tablewords = {
273
 
        "Name": "Name",
274
 
        "Enabled": "Enabled",
275
 
        "Timeout": "Timeout",
276
 
        "LastCheckedOK": "Last Successful Check",
277
 
        "LastApprovalRequest": "Last Approval Request",
278
 
        "Created": "Created",
279
 
        "Interval": "Interval",
280
 
        "Host": "Host",
281
 
        "Fingerprint": "Fingerprint",
282
 
        "KeyID": "Key ID",
283
 
        "CheckerRunning": "Check Is Running",
284
 
        "LastEnabled": "Last Enabled",
285
 
        "ApprovalPending": "Approval Is Pending",
286
 
        "ApprovedByDefault": "Approved By Default",
287
 
        "ApprovalDelay": "Approval Delay",
288
 
        "ApprovalDuration": "Approval Duration",
289
 
        "Checker": "Checker",
290
 
        "ExtendedTimeout": "Extended Timeout",
291
 
        "Expires": "Expires",
292
 
        "LastCheckerStatus": "Last Checker Status",
293
 
    }
294
 
 
295
 
    def __init__(self, clients, keywords, tablewords=None):
296
 
        self.clients = clients
297
 
        self.keywords = keywords
298
 
        if tablewords is not None:
299
 
            self.tablewords = tablewords
300
 
 
301
 
    def __str__(self):
302
 
        return "\n".join(self.rows())
303
 
 
304
 
    if sys.version_info.major == 2:
305
 
        __unicode__ = __str__
306
 
        def __str__(self):
307
 
            return str(self).encode(locale.getpreferredencoding())
308
 
 
309
 
    def rows(self):
310
 
        format_string = self.row_formatting_string()
311
 
        rows = [self.header_line(format_string)]
312
 
        rows.extend(self.client_line(client, format_string)
313
 
                    for client in self.clients)
314
 
        return rows
315
 
 
316
 
    def row_formatting_string(self):
317
 
        "Format string used to format table rows"
318
 
        return " ".join("{{{key}:{width}}}".format(
319
 
            width=max(len(self.tablewords[key]),
320
 
                      *(len(self.string_from_client(client, key))
321
 
                        for client in self.clients)),
322
 
            key=key)
323
 
                        for key in self.keywords)
324
 
 
325
 
    def string_from_client(self, client, key):
326
 
        return self.valuetostring(client[key], key)
327
 
 
328
 
    @staticmethod
329
 
    def valuetostring(value, keyword):
330
 
        if isinstance(value, dbus.Boolean):
331
 
            return "Yes" if value else "No"
332
 
        if keyword in ("Timeout", "Interval", "ApprovalDelay",
333
 
                       "ApprovalDuration", "ExtendedTimeout"):
334
 
            return milliseconds_to_string(value)
335
 
        return str(value)
336
 
 
337
 
    def header_line(self, format_string):
338
 
        return format_string.format(**self.tablewords)
339
 
 
340
 
    def client_line(self, client, format_string):
341
 
        return format_string.format(
342
 
            **{key: self.string_from_client(client, key)
343
 
               for key in self.keywords})
344
 
 
345
 
 
346
271
## Classes for commands.
347
272
 
348
273
# Abstract classes first
349
274
class Command(object):
350
275
    """Abstract class for commands"""
351
 
    def run(self, clients):
 
276
    def run(self, mandos, clients):
352
277
        """Normal commands should implement run_on_one_client(), but
353
278
        commands which want to operate on all clients at the same time
354
279
        can override this run() method instead."""
355
 
        for client in clients:
356
 
            self.run_on_one_client(client)
 
280
        self.mandos = mandos
 
281
        for client, properties in clients.items():
 
282
            self.run_on_one_client(client, properties)
357
283
 
358
284
class PrintCmd(Command):
359
285
    """Abstract class for commands printing client details"""
364
290
                    "LastApprovalRequest", "ApprovalDelay",
365
291
                    "ApprovalDuration", "Checker", "ExtendedTimeout",
366
292
                    "Expires", "LastCheckerStatus")
367
 
    def run(self, clients):
 
293
    def run(self, mandos, clients):
368
294
        print(self.output(clients))
369
295
 
370
296
class PropertyCmd(Command):
371
297
    """Abstract class for Actions for setting one client property"""
372
 
    def run_on_one_client(self, client):
 
298
    def run_on_one_client(self, client, properties):
373
299
        """Set the Client's D-Bus property"""
374
300
        client.Set(client_interface, self.property, self.value_to_set,
375
301
                   dbus_interface=dbus.PROPERTIES_IFACE)
395
321
class PrintTableCmd(PrintCmd):
396
322
    def __init__(self, verbose=False):
397
323
        self.verbose = verbose
 
324
 
398
325
    def output(self, clients):
 
326
        default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
 
327
        keywords = default_keywords
399
328
        if self.verbose:
400
329
            keywords = self.all_keywords
401
 
        else:
402
 
            keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
403
 
        return str(TableOfClients(clients.values(), keywords))
 
330
        return str(self.TableOfClients(clients.values(), keywords))
 
331
 
 
332
    class TableOfClients(object):
 
333
        tableheaders = {
 
334
            "Name": "Name",
 
335
            "Enabled": "Enabled",
 
336
            "Timeout": "Timeout",
 
337
            "LastCheckedOK": "Last Successful Check",
 
338
            "LastApprovalRequest": "Last Approval Request",
 
339
            "Created": "Created",
 
340
            "Interval": "Interval",
 
341
            "Host": "Host",
 
342
            "Fingerprint": "Fingerprint",
 
343
            "KeyID": "Key ID",
 
344
            "CheckerRunning": "Check Is Running",
 
345
            "LastEnabled": "Last Enabled",
 
346
            "ApprovalPending": "Approval Is Pending",
 
347
            "ApprovedByDefault": "Approved By Default",
 
348
            "ApprovalDelay": "Approval Delay",
 
349
            "ApprovalDuration": "Approval Duration",
 
350
            "Checker": "Checker",
 
351
            "ExtendedTimeout": "Extended Timeout",
 
352
            "Expires": "Expires",
 
353
            "LastCheckerStatus": "Last Checker Status",
 
354
        }
 
355
 
 
356
        def __init__(self, clients, keywords, tableheaders=None):
 
357
            self.clients = clients
 
358
            self.keywords = keywords
 
359
            if tableheaders is not None:
 
360
                self.tableheaders = tableheaders
 
361
 
 
362
        def __str__(self):
 
363
            return "\n".join(self.rows())
 
364
 
 
365
        if sys.version_info.major == 2:
 
366
            __unicode__ = __str__
 
367
            def __str__(self):
 
368
                return str(self).encode(locale.getpreferredencoding())
 
369
 
 
370
        def rows(self):
 
371
            format_string = self.row_formatting_string()
 
372
            rows = [self.header_line(format_string)]
 
373
            rows.extend(self.client_line(client, format_string)
 
374
                        for client in self.clients)
 
375
            return rows
 
376
 
 
377
        def row_formatting_string(self):
 
378
            "Format string used to format table rows"
 
379
            return " ".join("{{{key}:{width}}}".format(
 
380
                width=max(len(self.tableheaders[key]),
 
381
                          *(len(self.string_from_client(client, key))
 
382
                            for client in self.clients)),
 
383
                key=key)
 
384
                            for key in self.keywords)
 
385
 
 
386
        def string_from_client(self, client, key):
 
387
            return self.valuetostring(client[key], key)
 
388
 
 
389
        @staticmethod
 
390
        def valuetostring(value, keyword):
 
391
            if isinstance(value, dbus.Boolean):
 
392
                return "Yes" if value else "No"
 
393
            if keyword in ("Timeout", "Interval", "ApprovalDelay",
 
394
                           "ApprovalDuration", "ExtendedTimeout"):
 
395
                return milliseconds_to_string(value)
 
396
            return str(value)
 
397
 
 
398
        def header_line(self, format_string):
 
399
            return format_string.format(**self.tableheaders)
 
400
 
 
401
        def client_line(self, client, format_string):
 
402
            return format_string.format(
 
403
                **{key: self.string_from_client(client, key)
 
404
                   for key in self.keywords})
 
405
 
 
406
 
404
407
 
405
408
class DumpJSONCmd(PrintCmd):
406
409
    def output(self, clients):
416
419
        return value
417
420
 
418
421
class IsEnabledCmd(Command):
419
 
    def run_on_one_client(self, client):
420
 
        if self.is_enabled(client):
 
422
    def run_on_one_client(self, client, properties):
 
423
        if self.is_enabled(client, properties):
421
424
            sys.exit(0)
422
425
        sys.exit(1)
423
 
    def is_enabled(self, client):
424
 
        return client.Get(client_interface, "Enabled",
425
 
                          dbus_interface=dbus.PROPERTIES_IFACE)
 
426
    def is_enabled(self, client, properties):
 
427
        return bool(properties["Enabled"])
426
428
 
427
429
class RemoveCmd(Command):
428
 
    def __init__(self, mandos):
429
 
        self.mandos = mandos
430
 
    def run_on_one_client(self, client):
 
430
    def run_on_one_client(self, client, properties):
431
431
        self.mandos.RemoveClient(client.__dbus_object_path__)
432
432
 
433
433
class ApproveCmd(Command):
434
 
    def run_on_one_client(self, client):
 
434
    def run_on_one_client(self, client, properties):
435
435
        client.Approve(dbus.Boolean(True),
436
436
                       dbus_interface=client_interface)
437
437
 
438
438
class DenyCmd(Command):
439
 
    def run_on_one_client(self, client):
 
439
    def run_on_one_client(self, client, properties):
440
440
        client.Approve(dbus.Boolean(False),
441
441
                       dbus_interface=client_interface)
442
442
 
515
515
                options.approve,
516
516
                options.deny))
517
517
 
518
 
 
519
 
def main():
520
 
    parser = argparse.ArgumentParser()
 
518
def add_command_line_options(parser):
521
519
    parser.add_argument("--version", action="version",
522
520
                        version="%(prog)s {}".format(version),
523
521
                        help="show version number and exit")
580
578
    parser.add_argument("--check", action="store_true",
581
579
                        help="Run self-test")
582
580
    parser.add_argument("client", nargs="*", help="Client name")
583
 
    options = parser.parse_args()
584
 
 
585
 
    if has_actions(options) and not (options.client or options.all):
586
 
        parser.error("Options require clients names or --all.")
587
 
    if options.verbose and has_actions(options):
588
 
        parser.error("--verbose can only be used alone.")
589
 
    if options.dump_json and (options.verbose
590
 
                              or has_actions(options)):
591
 
        parser.error("--dump-json can only be used alone.")
592
 
    if options.all and not has_actions(options):
593
 
        parser.error("--all requires an action.")
594
 
    if options.is_enabled and len(options.client) > 1:
595
 
            parser.error("--is-enabled requires exactly one client")
596
 
 
597
 
    try:
598
 
        bus = dbus.SystemBus()
599
 
        mandos_dbus_objc = bus.get_object(busname, server_path)
600
 
    except dbus.exceptions.DBusException:
601
 
        log.critical("Could not connect to Mandos server")
602
 
        sys.exit(1)
603
 
 
604
 
    mandos_serv = dbus.Interface(mandos_dbus_objc,
605
 
                                 dbus_interface=server_interface)
606
 
    mandos_serv_object_manager = dbus.Interface(
607
 
        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
 
581
 
 
582
 
 
583
def commands_from_options(options):
608
584
 
609
585
    commands = []
610
586
 
618
594
        commands.append(DisableCmd())
619
595
 
620
596
    if options.bump_timeout:
621
 
        commands.append(BumpTimeoutCmd(options.bump_timeout))
 
597
        commands.append(BumpTimeoutCmd())
622
598
 
623
599
    if options.start_checker:
624
600
        commands.append(StartCheckerCmd())
630
606
        commands.append(IsEnabledCmd())
631
607
 
632
608
    if options.remove:
633
 
        commands.append(RemoveCmd(mandos_serv))
 
609
        commands.append(RemoveCmd())
634
610
 
635
611
    if options.checker is not None:
636
612
        commands.append(SetCheckerCmd())
675
651
    if not commands:
676
652
        commands.append(PrintTableCmd(verbose=options.verbose))
677
653
 
678
 
    # block stderr since dbus library prints to stderr
679
 
    null = os.open(os.path.devnull, os.O_RDWR)
680
 
    stderrcopy = os.dup(sys.stderr.fileno())
681
 
    os.dup2(null, sys.stderr.fileno())
682
 
    os.close(null)
683
 
    try:
684
 
        try:
685
 
            mandos_clients = {path: ifs_and_props[client_interface]
686
 
                              for path, ifs_and_props in
687
 
                              mandos_serv_object_manager
688
 
                              .GetManagedObjects().items()
689
 
                              if client_interface in ifs_and_props}
690
 
        finally:
691
 
            # restore stderr
692
 
            os.dup2(stderrcopy, sys.stderr.fileno())
693
 
            os.close(stderrcopy)
 
654
    return commands
 
655
 
 
656
 
 
657
def main():
 
658
    parser = argparse.ArgumentParser()
 
659
 
 
660
    add_command_line_options(parser)
 
661
 
 
662
    options = parser.parse_args()
 
663
 
 
664
    if has_actions(options) and not (options.client or options.all):
 
665
        parser.error("Options require clients names or --all.")
 
666
    if options.verbose and has_actions(options):
 
667
        parser.error("--verbose can only be used alone.")
 
668
    if options.dump_json and (options.verbose
 
669
                              or has_actions(options)):
 
670
        parser.error("--dump-json can only be used alone.")
 
671
    if options.all and not has_actions(options):
 
672
        parser.error("--all requires an action.")
 
673
    if options.is_enabled and len(options.client) > 1:
 
674
        parser.error("--is-enabled requires exactly one client")
 
675
 
 
676
    clientnames = options.client
 
677
 
 
678
    try:
 
679
        bus = dbus.SystemBus()
 
680
        mandos_dbus_objc = bus.get_object(busname, server_path)
 
681
    except dbus.exceptions.DBusException:
 
682
        log.critical("Could not connect to Mandos server")
 
683
        sys.exit(1)
 
684
 
 
685
    mandos_serv = dbus.Interface(mandos_dbus_objc,
 
686
                                 dbus_interface=server_interface)
 
687
    mandos_serv_object_manager = dbus.Interface(
 
688
        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
 
689
 
 
690
    # Filter out log message from dbus module
 
691
    dbus_logger = logging.getLogger("dbus.proxies")
 
692
    class NullFilter(logging.Filter):
 
693
        def filter(self, record):
 
694
            return False
 
695
    dbus_filter = NullFilter()
 
696
    try:
 
697
        dbus_logger.addFilter(dbus_filter)
 
698
        mandos_clients = {path: ifs_and_props[client_interface]
 
699
                          for path, ifs_and_props in
 
700
                          mandos_serv_object_manager
 
701
                          .GetManagedObjects().items()
 
702
                          if client_interface in ifs_and_props}
694
703
    except dbus.exceptions.DBusException as e:
695
704
        log.critical("Failed to access Mandos server through D-Bus:"
696
705
                     "\n%s", e)
697
706
        sys.exit(1)
 
707
    finally:
 
708
        # restore dbus logger
 
709
        dbus_logger.removeFilter(dbus_filter)
698
710
 
699
711
    # Compile dict of (clients: properties) to process
700
712
    clients = {}
701
713
 
702
 
    if options.all or not options.client:
 
714
    if not clientnames:
703
715
        clients = {bus.get_object(busname, path): properties
704
716
                   for path, properties in mandos_clients.items()}
705
717
    else:
706
 
        for name in options.client:
 
718
        for name in clientnames:
707
719
            for path, client in mandos_clients.items():
708
720
                if client["Name"] == name:
709
721
                    client_objc = bus.get_object(busname, path)
714
726
                sys.exit(1)
715
727
 
716
728
    # Run all commands on clients
 
729
    commands = commands_from_options(options)
717
730
    for command in commands:
718
 
        command.run(clients)
 
731
        command.run(mandos_serv, clients)
719
732
 
720
733
 
721
734
class Test_milliseconds_to_string(unittest.TestCase):
733
746
 
734
747
class Test_string_to_delta(unittest.TestCase):
735
748
    def test_handles_basic_rfc3339(self):
 
749
        self.assertEqual(string_to_delta("PT0S"),
 
750
                         datetime.timedelta())
 
751
        self.assertEqual(string_to_delta("P0D"),
 
752
                         datetime.timedelta())
 
753
        self.assertEqual(string_to_delta("PT1S"),
 
754
                         datetime.timedelta(0, 1))
736
755
        self.assertEqual(string_to_delta("PT2H"),
737
756
                         datetime.timedelta(0, 7200))
738
757
    def test_falls_back_to_pre_1_6_1_with_warning(self):
741
760
            with self.assertLogs(log, logging.WARNING):
742
761
                value = string_to_delta("2h")
743
762
        else:
744
 
            value = string_to_delta("2h")
 
763
            class WarningFilter(logging.Filter):
 
764
                """Don't show, but record the presence of, warnings"""
 
765
                def filter(self, record):
 
766
                    is_warning = record.levelno >= logging.WARNING
 
767
                    self.found = is_warning or getattr(self, "found",
 
768
                                                       False)
 
769
                    return not is_warning
 
770
            warning_filter = WarningFilter()
 
771
            log.addFilter(warning_filter)
 
772
            try:
 
773
                value = string_to_delta("2h")
 
774
            finally:
 
775
                log.removeFilter(warning_filter)
 
776
            self.assertTrue(getattr(warning_filter, "found", False))
745
777
        self.assertEqual(value, datetime.timedelta(0, 7200))
746
778
 
747
 
class Test_TableOfClients(unittest.TestCase):
748
 
    def setUp(self):
749
 
        self.tablewords = {
750
 
            "Attr1": "X",
751
 
            "AttrTwo": "Yy",
752
 
            "AttrThree": "Zzz",
753
 
            "Bool": "A D-BUS Boolean",
754
 
            "NonDbusBoolean": "A Non-D-BUS Boolean",
755
 
            "Integer": "An Integer",
756
 
            "Timeout": "Timedelta 1",
757
 
            "Interval": "Timedelta 2",
758
 
            "ApprovalDelay": "Timedelta 3",
759
 
            "ApprovalDuration": "Timedelta 4",
760
 
            "ExtendedTimeout": "Timedelta 5",
761
 
            "String": "A String",
 
779
 
 
780
class TestCmd(unittest.TestCase):
 
781
    """Abstract class for tests of command classes"""
 
782
    def setUp(self):
 
783
        testcase = self
 
784
        class MockClient(object):
 
785
            def __init__(self, name, **attributes):
 
786
                self.__dbus_object_path__ = "objpath_{}".format(name)
 
787
                self.attributes = attributes
 
788
                self.attributes["Name"] = name
 
789
                self.calls = []
 
790
            def Set(self, interface, property, value, dbus_interface):
 
791
                testcase.assertEqual(interface, client_interface)
 
792
                testcase.assertEqual(dbus_interface,
 
793
                                     dbus.PROPERTIES_IFACE)
 
794
                self.attributes[property] = value
 
795
            def Get(self, interface, property, dbus_interface):
 
796
                testcase.assertEqual(interface, client_interface)
 
797
                testcase.assertEqual(dbus_interface,
 
798
                                     dbus.PROPERTIES_IFACE)
 
799
                return self.attributes[property]
 
800
            def Approve(self, approve, dbus_interface):
 
801
                testcase.assertEqual(dbus_interface, client_interface)
 
802
                self.calls.append(("Approve", (approve,
 
803
                                               dbus_interface)))
 
804
        self.client = 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
        self.other_client = MockClient(
 
829
            "barbar",
 
830
            KeyID=("0558568eedd67d622f5c83b35a115f79"
 
831
                   "6ab612cff5ad227247e46c2b020f441c"),
 
832
            Secret=b"secretbar",
 
833
            Host="192.0.2.3",
 
834
            Enabled=dbus.Boolean(True),
 
835
            Timeout=300000,
 
836
            LastCheckedOK="2019-02-04T00:00:00",
 
837
            Created="2019-01-03T00:00:00",
 
838
            Interval=120000,
 
839
            Fingerprint=("3E393AEAEFB84C7E89E2"
 
840
                         "F547B3A107558FCA3A27"),
 
841
            CheckerRunning=dbus.Boolean(True),
 
842
            LastEnabled="2019-01-04T00:00:00",
 
843
            ApprovalPending=dbus.Boolean(False),
 
844
            ApprovedByDefault=dbus.Boolean(False),
 
845
            LastApprovalRequest="2019-01-03T00:00:00",
 
846
            ApprovalDelay=30000,
 
847
            ApprovalDuration=1000,
 
848
            Checker=":",
 
849
            ExtendedTimeout=900000,
 
850
            Expires="2019-02-05T00:00:00",
 
851
            LastCheckerStatus=-2)
 
852
        self.clients =  collections.OrderedDict(
 
853
            [
 
854
                (self.client, self.client.attributes),
 
855
                (self.other_client, self.other_client.attributes),
 
856
            ])
 
857
        self.one_client = {self.client: self.client.attributes}
 
858
 
 
859
class TestPrintTableCmd(TestCmd):
 
860
    def test_normal(self):
 
861
        output = PrintTableCmd().output(self.clients)
 
862
        expected_output = """
 
863
Name   Enabled Timeout  Last Successful Check
 
864
foo    Yes     00:05:00 2019-02-03T00:00:00  
 
865
barbar Yes     00:05:00 2019-02-04T00:00:00  
 
866
"""[1:-1]
 
867
        self.assertEqual(output, expected_output)
 
868
    def test_verbose(self):
 
869
        output = PrintTableCmd(verbose=True).output(self.clients)
 
870
        expected_output = """
 
871
Name   Enabled Timeout  Last Successful Check Created             Interval Host            Key ID                                                           Fingerprint                              Check Is Running Last Enabled        Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker              Extended Timeout Expires             Last Checker Status
 
872
foo    Yes     00:05:00 2019-02-03T00:00:00   2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No               2019-01-03T00:00:00 No                  Yes                                       00:00:00       00:00:01          fping -q -- %(host)s 00:15:00         2019-02-04T00:00:00 0                  
 
873
barbar Yes     00:05:00 2019-02-04T00:00:00   2019-01-03T00:00:00 00:02:00 192.0.2.3       0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes              2019-01-04T00:00:00 No                  No                  2019-01-03T00:00:00   00:00:30       00:00:01          :                    00:15:00         2019-02-05T00:00:00 -2                 
 
874
"""[1:-1]
 
875
        self.assertEqual(output, expected_output)
 
876
    def test_one_client(self):
 
877
        output = PrintTableCmd().output(self.one_client)
 
878
        expected_output = """
 
879
Name Enabled Timeout  Last Successful Check
 
880
foo  Yes     00:05:00 2019-02-03T00:00:00  
 
881
"""[1:-1]
 
882
        self.assertEqual(output, expected_output)
 
883
 
 
884
class TestDumpJSONCmd(TestCmd):
 
885
    def setUp(self):
 
886
        self.expected_json = {
 
887
            "foo": {
 
888
                "Name": "foo",
 
889
                "KeyID": ("92ed150794387c03ce684574b1139a65"
 
890
                          "94a34f895daaaf09fd8ea90a27cddb12"),
 
891
                "Host": "foo.example.org",
 
892
                "Enabled": True,
 
893
                "Timeout": 300000,
 
894
                "LastCheckedOK": "2019-02-03T00:00:00",
 
895
                "Created": "2019-01-02T00:00:00",
 
896
                "Interval": 120000,
 
897
                "Fingerprint": ("778827225BA7DE539C5A"
 
898
                                "7CFA59CFF7CDBD9A5920"),
 
899
                "CheckerRunning": False,
 
900
                "LastEnabled": "2019-01-03T00:00:00",
 
901
                "ApprovalPending": False,
 
902
                "ApprovedByDefault": True,
 
903
                "LastApprovalRequest": "",
 
904
                "ApprovalDelay": 0,
 
905
                "ApprovalDuration": 1000,
 
906
                "Checker": "fping -q -- %(host)s",
 
907
                "ExtendedTimeout": 900000,
 
908
                "Expires": "2019-02-04T00:00:00",
 
909
                "LastCheckerStatus": 0,
 
910
            },
 
911
            "barbar": {
 
912
                "Name": "barbar",
 
913
                "KeyID": ("0558568eedd67d622f5c83b35a115f79"
 
914
                          "6ab612cff5ad227247e46c2b020f441c"),
 
915
                "Host": "192.0.2.3",
 
916
                "Enabled": True,
 
917
                "Timeout": 300000,
 
918
                "LastCheckedOK": "2019-02-04T00:00:00",
 
919
                "Created": "2019-01-03T00:00:00",
 
920
                "Interval": 120000,
 
921
                "Fingerprint": ("3E393AEAEFB84C7E89E2"
 
922
                                "F547B3A107558FCA3A27"),
 
923
                "CheckerRunning": True,
 
924
                "LastEnabled": "2019-01-04T00:00:00",
 
925
                "ApprovalPending": False,
 
926
                "ApprovedByDefault": False,
 
927
                "LastApprovalRequest": "2019-01-03T00:00:00",
 
928
                "ApprovalDelay": 30000,
 
929
                "ApprovalDuration": 1000,
 
930
                "Checker": ":",
 
931
                "ExtendedTimeout": 900000,
 
932
                "Expires": "2019-02-05T00:00:00",
 
933
                "LastCheckerStatus": -2,
 
934
            },
762
935
        }
763
 
        self.keywords = ["Attr1", "AttrTwo"]
764
 
        self.clients = [
765
 
            {
766
 
                "Attr1": "x1",
767
 
                "AttrTwo": "y1",
768
 
                "AttrThree": "z1",
769
 
                "Bool": dbus.Boolean(False),
770
 
                "NonDbusBoolean": False,
771
 
                "Integer": 0,
772
 
                "Timeout": 0,
773
 
                "Interval": 1000,
774
 
                "ApprovalDelay": 2000,
775
 
                "ApprovalDuration": 3000,
776
 
                "ExtendedTimeout": 4000,
777
 
                "String": "",
778
 
            },
779
 
            {
780
 
                "Attr1": "x2",
781
 
                "AttrTwo": "y2",
782
 
                "AttrThree": "z2",
783
 
                "Bool": dbus.Boolean(True),
784
 
                "NonDbusBoolean": True,
785
 
                "Integer": 1,
786
 
                "Timeout": 93785000,
787
 
                "Interval": 93786000,
788
 
                "ApprovalDelay": 93787000,
789
 
                "ApprovalDuration": 93788000,
790
 
                "ExtendedTimeout": 93789000,
791
 
                "String": "A huge string which will not fit," * 10,
792
 
            },
793
 
        ]
794
 
    def test_short_header(self):
795
 
        text = str(TableOfClients(self.clients, self.keywords,
796
 
                                  self.tablewords))
797
 
        expected_text = """
798
 
X  Yy
799
 
x1 y1
800
 
x2 y2
801
 
"""[1:-1]
802
 
        self.assertEqual(text, expected_text)
803
 
    def test_booleans(self):
804
 
        keywords = ["Bool", "NonDbusBoolean"]
805
 
        text = str(TableOfClients(self.clients, keywords,
806
 
                                  self.tablewords))
807
 
        expected_text = """
808
 
A D-BUS Boolean A Non-D-BUS Boolean
809
 
No              False              
810
 
Yes             True               
811
 
"""[1:-1]
812
 
        self.assertEqual(text, expected_text)
813
 
    def test_milliseconds_detection(self):
814
 
        keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
815
 
                    "ApprovalDuration", "ExtendedTimeout"]
816
 
        text = str(TableOfClients(self.clients, keywords,
817
 
                                  self.tablewords))
818
 
        expected_text = """
819
 
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
820
 
0          00:00:00    00:00:01    00:00:02    00:00:03    00:00:04   
821
 
1          1T02:03:05  1T02:03:06  1T02:03:07  1T02:03:08  1T02:03:09 
822
 
"""[1:-1]
823
 
        self.assertEqual(text, expected_text)
824
 
    def test_empty_and_long_string_values(self):
825
 
        keywords = ["String"]
826
 
        text = str(TableOfClients(self.clients, keywords,
827
 
                                  self.tablewords))
828
 
        expected_text = """
829
 
A String                                                                                                                                                                                                                                                                                                                                  
830
 
                                                                                                                                                                                                                                                                                                                                          
831
 
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
832
 
"""[1:-1]
833
 
        self.assertEqual(text, expected_text)
 
936
        return super(TestDumpJSONCmd, self).setUp()
 
937
    def test_normal(self):
 
938
        json_data = json.loads(DumpJSONCmd().output(self.clients))
 
939
        self.assertDictEqual(json_data, self.expected_json)
 
940
    def test_one_client(self):
 
941
        clients = self.one_client
 
942
        json_data = json.loads(DumpJSONCmd().output(clients))
 
943
        expected_json = {"foo": self.expected_json["foo"]}
 
944
        self.assertDictEqual(json_data, expected_json)
 
945
 
 
946
class TestIsEnabledCmd(TestCmd):
 
947
    def test_is_enabled(self):
 
948
        self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
 
949
                            for client, properties in self.clients.items()))
 
950
    def test_is_enabled_run_exits_successfully(self):
 
951
        with self.assertRaises(SystemExit) as e:
 
952
            IsEnabledCmd().run(None, self.one_client)
 
953
        if e.exception.code is not None:
 
954
            self.assertEqual(e.exception.code, 0)
 
955
        else:
 
956
            self.assertIsNone(e.exception.code)
 
957
    def test_is_enabled_run_exits_with_failure(self):
 
958
        self.client.attributes["Enabled"] = dbus.Boolean(False)
 
959
        with self.assertRaises(SystemExit) as e:
 
960
            IsEnabledCmd().run(None, self.one_client)
 
961
        if isinstance(e.exception.code, int):
 
962
            self.assertNotEqual(e.exception.code, 0)
 
963
        else:
 
964
            self.assertIsNotNone(e.exception.code)
 
965
 
 
966
class TestRemoveCmd(TestCmd):
 
967
    def test_remove(self):
 
968
        class MockMandos(object):
 
969
            def __init__(self):
 
970
                self.calls = []
 
971
            def RemoveClient(self, dbus_path):
 
972
                self.calls.append(("RemoveClient", (dbus_path,)))
 
973
        mandos = MockMandos()
 
974
        super(TestRemoveCmd, self).setUp()
 
975
        RemoveCmd().run(mandos, self.clients)
 
976
        self.assertEqual(len(mandos.calls), 2)
 
977
        for client in self.clients:
 
978
            self.assertIn(("RemoveClient",
 
979
                           (client.__dbus_object_path__,)),
 
980
                          mandos.calls)
 
981
 
 
982
class TestApproveCmd(TestCmd):
 
983
    def test_approve(self):
 
984
        ApproveCmd().run(None, self.clients)
 
985
        for client in self.clients:
 
986
            self.assertIn(("Approve", (True, client_interface)),
 
987
                          client.calls)
 
988
 
 
989
class TestDenyCmd(TestCmd):
 
990
    def test_deny(self):
 
991
        DenyCmd().run(None, self.clients)
 
992
        for client in self.clients:
 
993
            self.assertIn(("Approve", (False, client_interface)),
 
994
                          client.calls)
 
995
 
 
996
class TestEnableCmd(TestCmd):
 
997
    def test_enable(self):
 
998
        for client in self.clients:
 
999
            client.attributes["Enabled"] = False
 
1000
 
 
1001
        EnableCmd().run(None, self.clients)
 
1002
 
 
1003
        for client in self.clients:
 
1004
            self.assertTrue(client.attributes["Enabled"])
 
1005
 
 
1006
class TestDisableCmd(TestCmd):
 
1007
    def test_disable(self):
 
1008
        DisableCmd().run(None, self.clients)
 
1009
 
 
1010
        for client in self.clients:
 
1011
            self.assertFalse(client.attributes["Enabled"])
 
1012
 
 
1013
class Unique(object):
 
1014
    """Class for objects which exist only to be unique objects, since
 
1015
unittest.mock.sentinel only exists in Python 3.3"""
 
1016
 
 
1017
class TestPropertyCmd(TestCmd):
 
1018
    """Abstract class for tests of PropertyCmd classes"""
 
1019
    def runTest(self):
 
1020
        if not hasattr(self, "command"):
 
1021
            return
 
1022
        values_to_get = getattr(self, "values_to_get",
 
1023
                                self.values_to_set)
 
1024
        for value_to_set, value_to_get in zip(self.values_to_set,
 
1025
                                              values_to_get):
 
1026
            for client in self.clients:
 
1027
                old_value = client.attributes[self.property]
 
1028
                self.assertNotIsInstance(old_value, Unique)
 
1029
                client.attributes[self.property] = Unique()
 
1030
            self.run_command(value_to_set, self.clients)
 
1031
            for client in self.clients:
 
1032
                value = client.attributes[self.property]
 
1033
                self.assertNotIsInstance(value, Unique)
 
1034
                self.assertEqual(value, value_to_get)
 
1035
    def run_command(self, value, clients):
 
1036
        self.command().run(None, clients)
 
1037
 
 
1038
class TestBumpTimeoutCmd(TestPropertyCmd):
 
1039
    command = BumpTimeoutCmd
 
1040
    property = "LastCheckedOK"
 
1041
    values_to_set = [""]
 
1042
 
 
1043
class TestStartCheckerCmd(TestPropertyCmd):
 
1044
    command = StartCheckerCmd
 
1045
    property = "CheckerRunning"
 
1046
    values_to_set = [dbus.Boolean(True)]
 
1047
 
 
1048
class TestStopCheckerCmd(TestPropertyCmd):
 
1049
    command = StopCheckerCmd
 
1050
    property = "CheckerRunning"
 
1051
    values_to_set = [dbus.Boolean(False)]
 
1052
 
 
1053
class TestApproveByDefaultCmd(TestPropertyCmd):
 
1054
    command = ApproveByDefaultCmd
 
1055
    property = "ApprovedByDefault"
 
1056
    values_to_set = [dbus.Boolean(True)]
 
1057
 
 
1058
class TestDenyByDefaultCmd(TestPropertyCmd):
 
1059
    command = DenyByDefaultCmd
 
1060
    property = "ApprovedByDefault"
 
1061
    values_to_set = [dbus.Boolean(False)]
 
1062
 
 
1063
class TestValueArgumentPropertyCmd(TestPropertyCmd):
 
1064
    """Abstract class for tests of PropertyCmd classes using the
 
1065
ValueArgumentMixIn"""
 
1066
    def runTest(self):
 
1067
        if type(self) is TestValueArgumentPropertyCmd:
 
1068
            return
 
1069
        return super(TestValueArgumentPropertyCmd, self).runTest()
 
1070
    def run_command(self, value, clients):
 
1071
        self.command(value).run(None, clients)
 
1072
 
 
1073
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
 
1074
    command = SetCheckerCmd
 
1075
    property = "Checker"
 
1076
    values_to_set = ["", ":", "fping -q -- %s"]
 
1077
 
 
1078
class TestSetHostCmd(TestValueArgumentPropertyCmd):
 
1079
    command = SetHostCmd
 
1080
    property = "Host"
 
1081
    values_to_set = ["192.0.2.3", "foo.example.org"]
 
1082
 
 
1083
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
 
1084
    command = SetSecretCmd
 
1085
    property = "Secret"
 
1086
    values_to_set = [b"", b"secret"]
 
1087
 
 
1088
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
 
1089
    command = SetTimeoutCmd
 
1090
    property = "Timeout"
 
1091
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1092
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1093
 
 
1094
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
 
1095
    command = SetExtendedTimeoutCmd
 
1096
    property = "ExtendedTimeout"
 
1097
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1098
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1099
 
 
1100
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
 
1101
    command = SetIntervalCmd
 
1102
    property = "Interval"
 
1103
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1104
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1105
 
 
1106
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
 
1107
    command = SetApprovalDelayCmd
 
1108
    property = "ApprovalDelay"
 
1109
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1110
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1111
 
 
1112
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
 
1113
    command = SetApprovalDurationCmd
 
1114
    property = "ApprovalDuration"
 
1115
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1116
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1117
 
 
1118
class TestOptions(unittest.TestCase):
 
1119
    def setUp(self):
 
1120
        self.parser = argparse.ArgumentParser()
 
1121
        add_command_line_options(self.parser)
 
1122
    def commands_from_args(self, args):
 
1123
        self.options = self.parser.parse_args(args)
 
1124
        return commands_from_options(self.options)
 
1125
    def test_default_is_show_table(self):
 
1126
        commands = self.commands_from_args([])
 
1127
        self.assertEqual(len(commands), 1)
 
1128
        command = commands[0]
 
1129
        self.assertIsInstance(command, PrintTableCmd)
 
1130
        self.assertEqual(command.verbose, False)
 
1131
    def test_show_table_verbose(self):
 
1132
        commands = self.commands_from_args(["--verbose"])
 
1133
        self.assertEqual(len(commands), 1)
 
1134
        command = commands[0]
 
1135
        self.assertIsInstance(command, PrintTableCmd)
 
1136
        self.assertEqual(command.verbose, True)
 
1137
    def test_enable(self):
 
1138
        commands = self.commands_from_args(["--enable", "foo"])
 
1139
        self.assertEqual(len(commands), 1)
 
1140
        command = commands[0]
 
1141
        self.assertIsInstance(command, EnableCmd)
 
1142
        self.assertEqual(self.options.client, ["foo"])
834
1143
 
835
1144
 
836
1145