~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/script.py

• browse files at revision 5036.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 5036.1.1

• reverse the comparison (5036.1.1 to 6079)
• stop comparing with revision 6079

Show diffs side-by-side

added

removed

bzrlib/tests/script.py

1

 

# Copyright (C) 2009, 2010, 2011 Canonical Ltd

 

1

# Copyright (C) 2009 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

24

24

import glob

25

25

import os

26

26

import shlex

27

 

import textwrap

 

27

from cStringIO import StringIO

28

28

 

29

29

from bzrlib import (

30

30

    osutils,

55

55

    Input lines start with '<'.

56

56

    Output lines start with nothing.

57

57

    Error lines start with '2>'.

58

 

 

59

 

    :return: A sequence of ([args], input, output, errors), where the args are

60

 

        split in to words, and the input, output, and errors are just strings,

61

 

        typically containing newlines.

62

58

    """

63

59

 

64

60

    commands = []

77

73

    cmd_line = 1

78

74

    lineno = 0

79

75

    input, output, error = None, None, None

80

 

    text = textwrap.dedent(text)

81

 

    lines = text.split('\n')

82

 

    # to make use of triple-quoted strings easier, we ignore a blank line

83

 

    # right at the start and right at the end; the rest are meaningful

84

 

    if lines and lines[0] == '':

85

 

        del lines[0]

86

 

    if lines and lines[-1] == '':

87

 

        del lines[-1]

88

 

    for line in lines:

 

76

    for line in text.split('\n'):

89

77

        lineno += 1

90

78

        # Keep a copy for error reporting

91

79

        orig = line

92

80

        comment =  line.find('#')

93

81

        if comment >= 0:

94

82

            # Delete comments

95

 

            # NB: this syntax means comments are allowed inside output, which

96

 

            # may be confusing...

97

83

            line = line[0:comment]

98

84

            line = line.rstrip()

99

 

            if line == '':

100

 

                continue

 

85

        if line == '':

 

86

            # Ignore empty lines

 

87

            continue

101

88

        if line.startswith('$'):

102

89

            # Time to output the current command

103

90

            add_command(cmd_cur, input, output, error)

194

181

        self.output_checker = doctest.OutputChecker()

195

182

        self.check_options = doctest.ELLIPSIS

196

183

 

197

 

    def run_script(self, test_case, text, null_output_matches_anything=False):

 

184

    def run_script(self, test_case, text):

198

185

        """Run a shell-like script as a test.

199

186

 

200

187

        :param test_case: A TestCase instance that should provide the fail(),

202

189

            attribute used as a jail root.

203

190

 

204

191

        :param text: A shell-like script (see _script_to_commands for syntax).

205

 

 

206

 

        :param null_output_matches_anything: For commands with no specified

207

 

            output, ignore any output that does happen, including output on

208

 

            standard error.

209

192

        """

210

 

        self.null_output_matches_anything = null_output_matches_anything

211

193

        for cmd, input, output, error in _script_to_commands(text):

212

194

            self.run_command(test_case, cmd, input, output, error)

213

195

 

216

198

        method = getattr(self, mname, None)

217

199

        if method is None:

218

200

            raise SyntaxError('Command not found "%s"' % (cmd[0],),

219

 

                              (None, 1, 1, ' '.join(cmd)))

 

201

                              None, 1, ' '.join(cmd))

220

202

        if input is None:

221

203

            str_input = ''

222

204

        else:

225

207

        retcode, actual_output, actual_error = method(test_case,

226

208

                                                      str_input, args)

227

209

 

228

 

        try:

229

 

            self._check_output(output, actual_output, test_case)

230

 

        except AssertionError, e:

231

 

            raise AssertionError(str(e) + " in stdout of command %s" % cmd)

232

 

        try:

233

 

            self._check_output(error, actual_error, test_case)

234

 

        except AssertionError, e:

235

 

            raise AssertionError(str(e) +

236

 

                " in stderr of running command %s" % cmd)

 

210

        self._check_output(output, actual_output, test_case)

 

211

        self._check_output(error, actual_error, test_case)

237

212

        if retcode and not error and actual_error:

238

213

            test_case.fail('In \n\t%s\nUnexpected error: %s'

239

214

                           % (' '.join(cmd), actual_error))

240

215

        return retcode, actual_output, actual_error

241

216

 

242

217

    def _check_output(self, expected, actual, test_case):

243

 

        if not actual:

244

 

            if expected is None:

245

 

                return

246

 

            elif expected == '...\n':

247

 

                return

248

 

            else:

249

 

                test_case.fail('expected output: %r, but found nothing'

250

 

                            % (expected,))

251

 

 

252

 

        null_output_matches_anything = getattr(

253

 

            self, 'null_output_matches_anything', False)

254

 

        if null_output_matches_anything and expected is None:

 

218

        if expected is None:

 

219

            # Specifying None means: any output is accepted

255

220

            return

256

 

 

257

 

        expected = expected or ''

 

221

        if actual is None:

 

222

            test_case.fail('We expected output: %r, but found None'

 

223

                           % (expected,))

258

224

        matching = self.output_checker.check_output(

259

225

            expected, actual, self.check_options)

260

226

        if not matching:

264

230

            # 'expected' parameter. So we just fallback to our good old

265

231

            # assertEqualDiff since we know there *are* differences and the

266

232

            # output should be decently readable.

267

 

            #

268

 

            # As a special case, we allow output that's missing a final

269

 

            # newline to match an expected string that does have one, so that

270

 

            # we can match a prompt printed on one line, then input given on

271

 

            # the next line.

272

 

            if expected == actual + '\n':

273

 

                pass

274

 

            else:

275

 

                test_case.assertEqualDiff(expected, actual)

 

233

            test_case.assertEqualDiff(expected, actual)

276

234

 

277

235

    def _pre_process_args(self, args):

278

236

        new_args = []

482

440

        super(TestCaseWithMemoryTransportAndScript, self).setUp()

483

441

        self.script_runner = ScriptRunner()

484

442

 

485

 

    def run_script(self, script, null_output_matches_anything=False):

486

 

        return self.script_runner.run_script(self, script, 

487

 

                   null_output_matches_anything=null_output_matches_anything)

 

443

    def run_script(self, script):

 

444

        return self.script_runner.run_script(self, script)

488

445

 

489

446

    def run_command(self, cmd, input, output, error):

490

447

        return self.script_runner.run_command(self, cmd, input, output, error)

512

469

        super(TestCaseWithTransportAndScript, self).setUp()

513

470

        self.script_runner = ScriptRunner()

514

471

 

515

 

    def run_script(self, script, null_output_matches_anything=False):

516

 

        return self.script_runner.run_script(self, script,

517

 

                   null_output_matches_anything=null_output_matches_anything)

 

472

    def run_script(self, script):

 

473

        return self.script_runner.run_script(self, script)

518

474

 

519

475

    def run_command(self, cmd, input, output, error):

520

476

        return self.script_runner.run_command(self, cmd, input, output, error)

521

477

 

522

 

 

523

 

def run_script(test_case, script_string, null_output_matches_anything=False):

524

 

    """Run the given script within a testcase"""

525

 

    return ScriptRunner().run_script(test_case, script_string,

526

 

               null_output_matches_anything=null_output_matches_anything)

527

 

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1