/mandos/trunk : revision 1199

1

#!/usr/bin/python

2

# -*- after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --test" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

1

#!/usr/bin/python3 -bbI

2

# -*- after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

46

import tempfile

47

import contextlib

48

49

if sys.version_info.major == 2:

50

__metaclass__ = type

51

str = unicode

52

53

class gi:

54

"""Dummy gi module, for the tests"""

55

class repository:

56

class GLib:

57

class Error(Exception):

58

pass

59

dbussy = None

60

ravel = None

61

dbus_python = None

62

pydbus = None

63

49

64

try:

50

import pydbus

51

import gi

52

dbus_python = None

65

import dbussy

66

import ravel

53

67

except ImportError:

54

import dbus as dbus_python

55

pydbus = None

56

class gi(object):

57

"""Dummy gi module, for the tests"""

58

class repository(object):

59

class GLib(object):

60

class Error(Exception):

61

pass

68

try:

69

import pydbus

70

import gi

71

except ImportError:

72

import dbus as dbus_python

73

62

74

63

75

# Show warnings by default

64

76

if not sys.warnoptions:

72

84

logging.captureWarnings(True) # Show warnings via the logging system

73

85

74

86

if sys.version_info.major == 2:

75

str = unicode

76

87

import StringIO

77

88

io.StringIO = StringIO.StringIO

78

89

79

90

locale.setlocale(locale.LC_ALL, "")

80

91

81

version = "1.8.4"

92

version = "1.8.9"

82

93

83

94

84

95

def main():

93

104

if options.debug:

94

105

log.setLevel(logging.DEBUG)

95

106

96

if pydbus is not None:

107

if dbussy is not None and ravel is not None:

108

bus = dbussy_adapter.CachingBus(dbussy, ravel)

109

elif pydbus is not None:

97

110

bus = pydbus_adapter.CachingBus(pydbus)

98

111

else:

99

112

bus = dbus_python_adapter.CachingBus(dbus_python)

250

263

def rfc3339_duration_to_delta(duration):

251

264

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

252

265

253

>>> rfc3339_duration_to_delta("P7D")

254

datetime.timedelta(7)

255

>>> rfc3339_duration_to_delta("PT60S")

256

datetime.timedelta(0, 60)

257

>>> rfc3339_duration_to_delta("PT60M")

258

datetime.timedelta(0, 3600)

259

>>> rfc3339_duration_to_delta("P60M")

260

datetime.timedelta(1680)

261

>>> rfc3339_duration_to_delta("PT24H")

262

datetime.timedelta(1)

263

>>> rfc3339_duration_to_delta("P1W")

264

datetime.timedelta(7)

265

>>> rfc3339_duration_to_delta("PT5M30S")

266

datetime.timedelta(0, 330)

267

>>> rfc3339_duration_to_delta("P1DT3M20S")

268

datetime.timedelta(1, 200)

266

>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)

267

True

268

>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)

269

True

270

>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(hours=1)

271

True

272

>>> # 60 months

273

>>> rfc3339_duration_to_delta("P60M") == datetime.timedelta(1680)

274

True

275

>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)

276

True

277

>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)

278

True

279

>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)

280

True

281

>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)

282

True

269

283

>>> # Can not be empty:

270

284

>>> rfc3339_duration_to_delta("")

271

285

Traceback (most recent call last):

381

395

"""Parse an interval string as documented by Mandos before 1.6.1,

382

396

and return a datetime.timedelta

383

397

384

>>> parse_pre_1_6_1_interval('7d')

385

datetime.timedelta(7)

386

>>> parse_pre_1_6_1_interval('60s')

387

datetime.timedelta(0, 60)

388

>>> parse_pre_1_6_1_interval('60m')

389

datetime.timedelta(0, 3600)

390

>>> parse_pre_1_6_1_interval('24h')

391

datetime.timedelta(1)

392

>>> parse_pre_1_6_1_interval('1w')

393

datetime.timedelta(7)

394

>>> parse_pre_1_6_1_interval('5m 30s')

395

datetime.timedelta(0, 330)

396

>>> parse_pre_1_6_1_interval('')

397

datetime.timedelta(0)

398

>>> parse_pre_1_6_1_interval('7d') == datetime.timedelta(days=7)

399

True

400

>>> parse_pre_1_6_1_interval('60s') == datetime.timedelta(0, 60)

401

True

402

>>> parse_pre_1_6_1_interval('60m') == datetime.timedelta(hours=1)

403

True

404

>>> parse_pre_1_6_1_interval('24h') == datetime.timedelta(days=1)

405

True

406

>>> parse_pre_1_6_1_interval('1w') == datetime.timedelta(days=7)

407

True

408

>>> parse_pre_1_6_1_interval('5m 30s') == datetime.timedelta(0, 330)

409

True

410

>>> parse_pre_1_6_1_interval('') == datetime.timedelta(0)

411

True

398

412

>>> # Ignore unknown characters, allow any order and repetitions

399

>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')

400

datetime.timedelta(2, 480, 18000)

413

>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m') == datetime.timedelta(2, 480, 18000)

414

True

401

415

402

416

"""

403

417

466

480

parser.error("--remove can only be combined with --deny")

467

481

468

482

469

class dbus(object):

483

class dbus:

470

484

471

class SystemBus(object):

485

class SystemBus:

472

486

473

487

object_manager_iface = "org.freedesktop.DBus.ObjectManager"

474

488

def get_managed_objects(self, busname, objectpath):

483

497

self.properties_iface, interface, key,

484

498

value)

485

499

500

def call_method(self, methodname, busname, objectpath,

501

interface, *args):

502

raise NotImplementedError()

503

486

504

487

505

class MandosBus(SystemBus):

488

506

busname_domain = "se.recompile"

520

538

pass

521

539

522

540

523

class dbus_python_adapter(object):

541

class dbus_python_adapter:

524

542

525

543

class SystemBus(dbus.MandosBus):

526

544

"""Use dbus-python"""

580

598

self.client_interface, key,

581

599

value)

582

600

583

class SilenceLogger(object):

601

class SilenceLogger:

584

602

"Simple context manager to silence a particular logger"

585

603

def __init__(self, loggername):

586

604

self.logger = logging.getLogger(loggername)

615

633

return new_object

616

634

617

635

618

class pydbus_adapter(object):

636

class pydbus_adapter:

619

637

class SystemBus(dbus.MandosBus):

620

638

def __init__(self, module=pydbus):

621

639

self.pydbus = module

678

696

return new_object

679

697

680

698

699

class dbussy_adapter:

700

class SystemBus(dbus.SystemBus):

701

"""Use DBussy"""

702

703

def __init__(self, dbussy, ravel):

704

self.dbussy = dbussy

705

self.ravel = ravel

706

self.bus = ravel.system_bus()

707

708

@contextlib.contextmanager

709

def convert_exception(self, exception_class=dbus.Error):

710

try:

711

yield

712

except self.dbussy.DBusError as e:

713

# This does what "raise from" would do

714

exc = exception_class(*e.args)

715

exc.__cause__ = e

716

raise exc

717

718

def call_method(self, methodname, busname, objectpath,

719

interface, *args):

720

proxy_object = self.get_object(busname, objectpath)

721

log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,

722

interface, methodname,

723

", ".join(repr(a) for a in args))

724

iface = proxy_object.get_interface(interface)

725

method = getattr(iface, methodname)

726

with self.convert_exception(dbus.Error):

727

value = method(*args)

728

# DBussy returns values either as an empty list or as a

729

# tuple: (signature, value)

730

if value:

731

return self.type_filter(value[0])

732

733

def get_object(self, busname, objectpath):

734

log.debug("D-Bus: Connect to: (busname=%r, path=%r)",

735

busname, objectpath)

736

with self.convert_exception(dbus.ConnectFailed):

737

return self.bus[busname][objectpath]

738

739

def type_filter(self, value):

740

"""Convert the most bothersome types to Python types"""

741

if isinstance(value, tuple):

742

if (len(value) == 2

743

and isinstance(value[0],

744

self.dbussy.DBUS.Signature)):

745

return self.type_filter(value[1])

746

elif isinstance(value, self.dbussy.DBUS.ObjectPath):

747

return str(value)

748

# Also recurse into dictionaries

749

elif isinstance(value, dict):

750

return {self.type_filter(key):

751

self.type_filter(subval)

752

for key, subval in value.items()}

753

return value

754

755

def set_property(self, busname, objectpath, interface, key,

756

value):

757

proxy_object = self.get_object(busname, objectpath)

758

log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,

759

objectpath, self.properties_iface, interface,

760

key, value)

761

if key == "Secret":

762

# DBussy wants a Byte Array to be a sequence of

763

# values, not a byte string

764

value = tuple(value)

765

setattr(proxy_object.get_interface(interface), key, value)

766

767

class MandosBus(SystemBus, dbus.MandosBus):

768

pass

769

770

class CachingBus(MandosBus):

771

"""A caching layer for dbussy_adapter.MandosBus"""

772

def __init__(self, *args, **kwargs):

773

self.object_cache = {}

774

super(dbussy_adapter.CachingBus, self).__init__(*args,

775

**kwargs)

776

def get_object(self, busname, objectpath):

777

try:

778

return self.object_cache[(busname, objectpath)]

779

except KeyError:

780

new_object = super(

781

dbussy_adapter.CachingBus,

782

self).get_object(busname, objectpath)

783

self.object_cache[(busname, objectpath)] = new_object

784

return new_object

785

786

681

787

def commands_from_options(options):

682

788

683

789

commands = list(options.commands)

711

817

return commands

712

818

713

819

714

class command(object):

820

class command:

715

821

"""A namespace for command classes"""

716

822

717

class Base(object):

823

class Base:

718

824

"""Abstract base class for commands"""

719

825

def run(self, clients, bus=None):

720

826

"""Normal commands should implement run_on_one_client(),

783

889

keywords = self.all_keywords

784

890

print(self.TableOfClients(clients.values(), keywords))

785

891

786

class TableOfClients(object):

892

class TableOfClients:

787

893

tableheaders = {

788

894

"Name": "Name",

789

895

"Enabled": "Enabled",

1020

1126

"output"))

1021

1127

1022

1128

1023

class Unique(object):

1129

class Unique:

1024

1130

"""Class for objects which exist only to be unique objects, since

1025

1131

unittest.mock.sentinel only exists in Python 3.3"""

1026

1132

1310

1416

class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):

1311

1417

1312

1418

def MockDBusPython_func(self, func):

1313

class mock_dbus_python(object):

1419

class mock_dbus_python:

1314

1420

"""mock dbus-python module"""

1315

class exceptions(object):

1421

class exceptions:

1316

1422

"""Pseudo-namespace"""

1317

1423

class DBusException(Exception):

1318

1424

pass

1319

class SystemBus(object):

1425

class SystemBus:

1320

1426

@staticmethod

1321

1427

def get_object(busname, objectpath):

1322

1428

DBusObject = collections.namedtuple(

1336

1442

dbus_interface=dbus_interface)

1337

1443

return DBusObject(methodname=method,

1338

1444

Set=set_property)

1339

class Boolean(object):

1445

class Boolean:

1340

1446

def __init__(self, value):

1341

1447

self.value = bool(value)

1342

1448

def __bool__(self):

1526

1632

finally:

1527

1633

dbus_logger.removeFilter(counting_handler)

1528

1634

1529

self.assertNotIsInstance(e, dbus.ConnectFailed)

1635

self.assertNotIsInstance(e.exception, dbus.ConnectFailed)

1530

1636

1531

1637

# Make sure the dbus logger was suppressed

1532

1638

self.assertEqual(0, counting_handler.count)

1554

1660

self.call_method(bus, "methodname", "busname",

1555

1661

"objectpath", "interface")

1556

1662

1557

class fake_dbus_python_raises_exception_on_connect(object):

1663

class fake_dbus_python_raises_exception_on_connect:

1558

1664

"""fake dbus-python module"""

1559

class exceptions(object):

1665

class exceptions:

1560

1666

"""Pseudo-namespace"""

1561

1667

class DBusException(Exception):

1562

1668

pass

1570

1676

1571

1677

1572

1678

class Test_dbus_python_adapter_CachingBus(unittest.TestCase):

1573

class mock_dbus_python(object):

1679

class mock_dbus_python:

1574

1680

"""mock dbus-python modules"""

1575

class SystemBus(object):

1681

class SystemBus:

1576

1682

@staticmethod

1577

1683

def get_object(busname, objectpath):

1578

1684

return Unique()

1624

1730

class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):

1625

1731

1626

1732

def Stub_pydbus_func(self, func):

1627

class stub_pydbus(object):

1733

class stub_pydbus:

1628

1734

"""stub pydbus module"""

1629

class SystemBus(object):

1735

class SystemBus:

1630

1736

@staticmethod

1631

1737

def get(busname, objectpath):

1632

1738

DBusObject = collections.namedtuple(

1669

1775

self.call_method(bus, "methodname", "busname",

1670

1776

"objectpath", "interface")

1671

1777

1672

self.assertNotIsInstance(e, dbus.ConnectFailed)

1778

self.assertNotIsInstance(e.exception, dbus.ConnectFailed)

1673

1779

1674

1780

def test_get_converts_to_correct_exception(self):

1675

1781

bus = pydbus_adapter.SystemBus(

1678

1784

self.call_method(bus, "methodname", "busname",

1679

1785

"objectpath", "interface")

1680

1786

1681

class fake_pydbus_raises_exception_on_connect(object):

1787

class fake_pydbus_raises_exception_on_connect:

1682

1788

"""fake dbus-python module"""

1683

1789

@classmethod

1684

1790

def SystemBus(cls):

1688

1794

return Bus(get=get)

1689

1795

1690

1796

def test_set_property_uses_setattr(self):

1691

class Object(object):

1797

class Object:

1692

1798

pass

1693

1799

obj = Object()

1694

class pydbus_spy(object):

1695

class SystemBus(object):

1800

class pydbus_spy:

1801

class SystemBus:

1696

1802

@staticmethod

1697

1803

def get(busname, objectpath):

1698

1804

return {"interface": obj}

1705

1811

def test_get_suppresses_xml_deprecation_warning(self):

1706

1812

if sys.version_info.major >= 3:

1707

1813

return

1708

class stub_pydbus_get(object):

1709

class SystemBus(object):

1814

class stub_pydbus_get:

1815

class SystemBus:

1710

1816

@staticmethod

1711

1817

def get(busname, objectpath):

1712

1818

warnings.warn_explicit(

1720

1826

1721

1827

1722

1828

class Test_pydbus_adapter_CachingBus(unittest.TestCase):

1723

class stub_pydbus(object):

1829

class stub_pydbus:

1724

1830

"""stub pydbus module"""

1725

class SystemBus(object):

1831

class SystemBus:

1726

1832

@staticmethod

1727

1833

def get(busname, objectpath):

1728

1834

return Unique()

1770

1876

self.assertIs(obj1, obj1b)

1771

1877

1772

1878

1879

class Test_dbussy_adapter_SystemBus(TestCaseWithAssertLogs):

1880

1881

class dummy_dbussy:

1882

class DBUS:

1883

class ObjectPath(str):

1884

pass

1885

class DBusError(Exception):

1886

pass

1887

1888

def fake_ravel_func(self, func):

1889

class fake_ravel:

1890

@staticmethod

1891

def system_bus():

1892

class DBusInterfaceProxy:

1893

@staticmethod

1894

def methodname(*args):

1895

return [func(*args)]

1896

class DBusObject:

1897

@staticmethod

1898

def get_interface(interface):

1899

if interface == "interface":

1900

return DBusInterfaceProxy()

1901

return {"busname": {"objectpath": DBusObject()}}

1902

return fake_ravel

1903

1904

def call_method(self, bus, methodname, busname, objectpath,

1905

interface, *args):

1906

with self.assertLogs(log, logging.DEBUG):

1907

return bus.call_method(methodname, busname, objectpath,

1908

interface, *args)

1909

1910

def test_call_method_returns(self):

1911

expected_method_return = Unique()

1912

method_args = (Unique(), Unique())

1913

def func(*args):

1914

self.assertEqual(len(method_args), len(args))

1915

for marg, arg in zip(method_args, args):

1916

self.assertIs(marg, arg)

1917

return expected_method_return

1918

fake_ravel = self.fake_ravel_func(func)

1919

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

1920

ret = self.call_method(bus, "methodname", "busname",

1921

"objectpath", "interface",

1922

*method_args)

1923

self.assertIs(ret, expected_method_return)

1924

1925

def test_call_method_filters_objectpath(self):

1926

def func():

1927

return method_return

1928

fake_ravel = self.fake_ravel_func(func)

1929

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

1930

method_return = (self.dummy_dbussy.DBUS

1931

.ObjectPath("objectpath"))

1932

ret = self.call_method(bus, "methodname", "busname",

1933

"objectpath", "interface")

1934

self.assertEqual("objectpath", ret)

1935

self.assertNotIsInstance(ret,

1936

self.dummy_dbussy.DBUS.ObjectPath)

1937

1938

def test_call_method_filters_objectpaths_in_dict(self):

1939

ObjectPath = self.dummy_dbussy.DBUS.ObjectPath

1940

def func():

1941

return method_return

1942

fake_ravel = self.fake_ravel_func(func)

1943

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

1944

method_return = {

1945

ObjectPath("objectpath_key_1"):

1946

ObjectPath("objectpath_value_1"),

1947

ObjectPath("objectpath_key_2"):

1948

ObjectPath("objectpath_value_2"),

1949

}

1950

ret = self.call_method(bus, "methodname", "busname",

1951

"objectpath", "interface")

1952

expected_method_return = {str(key): str(value)

1953

for key, value in

1954

method_return.items()}

1955

for key, value in ret.items():

1956

self.assertNotIsInstance(key, ObjectPath)

1957

self.assertNotIsInstance(value, ObjectPath)

1958

self.assertEqual(expected_method_return, ret)

1959

self.assertIsInstance(ret, dict)

1960

1961

def test_call_method_filters_objectpaths_in_dict_in_dict(self):

1962

ObjectPath = self.dummy_dbussy.DBUS.ObjectPath

1963

def func():

1964

return method_return

1965

fake_ravel = self.fake_ravel_func(func)

1966

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

1967

method_return = {

1968

ObjectPath("key1"): {

1969

ObjectPath("key11"): ObjectPath("value11"),

1970

ObjectPath("key12"): ObjectPath("value12"),

1971

},

1972

ObjectPath("key2"): {

1973

ObjectPath("key21"): ObjectPath("value21"),

1974

ObjectPath("key22"): ObjectPath("value22"),

1975

},

1976

}

1977

ret = self.call_method(bus, "methodname", "busname",

1978

"objectpath", "interface")

1979

expected_method_return = {

1980

"key1": {"key11": "value11",

1981

"key12": "value12"},

1982

"key2": {"key21": "value21",

1983

"key22": "value22"},

1984

}

1985

self.assertEqual(expected_method_return, ret)

1986

for key, value in ret.items():

1987

self.assertIsInstance(value, dict)

1988

self.assertEqual(expected_method_return[key], value)

1989

self.assertNotIsInstance(key, ObjectPath)

1990

for inner_key, inner_value in value.items():

1991

self.assertIsInstance(value, dict)

1992

self.assertEqual(

1993

expected_method_return[key][inner_key],

1994

inner_value)

1995

self.assertNotIsInstance(key, ObjectPath)

1996

1997

def test_call_method_filters_objectpaths_in_dict_three_deep(self):

1998

ObjectPath = self.dummy_dbussy.DBUS.ObjectPath

1999

def func():

2000

return method_return

2001

fake_ravel = self.fake_ravel_func(func)

2002

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

2003

method_return = {

2004

ObjectPath("key1"): {

2005

ObjectPath("key2"): {

2006

ObjectPath("key3"): ObjectPath("value"),

2007

},

2008

},

2009

}

2010

ret = self.call_method(bus, "methodname", "busname",

2011

"objectpath", "interface")

2012

expected_method_return = {"key1": {"key2": {"key3": "value"}}}

2013

self.assertEqual(expected_method_return, ret)

2014

self.assertIsInstance(ret, dict)

2015

self.assertNotIsInstance(next(iter(ret.keys())), ObjectPath)

2016

self.assertIsInstance(ret["key1"], dict)

2017

self.assertNotIsInstance(next(iter(ret["key1"].keys())),

2018

ObjectPath)

2019

self.assertIsInstance(ret["key1"]["key2"], dict)

2020

self.assertNotIsInstance(

2021

next(iter(ret["key1"]["key2"].keys())),

2022

ObjectPath)

2023

self.assertEqual("value", ret["key1"]["key2"]["key3"])

2024

self.assertNotIsInstance(ret["key1"]["key2"]["key3"],

2025

self.dummy_dbussy.DBUS.ObjectPath)

2026

2027

def test_call_method_handles_exception(self):

2028

def func():

2029

raise self.dummy_dbussy.DBusError()

2030

2031

fake_ravel = self.fake_ravel_func(func)

2032

bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)

2033

2034

with self.assertRaises(dbus.Error) as e:

2035

self.call_method(bus, "methodname", "busname",

2036

"objectpath", "interface")

2037

2038

self.assertNotIsInstance(e.exception, dbus.ConnectFailed)

2039

2040

def test_get_object_converts_to_correct_exception(self):

2041

class fake_ravel_raises_exception_on_connect:

2042

@staticmethod

2043

def system_bus():

2044

class Bus:

2045

@staticmethod

2046

def __getitem__(key):

2047

if key == "objectpath":

2048

raise self.dummy_dbussy.DBusError()

2049

raise Exception(key)

2050

return {"busname": Bus()}

2051

def func():

2052

raise self.dummy_dbussy.DBusError()

2053

bus = dbussy_adapter.SystemBus(

2054

self.dummy_dbussy,

2055

fake_ravel_raises_exception_on_connect)

2056

with self.assertRaises(dbus.ConnectFailed):

2057

self.call_method(bus, "methodname", "busname",

2058

"objectpath", "interface")

2059

2060

1773

2061

class Test_commands_from_options(unittest.TestCase):

1774

2062

1775

2063

def setUp(self):

2001

2289

2002

2290

2003

2291

def test_manual_page_example_1(self):

2004

self.assert_command_from_args("--verbose".split(),

2292

self.assert_command_from_args("",

2005

2293

command.PrintTable,

2006

2294

clients=[],

2007

verbose=True)

2295

verbose=False)

2008

2296

2009

2297

def test_manual_page_example_2(self):

2010

2298

self.assert_command_from_args(