/mandos/release : revision 237.7.647

45

import io

46

import tempfile

47

import contextlib

48

import abc

49

48

50

import dbus as dbus_python

49

try:

50

import pydbus

51

import gi

52

dbus_python = None

53

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

51

62

52

63

# Show warnings by default

53

64

if not sys.warnoptions:

82

93

if options.debug:

83

94

log.setLevel(logging.DEBUG)

84

95

85

bus = dbus_python_adapter.CachingBus(dbus_python)

96

if pydbus is not None:

97

bus = pydbus_adapter.CachingBus(pydbus)

98

else:

99

bus = dbus_python_adapter.CachingBus(dbus_python)

86

100

87

101

try:

88

102

all_clients = bus.get_clients_and_properties()

122

136

help="Select all clients")

123

137

parser.add_argument("-v", "--verbose", action="store_true",

124

138

help="Print all fields")

125

parser.add_argument("-j", "--dump-json", action="store_true",

139

parser.add_argument("-j", "--dump-json", dest="commands",

140

action="append_const", default=[],

141

const=command.DumpJSON(),

126

142

help="Dump client data in JSON format")

127

143

enable_disable = parser.add_mutually_exclusive_group()

128

enable_disable.add_argument("-e", "--enable", action="store_true",

144

enable_disable.add_argument("-e", "--enable", dest="commands",

145

action="append_const", default=[],

146

const=command.Enable(),

129

147

help="Enable client")

130

enable_disable.add_argument("-d", "--disable",

131

action="store_true",

148

enable_disable.add_argument("-d", "--disable", dest="commands",

149

action="append_const", default=[],

150

const=command.Disable(),

132

151

help="disable client")

133

parser.add_argument("-b", "--bump-timeout", action="store_true",

152

parser.add_argument("-b", "--bump-timeout", dest="commands",

153

action="append_const", default=[],

154

const=command.BumpTimeout(),

134

155

help="Bump timeout for client")

135

156

start_stop_checker = parser.add_mutually_exclusive_group()

136

157

start_stop_checker.add_argument("--start-checker",

137

action="store_true",

158

dest="commands",

159

action="append_const", default=[],

160

const=command.StartChecker(),

138

161

help="Start checker for client")

139

start_stop_checker.add_argument("--stop-checker",

140

action="store_true",

162

start_stop_checker.add_argument("--stop-checker", dest="commands",

163

action="append_const", default=[],

164

const=command.StopChecker(),

141

165

help="Stop checker for client")

142

parser.add_argument("-V", "--is-enabled", action="store_true",

166

parser.add_argument("-V", "--is-enabled", dest="commands",

167

action="append_const", default=[],

168

const=command.IsEnabled(),

143

169

help="Check if client is enabled")

144

parser.add_argument("-r", "--remove", action="store_true",

170

parser.add_argument("-r", "--remove", dest="commands",

171

action="append_const", default=[],

172

const=command.Remove(),

145

173

help="Remove client")

146

parser.add_argument("-c", "--checker",

174

parser.add_argument("-c", "--checker", dest="commands",

175

action="append", default=[],

176

metavar="COMMAND", type=command.SetChecker,

147

177

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")

178

parser.add_argument(

179

"-t", "--timeout", dest="commands", action="append",

180

default=[], metavar="TIME",

181

type=command.SetTimeout.argparse(string_to_delta),

182

help="Set timeout for client")

183

parser.add_argument(

184

"--extended-timeout", dest="commands", action="append",

185

default=[], metavar="TIME",

186

type=command.SetExtendedTimeout.argparse(string_to_delta),

187

help="Set extended timeout for client")

188

parser.add_argument(

189

"-i", "--interval", dest="commands", action="append",

190

default=[], metavar="TIME",

191

type=command.SetInterval.argparse(string_to_delta),

192

help="Set checker interval for client")

154

193

approve_deny_default = parser.add_mutually_exclusive_group()

155

194

approve_deny_default.add_argument(

156

"--approve-by-default", action="store_true",

157

default=None, dest="approved_by_default",

195

"--approve-by-default", dest="commands",

196

action="append_const", default=[],

197

const=command.ApproveByDefault(),

158

198

help="Set client to be approved by default")

159

199

approve_deny_default.add_argument(

160

"--deny-by-default", action="store_false",

161

dest="approved_by_default",

200

"--deny-by-default", dest="commands",

201

action="append_const", default=[],

202

const=command.DenyByDefault(),

162

203

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")

204

parser.add_argument(

205

"--approval-delay", dest="commands", action="append",

206

default=[], metavar="TIME",

207

type=command.SetApprovalDelay.argparse(string_to_delta),

208

help="Set delay before client approve/deny")

209

parser.add_argument(

210

"--approval-duration", dest="commands", action="append",

211

default=[], metavar="TIME",

212

type=command.SetApprovalDuration.argparse(string_to_delta),

213

help="Set duration of one client approval")

214

parser.add_argument("-H", "--host", dest="commands",

215

action="append", default=[], metavar="STRING",

216

type=command.SetHost,

217

help="Set host for client")

218

parser.add_argument(

219

"-s", "--secret", dest="commands", action="append",

220

default=[], metavar="FILENAME",

221

type=command.SetSecret.argparse(argparse.FileType(mode="rb")),

222

help="Set password blob (file) for client")

171

223

approve_deny = parser.add_mutually_exclusive_group()

172

224

approve_deny.add_argument(

173

"-A", "--approve", action="store_true",

225

"-A", "--approve", dest="commands", action="append_const",

226

default=[], const=command.Approve(),

174

227

help="Approve any current client request")

175

approve_deny.add_argument("-D", "--deny", action="store_true",

228

approve_deny.add_argument("-D", "--deny", dest="commands",

229

action="append_const", default=[],

230

const=command.Deny(),

176

231

help="Deny any current client request")

177

232

parser.add_argument("--debug", action="store_true",

178

233

help="Debug mode (show D-Bus commands)")

369

424

"""Apply additional restrictions on options, not expressible in

370

425

argparse"""

371

426

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))

427

def has_commands(options, commands=None):

428

if commands is None:

429

commands = (command.Enable,

430

command.Disable,

431

command.BumpTimeout,

432

command.StartChecker,

433

command.StopChecker,

434

command.IsEnabled,

435

command.Remove,

436

command.SetChecker,

437

command.SetTimeout,

438

command.SetExtendedTimeout,

439

command.SetInterval,

440

command.ApproveByDefault,

441

command.DenyByDefault,

442

command.SetApprovalDelay,

443

command.SetApprovalDuration,

444

command.SetHost,

445

command.SetSecret,

446

command.Approve,

447

command.Deny)

448

return any(isinstance(cmd, commands)

449

for cmd in options.commands)

391

450

392

if has_actions(options) and not (options.client or options.all):

451

if has_commands(options) and not (options.client or options.all):

393

452

parser.error("Options require clients names or --all.")

394

if options.verbose and has_actions(options):

453

if options.verbose and has_commands(options):

395

454

parser.error("--verbose can only be used alone.")

396

if options.dump_json and (options.verbose

397

or has_actions(options)):

455

if (has_commands(options, (command.DumpJSON,))

456

and (options.verbose or len(options.commands) > 1)):

398

457

parser.error("--dump-json can only be used alone.")

399

if options.all and not has_actions(options):

458

if options.all and not has_commands(options):

400

459

parser.error("--all requires an action.")

401

if options.is_enabled and len(options.client) > 1:

460

if (has_commands(options, (command.IsEnabled,))

461

and len(options.client) > 1):

402

462

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

463

if (len(options.commands) > 1

464

and has_commands(options, (command.Remove,))

465

and not has_commands(options, (command.Deny,))):

466

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

409

467

410

468

411

469

class dbus(object):

513

571

for key, subval in value.items()}

514

572

return value

515

573

574

def set_client_property(self, objectpath, key, value):

575

if key == "Secret":

576

if not isinstance(value, bytes):

577

value = value.encode("utf-8")

578

value = self.dbus_python.ByteArray(value)

579

return self.set_property(self.busname, objectpath,

580

self.client_interface, key,

581

value)

516

582

517

583

class SilenceLogger(object):

518

584

"Simple context manager to silence a particular logger"

549

615

return new_object

550

616

551

617

618

class pydbus_adapter(object):

619

class SystemBus(dbus.MandosBus):

620

def __init__(self, module=pydbus):

621

self.pydbus = module

622

self.bus = self.pydbus.SystemBus()

623

624

@contextlib.contextmanager

625

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

626

try:

627

yield

628

except gi.repository.GLib.Error as e:

629

# This does what "raise from" would do

630

exc = exception_class(*e.args)

631

exc.__cause__ = e

632

raise exc

633

634

def call_method(self, methodname, busname, objectpath,

635

interface, *args):

636

proxy_object = self.get(busname, objectpath)

637

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

638

interface, methodname,

639

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

640

method = getattr(proxy_object[interface], methodname)

641

with self.convert_exception():

642

return method(*args)

643

644

def get(self, busname, objectpath):

645

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

646

busname, objectpath)

647

with self.convert_exception(dbus.ConnectFailed):

648

if sys.version_info.major <= 2:

649

with warnings.catch_warnings():

650

warnings.filterwarnings(

651

"ignore", "", DeprecationWarning,

652

r"^xml\.etree\.ElementTree$")

653

return self.bus.get(busname, objectpath)

654

else:

655

return self.bus.get(busname, objectpath)

656

657

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

658

value):

659

proxy_object = self.get(busname, objectpath)

660

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

661

objectpath, self.properties_iface, interface,

662

key, value)

663

setattr(proxy_object[interface], key, value)

664

665

class CachingBus(SystemBus):

666

"""A caching layer for pydbus_adapter.SystemBus"""

667

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

668

self.object_cache = {}

669

super(pydbus_adapter.CachingBus,

670

self).__init__(*args, **kwargs)

671

def get(self, busname, objectpath):

672

try:

673

return self.object_cache[(busname, objectpath)]

674

except KeyError:

675

new_object = (super(pydbus_adapter.CachingBus, self)

676

.get(busname, objectpath))

677

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

678

return new_object

679

680

552

681

def commands_from_options(options):

553

682

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())

683

commands = list(options.commands)

684

685

def find_cmd(cmd, commands):

686

i = 0

687

for i, c in enumerate(commands):

688

if isinstance(c, cmd):

689

return i

690

return i+1

691

692

# If command.Remove is present, move any instances of command.Deny

693

# to occur ahead of command.Remove.

694

index_of_remove = find_cmd(command.Remove, commands)

695

before_remove = commands[:index_of_remove]

696

after_remove = commands[index_of_remove:]

697

cleaned_after = []

698

for cmd in after_remove:

699

if isinstance(cmd, command.Deny):

700

before_remove.append(cmd)

589

701

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))

702

cleaned_after.append(cmd)

703

if cleaned_after != after_remove:

704

commands = before_remove + cleaned_after

618

705

619

706

# If no command option has been given, show table of clients,

620

707

# optionally verbosely

835

922

def __init__(self, value):

836

923

self.value_to_set = value

837

924

925

@classmethod

926

def argparse(cls, argtype):

927

def cmdtype(arg):

928

return cls(argtype(arg))

929

return cmdtype

838

930

839

931

class SetChecker(PropertySetterValue):

840

932

propname = "Checker"

966

1058

967

1059

def test_actions_requires_client_or_all(self):

968

1060

for action, value in self.actions.items():

969

options = self.parser.parse_args()

970

setattr(options, action, value)

1061

args = self.actionargs(action, value)

971

1062

with self.assertParseError():

972

self.check_option_syntax(options)

1063

self.parse_args(args)

973

1064

974

# This mostly corresponds to the definition from has_actions() in

1065

# This mostly corresponds to the definition from has_commands() in

975

1066

# check_option_syntax()

976

1067

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,

1068

"--enable": None,

1069

"--disable": None,

1070

"--bump-timeout": None,

1071

"--start-checker": None,

1072

"--stop-checker": None,

1073

"--is-enabled": None,

1074

"--remove": None,

1075

"--checker": "x",

1076

"--timeout": "PT0S",

1077

"--extended-timeout": "PT0S",

1078

"--interval": "PT0S",

1079

"--approve-by-default": None,

1080

"--deny-by-default": None,

1081

"--approval-delay": "PT0S",

1082

"--approval-duration": "PT0S",

1083

"--host": "hostname",

1084

"--secret": "/dev/null",

1085

"--approve": None,

1086

"--deny": None,

998

1087

}

999

1088

1089

@staticmethod

1090

def actionargs(action, value, *args):

1091

if value is not None:

1092

return [action, value] + list(args)

1093

else:

1094

return [action] + list(args)

1095

1000

1096

@contextlib.contextmanager

1001

1097

def assertParseError(self):

1002

1098

with self.assertRaises(SystemExit) as e:

1007

1103

# /argparse.html#exiting-methods

1008

1104

self.assertEqual(2, e.exception.code)

1009

1105

1106

def parse_args(self, args):

1107

options = self.parser.parse_args(args)

1108

check_option_syntax(self.parser, options)

1109

1010

1110

@staticmethod

1011

1111

@contextlib.contextmanager

1012

1112

def redirect_stderr_to_devnull():

1023

1123

1024

1124

def test_actions_all_conflicts_with_verbose(self):

1025

1125

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

1126

args = self.actionargs(action, value, "--all",

1127

"--verbose")

1030

1128

with self.assertParseError():

1031

self.check_option_syntax(options)

1129

self.parse_args(args)

1032

1130

1033

1131

def test_actions_with_client_conflicts_with_verbose(self):

1034

1132

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"]

1133

args = self.actionargs(action, value, "--verbose",

1134

"client")

1039

1135

with self.assertParseError():

1040

self.check_option_syntax(options)

1136

self.parse_args(args)

1041

1137

1042

1138

def test_dump_json_conflicts_with_verbose(self):

1043

options = self.parser.parse_args()

1044

options.dump_json = True

1045

options.verbose = True

1139

args = ["--dump-json", "--verbose"]

1046

1140

with self.assertParseError():

1047

self.check_option_syntax(options)

1141

self.parse_args(args)

1048

1142

1049

1143

def test_dump_json_conflicts_with_action(self):

1050

1144

for action, value in self.actions.items():

1051

options = self.parser.parse_args()

1052

setattr(options, action, value)

1053

options.dump_json = True

1145

args = self.actionargs(action, value, "--dump-json")

1054

1146

with self.assertParseError():

1055

self.check_option_syntax(options)

1147

self.parse_args(args)

1056

1148

1057

1149

def test_all_can_not_be_alone(self):

1058

options = self.parser.parse_args()

1059

options.all = True

1150

args = ["--all"]

1060

1151

with self.assertParseError():

1061

self.check_option_syntax(options)

1152

self.parse_args(args)

1062

1153

1063

1154

def test_all_is_ok_with_any_action(self):

1064

1155

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)

1156

args = self.actionargs(action, value, "--all")

1157

self.parse_args(args)

1069

1158

1070

1159

def test_any_action_is_ok_with_one_client(self):

1071

1160

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)

1161

args = self.actionargs(action, value, "client")

1162

self.parse_args(args)

1076

1163

1077

1164

def test_one_client_with_all_actions_except_is_enabled(self):

1078

options = self.parser.parse_args()

1079

1165

for action, value in self.actions.items():

1080

if action == "is_enabled":

1166

if action == "--is-enabled":

1081

1167

continue

1082

setattr(options, action, value)

1083

options.client = ["client"]

1084

self.check_option_syntax(options)

1168

args = self.actionargs(action, value, "client")

1169

self.parse_args(args)

1085

1170

1086

1171

def test_two_clients_with_all_actions_except_is_enabled(self):

1087

options = self.parser.parse_args()

1088

1172

for action, value in self.actions.items():

1089

if action == "is_enabled":

1173

if action == "--is-enabled":

1090

1174

continue

1091

setattr(options, action, value)

1092

options.client = ["client1", "client2"]

1093

self.check_option_syntax(options)

1175

args = self.actionargs(action, value, "client1",

1176

"client2")

1177

self.parse_args(args)

1094

1178

1095

1179

def test_two_clients_are_ok_with_actions_except_is_enabled(self):

1096

1180

for action, value in self.actions.items():

1097

if action == "is_enabled":

1181

if action == "--is-enabled":

1098

1182

continue

1099

options = self.parser.parse_args()

1100

setattr(options, action, value)

1101

options.client = ["client1", "client2"]

1102

self.check_option_syntax(options)

1183

args = self.actionargs(action, value, "client1",

1184

"client2")

1185

self.parse_args(args)

1103

1186

1104

1187

def test_is_enabled_fails_without_client(self):

1105

options = self.parser.parse_args()

1106

options.is_enabled = True

1188

args = ["--is-enabled"]

1107

1189

with self.assertParseError():

1108

self.check_option_syntax(options)

1190

self.parse_args(args)

1109

1191

1110

1192

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"]

1193

args = ["--is-enabled", "client1", "client2"]

1114

1194

with self.assertParseError():

1115

self.check_option_syntax(options)

1195

self.parse_args(args)

1116

1196

1117

1197

def test_remove_can_only_be_combined_with_action_deny(self):

1118

1198

for action, value in self.actions.items():

1119

if action in {"remove", "deny"}:

1199

if action in {"--remove", "--deny"}:

1120

1200

continue

1121

options = self.parser.parse_args()

1122

setattr(options, action, value)

1123

options.all = True

1124

options.remove = True

1201

args = self.actionargs(action, value, "--all",

1202

"--remove")

1125

1203

with self.assertParseError():

1126

self.check_option_syntax(options)

1204

self.parse_args(args)

1127

1205

1128

1206

1129

1207

class Test_dbus_exceptions(unittest.TestCase):

1242

1320

@staticmethod

1243

1321

def get_object(busname, objectpath):

1244

1322

DBusObject = collections.namedtuple(

1245

"DBusObject", ("methodname",))

1323

"DBusObject", ("methodname", "Set"))

1246

1324

def method(*args, **kwargs):

1247

1325

self.assertEqual({"dbus_interface":

1248

1326

"interface"},

1249

1327

kwargs)

1250

1328

return func(*args)

1251

return DBusObject(methodname=method)

1329

def set_property(interface, key, value,

1330

dbus_interface=None):

1331

self.assertEqual(

1332

"org.freedesktop.DBus.Properties",

1333

dbus_interface)

1334

self.assertEqual("Secret", key)

1335

return func(interface, key, value,

1336

dbus_interface=dbus_interface)

1337

return DBusObject(methodname=method,

1338

Set=set_property)

1252

1339

class Boolean(object):

1253

1340

def __init__(self, value):

1254

1341

self.value = bool(value)

1260

1347

pass

1261

1348

class Dictionary(dict):

1262

1349

pass

1350

class ByteArray(bytes):

1351

pass

1263

1352

return mock_dbus_python

1264

1353

1265

1354

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

1442

1531

# Make sure the dbus logger was suppressed

1443

1532

self.assertEqual(0, counting_handler.count)

1444

1533

1534

def test_Set_Secret_sends_bytearray(self):

1535

ret = [None]

1536

def func(*args, **kwargs):

1537

ret[0] = (args, kwargs)

1538

mock_dbus_python = self.MockDBusPython_func(func)

1539

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1540

bus.set_client_property("objectpath", "Secret", "value")

1541

expected_call = (("se.recompile.Mandos.Client", "Secret",

1542

mock_dbus_python.ByteArray(b"value")),

1543

{"dbus_interface":

1544

"org.freedesktop.DBus.Properties"})

1545

self.assertEqual(expected_call, ret[0])

1546

if sys.version_info.major == 2:

1547

self.assertIsInstance(ret[0][0][-1],

1548

mock_dbus_python.ByteArray)

1549

1445

1550

def test_get_object_converts_to_correct_exception(self):

1446

1551

bus = dbus_python_adapter.SystemBus(

1447

1552

self.fake_dbus_python_raises_exception_on_connect)

1516

1621

self.assertIs(obj1, obj1b)

1517

1622

1518

1623

1624

class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):

1625

1626

def Stub_pydbus_func(self, func):

1627

class stub_pydbus(object):

1628

"""stub pydbus module"""

1629

class SystemBus(object):

1630

@staticmethod

1631

def get(busname, objectpath):

1632

DBusObject = collections.namedtuple(

1633

"DBusObject", ("methodname",))

1634

return {"interface":

1635

DBusObject(methodname=func)}

1636

return stub_pydbus

1637

1638

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

1639

interface, *args):

1640

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

1641

return bus.call_method(methodname, busname, objectpath,

1642

interface, *args)

1643

1644

def test_call_method_returns(self):

1645

expected_method_return = Unique()

1646

method_args = (Unique(), Unique())

1647

def func(*args):

1648

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

1649

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

1650

self.assertIs(marg, arg)

1651

return expected_method_return

1652

stub_pydbus = self.Stub_pydbus_func(func)

1653

bus = pydbus_adapter.SystemBus(stub_pydbus)

1654

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

1655

"objectpath", "interface",

1656

*method_args)

1657

self.assertIs(ret, expected_method_return)

1658

1659

def test_call_method_handles_exception(self):

1660

dbus_logger = logging.getLogger("dbus.proxies")

1661

1662

def func():

1663

raise gi.repository.GLib.Error()

1664

1665

stub_pydbus = self.Stub_pydbus_func(func)

1666

bus = pydbus_adapter.SystemBus(stub_pydbus)

1667

1668

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

1669

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

1670

"objectpath", "interface")

1671

1672

self.assertNotIsInstance(e, dbus.ConnectFailed)

1673

1674

def test_get_converts_to_correct_exception(self):

1675

bus = pydbus_adapter.SystemBus(

1676

self.fake_pydbus_raises_exception_on_connect)

1677

with self.assertRaises(dbus.ConnectFailed):

1678

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

1679

"objectpath", "interface")

1680

1681

class fake_pydbus_raises_exception_on_connect(object):

1682

"""fake dbus-python module"""

1683

@classmethod

1684

def SystemBus(cls):

1685

def get(busname, objectpath):

1686

raise gi.repository.GLib.Error()

1687

Bus = collections.namedtuple("Bus", ["get"])

1688

return Bus(get=get)

1689

1690

def test_set_property_uses_setattr(self):

1691

class Object(object):

1692

pass

1693

obj = Object()

1694

class pydbus_spy(object):

1695

class SystemBus(object):

1696

@staticmethod

1697

def get(busname, objectpath):

1698

return {"interface": obj}

1699

bus = pydbus_adapter.SystemBus(pydbus_spy)

1700

value = Unique()

1701

bus.set_property("busname", "objectpath", "interface", "key",

1702

value)

1703

self.assertIs(value, obj.key)

1704

1705

def test_get_suppresses_xml_deprecation_warning(self):

1706

if sys.version_info.major >= 3:

1707

return

1708

class stub_pydbus_get(object):

1709

class SystemBus(object):

1710

@staticmethod

1711

def get(busname, objectpath):

1712

warnings.warn_explicit(

1713

"deprecated", DeprecationWarning,

1714

"xml.etree.ElementTree", 0)

1715

bus = pydbus_adapter.SystemBus(stub_pydbus_get)

1716

with warnings.catch_warnings(record=True) as w:

1717

warnings.simplefilter("always")

1718

bus.get("busname", "objectpath")

1719

self.assertEqual(0, len(w))

1720

1721

1722

class Test_pydbus_adapter_CachingBus(unittest.TestCase):

1723

class stub_pydbus(object):

1724

"""stub pydbus module"""

1725

class SystemBus(object):

1726

@staticmethod

1727

def get(busname, objectpath):

1728

return Unique()

1729

1730

def setUp(self):

1731

self.bus = pydbus_adapter.CachingBus(self.stub_pydbus)

1732

1733

def test_returns_distinct_objectpaths(self):

1734

obj1 = self.bus.get("busname", "objectpath1")

1735

self.assertIsInstance(obj1, Unique)

1736

obj2 = self.bus.get("busname", "objectpath2")

1737

self.assertIsInstance(obj2, Unique)

1738

self.assertIsNot(obj1, obj2)

1739

1740

def test_returns_distinct_busnames(self):

1741

obj1 = self.bus.get("busname1", "objectpath")

1742

self.assertIsInstance(obj1, Unique)

1743

obj2 = self.bus.get("busname2", "objectpath")

1744

self.assertIsInstance(obj2, Unique)

1745

self.assertIsNot(obj1, obj2)

1746

1747

def test_returns_distinct_both(self):

1748

obj1 = self.bus.get("busname1", "objectpath")

1749

self.assertIsInstance(obj1, Unique)

1750

obj2 = self.bus.get("busname2", "objectpath")

1751

self.assertIsInstance(obj2, Unique)

1752

self.assertIsNot(obj1, obj2)

1753

1754

def test_returns_same(self):

1755

obj1 = self.bus.get("busname", "objectpath")

1756

self.assertIsInstance(obj1, Unique)

1757

obj2 = self.bus.get("busname", "objectpath")

1758

self.assertIsInstance(obj2, Unique)

1759

self.assertIs(obj1, obj2)

1760

1761

def test_returns_same_old(self):

1762

obj1 = self.bus.get("busname1", "objectpath1")

1763

self.assertIsInstance(obj1, Unique)

1764

obj2 = self.bus.get("busname2", "objectpath2")

1765

self.assertIsInstance(obj2, Unique)

1766

obj1b = self.bus.get("busname1", "objectpath1")

1767

self.assertIsInstance(obj1b, Unique)

1768

self.assertIsNot(obj1, obj2)

1769

self.assertIsNot(obj2, obj1b)

1770

self.assertIs(obj1, obj1b)

1771

1772

1519

1773

class Test_commands_from_options(unittest.TestCase):

1520

1774

1521

1775

def setUp(self):

2070

2324

def runTest(self):

2071

2325

if not hasattr(self, "command"):

2072

2326

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]

2327

2328

if hasattr(self, "values_to_set"):

2329

cmd_args = [(value,) for value in self.values_to_set]

2330

values_to_get = getattr(self, "values_to_get",

2331

self.values_to_set)

2332

else:

2333

cmd_args = [() for x in range(len(self.values_to_get))]

2334

values_to_get = self.values_to_get

2335

for value_to_get, cmd_arg in zip(values_to_get, cmd_args):

2336

for clientpath in self.bus.clients:

2337

self.bus.clients[clientpath][self.propname] = (

2338

Unique())

2339

self.command(*cmd_arg).run(self.bus.clients, self.bus)

2340

for clientpath in self.bus.clients:

2341

value = (self.bus.clients[clientpath]

2342

[self.propname])

2082

2343

self.assertNotIsInstance(value, Unique)

2083

2344

self.assertEqual(value_to_get, value)

2084

2345

2085

def run_command(self, value, clients):

2086

self.command().run(clients, self.bus)

2087

2088

2346

2089

2347

class TestEnableCmd(TestPropertySetterCmd):

2090

2348

command = command.Enable

2091

2349

propname = "Enabled"

2092

values_to_set = [True]

2350

values_to_get = [True]

2093

2351

2094

2352

2095

2353

class TestDisableCmd(TestPropertySetterCmd):

2096

2354

command = command.Disable

2097

2355

propname = "Enabled"

2098

values_to_set = [False]

2356

values_to_get = [False]

2099

2357

2100

2358

2101

2359

class TestBumpTimeoutCmd(TestPropertySetterCmd):

2102

2360

command = command.BumpTimeout

2103

2361

propname = "LastCheckedOK"

2104

values_to_set = [""]

2362

values_to_get = [""]

2105

2363

2106

2364

2107

2365

class TestStartCheckerCmd(TestPropertySetterCmd):

2108

2366

command = command.StartChecker

2109

2367

propname = "CheckerRunning"

2110

values_to_set = [True]

2368

values_to_get = [True]

2111

2369

2112

2370

2113

2371

class TestStopCheckerCmd(TestPropertySetterCmd):

2114

2372

command = command.StopChecker

2115

2373

propname = "CheckerRunning"

2116

values_to_set = [False]

2374

values_to_get = [False]

2117

2375

2118

2376

2119

2377

class TestApproveByDefaultCmd(TestPropertySetterCmd):

2120

2378

command = command.ApproveByDefault

2121

2379

propname = "ApprovedByDefault"

2122

values_to_set = [True]

2380

values_to_get = [True]

2123

2381

2124

2382

2125

2383

class TestDenyByDefaultCmd(TestPropertySetterCmd):

2126

2384

command = command.DenyByDefault

2127

2385

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):

2386

values_to_get = [False]

2387

2388

2389

class TestSetCheckerCmd(TestPropertySetterCmd):

2139

2390

command = command.SetChecker

2140

2391

propname = "Checker"

2141

2392

values_to_set = ["", ":", "fping -q -- %s"]

2142

2393

2143

2394

2144

class TestSetHostCmd(TestPropertySetterValueCmd):

2395

class TestSetHostCmd(TestPropertySetterCmd):

2145

2396

command = command.SetHost

2146

2397

propname = "Host"

2147

2398

values_to_set = ["192.0.2.3", "client.example.org"]

2148

2399

2149

2400

2150

class TestSetSecretCmd(TestPropertySetterValueCmd):

2401

class TestSetSecretCmd(TestPropertySetterCmd):

2151

2402

command = command.SetSecret

2152

2403

propname = "Secret"

2153

2404

values_to_set = [io.BytesIO(b""),

2155

2406

values_to_get = [f.getvalue() for f in values_to_set]

2156

2407

2157

2408

2158

class TestSetTimeoutCmd(TestPropertySetterValueCmd):

2409

class TestSetTimeoutCmd(TestPropertySetterCmd):

2159

2410

command = command.SetTimeout

2160

2411

propname = "Timeout"

2161

2412

values_to_set = [datetime.timedelta(),

2166

2417

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2167

2418

2168

2419

2169

class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):

2420

class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):

2170

2421

command = command.SetExtendedTimeout

2171

2422

propname = "ExtendedTimeout"

2172

2423

values_to_set = [datetime.timedelta(),

2177

2428

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2178

2429

2179

2430

2180

class TestSetIntervalCmd(TestPropertySetterValueCmd):

2431

class TestSetIntervalCmd(TestPropertySetterCmd):

2181

2432

command = command.SetInterval

2182

2433

propname = "Interval"

2183

2434

values_to_set = [datetime.timedelta(),

2188

2439

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2189

2440

2190

2441

2191

class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):

2442

class TestSetApprovalDelayCmd(TestPropertySetterCmd):

2192

2443

command = command.SetApprovalDelay

2193

2444

propname = "ApprovalDelay"

2194

2445

values_to_set = [datetime.timedelta(),

2199

2450

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2200

2451

2201

2452

2202

class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):

2453

class TestSetApprovalDurationCmd(TestPropertySetterCmd):

2203

2454

command = command.SetApprovalDuration

2204

2455

propname = "ApprovalDuration"

2205

2456

values_to_set = [datetime.timedelta(),